@knighted/module 1.1.0 → 1.2.0

package/dist/helpers/ast.d.ts

@@ -0,0 +1,39 @@
+import type { Node } from 'oxc-parser';
+import type { CjsExport } from '../types.js';
+export type IdentifierNode = Extract<Node, {
+    type: 'Identifier';
+}>;
+export type LiteralNode = Extract<Node, {
+    type: 'Literal';
+    value?: unknown;
+}>;
+export type MemberExpressionNode = Extract<Node, {
+    type: 'MemberExpression';
+}>;
+export type CallExpressionNode = Extract<Node, {
+    type: 'CallExpression';
+}>;
+export type ProgramNode = Extract<Node, {
+    type: 'Program';
+    body: Node[];
+}>;
+export type ModuleExportNameNode = Extract<Node, {
+    type: 'Identifier' | 'Literal';
+}>;
+export type ImportDefaultSpecifierNode = Extract<Node, {
+    type: 'ImportDefaultSpecifier';
+}>;
+export type ImportNamespaceSpecifierNode = Extract<Node, {
+    type: 'ImportNamespaceSpecifier';
+}>;
+export type ImportSpecifierNode = Extract<Node, {
+    type: 'ImportSpecifier';
+}>;
+export type ExportsMap = Map<string, CjsExport> & {
+    hasUnsupportedExportWrite?: boolean;
+};
+export declare const isAstNode: (value: unknown) => value is Node;
+export declare const isIdentifierNode: (node: Node | null | undefined) => node is IdentifierNode;
+export declare const isMemberExpressionNode: (node: Node | null | undefined) => node is MemberExpressionNode;
+export declare const isCallExpressionNode: (node: Node | null | undefined) => node is CallExpressionNode;
+export declare const getModuleExportName: (name: ModuleExportNameNode | null | undefined) => string | null;

package/dist/helpers/ast.js

@@ -0,0 +1,18 @@
+export const isAstNode = value => {
+  return Boolean(value) && typeof value === 'object' && 'type' in value;
+};
+export const isIdentifierNode = node => {
+  return node?.type === 'Identifier';
+};
+export const isMemberExpressionNode = node => {
+  return node?.type === 'MemberExpression';
+};
+export const isCallExpressionNode = node => {
+  return node?.type === 'CallExpression';
+};
+export const getModuleExportName = name => {
+  if (!name) return null;
+  if (name.type === 'Identifier') return name.name;
+  if (name.type === 'Literal' && typeof name.value === 'string') return name.value;
+  return null;
+};

package/dist/helpers/identifier.js

@@ -1,5 +1,4 @@
 import { analyze } from 'periscopic';
-
 /**
  * Focus exclusively on IdentifierName type as it has the name property,
  * which is what the identifer utilities are interested in.
@@ -121,14 +120,16 @@ const identifier = {
     const node = ancestors[ancestors.length - 1];
     const varBoundScopes = ['ClassDeclaration', 'ClassExpression', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
     const declaratorIndex = ancestors.findIndex(ancestor => {
-      return ancestor.type === 'VariableDeclarator' && (ancestor === node || isInBindingPattern(ancestor.id, node));
+      if (ancestor.type !== 'VariableDeclarator') return false;
+      return ancestor === node || isInBindingPattern(ancestor.id, node);
     });
     if (declaratorIndex === -1) return false;
-    const declarator = ancestors[declaratorIndex];
+    const declaratorNode = ancestors[declaratorIndex];
     const declaration = ancestors[declaratorIndex - 1];
+    if (declaratorNode?.type !== 'VariableDeclarator') return false;
     return declaration?.type === 'VariableDeclaration' && declaration.kind === 'var' && ancestors.every(ancestor => {
       return !varBoundScopes.includes(ancestor.type);
-    }) && (declarator.id === node || isInBindingPattern(declarator.id, node));
+    }) && (declaratorNode.id === node || isInBindingPattern(declaratorNode.id, node));
   },
   isIife(ancestors) {
     const parent = ancestors[ancestors.length - 2];

package/dist/module.js

@@ -1,14 +1,14 @@
 import { resolve } from 'node:path';
 import { readFile, writeFile } from 'node:fs/promises';
 import { specifier } from './specifier.js';
-import { parse } from '#parse';
-import { format } from '#format';
-import { getLangFromExt } from '#utils/lang.js';
+import { parse } from './parse.js';
+import { format } from './format.js';
+import { getLangFromExt } from './utils/lang.js';
 import { builtinModules } from 'node:module';
 import { resolve as pathResolve, dirname as pathDirname, extname, join } from 'node:path';
 import { readFile as fsReadFile, stat } from 'node:fs/promises';
-import { parse as parseModule } from '#parse';
-import { walk } from '#walk';
+import { parse as parseModule } from './parse.js';
+import { walk } from './walk.js';
 const collapseSpecifier = value => value.replace(/['"`+)\s]|new String\(/g, '');
 const builtinSpecifiers = new Set(builtinModules.map(mod => mod.startsWith('node:') ? mod.slice(5) : mod).flatMap(mod => {
   const parts = mod.split('/');
@@ -160,6 +160,7 @@ const defaultOptions = {
   idiomaticExports: 'safe',
   importMetaPrelude: 'auto',
   topLevelAwait: 'error',
+  cwd: undefined,
   out: undefined,
   inPlace: false
 };
@@ -169,10 +170,11 @@ const transform = async (filename, options = defaultOptions) => {
     ...options,
     filePath: filename
   };
+  const cwdBase = opts.cwd ? resolve(opts.cwd) : process.cwd();
   const appendMode = options?.appendJsExtension ?? (opts.target === 'module' ? 'relative-only' : 'off');
   const dirIndex = opts.appendDirectoryIndex === undefined ? 'index.js' : opts.appendDirectoryIndex;
   const detectCycles = opts.detectCircularRequires ?? 'off';
-  const file = resolve(filename);
+  const file = resolve(cwdBase, filename);
   const code = (await readFile(file)).toString();
   const ast = parse(filename, code);
   let source = await format(code, ast, opts);
@@ -189,7 +191,7 @@ const transform = async (filename, options = defaultOptions) => {
   if (detectCycles !== 'off' && opts.target === 'module' && opts.transformSyntax) {
     await detectCircularRequireGraph(file, detectCycles, dirIndex || 'index.js');
   }
-  const outputPath = opts.inPlace ? file : opts.out ? resolve(opts.out) : undefined;
+  const outputPath = opts.inPlace ? file : opts.out ? resolve(cwdBase, opts.out) : undefined;
   if (outputPath) {
     await writeFile(outputPath, source);
   }

package/dist/specifier.js

@@ -2,7 +2,7 @@ import { resolve } from 'node:path';
 import { stat, readFile } from 'node:fs/promises';
 import MagicString from 'magic-string';
 import { parseSync } from 'oxc-parser';
-import { walk } from '#walk';
+import { walk } from './walk.js';
 const isStringLiteral = node => {
   return node.type === 'Literal' && typeof node.value === 'string';
 };

package/dist/types.d.ts

@@ -48,6 +48,8 @@ export type ModuleOptions = {
     diagnostics?: (diag: Diagnostic) => void;
     /** Optional source file path used for diagnostics context. */
     filePath?: string;
+    /** Base directory used to resolve relative `out` paths; defaults to process.cwd(). */
+    cwd?: string;
     /** Output directory or file path when writing. */
     out?: string;
     /** Overwrite input files instead of writing to out. */

package/dist/{src/utils → utils}/exports.d.ts

@@ -2,5 +2,8 @@ import type { Node } from 'oxc-parser';
 import type { CjsExport } from '../types.js';
 declare const exportsRename = "__exports";
 declare const requireMainRgx: RegExp;
-declare const collectCjsExports: (ast: Node) => Promise<Map<string, CjsExport>>;
+type ExportsMap = Map<string, CjsExport> & {
+    hasUnsupportedExportWrite?: boolean;
+};
+declare const collectCjsExports: (ast: Node) => Promise<ExportsMap>;
 export { exportsRename, requireMainRgx, collectCjsExports };

package/dist/utils/exports.js

@@ -1,4 +1,4 @@
-import { ancestorWalk } from '#walk';
+import { ancestorWalk } from '../walk.js';
 const exportsRename = '__exports';
 const requireMainRgx = /(require\.main\s*===\s*module|module\s*===\s*require\.main)/g;
 const literalPropName = (prop, literals) => {

package/dist/utils/identifiers.js

@@ -1,5 +1,5 @@
-import { ancestorWalk } from '#walk';
-import { identifier } from '#helpers/identifier.js';
+import { ancestorWalk } from '../walk.js';
+import { identifier } from '../helpers/identifier.js';
 import { scopeNodes } from './scopeNodes.js';
 const addBindingNames = (pattern, into) => {
   if (!pattern) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/module",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Bidirectional transform for ES modules and CommonJS.",
   "type": "module",
   "main": "dist/module.js",
@@ -18,14 +18,6 @@
     },
     "./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": ">=22.21.1 <23 || >=24 <25"
   },
@@ -35,13 +27,13 @@
     "prettier": "prettier -w .",
     "prettier:check": "prettier -c .",
     "lint": "oxlint --config oxlint.json .",
-    "prepare": "husky install",
+    "prepare": "husky",
     "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",
     "build": "npm run build:types && npm run build:dual",
-    "prepack": "npm run build && node scripts/setImportsToDist.js",
-    "postpack": "node scripts/restoreImportsToSrc.js"
+    "cycles": "madge --circular src --extensions ts,js --ts-config tsconfig.json",
+    "prepack": "npm run build"
   },
   "keywords": [
     "esm",
@@ -72,6 +64,7 @@
     "c8": "^10.1.3",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
+    "madge": "^8.0.0",
     "oxlint": "^1.35.0",
     "prettier": "^3.7.4",
     "tsx": "^4.21.0",
@@ -79,10 +72,14 @@
   },
   "dependencies": {
     "magic-string": "^0.30.21",
-    "node-module-type": "^1.0.4",
     "oxc-parser": "^0.105.0",
     "periscopic": "^4.0.2"
   },
+  "overrides": {
+    "module-lookup-amd": {
+      "glob": "^9.0.0"
+    }
+  },
   "prettier": {
     "arrowParens": "avoid",
     "printWidth": 90,

package/dist/cjs/utils.cjs

@@ -1,274 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.requireMainRgx = exports.isValidUrl = exports.exportsRename = exports.collectScopeIdentifiers = exports.collectModuleIdentifiers = exports.collectCjsExports = void 0;
-var _walk = require("./walk.cjs");
-var _identifier = require("./helpers/identifier.cjs");
-var _scopeNodes = require("./utils/scopeNodes.cjs");
-const isValidUrl = url => {
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-};
-exports.isValidUrl = isValidUrl;
-const exportsRename = exports.exportsRename = '__exports';
-const requireMainRgx = exports.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 (0, _walk.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;
-};
-exports.collectCjsExports = collectCjsExports;
-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.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.
- */
-exports.collectScopeIdentifiers = collectScopeIdentifiers;
-const collectModuleIdentifiers = async (ast, hoisting = true) => {
-  const identifiers = new Map();
-  const globalReads = new Map();
-  const scopes = [];
-  await (0, _walk.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.identifier.isDeclaration(ancestors);
-        const inScope = scopes.some(scope => scope.idents.has(name) || scope.name === name);
-        if (hoisting && !_identifier.identifier.isDeclaration(ancestors) && !_identifier.identifier.isFunctionExpressionId(ancestors) && !_identifier.identifier.isExportSpecifierAlias(ancestors) && !_identifier.identifier.isClassPropertyKey(ancestors) && !_identifier.identifier.isMethodDefinitionKey(ancestors) && !_identifier.identifier.isMemberKey(ancestors) && !_identifier.identifier.isPropertyKey(ancestors) && !_identifier.identifier.isIife(ancestors) && !inScope) {
-          if (globalReads.has(name)) {
-            globalReads.get(name)?.push(node);
-          } else {
-            globalReads.set(name, [node]);
-          }
-        }
-        if (isDeclaration) {
-          const isModuleScope = _identifier.identifier.isModuleScope(ancestors);
-          const isClassOrFuncDeclaration = _identifier.identifier.isClassOrFuncDeclarationId(ancestors);
-          const isVarDeclarationInGlobalScope = _identifier.identifier.isVarDeclarationInGlobalScope(ancestors);
-          const parent = ancestors[ancestors.length - 2];
-          const grandParent = ancestors[ancestors.length - 3];
-          const hoistSafe = parent.type === 'FunctionDeclaration' || parent.type === 'VariableDeclarator' && grandParent?.type === 'VariableDeclaration' && grandParent.kind === 'var';
-          if (isModuleScope || isClassOrFuncDeclaration || isVarDeclarationInGlobalScope) {
-            meta.declare.push(node);
-
-            // Check for hoisted reads
-            if (hoisting && hoistSafe && 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.identifier.isIife(ancestors) && !_identifier.identifier.isFunctionExpressionId(ancestors) && !_identifier.identifier.isExportSpecifierAlias(ancestors) && !_identifier.identifier.isClassPropertyKey(ancestors) && !_identifier.identifier.isMethodDefinitionKey(ancestors) && !_identifier.identifier.isMemberKey(ancestors) && !_identifier.identifier.isPropertyKey(ancestors)) {
-            // Closure is referencing module scope identifier
-            meta.read.push(node);
-          }
-        }
-      }
-    },
-    leave(node) {
-      const {
-        type
-      } = node;
-      if (_scopeNodes.scopeNodes.includes(type)) {
-        scopes.pop();
-      }
-    }
-  });
-  return identifiers;
-};
-exports.collectModuleIdentifiers = collectModuleIdentifiers;

package/dist/cjs/utils.d.cts

@@ -1,23 +0,0 @@
-import type { Node } from 'oxc-parser';
-import type { IdentMeta, Scope, CjsExport } from './types.cjs';
-declare const isValidUrl: (url: string) => boolean;
-declare const exportsRename = "__exports";
-declare const requireMainRgx: RegExp;
-declare const collectCjsExports: (ast: Node) => Promise<Map<string, CjsExport>>;
-declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
-/**
- * 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.
- */
-declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
-export { isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/src/format.d.ts

@@ -1,9 +0,0 @@
-import type { ParseResult } from 'oxc-parser';
-import type { FormatterOptions } from './types.js';
-/**
- * Node added support for import.meta.main.
- * Added in: v24.2.0, v22.18.0
- * @see https://nodejs.org/api/esm.html#importmetamain
- */
-declare const format: (src: string, ast: ParseResult, opts: FormatterOptions) => Promise<string>;
-export { format };

package/dist/src/module.d.ts

@@ -1,3 +0,0 @@
-import type { ModuleOptions } from './types.js';
-declare const transform: (filename: string, options?: ModuleOptions) => Promise<string>;
-export { transform };

package/dist/src/parse.d.ts

@@ -1,2 +0,0 @@
-declare const parse: (filename: string, code: string) => import("oxc-parser").ParseResult;
-export { parse };

package/dist/src/specifier.d.ts

@@ -1,16 +0,0 @@
-import type { ParserOptions, StringLiteral, TemplateLiteral, BinaryExpression, NewExpression, ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, TSImportType, ImportExpression, CallExpression } from 'oxc-parser';
-type Spec = {
-    type: 'StringLiteral' | 'TemplateLiteral' | 'BinaryExpression' | 'NewExpression';
-    node: StringLiteral | TemplateLiteral | BinaryExpression | NewExpression;
-    parent: CallExpression | ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression | TSImportType;
-    start: number;
-    end: number;
-    value: string;
-};
-type Callback = (spec: Spec) => string | void;
-declare const specifier: {
-    update(path: string, callback: Callback): Promise<string>;
-    updateSrc(src: string, lang: ParserOptions["lang"], callback: Callback): Promise<string>;
-};
-export { specifier };
-export type { Spec, Callback };