@knighted/module 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/utils.js

@@ -0,0 +1,278 @@
+import { extname } from 'node:path';
+import { ancestorWalk } from './walk.js';
+import { scopes as scopeNodes } from './helpers/scope.js';
+import { identifier } from './helpers/identifier.js';
+const getLangFromExt = filename => {
+  const ext = extname(filename);
+  if (ext.endsWith('.js')) {
+    return 'js';
+  }
+  if (ext.endsWith('.ts')) {
+    return 'ts';
+  }
+  if (ext === '.tsx') {
+    return 'tsx';
+  }
+  if (ext === '.jsx') {
+    return 'jsx';
+  }
+};
+const isValidUrl = url => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const exportsRename = '__exports';
+const requireMainRgx = /(require\.main\s*===\s*module|module\s*===\s*require\.main)/g;
+const resolveExportTarget = node => {
+  if (node.type !== 'MemberExpression') return null;
+  const base = node.object;
+  const prop = node.property;
+  if (prop.type !== 'Identifier') return null;
+  if (base.type === 'Identifier' && base.name === 'exports') {
+    return {
+      key: prop.name,
+      via: 'exports'
+    };
+  }
+  if (base.type === 'MemberExpression' && base.object.type === 'Identifier' && base.object.name === 'module' && base.property.type === 'Identifier' && base.property.name === 'exports') {
+    return {
+      key: prop.name,
+      via: 'module.exports'
+    };
+  }
+  if (base.type === 'Identifier' && base.name === 'module' && prop.type === 'Identifier' && prop.name === 'exports') {
+    return {
+      key: 'default',
+      via: 'module.exports'
+    };
+  }
+  return null;
+};
+const collectCjsExports = async ast => {
+  const exportsMap = new Map();
+  const localToExport = new Map();
+  await ancestorWalk(ast, {
+    enter(node) {
+      if (node.type === 'AssignmentExpression') {
+        const target = resolveExportTarget(node.left);
+        if (target) {
+          const entry = exportsMap.get(target.key) ?? {
+            key: target.key,
+            writes: [],
+            via: new Set(),
+            reassignments: []
+          };
+          entry.via.add(target.via);
+          entry.writes.push(node);
+          if (node.right.type === 'Identifier') {
+            entry.fromIdentifier ??= node.right.name;
+            if (entry.fromIdentifier) {
+              const set = localToExport.get(entry.fromIdentifier) ?? new Set();
+              set.add(target.key);
+              localToExport.set(entry.fromIdentifier, set);
+            }
+          }
+          exportsMap.set(target.key, entry);
+          return;
+        }
+        if (node.left.type === 'Identifier') {
+          const keys = localToExport.get(node.left.name);
+          if (keys) {
+            keys.forEach(key => {
+              const entry = exportsMap.get(key);
+              if (entry) {
+                entry.reassignments.push(node);
+                exportsMap.set(key, entry);
+              }
+            });
+          }
+        }
+      }
+    }
+  });
+  return exportsMap;
+};
+const collectScopeIdentifiers = (node, scopes) => {
+  const {
+    type
+  } = node;
+  switch (type) {
+    case 'BlockStatement':
+    case 'ClassBody':
+      scopes.push({
+        node,
+        type: 'Block',
+        name: type,
+        idents: new Set()
+      });
+      break;
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ArrowFunctionExpression':
+      {
+        const name = node.id ? node.id.name : 'anonymous';
+        const scope = {
+          node,
+          name,
+          type: 'Function',
+          idents: new Set()
+        };
+        node.params.map(param => {
+          if (param.type === 'TSParameterProperty') {
+            return param.parameter;
+          }
+          if (param.type === 'RestElement') {
+            return param.argument;
+          }
+          if (param.type === 'AssignmentPattern') {
+            return param.left;
+          }
+          return param;
+        }).filter(identifier.isNamed).forEach(param => {
+          scope.idents.add(param.name);
+        });
+
+        /**
+         * If a FunctionExpression has an id, it is a named function expression.
+         * The function expression name shadows the module scope identifier, so
+         * we don't want to count reads of module identifers that have the same name.
+         * They also do not cause a SyntaxError if the function expression name is
+         * the same as a module scope identifier.
+         *
+         * TODO: Is this necessary for FunctionDeclaration?
+         */
+        if (node.type === 'FunctionExpression' && node.id) {
+          scope.idents.add(node.id.name);
+        }
+
+        // First add the function to any previous scopes
+        if (scopes.length > 0) {
+          scopes[scopes.length - 1].idents.add(name);
+        }
+
+        // Then add the function scope to the scopes stack
+        scopes.push(scope);
+      }
+      break;
+    case 'ClassDeclaration':
+      {
+        const className = node.id ? node.id.name : 'anonymous';
+
+        // First add the class to any previous scopes
+        if (scopes.length > 0) {
+          scopes[scopes.length - 1].idents.add(className);
+        }
+
+        // Then add the class to the scopes stack
+        scopes.push({
+          node,
+          name: className,
+          type: 'Class',
+          idents: new Set()
+        });
+      }
+      break;
+    case 'ClassExpression':
+      {}
+      break;
+    case 'VariableDeclaration':
+      if (scopes.length > 0) {
+        const scope = scopes[scopes.length - 1];
+        node.declarations.forEach(decl => {
+          if (decl.type === 'VariableDeclarator' && decl.id.type === 'Identifier') {
+            scope.idents.add(decl.id.name);
+          }
+        });
+      }
+      break;
+  }
+};
+
+/**
+ * Collects all module scope identifiers in the AST.
+ *
+ * Ignores identifiers that are in functions or classes.
+ * Ignores new scopes for StaticBlock nodes (can only reference static class members).
+ *
+ * Special case handling for these which create their own scopes,
+ * but are also valid module scope identifiers:
+ * - ClassDeclaration
+ * - FunctionDeclaration
+ *
+ * Special case handling for var inside BlockStatement
+ * which are also valid module scope identifiers.
+ */
+const collectModuleIdentifiers = async (ast, hoisting = true) => {
+  const identifiers = new Map();
+  const globalReads = new Map();
+  const scopes = [];
+  await ancestorWalk(ast, {
+    enter(node, ancestors) {
+      const {
+        type
+      } = node;
+      collectScopeIdentifiers(node, scopes);
+
+      // Add module scope identifiers to the registry map
+
+      if (type === 'Identifier') {
+        const {
+          name
+        } = node;
+        const meta = identifiers.get(name) ?? {
+          declare: [],
+          read: []
+        };
+        const isDeclaration = identifier.isDeclaration(ancestors);
+        const inScope = scopes.some(scope => scope.idents.has(name) || scope.name === name);
+        if (hoisting && !identifier.isDeclaration(ancestors) && !identifier.isFunctionExpressionId(ancestors) && !identifier.isExportSpecifierAlias(ancestors) && !identifier.isClassPropertyKey(ancestors) && !identifier.isMethodDefinitionKey(ancestors) && !identifier.isMemberKey(ancestors) && !identifier.isPropertyKey(ancestors) && !identifier.isIife(ancestors) && !inScope) {
+          if (globalReads.has(name)) {
+            globalReads.get(name)?.push(node);
+          } else {
+            globalReads.set(name, [node]);
+          }
+        }
+        if (isDeclaration) {
+          const isModuleScope = identifier.isModuleScope(ancestors);
+          const isClassOrFuncDeclaration = identifier.isClassOrFuncDeclarationId(ancestors);
+          const isVarDeclarationInGlobalScope = identifier.isVarDeclarationInGlobalScope(ancestors);
+          if (isModuleScope || isClassOrFuncDeclaration || isVarDeclarationInGlobalScope) {
+            meta.declare.push(node);
+
+            // Check for hoisted reads
+            if (hoisting && globalReads.has(name)) {
+              const reads = globalReads.get(name);
+              if (reads) {
+                reads.forEach(read => {
+                  if (!meta.read.includes(read)) {
+                    meta.read.push(read);
+                  }
+                });
+              }
+            }
+            identifiers.set(name, meta);
+          }
+        } else {
+          if (identifiers.has(name) && !inScope && !identifier.isIife(ancestors) && !identifier.isFunctionExpressionId(ancestors) && !identifier.isExportSpecifierAlias(ancestors) && !identifier.isClassPropertyKey(ancestors) && !identifier.isMethodDefinitionKey(ancestors) && !identifier.isMemberKey(ancestors) && !identifier.isPropertyKey(ancestors)) {
+            // Closure is referencing module scope identifier
+            meta.read.push(node);
+          }
+        }
+      }
+    },
+    leave(node) {
+      const {
+        type
+      } = node;
+      if (scopeNodes.includes(type)) {
+        scopes.pop();
+      }
+    }
+  });
+  return identifiers;
+};
+export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx };

package/dist/walk.d.ts

@@ -0,0 +1,20 @@
+import type { Node } from 'oxc-parser';
+/**
+ * Using visitorKeys instead of oxc Visitor to keep
+ * an ancestor-aware enter/leave API with this.skip()
+ * without per-node method boilerplate.
+ */
+type AncestorContext = {
+    skip: () => void;
+};
+type AncestorVisitor = {
+    enter?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+};
+type WalkVisitor = {
+    enter?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+};
+declare const ancestorWalk: (node: Node, visitors: AncestorVisitor) => Promise<void>;
+declare const walk: (node: Node, visitors: WalkVisitor) => Promise<void>;
+export { ancestorWalk, walk };

package/dist/walk.js

@@ -0,0 +1,69 @@
+import { visitorKeys } from 'oxc-parser';
+
+/**
+ * Using visitorKeys instead of oxc Visitor to keep
+ * an ancestor-aware enter/leave API with this.skip()
+ * without per-node method boilerplate.
+ */
+
+let skipDepth = -1;
+const isNodeLike = value => {
+  return Boolean(value && typeof value === 'object' && 'type' in value);
+};
+const traverse = async (node, visitors, ancestors, depth) => {
+  if (!node) return;
+  const keys = visitorKeys[node.type] ?? [];
+  const ctx = {
+    skip: () => {
+      skipDepth = depth;
+    }
+  };
+  ancestors.push(node);
+  if (visitors.enter) {
+    await visitors.enter.call(ctx, node, ancestors);
+  }
+  if (skipDepth === -1 || depth < skipDepth) {
+    const fields = node;
+    for (const key of keys) {
+      const child = fields[key];
+      if (Array.isArray(child)) {
+        for (const nested of child) {
+          if (isNodeLike(nested)) {
+            await traverse(nested, visitors, ancestors, depth + 1);
+          }
+        }
+      } else if (isNodeLike(child)) {
+        await traverse(child, visitors, ancestors, depth + 1);
+      }
+    }
+  }
+  if (visitors.leave) {
+    await visitors.leave.call(ctx, node, ancestors);
+  }
+  ancestors.pop();
+  if (skipDepth === depth) {
+    skipDepth = -1;
+  }
+};
+const ancestorWalk = async (node, visitors) => {
+  skipDepth = -1;
+  await traverse(node, visitors, [], 0);
+};
+const walk = async (node, visitors) => {
+  const wrap = {
+    enter(current, ancestors) {
+      const parent = ancestors[ancestors.length - 2] ?? null;
+      if (visitors.enter) {
+        return visitors.enter.call(this, current, parent);
+      }
+    },
+    leave(current, ancestors) {
+      const parent = ancestors[ancestors.length - 2] ?? null;
+      if (visitors.leave) {
+        return visitors.leave.call(this, current, parent);
+      }
+    }
+  };
+  await ancestorWalk(node, wrap);
+};
+export { ancestorWalk, walk };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@knighted/module",
-  "version": "1.0.0-alpha.9",
-  "description": "Transforms module differences between ES and CommonJS.",
+  "version": "1.0.0-beta.1",
+  "description": "Transforms differences between ES modules and CommonJS.",
   "type": "module",
   "main": "dist/module.js",
   "exports": {
@@ -18,13 +18,24 @@
     },
     "./package.json": "./package.json"
   },
+  "imports": {
+    "#parse": "./src/parse.js",
+    "#format": "./src/format.js",
+    "#utils/*.js": "./src/utils/*.js",
+    "#walk": "./src/walk.js",
+    "#helpers/*.js": "./src/helpers/*.js",
+    "#formatters/*.js": "./src/formatters/*.js"
+  },
   "engines": {
     "node": ">=20.11.0"
   },
   "engineStrict": true,
   "scripts": {
+    "check-types": "tsc -p tsconfig.test.json",
     "prettier": "prettier -w .",
-    "lint": "eslint --ignore-pattern dist .",
+    "prettier:check": "prettier -c .",
+    "lint": "oxlint --config oxlint.json .",
+    "prepare": "husky install",
     "test": "c8 --reporter=text --reporter=text-summary --reporter=lcov tsx --test --test-reporter=spec test/*.ts",
     "build:types": "tsc --emitDeclarationOnly",
     "build:dual": "babel-dual-package src --extensions .ts",
@@ -33,8 +44,14 @@
   },
   "keywords": [
     "transform",
-    "esm",
-    "commonjs"
+    "es module",
+    "commonjs",
+    "require",
+    "require.resolve",
+    "import.meta.url",
+    "import.meta.dirname",
+    "__dirname",
+    "__filename"
   ],
   "files": [
     "dist"
@@ -49,34 +66,35 @@
     "url": "https://github.com/knightedcodemonkey/module/issues"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.28.0",
-    "@babel/preset-typescript": "^7.27.1",
-    "@babel/types": "^7.28.2",
-    "@eslint/js": "^9.3.0",
-    "@types/babel__traverse": "^7.20.7",
+    "@knighted/dump": "^1.0.3",
     "@types/node": "^22.13.17",
-    "babel-dual-package": "^1.2.1",
+    "babel-dual-package": "^1.2.3",
     "c8": "^10.1.3",
-    "eslint": "^9.32.0",
-    "eslint-plugin-n": "^17.21.2",
-    "prettier": "^3.2.5",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.38.0"
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "oxlint": "^1.35.0",
+    "prettier": "^3.7.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@babel/parser": "^7.28.0",
-    "@babel/traverse": "^7.28.0",
-    "@knighted/specifier": "^2.0.7",
-    "@knighted/walk": "^1.0.0",
-    "magic-string": "^0.30.10",
-    "node-module-type": "^1.0.2",
-    "oxc-parser": "^0.78.0"
+    "@knighted/specifier": "^2.0.9",
+    "magic-string": "^0.30.21",
+    "node-module-type": "^1.0.4",
+    "oxc-parser": "^0.105.0",
+    "periscopic": "^4.0.2"
   },
   "prettier": {
     "arrowParens": "avoid",
-    "printWidth": 119,
+    "printWidth": 90,
     "semi": false,
     "singleQuote": true
+  },
+  "lint-staged": {
+    "*.{js,ts,tsx,jsx,cjs,mjs}": [
+      "prettier -c",
+      "oxlint --config oxlint.json"
+    ],
+    "*.{json,md,yml,yaml,css,scss,html}": "prettier -c"
   }
 }

package/dist/formatters/expressionStatement.d.ts

@@ -1,5 +0,0 @@
-import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { ExpressionStatement } from '@babel/types';
-import type { FormatterOptions } from '../types.js';
-export declare const expressionStatement: (nodePath: NodePath<ExpressionStatement>, src: MagicString, options: FormatterOptions) => void;

package/dist/formatters/identifier.d.ts

@@ -1,5 +0,0 @@
-import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { Identifier } from '@babel/types';
-import type { FormatterOptions } from '../types.js';
-export declare const identifier: (nodePath: NodePath<Identifier>, src: MagicString, options: FormatterOptions) => void;

package/dist/formatters/memberExpression.d.ts

@@ -1,5 +0,0 @@
-import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { MemberExpression } from '@babel/types';
-import type { FormatterOptions } from '../types.js';
-export declare const memberExpression: (nodePath: NodePath<MemberExpression>, src: MagicString, options: FormatterOptions) => void;

package/dist/formatters/metaProperty.d.ts

@@ -1,5 +0,0 @@
-import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { MetaProperty } from '@babel/types';
-import type { FormatterOptions } from '../types.js';
-export declare const metaProperty: (nodePath: NodePath<MetaProperty>, src: MagicString, options: FormatterOptions) => void;