Use usize as the TextSize

Author: hyf0

src/chunk.rs

@@ -1,6 +1,6 @@
-use std::{borrow::Cow, collections::VecDeque};
+use std::collections::VecDeque;
 
-use crate::{span::Span, ChunkIdx, CowStr};
+use crate::{span::Span, ChunkIdx, CowStr, TextSize};
 
 #[derive(Debug, Default)]
 pub struct Chunk<'str> {
@@ -21,15 +21,15 @@ impl<'s> Chunk<'s> {
 }
 
 impl<'str> Chunk<'str> {
-    pub fn start(&self) -> u32 {
+    pub fn start(&self) -> TextSize {
         self.span.start()
     }
 
-    pub fn end(&self) -> u32 {
+    pub fn end(&self) -> TextSize {
         self.span.end()
     }
 
-    pub fn contains(&self, text_index: u32) -> bool {
+    pub fn contains(&self, text_index: TextSize) -> bool {
         self.start() < text_index && text_index < self.end()
     }
 
@@ -49,7 +49,7 @@ impl<'str> Chunk<'str> {
         self.intro.push_front(content)
     }
 
-    pub fn split<'a>(&'a mut self, text_index: u32) -> Chunk<'str> {
+    pub fn split<'a>(&'a mut self, text_index: TextSize) -> Chunk<'str> {
         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);

src/lib.rs

@@ -3,6 +3,9 @@ mod chunk;
 mod span;
 mod joiner;
 mod magic_string;
+mod mappings;
+mod locator;
+
 use std::borrow::Cow;
 
 type CowStr<'s> = Cow<'s, str>;
@@ -23,4 +26,4 @@ index_vec::define_index_type! {
     struct SourceIdx = u32;
 }
 
-pub(crate) type TextSize = u32;
+pub(crate) type TextSize = usize;

src/locator.rs

@@ -0,0 +1,38 @@
+pub struct Locator {
+    line_offsets: Box<[usize]>,
+}
+
+impl Locator {
+    pub fn new(source: &str) -> Self {
+        let mut line_offsets = vec![];
+        let mut line_start_pos = 0;
+        for line in source.lines() {
+            line_offsets.push(line_start_pos);
+            line_start_pos += 1 + line.len();
+        }
+        Self {
+            line_offsets: line_offsets.into_boxed_slice(),
+        }
+    }
+
+    pub fn locate(&self, index: usize) -> Location {
+        let mut left_cursor = 0;
+        let mut right_cursor = self.line_offsets.len();
+        while left_cursor < right_cursor {
+            let mid = (left_cursor + right_cursor) >> 1;
+            if index < self.line_offsets[mid] {
+                right_cursor = mid;
+            } else {
+                left_cursor = mid + 1;
+            }
+        }
+        let line = left_cursor - 1;
+        let column = index - self.line_offsets[line];
+        Location { line, column }
+    }
+}
+
+pub struct Location {
+    pub line: usize,
+    pub column: usize,
+}

src/magic_string.rs

@@ -2,7 +2,10 @@ use std::collections::VecDeque;
 
 use rustc_hash::FxHashMap;
 
-use crate::{chunk::Chunk, span::Span, ChunkIdx, ChunkVec, CowStr, TextSize};
+use crate::{
+    chunk::Chunk, locator::Locator, mappings::Mappings, span::Span, ChunkIdx, ChunkVec, CowStr,
+    TextSize,
+};
 
 #[derive(Debug, Default)]
 pub struct MagicStringOptions {
@@ -15,12 +18,11 @@ pub struct MagicString<'s> {
     outro: VecDeque<CowStr<'s>>,
 
     source: CowStr<'s>,
-    source_len: u32,
     chunks: ChunkVec<'s>,
     first_chunk_idx: ChunkIdx,
     last_chunk_idx: ChunkIdx,
-    chunk_by_start: FxHashMap<u32, ChunkIdx>,
-    chunk_by_end: FxHashMap<u32, ChunkIdx>,
+    chunk_by_start: FxHashMap<TextSize, ChunkIdx>,
+    chunk_by_end: FxHashMap<TextSize, ChunkIdx>,
 }
 
 impl<'s> MagicString<'s> {
@@ -32,15 +34,13 @@ impl<'s> MagicString<'s> {
 
     pub fn with_options(source: impl Into<CowStr<'s>>, options: MagicStringOptions) -> Self {
         let source = source.into();
-        let source_len: u32 = source.len().try_into().expect("source is too big");
-        let initial_chunk = Chunk::new(Span(0, source_len));
+        let initial_chunk = Chunk::new(Span(0, source.len()));
         let mut chunks = ChunkVec::with_capacity(1);
         let initial_chunk_idx = chunks.push(initial_chunk);
         let mut magic_string = Self {
             intro: Default::default(),
             outro: Default::default(),
             source,
-            source_len,
             first_chunk_idx: initial_chunk_idx,
             last_chunk_idx: initial_chunk_idx,
             chunks,
@@ -53,7 +53,7 @@ impl<'s> MagicString<'s> {
         magic_string.chunk_by_start.insert(0, initial_chunk_idx);
         magic_string
             .chunk_by_end
-            .insert(source_len, initial_chunk_idx);
+            .insert(magic_string.source.len(), initial_chunk_idx);
 
         magic_string
     }
@@ -71,7 +71,11 @@ impl<'s> MagicString<'s> {
     /// s.append_left(2, "b");
     /// assert_eq!(s.to_string(), "01ab234")
     ///```
-    pub fn append_left(&mut self, text_index: u32, content: impl Into<CowStr<'s>>) -> &mut Self {
+    pub fn append_left(
+        &mut self,
+        text_index: TextSize,
+        content: impl Into<CowStr<'s>>,
+    ) -> &mut Self {
         match self.by_end_mut(text_index) {
             Some(chunk) => {
                 chunk.append_outro(content.into());
@@ -91,7 +95,11 @@ impl<'s> MagicString<'s> {
     /// s.append_left(2, "b");
     /// assert_eq!(s.to_string(), "01abAB234")
     ///```
-    pub fn append_right(&mut self, text_index: u32, content: impl Into<CowStr<'s>>) -> &mut Self {
+    pub fn append_right(
+        &mut self,
+        text_index: TextSize,
+        content: impl Into<CowStr<'s>>,
+    ) -> &mut Self {
         match self.by_start_mut(text_index) {
             Some(chunk) => {
                 chunk.append_intro(content.into());
@@ -143,12 +151,12 @@ impl<'s> MagicString<'s> {
         ret
     }
 
-    pub fn remove(&mut self, start: u32, end: u32) -> &mut Self {
+    pub fn remove(&mut self, start: TextSize, end: TextSize) -> &mut Self {
         if start == end {
             return self;
         }
-        
-        assert!(end <= self.source_len, "end is out of bounds");
+
+        assert!(end <= self.source.len(), "end is out of bounds");
         assert!(start < end, "end must be greater than start");
 
         self.split_at(start);
@@ -171,6 +179,19 @@ 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>>) {
@@ -218,7 +239,7 @@ impl<'s> MagicString<'s> {
             return;
         }
 
-        let mut target = if (self.source_len - text_index) > text_index {
+        let mut target = if (self.source.len() - text_index) > text_index {
             self.first_chunk()
         } else {
             self.last_chunk()
@@ -255,7 +276,7 @@ impl<'s> MagicString<'s> {
     }
 
     fn by_start_mut(&mut self, text_index: TextSize) -> Option<&mut Chunk<'s>> {
-        if text_index == self.source_len {
+        if text_index == self.source.len() {
             None
         } else {
             self.split_at(text_index);

src/mappings.rs

@@ -0,0 +1,24 @@
+
+
+#[derive(Debug, Default)]
+pub struct Mappings {
+    generated_code_line: usize,
+    generated_code_column: usize,
+}
+
+impl Mappings {
+    pub fn advance(&mut self, content: &str) {
+        if content.is_empty() {
+            return;
+        }
+        let mut lines = content.lines();
+        // SAFETY: The content at least has one line after checking of `content.is_empty()` .
+        // `"\n".lines().collect::<Vec<_>>()` would create `[""]`.
+        let last_line = unsafe { lines.next_back().unwrap_unchecked() };
+        for _ in lines {
+            self.generated_code_line += 1;
+            self.generated_code_column = 0;
+        }
+        self.generated_code_column += last_line.len();
+    }
+}

src/source_map.rs

@@ -1,20 +1,18 @@
+use crate::TextSize;
+
 #[derive(Debug, Default, Clone, Copy)]
-pub struct Span(pub u32, pub u32);
+pub struct Span(pub TextSize, pub TextSize);
 
 impl Span {
-    pub fn start(&self) -> u32 {
+    pub fn start(&self) -> TextSize {
         self.0
     }
 
-    pub fn end(&self) -> u32 {
+    pub fn end(&self) -> TextSize {
         self.1
     }
 
     pub fn text<'s>(&self, source: &'s str) -> &'s str {
-        &source[self.start() as usize..self.end() as usize]
+        &source[self.start()..self.end()]
     }
-
-    // pub fn size(&self) -> usize {
-    //     (self.1 - self.0) as usize
-    // }
 }