feat(napi/parser): introduce experimental magic string

Cargo.toml

@@ -123,7 +123,7 @@ unicode-id-start = "1"
 oxc-browserslist = "1.1.0"
 oxc_index = "2"
 oxc_resolver = "2.1.1"
-oxc_sourcemap = "1.0.3"
+oxc_sourcemap = "1"
 
 #
 allocator-api2 = "0.2.21"

napi/parser/Cargo.toml

@@ -26,7 +26,10 @@ oxc_ast = { workspace = true, features = ["serialize"] } # enable feature only
 oxc_napi = { workspace = true }
 
 rustc-hash = { workspace = true }
+self_cell = "1.0.4"
 serde_json = { workspace = true }
+string_wizard = { version = "0.0.23", features = ["sourcemap"] }
+# oxc_sourcemap = { workspace = true, features = ["napi"] }
 
 napi = { workspace = true, features = ["async"] }
 napi-derive = { workspace = true }

napi/parser/bindings.js

@@ -361,6 +361,8 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
+module.exports.MagicString = nativeBinding.MagicString
+module.exports.ParseResult = nativeBinding.ParseResult
 module.exports.ExportExportNameKind = nativeBinding.ExportExportNameKind
 module.exports.ExportImportNameKind = nativeBinding.ExportImportNameKind
 module.exports.ExportLocalNameKind = nativeBinding.ExportLocalNameKind

napi/parser/index.d.ts

@@ -2,6 +2,29 @@
 /* eslint-disable */
 
 export * from '@oxc-project/types';
+export declare class MagicString {
+  sourceText(start: number, end: number): string
+  length(): number
+  toString(): string
+  append(input: string): this
+  appendLeft(index: number, input: string): this
+  appendRight(index: number, input: string): this
+  indent(): this
+  prepend(input: string): this
+  prependLeft(index: number, input: string): this
+  prependRight(index: number, input: string): this
+  relocate(start: number, end: number, to: number): this
+  remove(start: number, end: number): this
+}
+
+export declare class ParseResult {
+  get program(): import("@oxc-project/types").Program
+  get module(): EcmaScriptModule
+  get comments(): Array<Comment>
+  get errors(): Array<Error>
+  get magicString(): MagicString
+}
+
 export interface Comment {
   type: 'Line' | 'Block'
   value: string
@@ -108,20 +131,17 @@ export declare const enum ImportNameKind {
   Default = 'Default'
 }
 
+export interface OverwriteOptions {
+  contentOnly: boolean
+}
+
 /**
  * Parse asynchronously.
  *
  * Note: This function can be slower than `parseSync` due to the overhead of spawning a thread.
  */
 export declare function parseAsync(filename: string, sourceText: string, options?: ParserOptions | undefined | null): Promise<ParseResult>
 
-export interface ParseResult {
-  program: import("@oxc-project/types").Program
-  module: EcmaScriptModule
-  comments: Array<Comment>
-  errors: Array<Error>
-}
-
 export interface ParserOptions {
   sourceType?: 'script' | 'module' | 'unambiguous' | undefined
   /** Treat the source text as `js`, `jsx`, `ts`, or `tsx`. */

napi/parser/index.js

@@ -1,14 +1,44 @@
 const bindings = require('./bindings.js');
 
+module.exports.MagicString = bindings.MagicString;
+module.exports.ParseResult = bindings.ParseResult;
+module.exports.ExportExportNameKind = bindings.ExportExportNameKind;
+module.exports.ExportImportNameKind = bindings.ExportImportNameKind;
+module.exports.ExportLocalNameKind = bindings.ExportLocalNameKind;
+module.exports.ImportNameKind = bindings.ImportNameKind;
 module.exports.parseWithoutReturn = bindings.parseWithoutReturn;
+module.exports.Severity = bindings.Severity;
+
+function wrap(result) {
+  let program, module, comments, errors, magicString;
+  return {
+    get program() {
+      if (!program) program = JSON.parse(result.program);
+      return program;
+    },
+    get module() {
+      if (!module) module = result.module;
+      return module;
+    },
+    get comments() {
+      if (!comments) comments = result.comments;
+      return comments;
+    },
+    get errors() {
+      if (!errors) errors = result.errors;
+      return errors;
+    },
+    get magicString() {
+      if (!magicString) magicString = result.magicString;
+      return magicString;
+    },
+  };
+}
 
 module.exports.parseAsync = async function parseAsync(...args) {
-  const result = await bindings.parseAsync(...args);
-  result.program = JSON.parse(result.program);
-  return result;
+  return wrap(await bindings.parseAsync(...args));
 };
+
 module.exports.parseSync = function parseSync(...args) {
-  const result = bindings.parseSync(...args);
-  result.program = JSON.parse(result.program);
-  return result;
+  return wrap(bindings.parseSync(...args));
 };

napi/parser/src/lib.rs

@@ -3,8 +3,11 @@
 )]
 
 mod convert;
+mod magic_string;
 mod types;
 
+use std::mem;
+
 use napi::{bindgen_prelude::AsyncTask, Task};
 use napi_derive::napi;
 
@@ -16,7 +19,10 @@ use oxc::{
 };
 use oxc_napi::Error;
 
-pub use crate::types::{Comment, EcmaScriptModule, ParseResult, ParserOptions};
+pub use crate::{
+    magic_string::MagicString,
+    types::{Comment, EcmaScriptModule, ParseResult, ParserOptions},
+};
 
 fn get_source_type(filename: &str, options: &ParserOptions) -> SourceType {
     match options.lang.as_deref() {
@@ -62,10 +68,10 @@ pub fn parse_without_return(filename: String, source_text: String, options: Opti
     parse(&allocator, source_type, &source_text, &options);
 }
 
-fn parse_with_return(filename: &str, source_text: &str, options: &ParserOptions) -> ParseResult {
+fn parse_with_return(filename: &str, source_text: String, options: &ParserOptions) -> ParseResult {
     let allocator = Allocator::default();
     let source_type = get_source_type(filename, options);
-    let ret = parse(&allocator, source_type, source_text, options);
+    let ret = parse(&allocator, source_type, &source_text, options);
     let program = serde_json::to_string(&ret.program).unwrap();
 
     let errors = ret.errors.into_iter().map(Error::from).collect::<Vec<_>>();
@@ -79,14 +85,14 @@ fn parse_with_return(filename: &str, source_text: &str, options: &ParserOptions)
                 CommentKind::Line => String::from("Line"),
                 CommentKind::Block => String::from("Block"),
             },
-            value: comment.content_span().source_text(source_text).to_string(),
+            value: comment.content_span().source_text(&source_text).to_string(),
             start: comment.span.start,
             end: comment.span.end,
         })
         .collect::<Vec<Comment>>();
 
     let module = EcmaScriptModule::from(&ret.module_record);
-    ParseResult { program, module, comments, errors }
+    ParseResult { source_text, program, module, comments, errors }
 }
 
 /// Parse synchronously.
@@ -97,7 +103,7 @@ pub fn parse_sync(
     options: Option<ParserOptions>,
 ) -> ParseResult {
     let options = options.unwrap_or_default();
-    parse_with_return(&filename, &source_text, &options)
+    parse_with_return(&filename, source_text, &options)
 }
 
 pub struct ResolveTask {
@@ -112,7 +118,8 @@ impl Task for ResolveTask {
     type Output = ParseResult;
 
     fn compute(&mut self) -> napi::Result<Self::Output> {
-        Ok(parse_with_return(&self.filename, &self.source_text, &self.options))
+        let source_text = mem::take(&mut self.source_text);
+        Ok(parse_with_return(&self.filename, source_text, &self.options))
     }
 
     fn resolve(&mut self, _: napi::Env, result: Self::Output) -> napi::Result<Self::JsValue> {