dctc 1.1.2 → 1.1.3

package/README.md

@@ -21,7 +21,7 @@ dctc [options] <file>
 ```
 -h, --help                    display help for command
 -v, --version                 output the version number
--c, --compiler <name>         specify compiler: es, rollup, rolldown (default: es)
+-c, --compiler <name>         specify compiler: es, swc, rollup, rolldown (default: es)
 ```
 
 ## Installation
@@ -118,6 +118,7 @@ dctc generate-html.tsx
 Or specify a compiler:
 
 ```shell
+dctc --compiler swc generate-html.tsx
 dctc --compiler rollup generate-html.tsx
 dctc -c rolldown generate-html.tsx
 ```
@@ -153,6 +154,54 @@ Some scenarios where you need to compile and execute tsx.
 - Developed using react, and needed to generate an html template for email.
 - When you want to preview a react component, but there is no suitable playground.
 
+## Performance (ASCII)
+
+Benchmark setup:
+- Entry: `test/generate-html.bench.tsx` (same as `test/generate-html.tsx`, but does **not** write files)
+- Per compiler: **compile 1x + execute 10000x**
+
+Raw numbers:
+
+```
+compiler   compile(ms)  exec_total(ms)  exec_avg(ms)  ops(/s)
+swc        13.5         1922.8         0.1923       5200.7
+es         13.1         2438.2         0.2438       4101.4
+rollup     850.4        6817.4         0.6817       1466.8
+rolldown   318.1        7709.3         0.7709       1297.1
+```
+
+Visuals (pure ASCII):
+
+Compile time (ms)  [lower is better]  (scale: max=850.4ms => 40 cols)
+
+```
+compiler  value    bar
+es        13.1ms  |#                                       |
+swc       13.5ms  |#                                       |
+rolldown  318.1ms |###############                         |
+rollup    850.4ms |########################################|
+```
+
+Execution avg (ms) [lower is better] (scale: max=0.7709ms => 40 cols)
+
+```
+compiler  value      bar
+swc       0.1923ms |##########                              |
+es        0.2438ms |#############                           |
+rollup    0.6817ms |###################################     |
+rolldown  0.7709ms |########################################|
+```
+
+Throughput (ops/s) [higher is better] (scale: max=5200.7/s => 40 cols)
+
+```
+compiler  value     bar
+swc       5200.7/s |########################################|
+es        4101.4/s |###############################         |
+rollup    1466.8/s |###########                             |
+rolldown  1297.1/s |##########                              |
+```
+
 ## Notice
 If you need to load the style file, perform an additional loader and eventually insert the style into the html template in the product, but the email template does not support external style import.
 

package/lib/actions/index.js

@@ -1,6 +1,7 @@
 const complie_es = require("../complie_es");
 const complie_rollup = require("../complie_rollup");
 const complie_rolldown = require("../complie_rolldown");
+const complie_swc = require("../complie_swc");
 const execute = require("../execute");
 const chalk = require("chalk");
 const log = content => console.log(chalk.green(content));
@@ -16,7 +17,7 @@ function applyHelp() {
   logInfo("Options:");
   logInfo(`  -v, --version        Print the version number`);
   logInfo(`  -h, --help           Print this help message`);
-  logInfo(`  -c, --compiler <name> Specify compiler: es, rollup, rolldown (default: es)`);
+  logInfo(`  -c, --compiler <name> Specify compiler: es, swc, rollup, rolldown (default: es)`);
   logInfo("Examples:");
   logInfo(`  dctc src/index.tsx`);
   logInfo(`  dctc src/index.ts`);
@@ -32,6 +33,9 @@ async function applyDctc(inputFile, compiler = 'es') {
     case 'esbuild':
       code = await complie_es(inputFile);
       break;
+    case 'swc':
+      code = await complie_swc(inputFile);
+      break;
     case 'rollup':
       code = await complie_rollup(inputFile);
       break;

package/lib/complie_swc.js

@@ -0,0 +1,478 @@
+/**
+ * Compile a given file to CommonJS format using SWC.
+ * This compiler bundles local (relative) TS/TSX/JS/JSX/JSON modules into a single CJS string
+ * so it can be executed via vm the same way as other compilers in this repo.
+ *
+ * Notes:
+ * - Non-relative imports (e.g. react, react-dom/server, node built-ins) remain as runtime requires.
+ * - Relative imports are resolved and bundled, with a tiny module loader injected.
+ *
+ * @param {string} filePath - The path to the file to be compiled.
+ * @returns {Promise<string>} - The compiled (bundled) code.
+ * @author pipi
+ */
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const swc = require("@swc/core");
+
+const logErr = (content) => console.log(chalk.red(content));
+
+const LOCAL_EXTS = [".ts", ".tsx", ".js", ".jsx", ".json"];
+
+/**
+ * Determine whether an import/require specifier should be treated as "local".
+ *
+ * In this compiler, only local specifiers are bundled into the output:
+ * - Relative paths like "./x" or "../x"
+ * - Absolute file paths like "/Users/.../x"
+ *
+ * Everything else (e.g. "react", "react-dom/server", "fs") is considered external and will be
+ * resolved at runtime via Node's `require`.
+ *
+ * @param {string} spec - The module specifier as written in source code.
+ * @returns {boolean} True if the specifier is local and should be bundled.
+ */
+function isLocalSpecifier(spec) {
+  return typeof spec === "string" && (spec.startsWith(".") || spec.startsWith("/"));
+}
+
+/**
+ * Best-effort file existence check.
+ *
+ * We wrap `fs.existsSync` + `fs.statSync` to avoid throwing (e.g. permission issues, broken symlinks)
+ * and to ensure the path is a regular file.
+ *
+ * @param {string} p - Path to check.
+ * @returns {boolean} True if the path exists and is a file.
+ */
+function fileExists(p) {
+  try {
+    return fs.existsSync(p) && fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Best-effort directory existence check.
+ *
+ * @param {string} p - Path to check.
+ * @returns {boolean} True if the path exists and is a directory.
+ */
+function dirExists(p) {
+  try {
+    return fs.existsSync(p) && fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolve a module path by trying common extensions and `index.*` fallbacks.
+ *
+ * This mimics typical TS/Node resolution for local imports:
+ * - If `basePath` is an existing file, return it as-is.
+ * - Otherwise, try appending known extensions: `.ts`, `.tsx`, `.js`, `.jsx`, `.json`.
+ * - If `basePath` is a directory, try `basePath/index.<ext>` in the same extension order.
+ *
+ * @param {string} basePath - Absolute path without extension (or a candidate path).
+ * @returns {string|null} The resolved file path, or null if not found.
+ */
+function resolveWithExt(basePath) {
+  if (fileExists(basePath)) return basePath;
+
+  for (const ext of LOCAL_EXTS) {
+    const candidate = basePath + ext;
+    if (fileExists(candidate)) return candidate;
+  }
+
+  if (dirExists(basePath)) {
+    for (const ext of LOCAL_EXTS) {
+      const candidate = path.join(basePath, "index" + ext);
+      if (fileExists(candidate)) return candidate;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve a local specifier (relative or absolute) into an absolute file path.
+ *
+ * @param {string} fromFile - Absolute path of the importing file.
+ * @param {string} spec - Import specifier found in `fromFile` (must be local).
+ * @returns {string} Absolute path to the resolved target file.
+ * @throws {Error} If the target cannot be resolved.
+ */
+function resolveLocal(fromFile, spec) {
+  const baseDir = path.dirname(fromFile);
+  const abs = spec.startsWith("/") ? path.resolve(spec) : path.resolve(baseDir, spec);
+  const resolved = resolveWithExt(abs);
+  if (!resolved) {
+    throw new Error(`Cannot resolve import '${spec}' from '${fromFile}'`);
+  }
+  return resolved;
+}
+
+/**
+ * Normalize a file path to a stable, absolute module id used as the bundle key.
+ *
+ * Using absolute, normalized paths as ids:
+ * - avoids duplicates (e.g. `a/../b` vs `b`)
+ * - makes dependency maps deterministic
+ *
+ * @param {string} p - Any file path.
+ * @returns {string} Normalized absolute path.
+ */
+function normalizeId(p) {
+  // Keep absolute path as module id for stable caching/resolution.
+  return path.resolve(p);
+}
+
+/**
+ * Replace `import.meta.url` with a CommonJS-compatible equivalent.
+ *
+ * The execution environment for dctc is CommonJS in a VM context. `import.meta` does not exist
+ * there, so we rewrite it to:
+ *   require("url").pathToFileURL(__filename).href
+ *
+ * This matches the behavior of the existing esbuild compiler in this repo.
+ *
+ * @param {string} source - Original source code.
+ * @returns {string} Transformed source code.
+ */
+function patchImportMetaUrl(source) {
+  // Keep parity with esbuild compiler behavior in this repo.
+  return source.replace(/import\.meta\.url/g, 'require("url").pathToFileURL(__filename).href');
+}
+
+/**
+ * Collect module specifiers from a SWC AST.
+ *
+ * We intentionally only collect:
+ * - ESM imports: `import ... from "x"`
+ * - Re-exports: `export ... from "x"` / `export * from "x"`
+ * - CommonJS requires with string literal arguments: `require("x")`
+ *
+ * Dynamic or non-literal requires are NOT collected (e.g. `require(name)`), because we cannot
+ * reliably bundle those.
+ *
+ * @param {object} ast - AST returned by `swc.parse`.
+ * @returns {string[]} Deduplicated list of specifier strings.
+ */
+function collectSpecifiersFromAst(ast) {
+  const specs = new Set();
+
+  const visit = (node) => {
+    if (!node) return;
+    if (Array.isArray(node)) {
+      for (const n of node) visit(n);
+      return;
+    }
+    if (typeof node !== "object") return;
+
+    // import ... from "x"
+    if (node.type === "ImportDeclaration" && node.source && typeof node.source.value === "string") {
+      specs.add(node.source.value);
+    }
+
+    // export ... from "x"
+    if (
+      (node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") &&
+      node.source &&
+      typeof node.source.value === "string"
+    ) {
+      specs.add(node.source.value);
+    }
+
+    // require("x")
+    if (
+      node.type === "CallExpression" &&
+      node.callee &&
+      node.callee.type === "Identifier" &&
+      node.callee.value === "require" &&
+      Array.isArray(node.arguments) &&
+      node.arguments.length === 1
+    ) {
+      const arg = node.arguments[0];
+      // SWC AST uses ExprOrSpread; string literal is { expression: { type: 'StringLiteral', value: '...' } }
+      const expr = arg && (arg.expression || arg);
+      if (expr && expr.type === "StringLiteral" && typeof expr.value === "string") {
+        specs.add(expr.value);
+      }
+    }
+
+    for (const key of Object.keys(node)) {
+      if (key === "span") continue;
+      visit(node[key]);
+    }
+  };
+
+  visit(ast);
+  return Array.from(specs);
+}
+
+/**
+ * Parse a file and extract local dependency specifiers.
+ *
+ * This function uses SWC to parse the source into an AST, collects all static module specifiers,
+ * and then filters down to only local specifiers (relative or absolute paths) that we intend to bundle.
+ *
+ * @param {string} absPath - Absolute file path (used to choose parser options).
+ * @param {string} source - File contents (possibly preprocessed).
+ * @returns {Promise<string[]>} Local specifiers only (e.g. ["./src", "../util"]).
+ */
+async function parseForImports(absPath, source) {
+  const ext = path.extname(absPath).toLowerCase();
+  const isTs = ext === ".ts" || ext === ".tsx";
+  const isTsx = ext === ".tsx";
+  const isJsx = ext === ".jsx";
+
+  const ast = await swc.parse(source, {
+    syntax: isTs ? "typescript" : "ecmascript",
+    tsx: isTsx,
+    jsx: isJsx,
+    decorators: false,
+    dynamicImport: true,
+  });
+
+  return collectSpecifiersFromAst(ast).filter(isLocalSpecifier);
+}
+
+/**
+ * Transform a single module to CommonJS using SWC.
+ *
+ * Important configuration choices:
+ * - React JSX transform uses "classic" runtime => outputs `React.createElement(...)`.
+ *   This matches dctc's VM context which injects a `React` global.
+ * - Module output is CommonJS to align with the VM execution strategy.
+ *
+ * @param {string} absPath - Absolute file path (passed to SWC for better diagnostics).
+ * @param {string} source - File contents (possibly preprocessed).
+ * @returns {Promise<string>} Transformed JavaScript code in CJS format.
+ */
+async function transformToCjs(absPath, source) {
+  const ext = path.extname(absPath).toLowerCase();
+  const isTs = ext === ".ts" || ext === ".tsx";
+  const isTsx = ext === ".tsx";
+  const isJsx = ext === ".jsx";
+
+  const out = await swc.transform(source, {
+    filename: absPath,
+    sourceMaps: false,
+    jsc: {
+      target: "es2015",
+      externalHelpers: false,
+      parser: {
+        syntax: isTs ? "typescript" : "ecmascript",
+        tsx: isTsx,
+        jsx: isJsx,
+        decorators: false,
+        dynamicImport: true,
+      },
+      transform: {
+        react: {
+          runtime: "classic",
+          pragma: "React.createElement",
+          pragmaFrag: "React.Fragment",
+          throwIfNamespace: true,
+          useBuiltins: false,
+        },
+      },
+    },
+    module: {
+      type: "commonjs",
+      strict: true,
+      strictMode: true,
+      lazy: false,
+      noInterop: false,
+    },
+  });
+
+  return out.code || "";
+}
+
+/**
+ * Escape a string so it can be embedded inside a double-quoted JavaScript string literal
+ * in the generated bundle code.
+ *
+ * @param {unknown} str - Any value convertible to string.
+ * @returns {string} Escaped string.
+ */
+function escapeForJsString(str) {
+  return String(str).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+/**
+ * Rewrite local `require(...)` calls inside transformed CJS code to route through the bundle loader.
+ *
+ * After SWC transforms ESM imports to CJS, local imports typically become `require("./x")`.
+ * In a single-string VM bundle, `require("./x")` would be resolved relative to runtime state and
+ * would bypass our in-bundle module table.
+ *
+ * So we replace:
+ *   require("./x")  -> __dctc_require("<absolute-module-id>")
+ *
+ * Only specifiers present in `requireMap` are rewritten.
+ *
+ * @param {string} transformedCode - Output from `transformToCjs`.
+ * @param {Record<string, string>} requireMap - Map: original specifier -> normalized absolute module id.
+ * @returns {string} Rewritten code.
+ */
+function rewriteLocalRequires(transformedCode, requireMap) {
+  let code = transformedCode;
+  for (const [spec, resolvedId] of Object.entries(requireMap)) {
+    const quoted = escapeForJsString(spec);
+    const idQuoted = escapeForJsString(resolvedId);
+
+    // Replace require("spec") and require('spec')
+    const reDouble = new RegExp(`\\brequire\\(\\"${quoted}\\"\\)`, "g");
+    const reSingle = new RegExp(`\\brequire\\(\\'${quoted.replace(/'/g, "\\'")}\\'\\)`, "g");
+
+    code = code
+      .replace(reDouble, `__dctc_require("${idQuoted}")`)
+      .replace(reSingle, `__dctc_require("${idQuoted}")`);
+  }
+  return code;
+}
+
+/**
+ * Compile an entry file using SWC and bundle local dependencies into a single CJS string.
+ *
+ * High-level flow:
+ * - Resolve the entry file to an absolute path.
+ * - Recursively walk local imports/re-exports/requires.
+ * - For each module:
+ *   - JSON: inline as `module.exports = <parsed-json>`
+ *   - Others: preprocess `import.meta.url`, SWC-transform to CJS, rewrite local requires.
+ * - Emit a small runtime module system:
+ *   - `__dctc_modules`: module table keyed by absolute ids
+ *   - `__dctc_require`: loads from table and falls back to Node `require` for externals
+ *   - `__dctc_cache`: require cache to avoid double execution
+ * - Execute the entry module.
+ *
+ * @param {string} filePath - Entry file path (relative or absolute).
+ * @returns {Promise<string>} A single JavaScript string in CommonJS style ready for vm execution.
+ */
+module.exports = async function complie_swc(filePath) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`File does not exist: ${filePath}`);
+    process.exit(1);
+  }
+
+  const entryAbs = path.resolve(filePath);
+
+  try {
+    const modules = {}; // id -> { code, filename, dirname }
+    const requireMaps = {}; // id -> { spec: resolvedId }
+    const visiting = new Set();
+    const visited = new Set();
+
+    /**
+     * Load (and compile) one module into the in-memory bundle tables.
+     *
+     * This function is intentionally DFS:
+     * - It records the dependency map for the current module.
+     * - Then loads dependencies first.
+     * - Finally transforms and stores the current module.
+     *
+     * `visiting`/`visited` are used to prevent infinite recursion for cyclic imports.
+     * This is a pragmatic cycle guard; it does not fully emulate Node's nuanced cyclic export timing,
+     * but is sufficient for common project structures.
+     *
+     * @param {string} absPath - Absolute file path of the module.
+     * @returns {Promise<void>}
+     */
+    const loadModule = async (absPath) => {
+      const id = normalizeId(absPath);
+      if (visited.has(id)) return;
+      if (visiting.has(id)) return; // avoid cycles
+      visiting.add(id);
+
+      const ext = path.extname(absPath).toLowerCase();
+      if (ext === ".json") {
+        const jsonText = await fs.promises.readFile(absPath, "utf8");
+        const jsonValue = JSON.parse(jsonText);
+        modules[id] = {
+          filename: absPath,
+          dirname: path.dirname(absPath),
+          code: `module.exports = ${JSON.stringify(jsonValue)};`,
+        };
+        requireMaps[id] = {};
+        visited.add(id);
+        visiting.delete(id);
+        return;
+      }
+
+      let source = await fs.promises.readFile(absPath, "utf8");
+      source = patchImportMetaUrl(source);
+
+      const localImports = await parseForImports(absPath, source);
+      const map = {};
+      for (const spec of localImports) {
+        const resolved = resolveLocal(absPath, spec);
+        const resolvedId = normalizeId(resolved);
+        map[spec] = resolvedId;
+      }
+      requireMaps[id] = map;
+
+      // Load deps first
+      for (const spec of localImports) {
+        await loadModule(resolveLocal(absPath, spec));
+      }
+
+      const transformed = await transformToCjs(absPath, source);
+      const rewritten = rewriteLocalRequires(transformed, map);
+
+      modules[id] = {
+        filename: absPath,
+        dirname: path.dirname(absPath),
+        code: rewritten,
+      };
+
+      visited.add(id);
+      visiting.delete(id);
+    };
+
+    await loadModule(entryAbs);
+
+    const entries = Object.entries(modules);
+    const moduleTable = entries
+      .map(([id, m]) => {
+        const idStr = escapeForJsString(id);
+        const filenameStr = escapeForJsString(m.filename);
+        const dirnameStr = escapeForJsString(m.dirname);
+        // Wrap each module in a function to emulate Node's per-module __filename/__dirname.
+        return `"${idStr}": { filename: "${filenameStr}", dirname: "${dirnameStr}", fn: function(module, exports, __dctc_require, require, __filename, __dirname) {\n${m.code}\n} }`;
+      })
+      .join(",\n");
+
+    const entryId = escapeForJsString(normalizeId(entryAbs));
+
+    const bundle = `(function () {
+  "use strict";
+  var __dctc_modules = {
+${moduleTable}
+  };
+  var __dctc_cache = Object.create(null);
+  function __dctc_require(id) {
+    if (__dctc_cache[id]) return __dctc_cache[id].exports;
+    var record = __dctc_modules[id];
+    if (!record) return require(id);
+    var module = { exports: {} };
+    __dctc_cache[id] = module;
+    record.fn(module, module.exports, __dctc_require, require, record.filename, record.dirname);
+    return module.exports;
+  }
+  __dctc_require("${entryId}");
+})();`;
+
+    return bundle;
+  } catch (error) {
+    logErr("Build failed:");
+    console.error(error);
+    throw error;
+  }
+};
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dctc",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Dynamically compile TSX/TS files and execute them.",
   "main": "./lib/index.js",
   "bin": {
@@ -44,6 +44,7 @@
     "@rollup/plugin-commonjs": "^28.0.1",
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-typescript": "^12.1.0",
+    "@swc/core": "^1.15.7",
     "@types/node": "^22.0.0",
     "chalk": "^4.1.2",
     "commander": "^13.1.0",