@knighted/module 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/cjs/utils/url.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidUrl = void 0;
+// URL validation used when rewriting import.meta.url assignments.
+const isValidUrl = url => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+exports.isValidUrl = isValidUrl;

package/dist/cjs/utils.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.requireMainRgx = exports.isValidUrl = exports.getLangFromExt = exports.exportsRename = exports.collectScopeIdentifiers = exports.collectModuleIdentifiers = void 0;
+exports.requireMainRgx = exports.isValidUrl = exports.getLangFromExt = exports.exportsRename = exports.collectScopeIdentifiers = exports.collectModuleIdentifiers = exports.collectCjsExports = void 0;
 var _nodePath = require("node:path");
 var _walk = require("./walk.cjs");
 var _scope = require("./helpers/scope.cjs");
@@ -35,6 +35,76 @@ const isValidUrl = url => {
 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

package/dist/cjs/utils.d.cts

@@ -1,11 +1,12 @@
 import type { Node } from 'oxc-parser';
 import type { Specifier } from '@knighted/specifier';
-import type { IdentMeta, Scope } from './types.cjs';
+import type { IdentMeta, Scope, CjsExport } from './types.cjs';
 type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
 declare const getLangFromExt: (filename: string) => UpdateSrcLang;
 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.
@@ -22,4 +23,4 @@ declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
  * which are also valid module scope identifiers.
  */
 declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
-export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, exportsRename, requireMainRgx, };
+export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/exports.d.ts

@@ -0,0 +1,6 @@
+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>>;
+export { exportsRename, requireMainRgx, collectCjsExports };

package/dist/format.d.ts

@@ -1,8 +1,9 @@
 import type { ParseResult } from 'oxc-parser';
 import type { FormatterOptions } from './types.js';
 /**
- * Note, there is no specific conversion for `import.meta.main` as it does not exist.
- * @see https://github.com/nodejs/node/issues/49440
+ * 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/format.js

@@ -1,15 +1,18 @@
 import MagicString from 'magic-string';
-import { identifier } from './formatters/identifier.js';
-import { metaProperty } from './formatters/metaProperty.js';
-import { memberExpression } from './formatters/memberExpression.js';
-import { assignmentExpression } from './formatters/assignmentExpression.js';
-import { isValidUrl, exportsRename, collectModuleIdentifiers } from './utils.js';
-import { isIdentifierName } from './helpers/identifier.js';
-import { ancestorWalk } from './walk.js';
+import { identifier } from '#formatters/identifier.js';
+import { metaProperty } from '#formatters/metaProperty.js';
+import { memberExpression } from '#formatters/memberExpression.js';
+import { assignmentExpression } from '#formatters/assignmentExpression.js';
+import { isValidUrl } from '#utils/url.js';
+import { exportsRename, collectCjsExports } from '#utils/exports.js';
+import { collectModuleIdentifiers } from '#utils/identifiers.js';
+import { isIdentifierName } from '#helpers/identifier.js';
+import { ancestorWalk } from '#walk';
 
 /**
- * Note, there is no specific conversion for `import.meta.main` as it does not exist.
- * @see https://github.com/nodejs/node/issues/49440
+ * Node added support for import.meta.main.
+ * Added in: v24.2.0, v22.18.0
+ * @see https://nodejs.org/api/esm.html#importmetamain
  */
 const format = async (src, ast, opts) => {
   const code = new MagicString(src);
@@ -19,6 +22,7 @@ const format = async (src, ast, opts) => {
     hasDefaultExportBeenReassigned: false,
     hasDefaultExportBeenAssigned: false
   };
+  const exportTable = opts.target === 'module' ? await collectCjsExports(ast.program) : null;
   await collectModuleIdentifiers(ast.program);
   if (opts.target === 'module' && opts.transformSyntax) {
     /**
@@ -104,6 +108,35 @@ void import.meta.filename;
       }
     }
   });
+  if (opts.target === 'module' && opts.transformSyntax && exportTable) {
+    const isValidExportName = name => /^[$A-Z_a-z][$\w]*$/.test(name);
+    const asExportName = name => isValidExportName(name) ? name : JSON.stringify(name);
+    const accessProp = name => isValidExportName(name) ? `${exportsRename}.${name}` : `${exportsRename}[${JSON.stringify(name)}]`;
+    const tempNameFor = name => {
+      const sanitized = name.replace(/[^$\w]/g, '_') || 'value';
+      const safe = /^[0-9]/.test(sanitized) ? `_${sanitized}` : sanitized;
+      return `__export_${safe}`;
+    };
+    const lines = [];
+    const defaultEntry = exportTable.get('default');
+    if (defaultEntry) {
+      const def = defaultEntry.fromIdentifier ?? exportsRename;
+      lines.push(`export default ${def};`);
+    }
+    for (const [key, entry] of exportTable) {
+      if (key === 'default') continue;
+      if (entry.fromIdentifier) {
+        lines.push(`export { ${entry.fromIdentifier} as ${asExportName(key)} };`);
+      } else {
+        const temp = tempNameFor(key);
+        lines.push(`const ${temp} = ${accessProp(key)};`);
+        lines.push(`export { ${temp} as ${asExportName(key)} };`);
+      }
+    }
+    if (lines.length) {
+      code.append(`\n${lines.join('\n')}\n`);
+    }
+  }
   return code.toString();
 };
 export { format };

package/dist/formatters/assignmentExpression.js

@@ -1,4 +1,4 @@
-import { walk } from '../walk.js';
+import { walk } from '#walk';
 export const assignmentExpression = async ({
   node,
   parent: _parent,

package/dist/formatters/identifier.js

@@ -1,5 +1,5 @@
-import { exportsRename } from '../utils.js';
-import { identifier as ident } from '../helpers/identifier.js';
+import { exportsRename } from '#utils/exports.js';
+import { identifier as ident } from '#helpers/identifier.js';
 export const identifier = ({
   node,
   ancestors,

package/dist/formatters/memberExpression.js

@@ -1,4 +1,4 @@
-import { exportsRename } from '../utils.js';
+import { exportsRename } from '#utils/exports.js';
 export const memberExpression = (node, parent, src, options) => {
   if (options.target === 'module') {
     if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'module' && node.property.name === 'exports') {

package/dist/identifiers.d.ts

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

package/dist/lang.d.ts

@@ -0,0 +1,4 @@
+import type { Specifier } from '@knighted/specifier';
+type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
+declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+export { getLangFromExt };

package/dist/module.js

@@ -1,9 +1,9 @@
 import { resolve } from 'node:path';
 import { readFile, writeFile } from 'node:fs/promises';
 import { specifier } from '@knighted/specifier';
-import { parse } from './parse.js';
-import { format } from './format.js';
-import { getLangFromExt } from './utils.js';
+import { parse } from '#parse';
+import { format } from '#format';
+import { getLangFromExt } from '#utils/lang.js';
 const defaultOptions = {
   target: 'commonjs',
   sourceType: 'auto',

package/dist/src/format.d.ts

@@ -0,0 +1,9 @@
+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

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

package/dist/src/parse.d.ts

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

package/dist/src/types.d.ts

@@ -0,0 +1,43 @@
+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);
+export type ModuleOptions = {
+    target: 'module' | 'commonjs';
+    sourceType?: 'auto' | 'module' | 'commonjs';
+    transformSyntax?: boolean;
+    liveBindings?: 'strict' | 'loose' | 'off';
+    rewriteSpecifier?: RewriteSpecifier;
+    dirFilename?: 'inject' | 'preserve' | 'error';
+    importMeta?: 'preserve' | 'shim' | 'error';
+    requireSource?: 'builtin' | 'create-require';
+    cjsDefault?: 'module-exports' | 'auto' | 'none';
+    topLevelAwait?: 'error' | 'wrap' | 'preserve';
+    out?: string;
+    inPlace?: boolean;
+};
+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;
+};
+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/exports.d.ts

@@ -0,0 +1,6 @@
+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>>;
+export { exportsRename, requireMainRgx, collectCjsExports };

package/dist/src/utils/identifiers.d.ts

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

package/dist/src/utils/lang.d.ts

@@ -0,0 +1,4 @@
+import type { Specifier } from '@knighted/specifier';
+type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
+declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+export { getLangFromExt };

package/dist/src/utils/url.d.ts

@@ -0,0 +1,2 @@
+declare const isValidUrl: (url: string) => boolean;
+export { isValidUrl };

package/dist/src/utils.d.ts

@@ -0,0 +1,26 @@
+import type { Node } from 'oxc-parser';
+import type { Specifier } from '@knighted/specifier';
+import type { IdentMeta, Scope, CjsExport } from './types.js';
+type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
+declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+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 { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/src/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/types.d.ts

@@ -21,6 +21,14 @@ export type ExportsMeta = {
     hasDefaultExportBeenAssigned: boolean;
     defaultExportValue: unknown;
 };
+export type CjsExport = {
+    key: string;
+    writes: SpannedNode[];
+    fromIdentifier?: string;
+    via: Set<'exports' | 'module.exports'>;
+    reassignments: SpannedNode[];
+    hasGetter?: boolean;
+};
 export type IdentMeta = {
     declare: SpannedNode[];
     read: SpannedNode[];

package/dist/url.d.ts

@@ -0,0 +1,2 @@
+declare const isValidUrl: (url: string) => boolean;
+export { isValidUrl };