feat(playground): add inject and replace plugins (#13805)

Author: Boshen

Cargo.lock

@@ -27,6 +27,7 @@ oxc_formatter = { workspace = true }
 oxc_index = { workspace = true }
 oxc_linter = { workspace = true }
 oxc_napi = { workspace = true }
+oxc_transformer_plugins = { workspace = true }
 
 napi = { workspace = true, features = ["async"] }
 napi-derive = { workspace = true }

napi/playground/Cargo.toml

@@ -63,6 +63,16 @@ export interface OxcControlFlowOptions {
   verbose?: boolean
 }
 
+export interface OxcDefineOptions {
+  /** Map of variable name to value for replacement */
+  define: Record<string, string>
+}
+
+export interface OxcInjectOptions {
+  /** Map of variable name to module source or [source, specifier] */
+  inject: Record<string, string | [string, string]>
+}
+
 export interface OxcIsolatedDeclarationsOptions {
   stripInternal: boolean
 }
@@ -86,6 +96,8 @@ export interface OxcOptions {
   compress?: OxcCompressOptions
   mangle?: OxcMangleOptions
   controlFlow?: OxcControlFlowOptions
+  inject?: OxcInjectOptions
+  define?: OxcDefineOptions
 }
 
 export interface OxcParserOptions {

napi/playground/index.d.ts

@@ -7,6 +7,7 @@ use std::{
 use options::OxcCodegenOptions;
 use rustc_hash::FxHashMap;
 
+use napi::Either;
 use napi_derive::napi;
 use serde::Serialize;
 
@@ -35,8 +36,15 @@ use oxc_linter::{
     ModuleRecord, Oxlintrc,
 };
 use oxc_napi::{Comment, OxcError, convert_utf8_to_utf16};
+use oxc_transformer_plugins::{
+    InjectGlobalVariables, InjectGlobalVariablesConfig, InjectImport, ReplaceGlobalDefines,
+    ReplaceGlobalDefinesConfig,
+};
 
-use crate::options::{OxcLinterOptions, OxcOptions, OxcRunOptions};
+use crate::options::{
+    OxcControlFlowOptions, OxcDefineOptions, OxcInjectOptions, OxcIsolatedDeclarationsOptions,
+    OxcLinterOptions, OxcOptions, OxcParserOptions, OxcRunOptions, OxcTransformerOptions,
+};
 
 mod options;
 
@@ -97,12 +105,16 @@ impl Oxc {
             control_flow: ref control_flow_options,
             isolated_declarations: ref isolated_declarations_options,
             codegen: ref codegen_options,
+            inject: ref inject_options,
+            define: ref define_options,
             ..
         } = options;
         let linter_options = linter_options.clone().unwrap_or_default();
         let transform_options = transform_options.clone().unwrap_or_default();
         let control_flow_options = control_flow_options.clone().unwrap_or_default();
         let codegen_options = codegen_options.clone().unwrap_or_default();
+        let inject_options = inject_options.clone();
+        let define_options = define_options.clone();
 
         let allocator = Allocator::default();
 
@@ -139,7 +151,7 @@ impl Oxc {
         };
         self.run_formatter(run_options, parse_options, &source_text, source_type);
 
-        let scoping = semantic.into_scoping();
+        let mut scoping = semantic.into_scoping();
 
         // Extract scope and symbol information if needed
         if !source_type.is_typescript_definition() {
@@ -164,9 +176,17 @@ impl Oxc {
             return Ok(());
         }
 
+        // Phase 5.5: Apply ReplaceGlobalDefines (before transformations)
+        if let Some(define_opts) = define_options {
+            let define_config = Self::build_define_config(&define_opts)?;
+            let ret =
+                ReplaceGlobalDefines::new(&allocator, define_config).build(scoping, &mut program);
+            scoping = ret.scoping;
+        }
+
         // Phase 6: Apply transformations
         if run_options.transform {
-            self.apply_transformations(
+            scoping = self.apply_transformations(
                 &allocator,
                 &path,
                 &mut program,
@@ -175,6 +195,13 @@ impl Oxc {
             );
         }
 
+        // Phase 6.5: Apply InjectGlobalVariables (after transformations)
+        if let Some(inject_opts) = inject_options {
+            let inject_config = Self::build_inject_config(&inject_opts)?;
+            let _ =
+                InjectGlobalVariables::new(&allocator, inject_config).build(scoping, &mut program);
+        }
+
         // Phase 7: Apply minification
         let scoping = Self::apply_minification(&allocator, &mut program, &options);
 
@@ -192,7 +219,7 @@ impl Oxc {
         allocator: &'a Allocator,
         source_text: &'a str,
         source_type: SourceType,
-        parser_options: &crate::options::OxcParserOptions,
+        parser_options: &OxcParserOptions,
     ) -> (Program<'a>, oxc::syntax::module_record::ModuleRecord<'a>) {
         let parser_options = ParseOptions {
             parse_regular_expression: true,
@@ -210,7 +237,7 @@ impl Oxc {
         &mut self,
         program: &'a Program<'a>,
         run_options: &OxcRunOptions,
-        control_flow_options: &crate::options::OxcControlFlowOptions,
+        control_flow_options: &OxcControlFlowOptions,
     ) -> oxc::semantic::Semantic<'a> {
         let mut semantic_builder = SemanticBuilder::new();
         if run_options.transform {
@@ -238,7 +265,7 @@ impl Oxc {
         program: &Program<'a>,
         run_options: &OxcRunOptions,
         codegen_options: &OxcCodegenOptions,
-        isolated_declarations_options: Option<crate::options::OxcIsolatedDeclarationsOptions>,
+        isolated_declarations_options: Option<OxcIsolatedDeclarationsOptions>,
     ) {
         let id_options = isolated_declarations_options
             .map(|o| IsolatedDeclarationsOptions { strip_internal: o.strip_internal })
@@ -259,7 +286,7 @@ impl Oxc {
         path: &Path,
         program: &mut Program<'a>,
         scoping: Scoping,
-        transform_options: &crate::options::OxcTransformerOptions,
+        transform_options: &OxcTransformerOptions,
     ) -> Scoping {
         let mut options = transform_options
             .target
@@ -493,6 +520,49 @@ impl Oxc {
         writer.scope_text
     }
 
+    fn build_inject_config(
+        inject_opts: &OxcInjectOptions,
+    ) -> napi::Result<InjectGlobalVariablesConfig> {
+        let mut imports = Vec::new();
+
+        for (local, value) in &inject_opts.inject {
+            let import = match value {
+                Either::A(source) => InjectImport::default_specifier(source, local),
+                Either::B(v) => {
+                    if v.len() != 2 {
+                        return Err(napi::Error::from_reason(
+                            "Inject plugin did not receive a tuple [string, string].",
+                        ));
+                    }
+                    let source = &v[0];
+                    if v[1] == "*" {
+                        InjectImport::namespace_specifier(source, local)
+                    } else {
+                        InjectImport::named_specifier(source, Some(&v[1]), local)
+                    }
+                }
+            };
+            imports.push(import);
+        }
+
+        Ok(InjectGlobalVariablesConfig::new(imports))
+    }
+
+    fn build_define_config(
+        define_opts: &OxcDefineOptions,
+    ) -> napi::Result<ReplaceGlobalDefinesConfig> {
+        let define_pairs: Vec<(String, String)> =
+            define_opts.define.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
+
+        ReplaceGlobalDefinesConfig::new(&define_pairs).map_err(|errors| {
+            let error_messages: Vec<String> = errors.iter().map(ToString::to_string).collect();
+            napi::Error::from_reason(format!(
+                "Invalid define config: {}",
+                error_messages.join(", ")
+            ))
+        })
+    }
+
     fn get_symbols_text(scoping: &Scoping) -> napi::Result<String> {
         #[derive(Serialize)]
         struct Data {

napi/playground/src/lib.rs

@@ -1,4 +1,6 @@
+use napi::Either;
 use napi_derive::napi;
+use rustc_hash::FxHashMap;
 
 #[napi(object)]
 #[derive(Default)]
@@ -12,6 +14,8 @@ pub struct OxcOptions {
     pub compress: Option<OxcCompressOptions>,
     pub mangle: Option<OxcMangleOptions>,
     pub control_flow: Option<OxcControlFlowOptions>,
+    pub inject: Option<OxcInjectOptions>,
+    pub define: Option<OxcDefineOptions>,
 }
 
 #[napi(object)]
@@ -53,6 +57,22 @@ pub struct OxcTransformerOptions {
     pub emit_decorator_metadata: bool,
 }
 
+#[napi(object)]
+#[derive(Default, Clone)]
+pub struct OxcInjectOptions {
+    /// Map of variable name to module source or [source, specifier]
+    #[napi(ts_type = "Record<string, string | [string, string]>")]
+    pub inject: FxHashMap<String, Either<String, Vec<String>>>,
+}
+
+#[napi(object)]
+#[derive(Default, Clone)]
+pub struct OxcDefineOptions {
+    /// Map of variable name to value for replacement
+    #[napi(ts_type = "Record<string, string>")]
+    pub define: FxHashMap<String, String>,
+}
+
 #[napi(object)]
 #[derive(Default, Clone)]
 pub struct OxcIsolatedDeclarationsOptions {