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

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/memberExpression.d.ts

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

package/dist/metaProperty.d.ts

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

package/dist/module.js

@@ -1,28 +1,22 @@
-import { resolve, extname } from 'node:path';
+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 { parse } from '#parse';
+import { format } from '#format';
+import { getLangFromExt } from '#utils/lang.js';
 const defaultOptions = {
-  type: 'commonjs',
+  target: 'commonjs',
+  sourceType: 'auto',
+  transformSyntax: true,
+  liveBindings: 'strict',
+  rewriteSpecifier: undefined,
+  dirFilename: 'inject',
+  importMeta: 'shim',
+  requireSource: 'builtin',
+  cjsDefault: 'auto',
+  topLevelAwait: 'error',
   out: undefined,
-  modules: false,
-  specifier: undefined
-};
-const getLangFromExt = filename => {
-  const ext = extname(filename);
-  if (/\.js$/.test(ext)) {
-    return 'js';
-  }
-  if (/\.ts$/.test(ext)) {
-    return 'ts';
-  }
-  if (ext === '.tsx') {
-    return 'tsx';
-  }
-  if (ext === '.jsx') {
-    return 'jsx';
-  }
+  inPlace: false
 };
 const transform = async (filename, options = defaultOptions) => {
   const opts = {
@@ -31,24 +25,29 @@ const transform = async (filename, options = defaultOptions) => {
   };
   const file = resolve(filename);
   const code = (await readFile(file)).toString();
-  const ast = parse(code);
-  let source = format(code, ast, opts).toString();
-  if (options.specifier) {
+  const ast = parse(filename, code);
+  let source = await format(code, ast, opts);
+  if (opts.rewriteSpecifier) {
     const code = await specifier.updateSrc(source, getLangFromExt(filename), ({
       value
     }) => {
+      if (typeof opts.rewriteSpecifier === 'function') {
+        return opts.rewriteSpecifier(value) ?? undefined;
+      }
+
       // Collapse any BinaryExpression or NewExpression to test for a relative specifier
       const collapsed = value.replace(/['"`+)\s]|new String\(/g, '');
       const relative = /^(?:\.|\.\.)\//;
       if (relative.test(collapsed)) {
         // $2 is for any closing quotation/parens around BE or NE
-        return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"`]*)?$/, `$1${options.specifier}$2`);
+        return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"]*)?$/, `$1${opts.rewriteSpecifier}$2`);
       }
     });
     source = code;
   }
-  if (opts.out) {
-    await writeFile(resolve(opts.out), source);
+  const outputPath = opts.inPlace ? file : opts.out ? resolve(opts.out) : undefined;
+  if (outputPath) {
+    await writeFile(outputPath, source);
   }
   return source;
 };

package/dist/parse.d.ts

@@ -1,2 +1,2 @@
-declare const parse: (source: string, dts?: boolean) => import("@babel/parser").ParseResult<import("@babel/types").File>;
+declare const parse: (filename: string, code: string) => import("oxc-parser").ParseResult;
 export { parse };

package/dist/parse.js

@@ -1,16 +1,5 @@
-import { parse as babelParse } from '@babel/parser';
-const parse = (source, dts = false) => {
-  const ast = babelParse(source, {
-    sourceType: 'module',
-    allowAwaitOutsideFunction: true,
-    allowReturnOutsideFunction: true,
-    allowImportExportEverywhere: true,
-    plugins: ['jsx', ['importAttributes', {
-      deprecatedAssertSyntax: true
-    }], ['typescript', {
-      dts
-    }]]
-  });
-  return ast;
+import { parseSync } from 'oxc-parser';
+const parse = (filename, code) => {
+  return parseSync(filename, code);
 };
 export { parse };

package/dist/scope.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

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/formatters/assignmentExpression.d.ts

@@ -0,0 +1,12 @@
+import MagicString from 'magic-string';
+import type { Node, AssignmentExpression } from 'oxc-parser';
+import type { FormatterOptions, ExportsMeta } from '../types.js';
+type AssignmentExpressionArg = {
+    node: AssignmentExpression;
+    parent: Node | null;
+    code: MagicString;
+    opts: FormatterOptions;
+    meta: ExportsMeta;
+};
+export declare const assignmentExpression: ({ node, parent: _parent, code: _code, opts, meta: _meta, }: AssignmentExpressionArg) => Promise<void>;
+export {};

package/dist/src/formatters/expressionStatement.d.ts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { Node, ExpressionStatement } from 'oxc-parser';
+import type { FormatterOptions } from '../types.js';
+export declare const expressionStatement: (node: ExpressionStatement, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/src/formatters/identifier.d.ts

@@ -0,0 +1,12 @@
+import MagicString from 'magic-string';
+import type { Node, IdentifierName } from 'oxc-parser';
+import type { FormatterOptions, ExportsMeta } from '../types.js';
+type IdentifierArg = {
+    node: IdentifierName;
+    ancestors: Node[];
+    code: MagicString;
+    opts: FormatterOptions;
+    meta: ExportsMeta;
+};
+export declare const identifier: ({ node, ancestors, code, opts, meta }: IdentifierArg) => void;
+export {};

package/dist/src/formatters/memberExpression.d.ts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { MemberExpression, Node } from 'oxc-parser';
+import type { FormatterOptions } from '../types.js';
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/src/formatters/metaProperty.d.ts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { Node, MetaProperty } from 'oxc-parser';
+import type { FormatterOptions } from '../types.js';
+export declare const metaProperty: (node: MetaProperty, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/src/helpers/identifier.d.ts

@@ -0,0 +1,31 @@
+import type { Node, IdentifierName } from 'oxc-parser';
+/**
+ * Focus exclusively on IdentifierName type as it has the name property,
+ * which is what the identifer utilities are interested in.
+ *
+ * Explicitly ignore the TSThisParameter type as it is not a valid identifier name.
+ */
+declare const isIdentifierName: (node: Node) => node is IdentifierName;
+/**
+ * All methods receive the full set of ancestors, which
+ * specifically includes the node itself as the last element.
+ * The second to last element is the parent node, and so on.
+ * The first element is the root node.
+ */
+declare const identifier: {
+    isNamed: (node: Node) => node is IdentifierName;
+    isMetaProperty(ancestors: Node[]): boolean;
+    isModuleScope(ancestors: Node[], includeImports?: boolean): boolean;
+    isMemberExpressionRoot(ancestors: Node[]): boolean;
+    isDeclaration(ancestors: Node[]): boolean;
+    isClassOrFuncDeclarationId(ancestors: Node[]): boolean;
+    isVarDeclarationInGlobalScope(ancestors: Node[]): boolean;
+    isIife(ancestors: Node[]): boolean;
+    isFunctionExpressionId(ancestors: Node[]): boolean;
+    isExportSpecifierAlias(ancestors: Node[]): boolean;
+    isClassPropertyKey(ancestors: Node[]): boolean;
+    isMethodDefinitionKey(ancestors: Node[]): boolean;
+    isMemberKey(ancestors: Node[]): boolean;
+    isPropertyKey(ancestors: Node[]): boolean;
+};
+export { identifier, isIdentifierName };

package/dist/src/helpers/scope.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

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

@@ -1,7 +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 = {
-    type?: 'module' | 'commonjs';
-    modules?: boolean;
-    specifier?: '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts';
+    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 FormatterOptions = Omit<ModuleOptions, 'out'> & Required<Pick<ModuleOptions, 'type'>>;
+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/url.d.ts

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