@knighted/module 1.3.0 → 1.3.1

package/dist/pipeline/idiomaticPlan.js

@@ -0,0 +1,218 @@
+import { isAstNode, isCallExpressionNode, isIdentifierNode, isMemberExpressionNode } from '../helpers/ast.js';
+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 (!isAstNode(n) || found) return;
+    if (isCallExpressionNode(n) && isIdentifierNode(n.callee) && n.callee.name === 'require' && !shadowed.has('require')) {
+      found = true;
+      return;
+    }
+    if (isCallExpressionNode(n) && isMemberExpressionNode(n.callee) && 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
+    }
+  };
+};
+export { buildIdiomaticPlan };

package/dist/pipeline/interopHelpers.d.ts

@@ -0,0 +1,5 @@
+declare const defaultInteropName = "__interopDefault";
+declare const interopHelper = "const __interopDefault = mod => (mod && mod.__esModule ? mod.default : mod);\n";
+declare const requireInteropName = "__requireDefault";
+declare const requireInteropHelper = "const __requireDefault = mod => (mod && typeof mod === 'object' && 'default' in mod ? mod.default : mod);\n";
+export { defaultInteropName, interopHelper, requireInteropHelper, requireInteropName };

package/dist/pipeline/interopHelpers.js

@@ -0,0 +1,5 @@
+const defaultInteropName = '__interopDefault';
+const interopHelper = `const ${defaultInteropName} = mod => (mod && mod.__esModule ? mod.default : mod);\n`;
+const requireInteropName = '__requireDefault';
+const requireInteropHelper = `const ${requireInteropName} = mod => (mod && typeof mod === 'object' && 'default' in mod ? mod.default : mod);\n`;
+export { defaultInteropName, interopHelper, requireInteropHelper, requireInteropName };

package/dist/pipeline/lowerCjsRequireToImports.d.ts

@@ -0,0 +1,17 @@
+import MagicString from 'magic-string';
+import { type CallExpressionNode, type ProgramNode, type Node } from '../helpers/ast.js';
+type RequireTransform = {
+    start: number;
+    end: number;
+    code: string;
+};
+declare const isStaticRequire: (node: Node, shadowed: Set<string>) => node is CallExpressionNode;
+declare const isRequireCall: (node: Node, shadowed: Set<string>) => node is CallExpressionNode;
+declare const lowerCjsRequireToImports: (program: ProgramNode, code: MagicString, shadowed: Set<string>) => {
+    transforms: RequireTransform[];
+    imports: string[];
+    hoisted: string[];
+    needsCreateRequire: boolean;
+    needsInteropHelper: boolean;
+};
+export { isRequireCall, isStaticRequire, lowerCjsRequireToImports, type RequireTransform };

package/dist/pipeline/lowerCjsRequireToImports.js

@@ -0,0 +1,102 @@
+import { isCallExpressionNode } from '../helpers/ast.js';
+import { requireInteropName } from './interopHelpers.js';
+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';
+const isRequireCall = (node, shadowed) => node.type === 'CallExpression' && isRequireCallee(node.callee, shadowed);
+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 || !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} = ${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} = ${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 (!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
+  };
+};
+export { isRequireCall, isStaticRequire, lowerCjsRequireToImports };

package/dist/pipeline/lowerEsmToCjs.d.ts

@@ -0,0 +1,22 @@
+import MagicString from 'magic-string';
+import { type ProgramNode } from '../helpers/ast.js';
+import type { FormatterOptions } from '../types.js';
+declare const exportAssignment: (name: string, expr: string, live: "strict" | "loose" | "off") => string;
+type ImportTransform = {
+    start: number;
+    end: number;
+    code: string;
+    needsInterop: boolean;
+};
+type ExportTransform = {
+    start: number;
+    end: number;
+    code: string;
+    needsInterop?: boolean;
+};
+declare const lowerEsmToCjs: (program: ProgramNode, code: MagicString, opts: FormatterOptions, containsTopLevelAwait: boolean) => {
+    importTransforms: ImportTransform[];
+    exportTransforms: ExportTransform[];
+    needsInterop: boolean;
+};
+export { exportAssignment, lowerEsmToCjs, type ExportTransform, type ImportTransform };

package/dist/pipeline/lowerEsmToCjs.js

@@ -0,0 +1,197 @@
+import { getModuleExportName } from '../helpers/ast.js';
+import { defaultInteropName } from './interopHelpers.js';
+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};`;
+};
+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 = `${defaultInteropName}(${modIdent})`;
+            needsInterop = true;
+            break;
+        }
+        lines.push(`const ${defaultSpec.local.name} = ${init};`);
+      }
+      if (namedSpecs.length) {
+        const pairs = namedSpecs.map(s => {
+          const imported = 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 = getModuleExportName(spec.exported);
+            const imported = getModuleExportName(spec.local);
+            if (!exported || !imported) continue;
+            let rhs = `${modIdent}.${imported}`;
+            if (imported === 'default') {
+              rhs = `${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 = getModuleExportName(spec.exported);
+            const local = 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 = 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
+  };
+};
+export { exportAssignment, lowerEsmToCjs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/module",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Bidirectional transform for ES modules and CommonJS.",
   "type": "module",
   "main": "dist/module.js",