@ohos-ports/jest_workaround 0.79.19-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) magic-akari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# [SWC plugin] workaround for jest
+
+[![Crates.io](https://img.shields.io/crates/v/jest_workaround)](https://crates.io/crates/jest_workaround)
+[![npm](https://img.shields.io/npm/v/jest_workaround)](https://www.npmjs.com/package/jest_workaround)
+
+[![Test](https://github.com/magic-akari/jest_workaround/actions/workflows/test.yml/badge.svg)](https://github.com/magic-akari/jest_workaround/actions/workflows/test.yml)
+[![with @swc/core@latest](https://github.com/magic-akari/jest_workaround/actions/workflows/cron.yml/badge.svg)](https://github.com/magic-akari/jest_workaround/actions/workflows/cron.yml)
+
+This is a SWC plugin to handle jest compatibility issues.
+
+This SWC plugin should be used with `@swc/jest`.
+
+## plugin version
+
+https://swc.rs/docs/plugin/selecting-swc-core
+
+## usage
+
+install
+
+```bash
+npm i -D jest @swc/core @swc/jest jest_workaround
+```
+
+```js
+// jest.config.js
+const fs = require("node:fs");
+
+const swcrc = JSON.parse(fs.readFileSync(".swcrc", "utf8"));
+
+// If you have other plugins, change this line.
+((swcrc.jsc ??= {}).experimental ??= {}).plugins = [["jest_workaround", {}]];
+
+module.exports = {
+  transform: {
+    "^.+\\.(t|j)sx?$": ["@swc/jest", swcrc],
+  },
+};
+```
+
+Make sure that `module.type` is `commonjs` in your `.swcrc` since this plugin
+does not touch non-workaround parts, such as import statements.
+
+## FAQ
+
+#### 1. When do I need this?
+
+If you're using the swc compiler to transform your code to comply with the ESM
+specification, but you're also using Jest to test it in a CJS environment, you
+may encounter issues due to the immutable issue of `exports`.
+
+This plugin can help by transforming the `export` statements into mutable
+`exports`.
+
+#### 2. Do I have a better choice?
+
+You may have other options depending on your specific needs:
+
+- If you're able to run Jest in an ESM environment, you can use swc to transpile
+  TypeScript/JSX syntax or downgrade JavaScript syntax without module
+  conversion. Simply set the value of `module.type` to `es6` to achieve this.
+
+- It's possible that some issues related to running Jest in an ESM environment
+  will be resolved over time. Keep an eye on
+  [facebook/jest#9430](https://github.com/facebook/jest/issues/9430) for
+  updates.
+
+- If you don't need the behavior of ESM specifically, you can stick with the CJS
+  syntax to get the CJS behavior of `exports`.
+
+These options may be worth considering before using this plugin.
+
+CJS syntax
+
+```JavaScript
+exports.foo = function foo() {
+  return 42;
+};
+```
+
+CTS(CJS in TypeScript) syntax
+
+```TypeScript
+export = {
+  foo: function foo() {
+    return 42;
+  },
+};
+```
+
+Notes:
+
+- ESM style export means immutable exports when transformed into CJS
+- ESM style import means hoisted require when transformed into CJS
+
+#### 3. After upgrading the plugin version, the changes have not taken effect.
+
+This is a known issue. You could remove the Jest cache by running
+[`jest --clearCache`](https://jestjs.io/docs/cli#--clearcache) as a workaround.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@ohos-ports/jest_workaround",
+  "version": "0.79.19-beta.0",
+  "description": "[SWC plugin] workaround for jest",
+  "author": "magic-akari <akari.ccino@gmail.com>",
+  "license": "MIT",
+  "keywords": [
+    "swc-plugin",
+    "jest"
+  ],
+  "scripts": {
+    "test:debug": "NODE_ENV=development pnpm build:debug && NODE_ENV=development jest",
+    "build:debug": "cargo build --target wasm32-wasi && cp -rf target/wasm32-wasi/debug/jest_workaround.wasm ./debug",
+    "test": "pnpm build && jest",
+    "build": "cargo prepublish --release && cp -rf target/wasm32-wasi/release/jest_workaround.wasm ."
+  },
+  "packageManager": "pnpm@8.6.8",
+  "main": "jest_workaround.wasm",
+  "files": [
+    "src",
+    "jest_workaround.wasm"
+  ],
+  "homepage": "https://github.com/magic-akari/jest_workaround#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/jest_workaround/0.79.19"
+  },
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "devDependencies": {
+    "@ohos-ports/swc-core": "^1.16.1-beta.1",
+    "@swc/jest": "^0.2.26",
+    "@types/jest": "^29.5.1",
+    "jest": "^29.5.0"
+  },
+  "peerDependencies": {
+    "@ohos-ports/swc-core": "^1.16.1-beta.1",
+    "@swc/jest": "^0.2.26"
+  }
+}

package/src/lib.rs

@@ -0,0 +1,282 @@
+mod local_export_strip;
+mod utils;
+
+use local_export_strip::LocalExportStrip;
+use std::collections::HashSet;
+
+use swc_core::{
+    common::{util::take::Take, Mark, SyntaxContext, DUMMY_SP},
+    ecma::{
+        ast::*,
+        utils::{
+            member_expr, private_ident, quote_ident, quote_str, ExprFactory, IntoIndirectCall,
+        },
+        visit::{noop_visit_mut_type, VisitMut, VisitMutWith},
+    },
+    plugin::{plugin_transform, proxies::TransformPluginProgramMetadata},
+};
+use utils::emit_export_stmts;
+
+#[derive(Debug)]
+pub struct TransformVisitor {
+    unresolved_mark: Mark,
+
+    export_decl_id: HashSet<Id>,
+}
+
+impl VisitMut for TransformVisitor {
+    noop_visit_mut_type!();
+
+    fn visit_mut_script(&mut self, _: &mut Script) {
+        // skip
+    }
+
+    fn visit_mut_module(&mut self, n: &mut Module) {
+        let mut strip = LocalExportStrip::default();
+        n.visit_mut_with(&mut strip);
+
+        let LocalExportStrip {
+            has_export_assign,
+            export,
+            export_all,
+            export_decl_id,
+            ..
+        } = strip;
+
+        self.export_decl_id = export_decl_id;
+
+        let mut stmts: Vec<ModuleItem> = Vec::with_capacity(n.body.len() + 1);
+
+        if !has_export_assign && !export.is_empty() {
+            // keep module env
+            stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
+                NamedExport::dummy(),
+            )));
+
+            let exports = self.exports();
+
+            let export_obj_prop_list = export.into_iter().map(Into::into).collect();
+
+            stmts.extend(
+                emit_export_stmts(exports, export_obj_prop_list)
+                    .into_iter()
+                    .map(Into::into),
+            );
+
+            if !self.export_decl_id.is_empty() {
+                n.visit_mut_children_with(self);
+            }
+        }
+
+        stmts.extend(export_all.into_iter().map(|id| self.export_all(id)));
+
+        stmts.extend(n.body.take());
+
+        n.body = stmts;
+    }
+
+    fn visit_mut_prop(&mut self, n: &mut Prop) {
+        match n {
+            Prop::Shorthand(ref_ident) => {
+                if self.export_decl_id.contains(&ref_ident.to_id()) {
+                    *n = KeyValueProp {
+                        key: ref_ident.clone().into(),
+                        value: Box::new(Expr::from(
+                            self.exports().make_member(ref_ident.take().into()),
+                        )),
+                    }
+                    .into()
+                }
+            }
+            _ => n.visit_mut_children_with(self),
+        }
+    }
+
+    fn visit_mut_expr(&mut self, n: &mut Expr) {
+        match n {
+            Expr::Ident(ref_ident) => {
+                if self.export_decl_id.contains(&ref_ident.to_id()) {
+                    *n = Expr::from(self.exports().make_member(ref_ident.take().into()));
+                }
+            }
+
+            _ => n.visit_mut_children_with(self),
+        };
+    }
+
+    fn visit_mut_tagged_tpl(&mut self, n: &mut TaggedTpl) {
+        let is_indirect = n
+            .tag
+            .as_ident()
+            .map(|ident| self.export_decl_id.contains(&ident.to_id()))
+            .unwrap_or_default();
+
+        n.visit_mut_children_with(self);
+
+        if is_indirect {
+            *n = n.take().into_indirect()
+        }
+    }
+
+    fn visit_mut_callee(&mut self, n: &mut Callee) {
+        match n {
+            Callee::Expr(e) if e.is_ident() => {
+                let is_indirect_callee = e
+                    .as_ident()
+                    .map(|ident| self.export_decl_id.contains(&ident.to_id()))
+                    .unwrap_or_default();
+
+                e.visit_mut_with(self);
+
+                if is_indirect_callee {
+                    *n = n.take().into_indirect()
+                }
+            }
+
+            _ => n.visit_mut_children_with(self),
+        }
+    }
+}
+
+impl TransformVisitor {
+    pub fn new(unresolved_mark: Mark) -> Self {
+        Self {
+            unresolved_mark,
+            export_decl_id: Default::default(),
+        }
+    }
+
+    fn exports(&self) -> Ident {
+        quote_ident!(SyntaxContext::empty().apply_mark(self.unresolved_mark), "exports")
+    }
+
+    /// ```JavaScript
+    /// Object.keys(_mod).forEach(function (key) {
+    ///     if (key === "default" || key === "__esModule") return;
+    ///     if (key in exports && exports[key] === _mod[key]) return;
+    ///     exports[key] = _mod[key];
+    /// });
+    /// ```
+    fn export_all(&self, id: Id) -> ModuleItem {
+        let mod_name = Ident::from(id);
+        let key = private_ident!("key");
+
+        member_expr!(Default::default(), DUMMY_SP, Object.keys)
+            .as_call(DUMMY_SP, vec![mod_name.clone().as_arg()])
+            .make_member(quote_ident!("forEach"))
+            .as_call(
+                DUMMY_SP,
+                vec![Function {
+                    params: vec![key.clone().into()],
+                    decorators: vec![],
+                    span: DUMMY_SP,
+                    ctxt: SyntaxContext::empty(),
+                    this_param: None,
+                    body: Some(FunctionBody {
+                        span: DUMMY_SP,
+                        stmts: vec![
+                            // if (key === "default" || key === "__esModule") return;
+                            IfStmt {
+                                span: DUMMY_SP,
+                                test: BinExpr {
+                                    span: DUMMY_SP,
+                                    op: op!("||"),
+                                    left: BinExpr {
+                                        span: DUMMY_SP,
+                                        op: op!("==="),
+                                        left: key.clone().into(),
+                                        right: quote_str!("default").into(),
+                                    }
+                                    .into(),
+                                    right: BinExpr {
+                                        span: DUMMY_SP,
+                                        op: op!("==="),
+                                        left: key.clone().into(),
+                                        right: quote_str!("__esModule").into(),
+                                    }
+                                    .into(),
+                                }
+                                .into(),
+                                cons: Box::new(
+                                    ReturnStmt {
+                                        span: DUMMY_SP,
+                                        arg: None,
+                                    }
+                                    .into(),
+                                ),
+                                alt: None,
+                            }
+                            .into(),
+                            // if (key in exports && exports[key] === _mod[key]) return;
+                            IfStmt {
+                                span: DUMMY_SP,
+                                test: BinExpr {
+                                    span: DUMMY_SP,
+                                    op: op!("&&"),
+                                    left: BinExpr {
+                                        span: DUMMY_SP,
+                                        op: op!("in"),
+                                        left: key.clone().into(),
+                                        right: self.exports().into(),
+                                    }
+                                    .into(),
+                                    right: BinExpr {
+                                        span: DUMMY_SP,
+                                        op: op!("==="),
+                                        left: self
+                                            .exports()
+                                            .computed_member(quote_ident!("key"))
+                                            .into(),
+                                        right: mod_name
+                                            .clone()
+                                            .computed_member(quote_ident!("key"))
+                                            .into(),
+                                    }
+                                    .into(),
+                                }
+                                .into(),
+                                cons: Box::new(
+                                    ReturnStmt {
+                                        span: DUMMY_SP,
+                                        arg: None,
+                                    }
+                                    .into(),
+                                ),
+                                alt: None,
+                            }
+                            .into(),
+                            // exports[key] = _mod[key];
+                            mod_name
+                                .clone()
+                                .computed_member(quote_ident!("key"))
+                                .make_assign_to(
+                                    op!("="),
+                                    self.exports()
+                                        .computed_member(quote_ident!("key"))
+                                        .into(),
+                                )
+                                .into_stmt(),
+                        ],
+                    }),
+                    is_generator: false,
+                    is_async: false,
+                    type_params: None,
+                    return_type: None,
+                }
+                .as_arg()],
+            )
+            .into_stmt()
+            .into()
+    }
+}
+
+#[plugin_transform]
+pub fn process_transform(
+    mut program: Program,
+    metadata: TransformPluginProgramMetadata,
+) -> Program {
+    program.visit_mut_with(&mut TransformVisitor::new(
+        metadata.unresolved_mark,
+    ));
+    program
+}

package/src/local_export_strip.rs

@@ -0,0 +1,340 @@
+use std::collections::HashSet;
+
+use indexmap::IndexMap;
+use swc_core::{
+    common::{util::take::Take, Span, DUMMY_SP},
+    ecma::{
+        ast::*,
+        atoms::{atom, Atom},
+        utils::{find_pat_ids, private_ident, ExprFactory},
+        visit::{noop_visit_mut_type, VisitMut, VisitMutWith},
+    },
+};
+
+use crate::utils::{key_from_export_name, local_ident_from_export_name};
+
+type Export = IndexMap<(Atom, Span), Ident>;
+
+#[derive(Debug, Default)]
+pub(crate) struct LocalExportStrip {
+    pub(crate) has_export_assign: bool,
+    pub(crate) export: Export,
+    pub(crate) export_all: HashSet<Id>,
+    pub(crate) export_decl_id: HashSet<Id>,
+    export_default: Option<Stmt>,
+}
+
+impl VisitMut for LocalExportStrip {
+    noop_visit_mut_type!();
+
+    fn visit_mut_script(&mut self, _: &mut Script) {
+        // skip
+    }
+
+    fn visit_mut_module(&mut self, n: &mut Module) {
+        let mut list = Vec::with_capacity(n.body.len());
+
+        for item in n.body.drain(..) {
+            match item {
+                ModuleItem::Stmt(stmt) => list.push(stmt.into()),
+
+                ModuleItem::ModuleDecl(mut module_decl) => {
+                    // collect link meta
+                    module_decl.visit_mut_with(self);
+
+                    // emit stmt
+                    match module_decl {
+                        ModuleDecl::ExportDecl(ExportDecl { decl, .. }) => {
+                            list.push(Stmt::Decl(decl).into());
+                        }
+                        ModuleDecl::ExportNamed(NamedExport { src: None, .. }) => continue,
+                        ModuleDecl::ExportNamed(
+                            item @ NamedExport {
+                                src: Some(..),
+                                type_only: false,
+                                ..
+                            },
+                        ) => {
+                            let decl: ModuleDecl = self.convert_export_decl(item).into();
+                            list.push(decl.into());
+                        }
+                        ModuleDecl::ExportAll(
+                            e @ ExportAll {
+                                type_only: false, ..
+                            },
+                        ) => {
+                            let decl: ModuleDecl = self.convert_export_all(e).into();
+                            list.push(decl.into());
+                        }
+                        ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {
+                            decl:
+                                decl @ (DefaultDecl::Class(ClassExpr {
+                                    ident: Some(..), ..
+                                })
+                                | DefaultDecl::Fn(FnExpr {
+                                    ident: Some(..), ..
+                                })),
+                            ..
+                        }) => match decl {
+                            DefaultDecl::Class(class_expr) => list.extend(
+                                class_expr
+                                    .as_class_decl()
+                                    .map(|decl| Stmt::Decl(Decl::Class(decl)))
+                                    .map(Into::into),
+                            ),
+                            DefaultDecl::Fn(fn_expr) => list.extend(
+                                fn_expr
+                                    .as_fn_decl()
+                                    .map(|decl| Stmt::Decl(Decl::Fn(decl)))
+                                    .map(Into::into),
+                            ),
+                            _ => unreachable!(),
+                        },
+                        ModuleDecl::ExportDefaultExpr(..) => {
+                            list.extend(self.export_default.take().map(From::from))
+                        }
+                        ModuleDecl::TsExportAssignment(..) => {
+                            self.has_export_assign = true;
+                            list.push(module_decl.into());
+                        }
+                        _ => list.push(module_decl.into()),
+                    };
+                }
+            };
+        }
+
+        n.body = list;
+    }
+
+    /// ```javascript
+    /// export const foo = 1, bar = 2, { baz } = { baz: 3 };
+    /// export let a = 1, [b] = [2];
+    /// export function x() {}
+    /// export class y {}
+    /// ```
+    /// ->
+    /// ```javascript
+    /// const foo = 1, bar = 2, { baz } = { baz: 3 };
+    /// let a = 1, [b] = [2];
+    /// function x() {}
+    /// class y {}
+    /// ```
+    fn visit_mut_export_decl(&mut self, n: &mut ExportDecl) {
+        match &n.decl {
+            Decl::Class(ClassDecl { ident, .. }) | Decl::Fn(FnDecl { ident, .. }) => {
+                let ident = ident.clone();
+
+                self.export.insert((ident.sym.clone(), ident.span), ident);
+            }
+
+            Decl::Var(v) => {
+                let ids = find_pat_ids::<_, Ident>(&v.decls);
+
+                self.export_decl_id.extend(ids.iter().map(Ident::to_id));
+
+                self.export.extend(ids.into_iter().map(|id| {
+                    let ident = id.clone();
+
+                    ((id.sym, id.span), ident)
+                }));
+            }
+            _ => {}
+        };
+    }
+
+    /// ```javascript
+    /// export { foo, foo as bar, foo as "baz" };
+    /// export { "foo", foo as bar, "foo" as "baz" } from "mod";
+    /// export * as foo from "mod";
+    /// export * as "bar" from "mod";
+    /// ```
+    fn visit_mut_named_export(&mut self, n: &mut NamedExport) {
+        if n.type_only || n.src.is_some() {
+            return;
+        }
+
+        let NamedExport { specifiers, .. } = n.take();
+
+        self.export.extend(specifiers.into_iter().map(|e| match e {
+            ExportSpecifier::Namespace(..) => {
+                unreachable!("`export *` without src is invalid")
+            }
+            ExportSpecifier::Default(..) => {
+                unreachable!("`export foo` without src is invalid")
+            }
+            ExportSpecifier::Named(ExportNamedSpecifier { orig, exported, .. }) => {
+                let orig = match orig {
+                    ModuleExportName::Ident(id) => id,
+                    ModuleExportName::Str(_) => {
+                        unreachable!(r#"`export {{ "foo" }}` without src is invalid"#)
+                    }
+                };
+
+                if let Some(exported) = exported {
+                    let exported = match exported {
+                        ModuleExportName::Ident(Ident { span, sym, .. }) => (sym, span),
+                        ModuleExportName::Str(Str { span, value, .. }) => (value.to_atom_lossy().into_owned(), span),
+                    };
+
+                    (exported, orig)
+                } else {
+                    let exported = orig.sym.clone();
+                    ((exported, orig.span), orig)
+                }
+            }
+        }))
+    }
+
+    /// ```javascript
+    /// export default class foo {};
+    /// export default class {};
+    /// export default function bar () {};
+    /// export default function () {};
+    /// ```
+    /// ->
+    /// ```javascript
+    /// class foo {};
+    /// class _default {};
+    /// function bar () {};
+    /// function _default () {};
+    /// ```
+    fn visit_mut_export_default_decl(&mut self, n: &mut ExportDefaultDecl) {
+        match &mut n.decl {
+            DefaultDecl::Class(class_expr) => {
+                if let Some(ident) = class_expr.ident.clone() {
+                    self.export.insert((atom!("default"), n.span), ident);
+                }
+            }
+            DefaultDecl::Fn(fn_expr) => {
+                if let Some(ident) = fn_expr.ident.clone() {
+                    self.export.insert((atom!("default"), n.span), ident);
+                }
+            }
+            DefaultDecl::TsInterfaceDecl(_) => {}
+        }
+    }
+
+    /// ```javascript
+    /// export default foo;
+    /// export default 1
+    /// ```
+    /// ->
+    /// ```javascript
+    /// var _default = foo;
+    /// var _default = 1;
+    /// ```
+    fn visit_mut_export_default_expr(&mut self, n: &mut ExportDefaultExpr) {
+        let ident = private_ident!(n.span, "_default");
+
+        self.export
+            .insert((atom!("default"), n.span), ident.clone());
+
+        self.export_default = Some(Stmt::Decl(
+            n.expr
+                .take()
+                .into_var_decl(VarDeclKind::Const, ident.into())
+                .into(),
+        ));
+    }
+}
+
+impl LocalExportStrip {
+    fn convert_export_decl(&mut self, n: NamedExport) -> ImportDecl {
+        let NamedExport {
+            span,
+            specifiers,
+            src,
+            type_only,
+            with,
+        } = n;
+
+        let src = src.unwrap();
+
+        let specifiers = specifiers
+            .into_iter()
+            .flat_map(|s| self.convert_export_specifier(s))
+            .collect();
+
+        ImportDecl {
+            span,
+            specifiers,
+            src,
+            type_only,
+            with,
+            phase: ImportPhase::Evaluation,
+        }
+    }
+
+    fn convert_export_specifier(&mut self, s: ExportSpecifier) -> Option<ImportSpecifier> {
+        match s {
+            ExportSpecifier::Namespace(ExportNamespaceSpecifier { span, name }) => {
+                let key = key_from_export_name(&name);
+                let local = local_ident_from_export_name(name);
+                self.export.insert(key, local.clone());
+
+                Some(ImportSpecifier::Namespace(ImportStarAsSpecifier {
+                    span,
+                    local,
+                }))
+            }
+            ExportSpecifier::Default(ExportDefaultSpecifier { exported }) => {
+                let key = (exported.sym.clone(), exported.span);
+                let local = exported.into_private();
+                self.export.insert(key, local.clone());
+
+                Some(ImportSpecifier::Default(ImportDefaultSpecifier {
+                    local,
+                    span: DUMMY_SP,
+                }))
+            }
+            ExportSpecifier::Named(ExportNamedSpecifier {
+                span,
+                orig,
+                exported,
+                is_type_only: false,
+            }) => {
+                // export { "x-1" as "y-1" } from "foo"
+                // ->
+                // import { "x-1" as x1 } from "foo"
+                // export { x1 as "y-1" }
+                let name = exported.as_ref().unwrap_or(&orig);
+
+                let key = key_from_export_name(name);
+                let local = local_ident_from_export_name(orig.clone());
+                self.export.insert(key, local.clone());
+
+                Some(ImportSpecifier::Named(ImportNamedSpecifier {
+                    span,
+                    local,
+                    imported: Some(orig),
+                    is_type_only: false,
+                }))
+            }
+            _ => None,
+        }
+    }
+
+    fn convert_export_all(&mut self, e: ExportAll) -> ImportDecl {
+        let ExportAll {
+            span, src, with, ..
+        } = e;
+
+        let mod_name = private_ident!("mod");
+
+        self.export_all.insert(mod_name.to_id());
+
+        let star = ImportStarAsSpecifier {
+            span,
+            local: mod_name.clone(),
+        };
+
+        ImportDecl {
+            span,
+            specifiers: vec![star.into()],
+            src,
+            type_only: false,
+            with,
+            phase: ImportPhase::Evaluation,
+        }
+    }
+}

package/src/utils.rs

@@ -0,0 +1,257 @@
+use swc_core::{
+    common::{Span, Spanned, SyntaxContext, DUMMY_SP},
+    ecma::{
+        ast::*,
+        atoms::{atom, Atom},
+        utils::{
+            is_valid_prop_ident, member_expr, private_ident, quote_ident, quote_str, ExprFactory,
+            FunctionFactory,
+        },
+    },
+};
+
+/// {
+///     "key": ident,
+/// }
+pub(crate) struct ObjPropKeyIdent(Atom, Span, Ident);
+
+impl From<((Atom, Span), Ident)> for ObjPropKeyIdent {
+    fn from(((key, span), ident): ((Atom, Span), Ident)) -> Self {
+        Self(key, span, ident)
+    }
+}
+
+impl From<(Atom, Span, Ident)> for ObjPropKeyIdent {
+    fn from((key, span, ident): (Atom, Span, Ident)) -> Self {
+        Self(key, span, ident)
+    }
+}
+
+impl Spanned for ObjPropKeyIdent {
+    fn span(&self) -> Span {
+        self.1
+    }
+}
+
+impl ObjPropKeyIdent {
+    pub fn key(&self) -> &Atom {
+        &self.0
+    }
+
+    pub fn into_expr(self) -> Expr {
+        self.2.into()
+    }
+}
+
+/// ```javascript
+/// {
+///     key: () => expr,
+/// }
+/// ```
+pub(crate) fn prop_arrow(prop: ObjPropKeyIdent) -> Prop {
+    let key = prop_name(prop.key(), prop.span()).into();
+
+    KeyValueProp {
+        key,
+        value: Box::new(prop.into_expr().into_lazy_arrow(Default::default()).into()),
+    }
+    .into()
+}
+
+pub(crate) fn prop_name(key: &str, span: Span) -> IdentOrStr {
+    if is_valid_prop_ident(key) {
+        IdentOrStr::Ident(quote_ident!(Default::default(), span, key))
+    } else {
+        IdentOrStr::Str(quote_str!(span, key))
+    }
+}
+
+pub(crate) enum IdentOrStr {
+    Ident(Ident),
+    Str(Str),
+}
+
+impl From<IdentOrStr> for PropName {
+    fn from(val: IdentOrStr) -> Self {
+        match val {
+            IdentOrStr::Ident(i) => Self::Ident(i.into()),
+            IdentOrStr::Str(s) => Self::Str(s),
+        }
+    }
+}
+
+impl From<IdentOrStr> for MemberProp {
+    fn from(val: IdentOrStr) -> Self {
+        match val {
+            IdentOrStr::Ident(i) => Self::Ident(i.into()),
+            IdentOrStr::Str(s) => Self::Computed(ComputedPropName {
+                span: DUMMY_SP,
+                expr: s.into(),
+            }),
+        }
+    }
+}
+
+/// Creates
+///
+///```js
+///
+///  Object.defineProperty(target, prop_name, {
+///      ...props
+///  });
+/// ```
+pub(super) fn object_define_property(
+    target: ExprOrSpread,
+    prop_name: ExprOrSpread,
+    descriptor: ExprOrSpread,
+) -> Expr {
+    member_expr!(Default::default(), DUMMY_SP, Object.defineProperty)
+        .as_call(DUMMY_SP, vec![target, prop_name, descriptor])
+}
+
+pub(crate) fn object_define_enumerable_configurable(
+    target: ExprOrSpread,
+    prop_name: ExprOrSpread,
+    prop: PropOrSpread,
+) -> Expr {
+    object_define_property(
+        target,
+        prop_name,
+        ObjectLit {
+            span: DUMMY_SP,
+            props: vec![
+                PropOrSpread::Prop(Box::new(
+                    KeyValueProp {
+                        key: quote_ident!("enumerable").into(),
+                        value: Box::new(true.into()),
+                    }
+                    .into(),
+                )),
+                prop,
+                PropOrSpread::Prop(Box::new(
+                    KeyValueProp {
+                        key: quote_ident!("configurable").into(),
+                        value: Box::new(true.into()),
+                    }
+                    .into(),
+                )),
+            ],
+        }
+        .as_arg(),
+    )
+}
+
+pub(crate) fn emit_export_stmts(exports: Ident, mut prop_list: Vec<ObjPropKeyIdent>) -> Vec<Stmt> {
+    match prop_list.len() {
+        0 | 1 => prop_list
+            .pop()
+            .map(|obj_prop| {
+                object_define_enumerable_configurable(
+                    exports.as_arg(),
+                    quote_str!(obj_prop.span(), obj_prop.key().clone()).as_arg(),
+                    prop_arrow((atom!("get"), DUMMY_SP, obj_prop.2.clone()).into()).into(),
+                )
+                .into_stmt()
+            })
+            .into_iter()
+            .collect(),
+        _ => {
+            let props = prop_list
+                .into_iter()
+                .map(prop_arrow)
+                .map(Into::into)
+                .collect();
+            let obj_lit = ObjectLit {
+                span: DUMMY_SP,
+                props,
+            };
+
+            let esm_export_ident = private_ident!("_export");
+
+            vec![
+                Stmt::Decl(Decl::Fn(
+                    esm_export().into_fn_decl(esm_export_ident.clone()),
+                )),
+                esm_export_ident
+                    .as_call(DUMMY_SP, vec![exports.as_arg(), obj_lit.as_arg()])
+                    .into_stmt(),
+            ]
+        }
+    }
+}
+
+/// ```javascript
+/// function _esmExport(target, all) {
+///    for (var name in all)Object.defineProperty(target, name, { get: all[name], enumerable: true, configurable: true });
+/// }
+/// ```
+pub(crate) fn esm_export() -> Function {
+    let target = private_ident!("target");
+    let all = private_ident!("all");
+    let name = private_ident!("name");
+
+    let getter = KeyValueProp {
+        key: quote_ident!("get").into(),
+        value: Box::new(Expr::from(all.clone().computed_member(Expr::from(name.clone())))),
+    };
+
+    let body = object_define_enumerable_configurable(
+        target.clone().as_arg(),
+        name.clone().as_arg(),
+        PropOrSpread::Prop(Box::new(Prop::KeyValue(getter))),
+    )
+    .into_stmt();
+
+    let for_in_stmt: Stmt = ForInStmt {
+        span: DUMMY_SP,
+        left: VarDecl {
+            span: DUMMY_SP,
+            ctxt: SyntaxContext::empty(),
+            kind: VarDeclKind::Var,
+            declare: false,
+            decls: vec![VarDeclarator {
+                span: DUMMY_SP,
+                name: name.into(),
+                init: None,
+                definite: false,
+            }],
+        }
+        .into(),
+        right: Box::new(all.clone().into()),
+        body: Box::new(body),
+    }
+    .into();
+
+    Function {
+        params: vec![target.into(), all.into()],
+        decorators: Default::default(),
+        span: DUMMY_SP,
+        ctxt: SyntaxContext::empty(),
+        this_param: None,
+        body: Some(FunctionBody {
+            span: DUMMY_SP,
+            stmts: vec![for_in_stmt],
+        }),
+        is_generator: false,
+        is_async: false,
+        type_params: None,
+        return_type: None,
+    }
+}
+
+pub(crate) fn key_from_export_name(n: &ModuleExportName) -> (Atom, Span) {
+    match n {
+        ModuleExportName::Ident(ident) => (ident.sym.clone(), ident.span),
+        ModuleExportName::Str(str) => (str.value.to_atom_lossy().into_owned(), str.span),
+    }
+}
+
+pub(crate) fn local_ident_from_export_name(n: ModuleExportName) -> Ident {
+    match n {
+        ModuleExportName::Ident(ident) => private_ident!(ident.span, ident.sym.clone()),
+        ModuleExportName::Str(str) => match Ident::verify_symbol(&str.value.to_string_lossy()) {
+            Ok(_) => private_ident!(str.value.to_atom_lossy().into_owned()),
+            Err(s) => private_ident!(s),
+        },
+    }
+}