@knighted/module 1.1.0 → 1.2.0

package/dist/src/types.d.ts

@@ -1,93 +0,0 @@
-import type { Node, Span, IdentifierName, IdentifierReference, BindingIdentifier, LabelIdentifier, TSIndexSignatureName } from 'oxc-parser';
-export type RewriteSpecifier = '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts' | ((value: string) => string | null | undefined);
-/** Options that control how modules are parsed, transformed, and emitted. */
-export type ModuleOptions = {
-    /** Output format to emit. */
-    target: 'module' | 'commonjs';
-    /** Explicit source type; auto infers from file extension. */
-    sourceType?: 'auto' | 'module' | 'commonjs';
-    /**
-     * Enable syntax transforms beyond parsing.
-     * - true: full CJS↔ESM lowering/raising
-     * - 'globals-only': rewrite module-global differences (import.meta, __dirname/filename, require.main shims) while leaving import/export shapes untouched
-     * - false/undefined: no syntax transforms
-     */
-    transformSyntax?: boolean | 'globals-only';
-    /** How to emit live bindings for ESM exports. */
-    liveBindings?: 'strict' | 'loose' | 'off';
-    /** Rewrite import specifiers (e.g. add extensions). */
-    rewriteSpecifier?: RewriteSpecifier;
-    /** Whether to append .js to relative imports. */
-    appendJsExtension?: 'off' | 'relative-only' | 'all';
-    /** Add directory index (e.g. /index.js) or disable. */
-    appendDirectoryIndex?: string | false;
-    /** Precedence: rewriteSpecifier runs first; if it returns a string that wins. If it returns undefined or null, appenders apply. Bare specifiers are never modified by appenders. */
-    /** Control __dirname/__filename handling (inject shims, preserve existing, or throw on use). */
-    dirFilename?: 'inject' | 'preserve' | 'error';
-    /** How to treat import.meta. */
-    importMeta?: 'preserve' | 'shim' | 'error';
-    /** Strategy for import.meta.main emulation. */
-    importMetaMain?: 'shim' | 'warn' | 'error';
-    /** Resolution strategy for detecting the main module. */
-    requireMainStrategy?: 'import-meta-main' | 'realpath';
-    /** Detect circular require usage level. */
-    detectCircularRequires?: 'off' | 'warn' | 'error';
-    /** Source used to provide require in ESM output. */
-    requireSource?: 'builtin' | 'create-require';
-    /** How to rewrite nested or non-hoistable require calls. */
-    nestedRequireStrategy?: 'create-require' | 'dynamic-import';
-    /** Default interop style for CommonJS default imports. */
-    cjsDefault?: 'module-exports' | 'auto' | 'none';
-    /** Emit idiomatic exports when raising CJS to ESM. */
-    idiomaticExports?: 'off' | 'safe' | 'aggressive';
-    /** Control whether a no-op import.meta prelude is emitted. */
-    importMetaPrelude?: 'off' | 'auto' | 'on';
-    /** Handling for top-level await constructs. */
-    topLevelAwait?: 'error' | 'wrap' | 'preserve';
-    /** Optional diagnostics sink for warnings/errors emitted during transform. */
-    diagnostics?: (diag: Diagnostic) => void;
-    /** Optional source file path used for diagnostics context. */
-    filePath?: string;
-    /** Output directory or file path when writing. */
-    out?: string;
-    /** Overwrite input files instead of writing to out. */
-    inPlace?: boolean;
-};
-export type Diagnostic = {
-    level: 'warning' | 'error';
-    code: string;
-    message: string;
-    filePath?: string;
-    loc?: {
-        start: number;
-        end: number;
-    };
-};
-export type SpannedNode = Node & Span;
-export type ExportsMeta = {
-    hasExportsBeenReassigned: boolean;
-    hasDefaultExportBeenReassigned: boolean;
-    hasDefaultExportBeenAssigned: boolean;
-    defaultExportValue: unknown;
-};
-export type CjsExport = {
-    key: string;
-    writes: SpannedNode[];
-    fromIdentifier?: string;
-    via: Set<'exports' | 'module.exports'>;
-    reassignments: SpannedNode[];
-    hasGetter?: boolean;
-    hasNonTopLevelWrite?: boolean;
-};
-export type IdentMeta = {
-    declare: SpannedNode[];
-    read: SpannedNode[];
-};
-export type Scope = {
-    type: string;
-    name: string;
-    node: Node;
-    idents: Set<string>;
-};
-export type FormatterOptions = Omit<ModuleOptions, 'out' | 'inPlace'>;
-export type Identifier = IdentifierName | IdentifierReference | BindingIdentifier | LabelIdentifier | TSIndexSignatureName;

package/dist/src/utils.d.ts

@@ -1,23 +0,0 @@
-import type { Node } from 'oxc-parser';
-import type { IdentMeta, Scope, CjsExport } from './types.js';
-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/walk.d.ts

@@ -1,20 +0,0 @@
-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/utils.d.ts

@@ -1,23 +0,0 @@
-import type { Node } from 'oxc-parser';
-import type { IdentMeta, Scope, CjsExport } from './types.js';
-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/utils.js

@@ -1,265 +0,0 @@
-import { ancestorWalk } from './walk.js';
-import { identifier } from './helpers/identifier.js';
-import { scopeNodes } from './utils/scopeNodes.js';
-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);
-          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.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 { isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx };