feat(next-core): port remaining next.js custom transforms

packages/next-swc/crates/next-core/Cargo.toml

@@ -33,6 +33,7 @@ futures = { workspace = true }
 lazy_static = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
+rustc-hash = { workspace = true }
 turbopack-binding = { workspace = true, features = [
   "__swc_transform_modularize_imports",
   "__swc_transform_relay",

packages/next-swc/crates/next-core/src/next_client/transforms.rs

@@ -10,7 +10,11 @@ use crate::{
     next_shared::transforms::{
         get_next_dynamic_transform_rule, get_next_font_transform_rule, get_next_image_rule,
         get_next_modularize_imports_rule, get_next_pages_transforms_rule,
-        get_server_actions_transform_rule, server_actions::ActionsTransform,
+        get_server_actions_transform_rule, next_amp_attributes::get_next_amp_attr_rule,
+        next_cjs_optimizer::get_next_cjs_optimizer_rule,
+        next_disallow_re_export_all_in_page::get_next_disallow_export_all_in_page_rule,
+        next_page_config::get_next_page_config_rule, next_pure::get_next_pure_rule,
+        server_actions::ActionsTransform,
     },
 };
 
@@ -52,6 +56,15 @@ pub async fn get_next_client_transforms_rules(
         ClientContextType::Fallback | ClientContextType::Other => None,
     };
 
+    rules.push(get_next_amp_attr_rule(mdx_rs));
+    rules.push(get_next_cjs_optimizer_rule(mdx_rs));
+    rules.push(get_next_disallow_export_all_in_page_rule(
+        mdx_rs,
+        pages_dir.is_some(),
+    ));
+    rules.push(get_next_page_config_rule(mdx_rs, pages_dir.is_some()));
+    rules.push(get_next_pure_rule(mdx_rs));
+
     rules.push(get_next_dynamic_transform_rule(false, false, pages_dir, mode, mdx_rs).await?);
 
     rules.push(get_next_image_rule());

packages/next-swc/crates/next-core/src/next_server/transforms.rs

@@ -11,7 +11,10 @@ use crate::{
     next_shared::transforms::{
         get_next_dynamic_transform_rule, get_next_font_transform_rule, get_next_image_rule,
         get_next_modularize_imports_rule, get_next_pages_transforms_rule,
-        get_server_actions_transform_rule,
+        get_server_actions_transform_rule, next_amp_attributes::get_next_amp_attr_rule,
+        next_cjs_optimizer::get_next_cjs_optimizer_rule,
+        next_disallow_re_export_all_in_page::get_next_disallow_export_all_in_page_rule,
+        next_pure::get_next_pure_rule,
         next_react_server_components::get_next_react_server_components_transform_rule,
         server_actions::ActionsTransform,
     },
@@ -85,6 +88,19 @@ pub async fn get_next_server_transforms_rules(
             .await?,
     );
 
+    rules.push(get_next_amp_attr_rule(mdx_rs));
+    rules.push(get_next_cjs_optimizer_rule(mdx_rs));
+    rules.push(get_next_disallow_export_all_in_page_rule(
+        mdx_rs,
+        pages_dir.is_some(),
+    ));
+    rules.push(get_next_pure_rule(mdx_rs));
+
+    // [NOTE]: this rule only works in prod config
+    // https://github.com/vercel/next.js/blob/a1d0259ea06592c5ca6df882e9b1d0d0121c5083/packages/next/src/build/swc/options.ts#L409
+    // rules.push(get_next_optimize_server_react_rule(enable_mdx_rs,
+    // optimize_use_state))
+
     rules.push(get_next_image_rule());
 
     Ok(rules)

packages/next-swc/crates/next-core/src/next_shared/transforms/mod.rs

@@ -1,8 +1,15 @@
 pub(crate) mod emotion;
 pub(crate) mod modularize_imports;
+pub(crate) mod next_amp_attributes;
+pub(crate) mod next_cjs_optimizer;
+pub(crate) mod next_disallow_re_export_all_in_page;
 pub(crate) mod next_dynamic;
 pub(crate) mod next_font;
+pub(crate) mod next_optimize_server_react;
+pub(crate) mod next_page_config;
+pub(crate) mod next_pure;
 pub(crate) mod next_react_server_components;
+pub(crate) mod next_shake_exports;
 pub(crate) mod next_strip_page_exports;
 pub(crate) mod relay;
 pub(crate) mod server_actions;

packages/next-swc/crates/next-core/src/next_shared/transforms/next_amp_attributes.rs

@@ -0,0 +1,39 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use next_custom_transforms::transforms::amp_attributes::amp_attributes;
+use turbo_tasks::Vc;
+use turbopack_binding::{
+    swc::core::{
+        common::util::take::Take,
+        ecma::{ast::*, visit::FoldWith},
+    },
+    turbopack::{
+        ecmascript::{CustomTransformer, EcmascriptInputTransform, TransformContext},
+        turbopack::module_options::{ModuleRule, ModuleRuleEffect},
+    },
+};
+
+use super::module_rule_match_js_no_url;
+
+pub fn get_next_amp_attr_rule(enable_mdx_rs: bool) -> ModuleRule {
+    let transformer =
+        EcmascriptInputTransform::Plugin(Vc::cell(Box::new(NextAmpAttributes {}) as _));
+    ModuleRule::new(
+        module_rule_match_js_no_url(enable_mdx_rs),
+        vec![ModuleRuleEffect::AddEcmascriptTransforms(Vc::cell(vec![
+            transformer,
+        ]))],
+    )
+}
+
+#[derive(Debug)]
+struct NextAmpAttributes {}
+
+#[async_trait]
+impl CustomTransformer for NextAmpAttributes {
+    async fn transform(&self, program: &mut Program, _ctx: &TransformContext<'_>) -> Result<()> {
+        let p = std::mem::replace(program, Program::Module(Module::dummy()));
+        *program = p.fold_with(&mut amp_attributes());
+        Ok(())
+    }
+}

packages/next-swc/crates/next-core/src/next_shared/transforms/next_cjs_optimizer.rs

@@ -0,0 +1,79 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use next_custom_transforms::transforms::cjs_optimizer::{cjs_optimizer, Config, PackageConfig};
+use rustc_hash::FxHashMap;
+use turbo_tasks::Vc;
+use turbopack_binding::{
+    swc::core::{
+        common::SyntaxContext,
+        ecma::{ast::*, visit::VisitMutWith},
+    },
+    turbopack::{
+        ecmascript::{CustomTransformer, EcmascriptInputTransform, TransformContext},
+        turbopack::module_options::{ModuleRule, ModuleRuleEffect},
+    },
+};
+
+use super::module_rule_match_js_no_url;
+
+pub fn get_next_cjs_optimizer_rule(enable_mdx_rs: bool) -> ModuleRule {
+    // [NOTE]: This isn't user configurable config
+    // (https://github.com/vercel/next.js/blob/a1d0259ea06592c5ca6df882e9b1d0d0121c5083/packages/next/src/build/swc/options.ts#L395)
+    // build it internally without accepting customization.
+    let config = Config {
+        packages: FxHashMap::from_iter([(
+            "next/server".to_string(),
+            PackageConfig {
+                transforms: FxHashMap::from_iter([
+                    (
+                        "NextRequest".into(),
+                        "next/dist/server/web/spec-extension/request".into(),
+                    ),
+                    (
+                        "NextResponse".into(),
+                        "next/dist/server/web/spec-extension/response".into(),
+                    ),
+                    (
+                        "ImageResponse".into(),
+                        "next/dist/server/web/spec-extension/image-response".into(),
+                    ),
+                    (
+                        "userAgentFromString".into(),
+                        "next/dist/server/web/spec-extension/user-agent".into(),
+                    ),
+                    (
+                        "userAgent".into(),
+                        "next/dist/server/web/spec-extension/user-agent".into(),
+                    ),
+                ]),
+            },
+        )]),
+    };
+
+    let transformer =
+        EcmascriptInputTransform::Plugin(Vc::cell(Box::new(NextCjsOptimizer { config }) as _));
+    ModuleRule::new(
+        module_rule_match_js_no_url(enable_mdx_rs),
+        vec![ModuleRuleEffect::AddEcmascriptTransforms(Vc::cell(vec![
+            transformer,
+        ]))],
+    )
+}
+
+#[derive(Debug)]
+struct NextCjsOptimizer {
+    config: Config,
+}
+
+#[async_trait]
+impl CustomTransformer for NextCjsOptimizer {
+    async fn transform(&self, program: &mut Program, ctx: &TransformContext<'_>) -> Result<()> {
+        let mut visitor = cjs_optimizer(
+            self.config.clone(),
+            SyntaxContext::empty().apply_mark(ctx.unresolved_mark),
+        );
+
+        program.visit_mut_with(&mut visitor);
+        Ok(())
+    }
+}

packages/next-swc/crates/next-core/src/next_shared/transforms/next_disallow_re_export_all_in_page.rs

@@ -0,0 +1,46 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use next_custom_transforms::transforms::disallow_re_export_all_in_page::disallow_re_export_all_in_page;
+use turbo_tasks::Vc;
+use turbopack_binding::{
+    swc::core::{
+        common::util::take::Take,
+        ecma::{ast::*, visit::FoldWith},
+    },
+    turbopack::{
+        ecmascript::{CustomTransformer, EcmascriptInputTransform, TransformContext},
+        turbopack::module_options::{ModuleRule, ModuleRuleEffect},
+    },
+};
+
+use super::module_rule_match_js_no_url;
+
+pub fn get_next_disallow_export_all_in_page_rule(
+    enable_mdx_rs: bool,
+    is_page_file: bool,
+) -> ModuleRule {
+    let transformer =
+        EcmascriptInputTransform::Plugin(Vc::cell(Box::new(NextDisallowReExportAllInPage {
+            is_page_file,
+        }) as _));
+    ModuleRule::new(
+        module_rule_match_js_no_url(enable_mdx_rs),
+        vec![ModuleRuleEffect::AddEcmascriptTransforms(Vc::cell(vec![
+            transformer,
+        ]))],
+    )
+}
+
+#[derive(Debug)]
+struct NextDisallowReExportAllInPage {
+    is_page_file: bool,
+}
+
+#[async_trait]
+impl CustomTransformer for NextDisallowReExportAllInPage {
+    async fn transform(&self, program: &mut Program, _ctx: &TransformContext<'_>) -> Result<()> {
+        let p = std::mem::replace(program, Program::Module(Module::dummy()));
+        *program = p.fold_with(&mut disallow_re_export_all_in_page(self.is_page_file));
+        Ok(())
+    }
+}

packages/next-swc/crates/next-core/src/next_shared/transforms/next_optimize_server_react.rs

@@ -0,0 +1,50 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use next_custom_transforms::transforms::optimize_server_react::{optimize_server_react, Config};
+use turbo_tasks::Vc;
+use turbopack_binding::{
+    swc::core::{
+        common::util::take::Take,
+        ecma::{ast::*, visit::FoldWith},
+    },
+    turbopack::{
+        ecmascript::{CustomTransformer, EcmascriptInputTransform, TransformContext},
+        turbopack::module_options::{ModuleRule, ModuleRuleEffect},
+    },
+};
+
+use super::module_rule_match_js_no_url;
+
+#[allow(dead_code)]
+pub fn get_next_optimize_server_react_rule(
+    enable_mdx_rs: bool,
+    optimize_use_state: bool,
+) -> ModuleRule {
+    let transformer =
+        EcmascriptInputTransform::Plugin(Vc::cell(Box::new(NextOptimizeServerReact {
+            optimize_use_state,
+        }) as _));
+    ModuleRule::new(
+        module_rule_match_js_no_url(enable_mdx_rs),
+        vec![ModuleRuleEffect::AddEcmascriptTransforms(Vc::cell(vec![
+            transformer,
+        ]))],
+    )
+}
+
+#[derive(Debug)]
+struct NextOptimizeServerReact {
+    optimize_use_state: bool,
+}
+
+#[async_trait]
+impl CustomTransformer for NextOptimizeServerReact {
+    async fn transform(&self, program: &mut Program, _ctx: &TransformContext<'_>) -> Result<()> {
+        let p = std::mem::replace(program, Program::Module(Module::dummy()));
+
+        *program = p.fold_with(&mut optimize_server_react(Config {
+            optimize_use_state: self.optimize_use_state,
+        }));
+        Ok(())
+    }
+}

packages/next-swc/crates/next-core/src/next_shared/transforms/next_page_config.rs

@@ -0,0 +1,46 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use next_custom_transforms::transforms::page_config::page_config;
+use turbo_tasks::Vc;
+use turbopack_binding::{
+    swc::core::{
+        common::util::take::Take,
+        ecma::{ast::*, visit::FoldWith},
+    },
+    turbopack::{
+        ecmascript::{CustomTransformer, EcmascriptInputTransform, TransformContext},
+        turbopack::module_options::{ModuleRule, ModuleRuleEffect},
+    },
+};
+
+use super::module_rule_match_js_no_url;
+
+pub fn get_next_page_config_rule(enable_mdx_rs: bool, is_page_file: bool) -> ModuleRule {
+    let transformer = EcmascriptInputTransform::Plugin(Vc::cell(Box::new(NextPageConfig {
+        // [TODO]: update once turbopack build works
+        is_development: true,
+        is_page_file,
+    }) as _));
+    ModuleRule::new(
+        module_rule_match_js_no_url(enable_mdx_rs),
+        vec![ModuleRuleEffect::AddEcmascriptTransforms(Vc::cell(vec![
+            transformer,
+        ]))],
+    )
+}
+
+#[derive(Debug)]
+struct NextPageConfig {
+    is_development: bool,
+    is_page_file: bool,
+}
+
+#[async_trait]
+impl CustomTransformer for NextPageConfig {
+    async fn transform(&self, program: &mut Program, _ctx: &TransformContext<'_>) -> Result<()> {
+        let p = std::mem::replace(program, Program::Module(Module::dummy()));
+
+        *program = p.fold_with(&mut page_config(self.is_development, self.is_page_file));
+        Ok(())
+    }
+}

packages/next-swc/crates/next-core/src/next_shared/transforms/next_pure.rs

@@ -0,0 +1,34 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use next_custom_transforms::transforms::pure::pure_magic;
+use turbo_tasks::Vc;
+use turbopack_binding::{
+    swc::core::ecma::{ast::*, visit::VisitMutWith},
+    turbopack::{
+        ecmascript::{CustomTransformer, EcmascriptInputTransform, TransformContext},
+        turbopack::module_options::{ModuleRule, ModuleRuleEffect},
+    },
+};
+
+use super::module_rule_match_js_no_url;
+
+pub fn get_next_pure_rule(enable_mdx_rs: bool) -> ModuleRule {
+    let transformer = EcmascriptInputTransform::Plugin(Vc::cell(Box::new(NextPure {}) as _));
+    ModuleRule::new(
+        module_rule_match_js_no_url(enable_mdx_rs),
+        vec![ModuleRuleEffect::AddEcmascriptTransforms(Vc::cell(vec![
+            transformer,
+        ]))],
+    )
+}
+
+#[derive(Debug)]
+struct NextPure {}
+
+#[async_trait]
+impl CustomTransformer for NextPure {
+    async fn transform(&self, program: &mut Program, ctx: &TransformContext<'_>) -> Result<()> {
+        program.visit_mut_with(&mut pure_magic(ctx.comments.clone()));
+        Ok(())
+    }
+}