Use u32 and fix source map

Author: hyf0

examples/source_map.rs

@@ -6,39 +6,19 @@ fn main() {
 </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()
-            },
-        );
+    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", update_options.clone());
 
     let sm = s.source_map(SourceMapOptions {
         include_content: true,
     });
 
-    std::fs::write("./demo.jsx.map", sm.to_string()).unwrap();
+    std::fs::write("./demo.map.json", sm.to_string()).unwrap();
     std::fs::write("./demo.jsx", s.to_string()).unwrap();
 
     println!("{:#?}", s.to_string());

src/basic_types.rs

@@ -0,0 +1,40 @@
+use std::borrow::Cow;
+
+#[derive(Debug, Clone)]
+pub struct BasicCowStr<'text> {
+    inner: Cow<'text, str>,
+}
+
+impl<'text> BasicCowStr<'text> {
+    pub fn new(inner: Cow<'text, str>) -> Self {
+        assert!(
+            u32::try_from(inner.len()).is_ok(),
+            "We only support string up to 4GB in size, which is the maximum size of the u32."
+        );
+        Self { inner }
+    }
+
+    pub fn len(&self) -> u32 {
+        // We can safely do converting here because we have already asserted that
+        // the length of the string is less than or equal `u32::MAX`
+        self.inner.len() as u32
+    }
+
+    pub fn as_str(&self) -> &str {
+        self.inner.as_ref()
+    }
+}
+
+impl<'text> std::ops::Deref for BasicCowStr<'text> {
+    type Target = Cow<'text, str>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<'text, T: Into<Cow<'text, str>>> From<T> for BasicCowStr<'text> {
+    fn from(value: T) -> Self {
+        Self::new(value.into())
+    }
+}

src/chunk.rs

@@ -100,8 +100,9 @@ impl<'str> Chunk<'str> {
         let intro_iter = self.intro.iter().map(|frag| frag.as_ref());
         let source_frag = self
             .edited_content
-            .as_deref()
-            .unwrap_or_else(|| self.span.text(original_source.as_ref()));
+            .as_ref()
+            .map(|s| s.as_str())
+            .unwrap_or_else(|| self.span.text(original_source.as_str()));
         let outro_iter = self.outro.iter().map(|frag| frag.as_ref());
         intro_iter.chain(Some(source_frag)).chain(outro_iter)
     }

src/decoded_map.rs

@@ -1,7 +1,4 @@
-use crate::{
-    mappings::{Mappings, Segment},
-    source_map::SourceMap,
-};
+use crate::{mappings::Mappings, source_map::SourceMap};
 
 #[derive(Debug)]
 pub struct DecodedMap {

src/lib.rs

@@ -6,10 +6,13 @@ mod magic_string;
 mod mappings;
 mod source_map;
 mod span;
+mod basic_types;
 
-type CowStr<'text> = std::borrow::Cow<'text, str>;
+type CowStr<'text> = BasicCowStr<'text>;
 
-pub(crate) type TextSize = usize;
+pub(crate) type TextSize = u32;
+
+use basic_types::BasicCowStr;
 
 pub use crate::{
     joiner::{Joiner, JoinerOptions},

src/locator.rs

@@ -1,4 +1,6 @@
+#[derive(Debug)]
 pub struct Locator {
+    /// offsets are calculated based on utf-16
     line_offsets: Box<[usize]>,
 }
 
@@ -8,14 +10,17 @@ impl Locator {
         let mut line_start_pos = 0;
         for line in source.lines() {
             line_offsets.push(line_start_pos);
-            line_start_pos += 1 + line.len();
+            line_start_pos += 1 + line.chars().map(|c| c.len_utf16()).sum::<usize>();
         }
         Self {
             line_offsets: line_offsets.into_boxed_slice(),
         }
     }
 
-    pub fn locate(&self, index: usize) -> Location {
+    /// Pass the index based on utf-16 and return the [Location] based on utf-16
+    pub fn locate(&self, index: u32) -> Location {
+        let index = index as usize;
+
         let mut left_cursor = 0;
         let mut right_cursor = self.line_offsets.len();
         while left_cursor < right_cursor {
@@ -28,14 +33,18 @@ impl Locator {
         }
         let line = left_cursor - 1;
         let column = index - self.line_offsets[line];
-        Location { line, column }
+        Location {
+            line: line.try_into().unwrap(),
+            column: column.try_into().unwrap(),
+        }
     }
 }
 
 #[derive(Debug, PartialEq)]
 pub struct Location {
-    pub line: usize,
-    pub column: usize,
+    pub line: u32,
+    // columns are calculated based on utf-16
+    pub column: u32,
 }
 
 impl Location {
@@ -47,23 +56,27 @@ impl Location {
 
 #[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(0), Location { line: 0, column: 0 });
+    assert_eq!(locator.locate(12), Location { line: 1, column: 5 });
+    assert_eq!(locator.locate(7), Location { line: 1, column: 0 });
+    assert_eq!(locator.locate(1), Location { line: 0, column: 1 });
     assert_eq!(locator.locate(8), Location { line: 1, column: 1 });
 }
+
+#[test]
+fn special_chars() {
+    let source = "ß💣\n💣ß";
+    let locator = Locator::new(source);
+    assert_eq!(locator.line_offsets[0], 0);
+    assert_eq!(locator.line_offsets[1], 4);
+
+    assert_eq!(locator.locate(0), Location { line: 0, column: 0 });
+    assert_eq!(locator.locate(4), Location { line: 1, column: 0 });
+    assert_eq!(locator.locate(6), Location { line: 1, column: 2 });
+}

src/magic_string/mod.rs

@@ -6,8 +6,9 @@ use std::collections::VecDeque;
 use rustc_hash::FxHashMap;
 
 use crate::{
-    chunk::{Chunk, ChunkVec, ChunkIdx}, locator::Locator, mappings::Mappings, span::Span, CowStr,
-    TextSize,
+    chunk::{Chunk, ChunkIdx, ChunkVec},
+    span::Span,
+    CowStr, TextSize,
 };
 
 #[derive(Debug, Default)]
@@ -157,8 +158,6 @@ impl<'s> MagicString<'s> {
         ret
     }
 
-   
-
     // --- private
 
     fn prepend_intro(&mut self, content: impl Into<CowStr<'s>>) {
@@ -201,16 +200,17 @@ impl<'s> MagicString<'s> {
     ///
     /// Chunk{span: (0, 3)} => "abc"
     /// Chunk{span: (3, 7)} => "defg"
-    fn split_at(&mut self, text_index: TextSize) {
+    fn split_at(&mut self, text_index: u32) {
         if text_index == 0 || self.chunk_by_end.contains_key(&text_index) {
             return;
         }
 
-        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_idx, false)
-        };
+        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_idx, false)
+            };
 
         while !target.contains(text_index) {
             let next_idx = if search_right {

src/magic_string/mutation.rs

@@ -1,4 +1,4 @@
-use crate::{chunk::EditOptions, CowStr, MagicString, TextSize};
+use crate::{chunk::EditOptions, CowStr, MagicString};
 
 #[derive(Debug, Default, Clone)]
 pub struct UpdateOptions {
@@ -12,25 +12,25 @@ impl<'text> MagicString<'text> {
     /// A shorthand for `update_with(start, end, content, Default::default())`;
     pub fn update(
         &mut self,
-        start: TextSize,
-        end: TextSize,
+        start: usize,
+        end: usize,
         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,
+        start: usize,
+        end: usize,
         content: impl Into<CowStr<'text>>,
         opts: UpdateOptions,
     ) -> &mut Self {
         self.update_with_inner(start, end, content.into(), opts, true);
         self
     }
 
-    pub fn remove(&mut self, start: TextSize, end: TextSize) -> &mut Self {
+    pub fn remove(&mut self, start: usize, end: usize) -> &mut Self {
         self.update_with_inner(
             start,
             end,
@@ -49,12 +49,14 @@ impl<'text> MagicString<'text> {
 
     fn update_with_inner(
         &mut self,
-        start: TextSize,
-        end: TextSize,
+        start: usize,
+        end: usize,
         content: CowStr<'text>,
         opts: UpdateOptions,
         panic_if_start_equal_end: bool,
     ) -> &mut Self {
+        let start = start as u32;
+        let end = end as u32;
         if panic_if_start_equal_end && start == end {
             panic!(
                 "Cannot overwrite a zero-length range – use append_left or prepend_right instead"

src/magic_string/source_map.rs

@@ -37,7 +37,7 @@ impl<'s> MagicString<'s> {
                         next_idx
                     });
                 debug_assert!(idx < names.len());
-                Some(idx)
+                Some(idx as u32)
             } else {
                 None
             };
@@ -54,7 +54,7 @@ impl<'s> MagicString<'s> {
             sources: vec!["".to_string()],
             sources_content: opts
                 .include_content
-                .then(|| vec![self.source.clone().into_owned()])
+                .then(|| vec![self.source.as_str().to_string()])
                 .unwrap_or_default(),
             mappings,
             names,