@knighted/module 1.3.0 → 1.3.1

package/dist/cjs/pipeline/idiomaticPlan.cjs

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildIdiomaticPlan = void 0;
+var _ast = require("../helpers/ast.cjs");
+const reservedExports = new Set(['await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'implements', 'import', 'in', 'instanceof', 'interface', 'let', 'new', 'null', 'package', 'private', 'protected', 'public', 'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield']);
+const isValidExportName = name => /^[$A-Z_a-z][$\w]*$/.test(name) && !reservedExports.has(name);
+const isAllowedRhs = node => node.type === 'Identifier' || node.type === 'Literal' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression' || node.type === 'ClassExpression';
+const expressionHasRequireCall = (node, shadowed) => {
+  let found = false;
+  const walkNode = n => {
+    if (!(0, _ast.isAstNode)(n) || found) return;
+    if ((0, _ast.isCallExpressionNode)(n) && (0, _ast.isIdentifierNode)(n.callee) && n.callee.name === 'require' && !shadowed.has('require')) {
+      found = true;
+      return;
+    }
+    if ((0, _ast.isCallExpressionNode)(n) && (0, _ast.isMemberExpressionNode)(n.callee) && (0, _ast.isIdentifierNode)(n.callee.object) && n.callee.object.name === 'require' && !shadowed.has('require')) {
+      found = true;
+      return;
+    }
+    const record = n;
+    const keys = Object.keys(record);
+    for (const key of keys) {
+      const value = record[key];
+      if (!value) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === 'object') walkNode(item);
+          if (found) return;
+        }
+      } else if (value && typeof value === 'object') {
+        walkNode(value);
+        if (found) return;
+      }
+    }
+  };
+  walkNode(node);
+  return found;
+};
+const rhsSourceFor = (code, node) => code.slice(node.start, node.end).replace(/\b__dirname\b/g, 'import.meta.dirname').replace(/\b__filename\b/g, 'import.meta.filename');
+const tryObjectLiteralExport = (rhs, code, requireShadowed, baseIsModuleExports, propName) => {
+  if (!baseIsModuleExports || propName !== 'exports') return null;
+  if (rhs.type !== 'ObjectExpression') return null;
+  const exportsOut = [];
+  const seenKeys = new Set();
+  for (const prop of rhs.properties) {
+    if (prop.type !== 'Property') return null;
+    if (prop.kind !== 'init') return null;
+    if (prop.computed || prop.method) return null;
+    if (prop.key.type !== 'Identifier') return null;
+    const key = prop.key.name;
+    if (key === '__proto__' || key === 'prototype') return null;
+    if (!isValidExportName(key)) return null;
+    if (seenKeys.has(key)) return null;
+    const value = prop.value.type === 'Identifier' && prop.shorthand ? prop.key : prop.value;
+    if (!isAllowedRhs(value)) return null;
+    if (expressionHasRequireCall(value, requireShadowed)) return null;
+    const rhsSrc = rhsSourceFor(code, value);
+    if (value.type === 'Identifier' && value.name === key) {
+      exportsOut.push(`export { ${key} };`);
+    } else if (value.type === 'Identifier') {
+      exportsOut.push(`export { ${rhsSrc} as ${key} };`);
+    } else {
+      exportsOut.push(`export const ${key} = ${rhsSrc};`);
+    }
+    seenKeys.add(key);
+  }
+  exportsOut.push(`export default ${rhsSourceFor(code, rhs)};`);
+  return {
+    exportsOut,
+    seenKeys
+  };
+};
+const buildIdiomaticPlan = ({
+  src,
+  code,
+  exportTable,
+  shadowedBindings,
+  idiomaticMode
+}) => {
+  if (idiomaticMode === 'off') return {
+    ok: false,
+    reason: 'disabled'
+  };
+  const entries = [...exportTable.values()];
+  if (!entries.length) return {
+    ok: false,
+    reason: 'no-exports'
+  };
+  if (exportTable.hasUnsupportedExportWrite) {
+    return {
+      ok: false,
+      reason: 'unsupported-left'
+    };
+  }
+  const viaSet = new Set();
+  for (const entry of entries) {
+    entry.via.forEach(v => viaSet.add(v));
+    if (entry.hasGetter) return {
+      ok: false,
+      reason: 'getter-present'
+    };
+    if (entry.reassignments.length) return {
+      ok: false,
+      reason: 'reassignment'
+    };
+    if (entry.hasNonTopLevelWrite) return {
+      ok: false,
+      reason: 'non-top-level'
+    };
+    if (entry.writes.length !== 1) return {
+      ok: false,
+      reason: 'multiple-writes'
+    };
+    if (entry.key !== 'default' && !isValidExportName(entry.key)) return {
+      ok: false,
+      reason: 'non-identifier-key'
+    };
+  }
+  if (viaSet.size > 1) return {
+    ok: false,
+    reason: 'mixed-exports'
+  };
+  const replacements = [];
+  const exportsOut = [];
+  const seen = new Set();
+  const requireShadowed = shadowedBindings;
+  for (const entry of entries) {
+    const write = entry.writes[0];
+    if (write.type !== 'AssignmentExpression') {
+      return {
+        ok: false,
+        reason: 'unsupported-write-kind'
+      };
+    }
+    const left = write.left;
+    if (left.type !== 'MemberExpression' || left.computed || left.property.type !== 'Identifier') {
+      return {
+        ok: false,
+        reason: 'unsupported-left'
+      };
+    }
+    const base = left.object;
+    const propName = left.property.name;
+    const baseIsExports = base.type === 'Identifier' && base.name === 'exports';
+    const baseIsModuleExports = base.type === 'Identifier' && base.name === 'module' && propName === 'exports' || base.type === 'MemberExpression' && base.object.type === 'Identifier' && base.object.name === 'module' && base.property.type === 'Identifier' && base.property.name === 'exports';
+    if (!baseIsExports && !baseIsModuleExports) {
+      return {
+        ok: false,
+        reason: 'unsupported-base'
+      };
+    }
+    const rhs = write.right;
+    const objectLiteralPlan = tryObjectLiteralExport(rhs, code, requireShadowed, baseIsModuleExports, propName);
+    if (!objectLiteralPlan) {
+      if (!isAllowedRhs(rhs)) return {
+        ok: false,
+        reason: 'unsupported-rhs'
+      };
+      if (expressionHasRequireCall(rhs, requireShadowed)) {
+        return {
+          ok: false,
+          reason: 'rhs-require'
+        };
+      }
+    }
+    const rhsSrc = rhsSourceFor(code, rhs);
+    if (propName === 'exports' && baseIsModuleExports) {
+      if (objectLiteralPlan) {
+        for (const line of objectLiteralPlan.exportsOut) {
+          exportsOut.push(line);
+        }
+        objectLiteralPlan.seenKeys.forEach(k => seen.add(k));
+      } else {
+        if (seen.has('default')) return {
+          ok: false,
+          reason: 'duplicate-default'
+        };
+        seen.add('default');
+        exportsOut.push(`export default ${rhsSrc};`);
+      }
+    } else {
+      if (seen.has(propName)) return {
+        ok: false,
+        reason: 'duplicate-key'
+      };
+      seen.add(propName);
+      if (rhs.type === 'Identifier') {
+        const rhsId = rhsSourceFor(code, rhs);
+        const rhsName = rhs.name;
+        if (rhsId === rhsName && rhsName === propName) {
+          exportsOut.push(`export { ${propName} };`);
+        } else if (rhsId === rhsName) {
+          exportsOut.push(`export { ${rhsId} as ${propName} };`);
+        } else {
+          exportsOut.push(`export const ${propName} = ${rhsId};`);
+        }
+      } else {
+        exportsOut.push(`export const ${propName} = ${rhsSrc};`);
+      }
+    }
+    let end = write.end;
+    while (end < src.length && (src[end] === ' ' || src[end] === '\t')) end++;
+    if (end < src.length && src[end] === ';') end++;
+    replacements.push({
+      start: write.start,
+      end
+    });
+  }
+  if (!seen.size) return {
+    ok: false,
+    reason: 'no-seen'
+  };
+  return {
+    ok: true,
+    plan: {
+      replacements,
+      exports: exportsOut
+    }
+  };
+};
+exports.buildIdiomaticPlan = buildIdiomaticPlan;

package/dist/cjs/pipeline/interopHelpers.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireInteropName = exports.requireInteropHelper = exports.interopHelper = exports.defaultInteropName = void 0;
+const defaultInteropName = exports.defaultInteropName = '__interopDefault';
+const interopHelper = exports.interopHelper = `const ${defaultInteropName} = mod => (mod && mod.__esModule ? mod.default : mod);\n`;
+const requireInteropName = exports.requireInteropName = '__requireDefault';
+const requireInteropHelper = exports.requireInteropHelper = `const ${requireInteropName} = mod => (mod && typeof mod === 'object' && 'default' in mod ? mod.default : mod);\n`;

package/dist/cjs/pipeline/lowerCjsRequireToImports.cjs

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lowerCjsRequireToImports = exports.isStaticRequire = exports.isRequireCall = void 0;
+var _ast = require("../helpers/ast.cjs");
+var _interopHelpers = require("./interopHelpers.cjs");
+const isRequireCallee = (callee, shadowed) => {
+  if (callee.type === 'Identifier' && callee.name === 'require' && !shadowed.has('require')) {
+    return true;
+  }
+  if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'module' && !shadowed.has('module') && callee.property.type === 'Identifier' && callee.property.name === 'require') {
+    return true;
+  }
+  return false;
+};
+const isStaticRequire = (node, shadowed) => node.type === 'CallExpression' && isRequireCallee(node.callee, shadowed) && node.arguments.length === 1 && node.arguments[0].type === 'Literal' && typeof node.arguments[0].value === 'string';
+exports.isStaticRequire = isStaticRequire;
+const isRequireCall = (node, shadowed) => node.type === 'CallExpression' && isRequireCallee(node.callee, shadowed);
+exports.isRequireCall = isRequireCall;
+const lowerCjsRequireToImports = (program, code, shadowed) => {
+  const transforms = [];
+  const imports = [];
+  const hoisted = [];
+  let nsIndex = 0;
+  let needsCreateRequire = false;
+  let needsInteropHelper = false;
+  const isJsonSpecifier = value => {
+    const base = value.split(/[?#]/)[0] ?? value;
+    return base.endsWith('.json');
+  };
+  for (const stmt of program.body) {
+    if (stmt.type === 'VariableDeclaration') {
+      const decls = stmt.declarations;
+      const allStatic = decls.length > 0 && decls.every(decl => decl.init && isStaticRequire(decl.init, shadowed));
+      if (allStatic) {
+        for (const decl of decls) {
+          const init = decl.init;
+          if (!init || !(0, _ast.isCallExpressionNode)(init)) {
+            needsCreateRequire = true;
+            continue;
+          }
+          const arg = init.arguments[0];
+          const source = code.slice(arg.start, arg.end);
+          const value = arg.value;
+          const isJson = typeof value === 'string' && isJsonSpecifier(value);
+          const ns = `__cjsImport${nsIndex++}`;
+          const jsonImport = isJson ? `${source} with { type: "json" }` : source;
+          if (decl.id.type === 'Identifier') {
+            imports.push(isJson ? `import ${ns} from ${jsonImport};\n` : `import * as ${ns} from ${jsonImport};\n`);
+            hoisted.push(isJson ? `const ${decl.id.name} = ${ns};\n` : `const ${decl.id.name} = ${_interopHelpers.requireInteropName}(${ns});\n`);
+            needsInteropHelper ||= !isJson;
+          } else if (decl.id.type === 'ObjectPattern' || decl.id.type === 'ArrayPattern') {
+            const pattern = code.slice(decl.id.start, decl.id.end);
+            imports.push(isJson ? `import ${ns} from ${jsonImport};\n` : `import * as ${ns} from ${jsonImport};\n`);
+            hoisted.push(isJson ? `const ${pattern} = ${ns};\n` : `const ${pattern} = ${_interopHelpers.requireInteropName}(${ns});\n`);
+            needsInteropHelper ||= !isJson;
+          } else {
+            needsCreateRequire = true;
+          }
+        }
+        transforms.push({
+          start: stmt.start,
+          end: stmt.end,
+          code: ';\n'
+        });
+        continue;
+      }
+      for (const decl of decls) {
+        const init = decl.init;
+        if (init && isRequireCall(init, shadowed)) {
+          needsCreateRequire = true;
+        }
+      }
+    }
+    if (stmt.type === 'ExpressionStatement') {
+      const expr = stmt.expression;
+      if (expr && isStaticRequire(expr, shadowed)) {
+        if (!(0, _ast.isCallExpressionNode)(expr)) {
+          needsCreateRequire = true;
+          continue;
+        }
+        const arg = expr.arguments[0];
+        const source = code.slice(arg.start, arg.end);
+        const value = arg.value;
+        const isJson = typeof value === 'string' && isJsonSpecifier(value);
+        const jsonImport = isJson ? `${source} with { type: "json" }` : source;
+        imports.push(`import ${jsonImport};\n`);
+        transforms.push({
+          start: stmt.start,
+          end: stmt.end,
+          code: ';\n'
+        });
+        continue;
+      }
+      if (expr && isRequireCall(expr, shadowed)) {
+        needsCreateRequire = true;
+      }
+    }
+  }
+  return {
+    transforms,
+    imports,
+    hoisted,
+    needsCreateRequire,
+    needsInteropHelper
+  };
+};
+exports.lowerCjsRequireToImports = lowerCjsRequireToImports;

package/dist/cjs/pipeline/lowerEsmToCjs.cjs

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lowerEsmToCjs = exports.exportAssignment = void 0;
+var _ast = require("../helpers/ast.cjs");
+var _interopHelpers = require("./interopHelpers.cjs");
+const isValidIdent = name => /^[$A-Z_a-z][$\w]*$/.test(name);
+const exportAssignment = (name, expr, live) => {
+  const prop = isValidIdent(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+  if (live === 'strict') {
+    const key = JSON.stringify(name);
+    return `Object.defineProperty(exports, ${key}, { enumerable: true, get: () => ${expr} });`;
+  }
+  return `exports${prop} = ${expr};`;
+};
+exports.exportAssignment = exportAssignment;
+const lowerEsmToCjs = (program, code, opts, containsTopLevelAwait) => {
+  const live = opts.liveBindings ?? 'strict';
+  const importTransforms = [];
+  const exportTransforms = [];
+  let needsInterop = false;
+  let importIndex = 0;
+  for (const node of program.body) {
+    if (node.type === 'ImportDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      const specifiers = node.specifiers ?? [];
+      const defaultSpec = specifiers.find(s => s.type === 'ImportDefaultSpecifier');
+      const namespaceSpec = specifiers.find(s => s.type === 'ImportNamespaceSpecifier');
+      const namedSpecs = specifiers.filter(s => s.type === 'ImportSpecifier');
+      if (!specifiers.length) {
+        importTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `require(${srcLiteral});\n`,
+          needsInterop: false
+        });
+        continue;
+      }
+      const modIdent = `__mod${importIndex++}`;
+      const lines = [];
+      lines.push(`const ${modIdent} = require(${srcLiteral});`);
+      if (namespaceSpec) {
+        lines.push(`const ${namespaceSpec.local.name} = ${modIdent};`);
+      }
+      if (defaultSpec) {
+        let init = modIdent;
+        switch (opts.cjsDefault) {
+          case 'module-exports':
+            init = modIdent;
+            break;
+          case 'none':
+            init = `${modIdent}.default`;
+            break;
+          case 'auto':
+          default:
+            init = `${_interopHelpers.defaultInteropName}(${modIdent})`;
+            needsInterop = true;
+            break;
+        }
+        lines.push(`const ${defaultSpec.local.name} = ${init};`);
+      }
+      if (namedSpecs.length) {
+        const pairs = namedSpecs.map(s => {
+          const imported = (0, _ast.getModuleExportName)(s.imported);
+          if (!imported) return s.local.name;
+          const local = s.local.name;
+          return imported === local ? imported : `${imported}: ${local}`;
+        });
+        lines.push(`const { ${pairs.join(', ')} } = ${modIdent};`);
+      }
+      importTransforms.push({
+        start: node.start,
+        end: node.end,
+        code: `${lines.join('\n')}\n`,
+        needsInterop
+      });
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+      if (node.declaration) {
+        const decl = node.declaration;
+        const declSrc = code.slice(decl.start, decl.end);
+        const exportedNames = [];
+        if (decl.type === 'VariableDeclaration') {
+          for (const d of decl.declarations) {
+            if (d.id.type === 'Identifier') {
+              exportedNames.push(d.id.name);
+            }
+          }
+        } else if ('id' in decl && decl.id?.type === 'Identifier') {
+          exportedNames.push(decl.id.name);
+        }
+        const exportLines = exportedNames.map(name => exportAssignment(name, name, live));
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${declSrc}\n${exportLines.join('\n')}\n`
+        });
+        continue;
+      }
+      if (node.specifiers?.length) {
+        if (node.source) {
+          const srcLiteral = code.slice(node.source.start, node.source.end);
+          const modIdent = `__mod${importIndex++}`;
+          const lines = [`const ${modIdent} = require(${srcLiteral});`];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = (0, _ast.getModuleExportName)(spec.exported);
+            const imported = (0, _ast.getModuleExportName)(spec.local);
+            if (!exported || !imported) continue;
+            let rhs = `${modIdent}.${imported}`;
+            if (imported === 'default') {
+              rhs = `${_interopHelpers.defaultInteropName}(${modIdent})`;
+              needsInterop = true;
+            }
+            lines.push(exportAssignment(exported, rhs, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`,
+            needsInterop
+          });
+        } else {
+          const lines = [];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = (0, _ast.getModuleExportName)(spec.exported);
+            const local = (0, _ast.getModuleExportName)(spec.local);
+            if (!exported || !local) continue;
+            lines.push(exportAssignment(exported, local, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`
+          });
+        }
+      }
+    }
+    if (node.type === 'ExportDefaultDeclaration') {
+      const decl = node.declaration;
+      const useExportsObject = containsTopLevelAwait && opts.topLevelAwait !== 'error';
+      if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
+        if (decl.id?.name) {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${decl.id.name};` : `module.exports = ${decl.id.name};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${declSrc}\n${assign}\n`
+          });
+        } else {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${declSrc};` : `module.exports = ${declSrc};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${assign}\n`
+          });
+        }
+      } else {
+        const exprSrc = code.slice(decl.start, decl.end);
+        const assign = useExportsObject ? `exports.default = ${exprSrc};` : `module.exports = ${exprSrc};`;
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${assign}\n`
+        });
+      }
+    }
+    if (node.type === 'ExportAllDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      if ('exported' in node && node.exported) {
+        const exported = (0, _ast.getModuleExportName)(node.exported);
+        if (!exported) continue;
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`, exportAssignment(exported, modIdent, live)];
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      } else {
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`];
+        const loop = `for (const k in ${modIdent}) {\n  if (k === 'default') continue;\n  if (!Object.prototype.hasOwnProperty.call(${modIdent}, k)) continue;\n  Object.defineProperty(exports, k, { enumerable: true, get: () => ${modIdent}[k] });\n}`;
+        lines.push(loop);
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      }
+    }
+  }
+  return {
+    importTransforms,
+    exportTransforms,
+    needsInterop
+  };
+};
+exports.lowerEsmToCjs = lowerEsmToCjs;

package/dist/exportBagToEsm.d.ts

@@ -0,0 +1,13 @@
+import MagicString from 'magic-string';
+import type { ExportsMap } from '../helpers/ast.js';
+type WarnOnce = (codeId: string, message: string, loc?: {
+    start: number;
+    end: number;
+}) => void;
+declare const exportBagToEsm: (params: {
+    code: MagicString;
+    exportTable: ExportsMap;
+    warnOnce: WarnOnce;
+    importMetaRef: boolean;
+}) => boolean;
+export { exportBagToEsm, type WarnOnce };