Prepare supporting source map

Author: hyf0

Cargo.toml

@@ -11,11 +11,14 @@ description = "manipulate string like wizards"
 glob = "0.3.1"
 index_vec = { version = "0.1.3" }
 rustc-hash = { version = "1.1.0" }
-
+vlq = "0.5.1"
+serde = {version = "1.0", features = ["derive"]}
+serde_json = "1.0"
 
 [dev-dependencies]
 glob = "0.3.1"
 criterion = { version = "0.4" }
+insta = "1.31.0"
 
 [[bench]]
 name = "joiner_join"

examples/source_map.rs

@@ -0,0 +1,45 @@
+use string_wizard::{MagicString, SourceMapOptions, UpdateOptions};
+
+fn main() {
+    let demo = "<div>
+    hello, world
+</div>";
+    let mut s = MagicString::new(demo);
+
+    // s.prepend("import React from 'react';\n")
+    let update_options = UpdateOptions {
+        store_name: true,
+        ..Default::default()
+    };
+    s
+        .update_with(
+            1,
+            2,
+            "v",
+            update_options.clone(),
+        )
+        .update_with(
+            3,
+            4,
+            "d",
+            update_options.clone(),
+        )
+        .update_with(
+            demo.len() - 4,
+            demo.len() - 1,
+            "h1",
+            UpdateOptions {
+                store_name: true,
+                ..Default::default()
+            },
+        );
+
+    let sm = s.source_map(SourceMapOptions {
+        include_content: true,
+    });
+
+    std::fs::write("./demo.jsx.map", sm.to_string()).unwrap();
+    std::fs::write("./demo.jsx", s.to_string()).unwrap();
+
+    println!("{:#?}", s.to_string());
+}

src/chunk.rs

@@ -6,13 +6,15 @@ use crate::{span::Span, ChunkIdx, CowStr, TextSize};
 pub struct Chunk<'str> {
     pub intro: VecDeque<CowStr<'str>>,
     pub outro: VecDeque<CowStr<'str>>,
-    span: Span,
-    content: Option<CowStr<'str>>,
+    pub span: Span,
+    pub edited_content: Option<CowStr<'str>>,
     pub(crate) next: Option<ChunkIdx>,
+    pub store_name: bool,
 }
 
 impl<'s> Chunk<'s> {
     pub fn new(span: Span) -> Self {
+        debug_assert!(span.0 < span.1);
         Self {
             span,
             ..Default::default()
@@ -50,11 +52,13 @@ impl<'str> Chunk<'str> {
     }
 
     pub fn split<'a>(&'a mut self, text_index: TextSize) -> Chunk<'str> {
+        debug_assert!(text_index > self.start());
+        debug_assert!(text_index < self.end());
         let first_slice_span = Span(self.start(), text_index);
         let last_slice_span = Span(text_index, self.end());
         let mut new_chunk = Chunk::new(last_slice_span);
         if self.is_edited() {
-            new_chunk.edit("".into())
+            new_chunk.edit("".into(), true, false);
         }
         std::mem::swap(&mut new_chunk.outro, &mut self.outro);
         self.span = first_slice_span;
@@ -68,18 +72,23 @@ impl<'str> Chunk<'str> {
     ) -> impl Iterator<Item = &'str str> {
         let intro_iter = self.intro.iter().map(|frag| frag.as_ref());
         let source_frag = self
-            .content
+            .edited_content
             .as_deref()
             .unwrap_or_else(|| self.span.text(original_source.as_ref()));
         let outro_iter = self.outro.iter().map(|frag| frag.as_ref());
         intro_iter.chain(Some(source_frag)).chain(outro_iter)
     }
 
-    pub fn edit(&mut self, content: CowStr<'str>) {
-        self.content = Some(content);
+    pub fn edit(&mut self, content: CowStr<'str>, overwrite: bool, store_name: bool) {
+        if overwrite {
+            self.intro.clear();
+            self.outro.clear();
+        }
+        self.store_name = store_name;
+        self.edited_content = Some(content);
     }
 
     pub fn is_edited(&self) -> bool {
-        self.content.is_some()
+        self.edited_content.is_some()
     }
 }

src/decoded_map.rs

@@ -0,0 +1,25 @@
+use crate::{
+    mappings::{Mappings, Segment},
+    source_map::SourceMap,
+};
+
+#[derive(Debug)]
+pub struct DecodedMap {
+    pub version: u8,
+    pub sources: Vec<String>,
+    pub sources_content: Vec<String>,
+    pub mappings: Mappings,
+    pub names: Vec<String>,
+}
+
+impl DecodedMap {
+    pub fn into_source_map(self) -> SourceMap {
+        SourceMap {
+            version: self.version,
+            sources: self.sources,
+            sources_content: self.sources_content,
+            mappings: self.mappings.encoded(),
+            names: self.names,
+        }
+    }
+}

src/lib.rs

@@ -1,10 +1,11 @@
-
 mod chunk;
-mod span;
 mod joiner;
+mod locator;
 mod magic_string;
 mod mappings;
-mod locator;
+mod source_map;
+mod span;
+mod decoded_map;
 
 use std::borrow::Cow;
 
@@ -13,8 +14,12 @@ type CowStr<'s> = Cow<'s, str>;
 use chunk::Chunk;
 use index_vec::IndexVec;
 
-pub use crate::{magic_string::{MagicString, MagicStringOptions}, joiner::{Joiner, JoinerOptions}};
-
+pub use crate::{
+    joiner::{Joiner, JoinerOptions},
+    magic_string::{
+        mutation::UpdateOptions, source_map::SourceMapOptions, MagicString, MagicStringOptions,
+    },
+};
 
 index_vec::define_index_type! {
     struct ChunkIdx = u32;
@@ -26,4 +31,4 @@ index_vec::define_index_type! {
     struct SourceIdx = u32;
 }
 
-pub(crate) type TextSize = usize;
+pub(crate) type TextSize = usize;

src/locator.rs

@@ -32,7 +32,38 @@ impl Locator {
     }
 }
 
+#[derive(Debug, PartialEq)]
 pub struct Location {
     pub line: usize,
     pub column: usize,
 }
+
+impl Location {
+    pub fn bump_line(&mut self) {
+        self.line += 1;
+        self.column = 0;
+    }
+}
+
+#[test]
+fn basic() {
+    use std::ops::Range;
+    let source = "string\nwizard";
+    let locator = Locator::new(source);
+    let line_range = |line: usize| -> Range<usize> {
+        assert!(line < locator.line_offsets.len());
+        if line == locator.line_offsets.len() - 1 {
+            locator.line_offsets[line]..source.len()
+        } else {
+            locator.line_offsets[line]..(locator.line_offsets[line + 1] - 1)
+        }
+    };
+    assert_eq!(&source[line_range(0)], "string");
+    assert_eq!(&source[line_range(1)], "wizard");
+
+    assert_eq!(locator.line_offsets[0], 0);
+    assert_eq!(locator.line_offsets[1], 7);
+
+    assert_eq!(locator.locate(2), Location { line: 0, column: 2 });
+    assert_eq!(locator.locate(8), Location { line: 1, column: 1 });
+}

src/magic_string.rs renamed to src/magic_string/mod.rs

@@ -1,3 +1,6 @@
+pub mod mutation;
+pub mod source_map;
+
 use std::collections::VecDeque;
 
 use rustc_hash::FxHashMap;
@@ -17,6 +20,7 @@ pub struct MagicString<'s> {
     intro: VecDeque<CowStr<'s>>,
     outro: VecDeque<CowStr<'s>>,
 
+    stored_names: Vec<Span>,
     source: CowStr<'s>,
     chunks: ChunkVec<'s>,
     first_chunk_idx: ChunkIdx,
@@ -48,6 +52,7 @@ impl<'s> MagicString<'s> {
             chunk_by_end: Default::default(),
             // setup options
             filename: options.filename,
+            stored_names: Default::default(),
         };
 
         magic_string.chunk_by_start.insert(0, initial_chunk_idx);
@@ -168,7 +173,7 @@ impl<'s> MagicString<'s> {
             let chunk = &mut self.chunks[chunk_idx];
             chunk.intro.clear();
             chunk.outro.clear();
-            chunk.edit("".into());
+            chunk.edit("".into(), true, false);
             searched = if end == chunk.end() {
                 None
             } else {
@@ -179,19 +184,6 @@ impl<'s> MagicString<'s> {
         self
     }
 
-    pub fn generate_decoded_map(&self) {
-        let mut mappings = Mappings::default();
-        let locator = Locator::new(&self.source);
-
-        self.intro.iter().for_each(|frag| {
-            mappings.advance(frag);
-        });
-
-        self.iter_chunks().for_each(|chunk| {
-            let loc = locator.locate(chunk.start());
-        });
-    }
-
     // --- private
 
     fn prepend_intro(&mut self, content: impl Into<CowStr<'s>>) {
@@ -239,16 +231,12 @@ impl<'s> MagicString<'s> {
             return;
         }
 
-        let mut target = if (self.source.len() - text_index) > text_index {
-            self.first_chunk()
+        let (mut target, mut target_idx, search_right) = if (self.source.len() - text_index) > text_index {
+            (self.first_chunk(), self.first_chunk_idx, true)
         } else {
-            self.last_chunk()
+            (self.last_chunk(), self.last_chunk_idx, false)
         };
 
-        let mut target_idx = self.first_chunk_idx;
-
-        let search_right = text_index > target.end();
-
         while !target.contains(text_index) {
             let next_idx = if search_right {
                 self.chunk_by_start.get(&target.end()).unwrap()
@@ -260,7 +248,6 @@ impl<'s> MagicString<'s> {
         }
 
         let chunk_contains_index = &mut self.chunks[target_idx];
-
         let new_chunk = chunk_contains_index.split(text_index);
         self.chunk_by_end.insert(text_index, target_idx);
         let new_chunk_end = new_chunk.end();

src/magic_string/mutation.rs

@@ -0,0 +1,34 @@
+use crate::{CowStr, MagicString, TextSize};
+
+#[derive(Debug, Default, Clone)]
+pub struct UpdateOptions {
+    pub store_name: bool,
+    pub overwrite: bool,
+}
+
+impl<'text> MagicString<'text> {
+    pub fn update(&mut self, start: TextSize, end: TextSize, content: impl Into<CowStr<'text>>) -> &mut Self {
+        self.update_with(start, end, content, Default::default())
+    }
+
+    pub fn update_with(
+        &mut self,
+        start: TextSize,
+        end: TextSize,
+        content: impl Into<CowStr<'text>>,
+        opts: UpdateOptions,
+    ) -> &mut Self {
+        assert!(start < end);
+        self.split_at(start);
+        self.split_at(end);
+
+        let first = self.chunk_by_start.get(&start).unwrap();
+        let end = self.chunk_by_end.get(&start).unwrap();
+
+        // let chunk_after_next =
+
+        self.chunks[*first].edit(content.into(), opts.overwrite, opts.store_name);
+
+        self
+    }
+}