@ricsam/isolate 0.0.1 → 0.1.0

package/dist/cjs/internal/module-loader/strip-types.cjs

@@ -0,0 +1,236 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/isolate/src/internal/module-loader/strip-types.ts
+var exports_strip_types = {};
+__export(exports_strip_types, {
+  processTypeScript: () => processTypeScript,
+  isTypeScriptFile: () => isTypeScriptFile
+});
+module.exports = __toCommonJS(exports_strip_types);
+var import_node_module = __toESM(require("node:module"));
+var import_node_path = __toESM(require("node:path"));
+var _stripTypeScriptTypes;
+var bunTranspilerCache = {};
+function getStripTypeScriptTypes() {
+  const strip = import_node_module.default.stripTypeScriptTypes;
+  if (typeof strip !== "function") {
+    _stripTypeScriptTypes = undefined;
+    return;
+  }
+  if (_stripTypeScriptTypes !== strip) {
+    _stripTypeScriptTypes = strip;
+  }
+  return _stripTypeScriptTypes;
+}
+function getBunTranspiler(loader) {
+  const cached = bunTranspilerCache[loader];
+  if (cached)
+    return cached;
+  const bunGlobal = globalThis.Bun;
+  if (!bunGlobal?.Transpiler) {
+    return;
+  }
+  const transpiler = new bunGlobal.Transpiler({ loader });
+  bunTranspilerCache[loader] = transpiler;
+  return transpiler;
+}
+function transpileWithBunFallback(code, filename) {
+  const loader = import_node_path.default.extname(filename) === ".tsx" ? "tsx" : "ts";
+  const transpiler = getBunTranspiler(loader);
+  if (!transpiler) {
+    return null;
+  }
+  return transpiler.transformSync(code, { loader });
+}
+var TS_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+function isTypeScriptFile(filePath) {
+  return TS_EXTENSIONS.has(import_node_path.default.extname(filePath));
+}
+function processTypeScript(code, filename) {
+  const typeExportNames = findTypeOnlyExports(code);
+  const stripTypes = getStripTypeScriptTypes();
+  let stripped;
+  if (stripTypes) {
+    try {
+      stripped = stripTypes(code, {
+        mode: "transform",
+        sourceMap: false
+      });
+    } catch {
+      stripped = stripTypes(code, {
+        mode: "strip"
+      });
+    }
+  } else {
+    const bunTranspiled = transpileWithBunFallback(code, filename);
+    if (bunTranspiled === null) {
+      throw new Error("TypeScript processing is unavailable in this runtime. " + "Requires Node.js >= 22.7.0 (Module.stripTypeScriptTypes) " + "or Bun.Transpiler.");
+    }
+    stripped = bunTranspiled;
+  }
+  stripped = elideUnusedImports(stripped);
+  if (typeExportNames.length > 0) {
+    const needsPlaceholder = typeExportNames.filter((name) => !isValueExported(name, stripped));
+    if (needsPlaceholder.length > 0) {
+      const vars = needsPlaceholder.map((n) => `var ${n} = undefined;`).join(" ");
+      stripped += `
+` + vars + `
+export { ` + needsPlaceholder.join(", ") + ` };
+`;
+    }
+  }
+  return stripped;
+}
+var NAMED_IMPORT_RE = /import\s+([\w$]+\s*,\s*)?\{([\s\S]*?)\}\s*from\s*['"]([^'"]+)['"];?/g;
+function getImportedLocalName(specifier) {
+  const trimmed = specifier.trim();
+  const asMatch = trimmed.match(/^(.+?)\s+as\s+([A-Za-z_$][\w$]*)$/);
+  return asMatch ? asMatch[2] : trimmed;
+}
+function createImportedNameReferenceRegex(localName) {
+  const escaped = escapeRegExp(localName);
+  return new RegExp(`(?<![\\w$])${escaped}(?![\\w$])`);
+}
+function elideUnusedImports(code) {
+  const entries = [];
+  NAMED_IMPORT_RE.lastIndex = 0;
+  let m;
+  while ((m = NAMED_IMPORT_RE.exec(code)) !== null) {
+    entries.push({
+      fullMatch: m[0],
+      start: m.index,
+      end: m.index + m[0].length,
+      defaultPart: m[1] ?? "",
+      specifiers: m[2].split(",").map((s) => s.trim()).filter((s) => s.length > 0),
+      modulePath: m[3]
+    });
+  }
+  if (entries.length === 0)
+    return code;
+  let body = code;
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const { start, end } = entries[i];
+    body = body.slice(0, start) + " ".repeat(end - start) + body.slice(end);
+  }
+  let result = code;
+  for (let i = entries.length - 1;i >= 0; i--) {
+    const entry = entries[i];
+    const kept = [];
+    for (const spec of entry.specifiers) {
+      const localName = getImportedLocalName(spec);
+      if (createImportedNameReferenceRegex(localName).test(body)) {
+        kept.push(spec);
+      }
+    }
+    if (kept.length === entry.specifiers.length)
+      continue;
+    let replacement;
+    if (kept.length === 0 && !entry.defaultPart) {
+      replacement = "";
+    } else if (kept.length === 0) {
+      const def = entry.defaultPart.replace(/\s*,\s*$/, "").trim();
+      replacement = `import ${def} from '${entry.modulePath}';`;
+    } else {
+      replacement = `import ${entry.defaultPart}{ ${kept.join(", ")} } from '${entry.modulePath}';`;
+    }
+    result = result.slice(0, entry.start) + replacement + result.slice(entry.end);
+  }
+  return result;
+}
+function findTypeOnlyExports(code) {
+  const names = new Set;
+  let m;
+  const iface = /\bexport\s+interface\s+(\w+)/g;
+  while ((m = iface.exec(code)) !== null)
+    names.add(m[1]);
+  const alias = /\bexport\s+type\s+(\w+)\s*[=<]/g;
+  while ((m = alias.exec(code)) !== null)
+    names.add(m[1]);
+  const reExport = /\bexport\s+type\s*\{([^}]+)\}/g;
+  while ((m = reExport.exec(code)) !== null) {
+    for (const item of m[1].split(",")) {
+      const trimmed = item.trim();
+      const asMatch = trimmed.match(/\w+\s+as\s+(\w+)/);
+      if (asMatch)
+        names.add(asMatch[1]);
+      else if (/^\w+$/.test(trimmed))
+        names.add(trimmed);
+    }
+  }
+  return [...names];
+}
+function isValueExported(name, code) {
+  const e = escapeRegExp(name);
+  if (new RegExp(`\\bexport\\s+(?:var|let|const|function|class|async\\s+function)\\s+${e}\\b`).test(code))
+    return true;
+  if (new RegExp(`\\bexport\\s*\\{[^}]*\\b${e}\\b[^}]*\\}`).test(code))
+    return true;
+  if (name === "default" && /\bexport\s+default\b/.test(code))
+    return true;
+  return false;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+//# debugId=C2EBF8AAB5761F2C64756E2164756E21

package/dist/cjs/internal/module-loader/strip-types.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/internal/module-loader/strip-types.ts"],
+  "sourcesContent": [
+    "import Module from \"node:module\";\nimport path from \"node:path\";\n\ntype StripTypeScriptTypesFn = NonNullable<typeof Module.stripTypeScriptTypes>;\ntype TsLoader = \"ts\" | \"tsx\";\ntype BunTranspilerLike = {\n  transformSync(code: string, options?: { loader?: TsLoader }): string;\n};\ntype BunGlobalLike = {\n  Transpiler?: new (options: { loader: TsLoader }) => BunTranspilerLike;\n};\n\nlet _stripTypeScriptTypes: StripTypeScriptTypesFn | undefined;\nconst bunTranspilerCache: Partial<Record<TsLoader, BunTranspilerLike>> = {};\n\nfunction getStripTypeScriptTypes(): StripTypeScriptTypesFn | undefined {\n  const strip = Module.stripTypeScriptTypes;\n  if (typeof strip !== \"function\") {\n    _stripTypeScriptTypes = undefined;\n    return undefined;\n  }\n\n  if (_stripTypeScriptTypes !== strip) {\n    _stripTypeScriptTypes = strip;\n  }\n\n  return _stripTypeScriptTypes;\n}\n\nfunction getBunTranspiler(loader: TsLoader): BunTranspilerLike | undefined {\n  const cached = bunTranspilerCache[loader];\n  if (cached) return cached;\n\n  const bunGlobal = (globalThis as { Bun?: BunGlobalLike }).Bun;\n  if (!bunGlobal?.Transpiler) {\n    return undefined;\n  }\n\n  const transpiler = new bunGlobal.Transpiler({ loader });\n  bunTranspilerCache[loader] = transpiler;\n  return transpiler;\n}\n\nfunction transpileWithBunFallback(code: string, filename: string): string | null {\n  const loader: TsLoader = path.extname(filename) === \".tsx\" ? \"tsx\" : \"ts\";\n  const transpiler = getBunTranspiler(loader);\n  if (!transpiler) {\n    return null;\n  }\n\n  return transpiler.transformSync(code, { loader });\n}\n\nconst TS_EXTENSIONS = new Set([\".ts\", \".tsx\", \".mts\", \".cts\"]);\n\n/**\n * Check if a file path is a TypeScript file that needs type processing.\n */\nexport function isTypeScriptFile(filePath: string): boolean {\n  return TS_EXTENSIONS.has(path.extname(filePath));\n}\n\n/**\n * Process a TypeScript file for isolate use:\n *\n * 1. Strip TypeScript types\n * 2. Elide import specifiers no longer referenced in the code body\n *    (handles: `import { SomeType } from 'pkg'` where SomeType was only\n *    used in type positions — the import survives stripping but the\n *    usage doesn't, so V8 demands an export that doesn't exist in the bundle)\n * 3. Add placeholder exports for type-only export names\n *    (handles: `export interface Foo {}` disappears after stripping,\n *    but other files may `import { Foo }` from this module)\n *\n * Returns valid JavaScript.\n */\nexport function processTypeScript(code: string, filename: string): string {\n  // Find type-only export names BEFORE stripping\n  const typeExportNames = findTypeOnlyExports(code);\n\n  // Prefer Node's native strip API when available.\n  // Fall back to Bun.Transpiler for Bun-hosted callbacks.\n  const stripTypes = getStripTypeScriptTypes();\n  let stripped: string;\n  if (stripTypes) {\n    try {\n      stripped = stripTypes(code, {\n        mode: \"transform\",\n        sourceMap: false,\n      });\n    } catch {\n      stripped = stripTypes(code, {\n        mode: \"strip\",\n      });\n    }\n  } else {\n    const bunTranspiled = transpileWithBunFallback(code, filename);\n    if (bunTranspiled === null) {\n      throw new Error(\n        \"TypeScript processing is unavailable in this runtime. \" +\n        \"Requires Node.js >= 22.7.0 (Module.stripTypeScriptTypes) \" +\n        \"or Bun.Transpiler.\"\n      );\n    }\n    stripped = bunTranspiled;\n  }\n\n  // Elide unused import specifiers\n  stripped = elideUnusedImports(stripped);\n\n  // Add placeholder exports for type-only names not already value-exported\n  if (typeExportNames.length > 0) {\n    const needsPlaceholder = typeExportNames.filter(\n      (name) => !isValueExported(name, stripped),\n    );\n    if (needsPlaceholder.length > 0) {\n      const vars = needsPlaceholder.map((n) => `var ${n} = undefined;`).join(\" \");\n      stripped += \"\\n\" + vars + \"\\nexport { \" + needsPlaceholder.join(\", \") + \" };\\n\";\n    }\n  }\n\n  return stripped;\n}\n\n// ─── Import elision ──────────────────────────────────────────────────────────\n\n/**\n * Named import regex (handles single-line and multi-line).\n * Captures: [1] optional default part, [2] specifier list, [3] module path\n */\nconst NAMED_IMPORT_RE =\n  /import\\s+([\\w$]+\\s*,\\s*)?\\{([\\s\\S]*?)\\}\\s*from\\s*['\"]([^'\"]+)['\"];?/g;\n\nfunction getImportedLocalName(specifier: string): string {\n  const trimmed = specifier.trim();\n  const asMatch = trimmed.match(/^(.+?)\\s+as\\s+([A-Za-z_$][\\w$]*)$/);\n  return asMatch ? asMatch[2]! : trimmed;\n}\n\nfunction createImportedNameReferenceRegex(localName: string): RegExp {\n  const escaped = escapeRegExp(localName);\n  return new RegExp(`(?<![\\\\w$])${escaped}(?![\\\\w$])`);\n}\n\n/**\n * After type stripping, imported names that were only used in type positions\n * are unreferenced in the code body. Remove them from import statements\n * so V8's module linker doesn't demand them from the resolved module.\n */\nfunction elideUnusedImports(code: string): string {\n  // Collect all named-import regions\n  const entries: Array<{\n    fullMatch: string;\n    start: number;\n    end: number;\n    defaultPart: string;\n    specifiers: string[];\n    modulePath: string;\n  }> = [];\n\n  NAMED_IMPORT_RE.lastIndex = 0;\n  let m: RegExpExecArray | null;\n  while ((m = NAMED_IMPORT_RE.exec(code)) !== null) {\n    entries.push({\n      fullMatch: m[0],\n      start: m.index,\n      end: m.index + m[0].length,\n      defaultPart: m[1] ?? \"\",\n      specifiers: m[2]!\n        .split(\",\")\n        .map((s) => s.trim())\n        .filter((s) => s.length > 0),\n      modulePath: m[3]!,\n    });\n  }\n\n  if (entries.length === 0) return code;\n\n  // Build \"body\" = code with all import declarations blanked out\n  let body = code;\n  for (let i = entries.length - 1; i >= 0; i--) {\n    const { start, end } = entries[i]!;\n    body = body.slice(0, start) + \" \".repeat(end - start) + body.slice(end);\n  }\n\n  // Process imports in reverse order to preserve string indices\n  let result = code;\n  for (let i = entries.length - 1; i >= 0; i--) {\n    const entry = entries[i]!;\n    const kept: string[] = [];\n\n    for (const spec of entry.specifiers) {\n      // \"A as B\" → local name is B; \"A\" → local name is A\n      const localName = getImportedLocalName(spec);\n\n      // Keep if referenced anywhere in the body as a whole word\n      if (createImportedNameReferenceRegex(localName).test(body)) {\n        kept.push(spec);\n      }\n    }\n\n    // Nothing changed for this import\n    if (kept.length === entry.specifiers.length) continue;\n\n    let replacement: string;\n    if (kept.length === 0 && !entry.defaultPart) {\n      // All named specifiers gone, no default → remove entire import\n      replacement = \"\";\n    } else if (kept.length === 0) {\n      // Default import survives, named specifiers all gone\n      const def = entry.defaultPart.replace(/\\s*,\\s*$/, \"\").trim();\n      replacement = `import ${def} from '${entry.modulePath}';`;\n    } else {\n      replacement = `import ${entry.defaultPart}{ ${kept.join(\", \")} } from '${entry.modulePath}';`;\n    }\n\n    result = result.slice(0, entry.start) + replacement + result.slice(entry.end);\n  }\n\n  return result;\n}\n\n// ─── Type-only export placeholders ───────────────────────────────────────────\n\n/**\n * Find export names that are type-only (will vanish after stripping).\n */\nfunction findTypeOnlyExports(code: string): string[] {\n  const names = new Set<string>();\n  let m: RegExpExecArray | null;\n\n  // export interface Name  /  export interface Name<T>\n  const iface = /\\bexport\\s+interface\\s+(\\w+)/g;\n  while ((m = iface.exec(code)) !== null) names.add(m[1]!);\n\n  // export type Name = ...  /  export type Name<T> = ...\n  // (but NOT `export type { ... }`)\n  const alias = /\\bexport\\s+type\\s+(\\w+)\\s*[=<]/g;\n  while ((m = alias.exec(code)) !== null) names.add(m[1]!);\n\n  // export type { A, B }  /  export type { A } from './mod.cjs'\n  const reExport = /\\bexport\\s+type\\s*\\{([^}]+)\\}/g;\n  while ((m = reExport.exec(code)) !== null) {\n    for (const item of m[1]!.split(\",\")) {\n      const trimmed = item.trim();\n      const asMatch = trimmed.match(/\\w+\\s+as\\s+(\\w+)/);\n      if (asMatch) names.add(asMatch[1]!);\n      else if (/^\\w+$/.test(trimmed)) names.add(trimmed);\n    }\n  }\n\n  return [...names];\n}\n\n/**\n * Check if a name is still exported as a runtime value in the stripped code.\n */\nfunction isValueExported(name: string, code: string): boolean {\n  const e = escapeRegExp(name);\n  if (new RegExp(`\\\\bexport\\\\s+(?:var|let|const|function|class|async\\\\s+function)\\\\s+${e}\\\\b`).test(code)) return true;\n  if (new RegExp(`\\\\bexport\\\\s*\\\\{[^}]*\\\\b${e}\\\\b[^}]*\\\\}`).test(code)) return true;\n  if (name === \"default\" && /\\bexport\\s+default\\b/.test(code)) return true;\n  return false;\n}\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "C2EBF8AAB5761F2C64756E2164756E21",
+  "names": []
+}