Struct sourcemap::SourceView

source ·

pub struct SourceView<'a> { /* private fields */ }

Expand description

Provides efficient access to minified sources.

This type is used to implement fairly efficient source mapping operations.

Implementations§

source §

impl<'a> SourceView<'a>

source

pub fn new(source: &'a str) -> SourceView<'a>

Creates an optimized view of a given source.

source

pub fn from_string(source: String) -> SourceView<'static>

Creates an optimized view from a given source string

source

pub fn get_line(&self, idx: u32) -> Option<&str>

Returns a requested minified line.

source

pub fn get_line_slice(&self, line: u32, col: u32, span: u32) -> Option<&str>

Returns a line slice.

Note that columns are indexed as JavaScript WTF-16 columns.

source

pub fn lines(&'a self) -> Lines<'a>

Returns an iterator over all lines.

source

pub fn source(&self) -> &str

Returns the source.

Examples found in repository ?

examples/split_ram_bundle.rs (line 51)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = env::args().collect();
    if args.len() < 4 {
        println!("{USAGE}");
        std::process::exit(1);
    }

    let bundle_path = Path::new(&args[1]);
    let ram_bundle = RamBundle::parse_indexed_from_path(bundle_path)
        .or_else(|_| RamBundle::parse_unbundle_from_path(bundle_path))?;

    match ram_bundle.bundle_type() {
        RamBundleType::Indexed => println!("Indexed RAM Bundle detected"),
        RamBundleType::Unbundle => println!("File RAM Bundle detected"),
    }

    let sourcemap_file = File::open(&args[2])?;
    let ism = SourceMapIndex::from_reader(sourcemap_file).unwrap();

    let output_directory = Path::new(&args[3]);
    if !output_directory.exists() {
        panic!("Directory {} does not exist!", output_directory.display());
    }

    println!(
        "Ouput directory: {}",
        output_directory.canonicalize()?.display()
    );
    let ram_bundle_iter = split_ram_bundle(&ram_bundle, &ism).unwrap();
    for result in ram_bundle_iter {
        let (name, sv, sm) = result.unwrap();
        println!("Writing down source: {name}");
        fs::write(output_directory.join(name.clone()), sv.source())?;

        let sourcemap_name = format!("{name}.map");
        println!("Writing down sourcemap: {sourcemap_name}");
        let out_sm = File::create(output_directory.join(sourcemap_name))?;
        sm.to_writer(out_sm)?;
    }
    println!("Done.");

    Ok(())
}

source

pub fn get_original_function_name<'map>(
 &self,
 token: Token<'map>,
 minified_name: &str
) -> Option<&'map str>

Given a token and minified function name this attemps to resolve the name to an original function name.

This invokes some guesswork and requires access to the original minified source. This will not yield proper results for anonymous functions or functions that do not have clear function names. (For instance it’s recommended that dotted function names are not passed to this function).

source