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

package/dist/cjs/walk.d.cts

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

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

package/dist/format.d.ts

@@ -1,9 +1,8 @@
-import MagicString from 'magic-string';
-import type { ParseResult } from '@babel/parser';
-import type { File } from '@babel/types';
+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
  */
-export declare const format: (code: string, ast: ParseResult<File>, options: FormatterOptions) => MagicString;
+declare const format: (src: string, ast: ParseResult, opts: FormatterOptions) => Promise<string>;
+export { format };

package/dist/format.js

@@ -1,34 +1,109 @@
 import MagicString from 'magic-string';
-import _traverse from '@babel/traverse';
-import { moduleType } from 'node-module-type';
 import { identifier } from './formatters/identifier.js';
 import { metaProperty } from './formatters/metaProperty.js';
 import { memberExpression } from './formatters/memberExpression.js';
-
-/**
- * Runtime hack to prevent issues with babel's default interop while dual building with tsc.
- * @see https://github.com/babel/babel/discussions/13093#discussioncomment-12705927
- * Temporary fix until I switch to oxc-parser.
- */
-const type = moduleType();
-const traverse = typeof _traverse === 'function' || type === 'commonjs' ? _traverse : _traverse.default;
+import { assignmentExpression } from './formatters/assignmentExpression.js';
+import { isValidUrl, exportsRename, collectModuleIdentifiers } from './utils.js';
+import { isIdentifierName } from './helpers/identifier.js';
+import { ancestorWalk } from './walk.js';
 
 /**
  * Note, there is no specific conversion for `import.meta.main` as it does not exist.
  * @see https://github.com/nodejs/node/issues/49440
  */
-export const format = (code, ast, options) => {
-  const src = new MagicString(code);
-  traverse(ast, {
-    Identifier(path) {
-      identifier(path, src, options);
-    },
-    MetaProperty(path) {
-      metaProperty(path, src, options);
-    },
-    MemberExpression(path) {
-      memberExpression(path, src, options);
+const format = async (src, ast, opts) => {
+  const code = new MagicString(src);
+  const exportsMeta = {
+    hasExportsBeenReassigned: false,
+    defaultExportValue: undefined,
+    hasDefaultExportBeenReassigned: false,
+    hasDefaultExportBeenAssigned: false
+  };
+  await collectModuleIdentifiers(ast.program);
+  if (opts.target === 'module' && opts.transformSyntax) {
+    /**
+     * Prepare ESM output by renaming `exports` to `__exports` and seeding an
+     * `import.meta.filename` touch so import.meta is present even when the
+     * original source never referenced it.
+     */
+    code.prepend(`let ${exportsRename} = {};
+void import.meta.filename;
+`);
+  }
+  await ancestorWalk(ast.program, {
+    async enter(node, ancestors) {
+      const parent = ancestors[ancestors.length - 2] ?? null;
+      if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+        const skipped = ['__filename', '__dirname'];
+        const skippedParams = node.params.filter(param => param.type === 'Identifier' && skipped.includes(param.name));
+        const skippedFuncIdentifier = node.id?.type === 'Identifier' && skipped.includes(node.id.name);
+        if (skippedParams.length || skippedFuncIdentifier) {
+          this.skip();
+        }
+      }
+
+      /**
+       * Check for assignment to `import.meta.url`.
+       */
+      if (node.type === 'AssignmentExpression' && node.left.type === 'MemberExpression' && node.left.object.type === 'MetaProperty' && node.left.property.type === 'Identifier' && node.left.property.name === 'url') {
+        if (node.right.type === 'Literal' && typeof node.right.value === 'string') {
+          if (!isValidUrl(node.right.value)) {
+            const rhs = code.snip(node.right.start, node.right.end).toString();
+            const assignment = code.snip(node.start, node.end).toString();
+            code.update(node.start, node.end, `/* Invalid assignment: ${rhs} is not a URL. ${assignment} */`);
+            this.skip();
+          }
+        }
+      }
+
+      /**
+       * Skip module scope CJS globals when they are object properties.
+       * Ignoring `exports` here.
+       */
+      if (node.type === 'MemberExpression' && node.property.type === 'Identifier' && ['__filename', '__dirname'].includes(node.property.name)) {
+        this.skip();
+      }
+
+      /**
+       * Check for bare `module.exports` expressions.
+       */
+      if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'module' && node.property.type === 'Identifier' && node.property.name === 'exports' && parent?.type === 'ExpressionStatement') {
+        if (opts.target === 'module') {
+          code.update(node.start, node.end, ';');
+          // Prevent parsing the `exports` identifier again.
+          this.skip();
+        }
+      }
+
+      /**
+       * Format `module.exports` and `exports` assignments.
+       */
+      if (node.type === 'AssignmentExpression') {
+        await assignmentExpression({
+          node,
+          parent,
+          code,
+          opts,
+          meta: exportsMeta
+        });
+      }
+      if (node.type === 'MetaProperty') {
+        metaProperty(node, parent, code, opts);
+      }
+      if (node.type === 'MemberExpression') {
+        memberExpression(node, parent, code, opts);
+      }
+      if (isIdentifierName(node)) {
+        identifier({
+          node,
+          ancestors,
+          code,
+          opts,
+          meta: exportsMeta
+        });
+      }
     }
   });
-  return src;
-};
+  return code.toString();
+};
+export { format };

package/dist/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/formatters/assignmentExpression.js

@@ -0,0 +1,30 @@
+import { walk } from '../walk.js';
+export const assignmentExpression = async ({
+  node,
+  parent: _parent,
+  code: _code,
+  opts,
+  meta: _meta
+}) => {
+  if (opts.target === 'module' && opts.transformSyntax) {
+    await walk(node, {
+      enter(childNode, childParent) {
+        if (childNode.type === 'Identifier' && childNode.name === 'exports') {
+          if (childParent === node && node.left === childNode) {
+            /**
+             * The code is reassigning `exports` to something else.
+             * Redeclare it with a new variable name using var.
+             */
+            //meta.hasExportsBeenReassigned = true
+            //console.log('writing exports reassignment')
+            //code.update(node.left.start, node.left.end, exportsRename)
+            //console.log(code.slice(node.start, node.end))
+            //code.update(childNode.start, childNode.end, exportsRename)
+            //console.log('reassigning exports', childParent, code.update(node.left.start, node.left.end, exportsRename))
+          }
+          //console.log('found exports assignment', meta.hasExportsBeenReassigned, expr)
+        }
+      }
+    });
+  }
+};

package/dist/formatters/expressionStatement.d.ts

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

package/dist/formatters/expressionStatement.js

@@ -1,61 +1,42 @@
-export const expressionStatement = (nodePath, src, options) => {
-  if (options.type === 'module') {
-    const {
-      node
-    } = nodePath;
-    const {
-      start,
-      end
-    } = node;
-    if (typeof start === 'number' && typeof end === 'number') {
-      const isMemberExpressionModuleExports = expression => {
-        return expression.object.type === 'Identifier' && expression.object.name === 'module' && expression.property.type === 'Identifier' && expression.property.name === 'exports';
-      };
-      if (node.expression.type === 'Identifier') {
-        const name = node.expression.name;
+export const expressionStatement = (node, parent, src, options) => {
+  if (options.target === 'module') {
+    if (node.expression.type === 'Identifier') {
+      const {
+        start,
+        end
+      } = node;
+      const name = node.expression.name;
 
-        // CommonJS globals
-        switch (name) {
-          case 'module':
-            src.update(start, end, 'import.meta');
-            break;
-          case 'exports':
-            src.update(start, end, '{}');
-            break;
-          case '__filename':
-            src.update(start, end, 'import.meta.filename');
-            break;
-          case '__dirname':
-            src.update(start, end, 'import.meta.dirname');
-            break;
-        }
-      }
-      if (node.expression.type === 'MemberExpression') {
-        const {
-          expression
-        } = node;
-
-        // Check for `module.exports` without an assignment
-        if (isMemberExpressionModuleExports(expression)) {
-          /**
-           * @TODO: Should this depend on `options.modules` being enabled?
-           * Probably not for the same reason `exports` is converted to an empty object (ReferenceError in ESM).
-           * This is a standalone reference to `module.exports` without being part of an AssignmentExpression.
-           */
+      // CommonJS globals (as bare identifiers)
+      switch (name) {
+        case 'require':
+          src.remove(start, end);
+          break;
+        case 'module':
+          src.update(start, end, 'import.meta');
+          break;
+        case 'exports':
           src.update(start, end, '{}');
-        }
-      }
-
-      /*
-      if (
-        options.modules &&
-        node.expression.type === 'AssignmentExpression' &&
-        node.expression.left.type === 'MemberExpression' &&
-        isMemberExpressionModuleExports(node.expression.left)
-      ) {
-        // @TODO support `modules` option.
+          break;
+        case '__filename':
+          src.update(start, end, 'import.meta.filename');
+          break;
+        case '__dirname':
+          src.update(start, end, 'import.meta.dirname');
+          break;
       }
-      */
+    }
+  }
+  if (options.target === 'commonjs') {
+    if (node.expression.type === 'Identifier') {
+      const {
+        start,
+        end
+      } = node;
+      const name = node.expression.name;
+      void start;
+      void end;
+      void name;
     }
   }
 };

package/dist/formatters/identifier.d.ts

@@ -1,5 +1,12 @@
 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;
+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/formatters/identifier.js

@@ -1,41 +1,41 @@
-export const identifier = (nodePath, src, options) => {
-  if (options.type === 'module') {
-    const {
-      node
-    } = nodePath;
+import { exportsRename } from '../utils.js';
+import { identifier as ident } from '../helpers/identifier.js';
+export const identifier = ({
+  node,
+  ancestors,
+  code,
+  opts,
+  meta
+}) => {
+  if (opts.target === 'module') {
     const {
       start,
-      end
+      end,
+      name
     } = node;
-    if (typeof start === 'number' && typeof end === 'number' && node.type === 'Identifier') {
-      const {
-        name
-      } = node;
-      const isMemberExpression = Boolean(nodePath.findParent(path => path.isMemberExpression()));
+    switch (name) {
+      case '__filename':
+        code.update(start, end, 'import.meta.url');
+        break;
+      case '__dirname':
+        code.update(start, end, 'import.meta.dirname');
+        break;
+      case 'exports':
+        {
+          const parent = ancestors[ancestors.length - 2];
+          if (opts.transformSyntax) {
+            if (parent.type === 'AssignmentExpression' && parent.left === node) {
+              // The code is reassigning `exports` to something else.
 
-      // CommonJS globals in expression/statement
-      switch (name) {
-        case 'module':
-          {
-            if (!isMemberExpression) {
-              src.update(start, end, 'import.meta');
+              meta.hasExportsBeenReassigned = true;
+              code.update(parent.left.start, parent.left.end, exportsRename);
             }
-            break;
-          }
-        case 'exports':
-          {
-            if (!isMemberExpression) {
-              src.update(start, end, '{}');
+            if (ident.isModuleScope(ancestors) && !ident.isFunctionExpressionId(ancestors) && !ident.isExportSpecifierAlias(ancestors) && !ident.isClassPropertyKey(ancestors) && !ident.isMethodDefinitionKey(ancestors) && !ident.isMemberKey(ancestors) && !ident.isPropertyKey(ancestors) && !ident.isIife(ancestors)) {
+              code.update(start, end, exportsRename);
             }
-            break;
           }
-        case '__filename':
-          src.update(start, end, 'import.meta.filename');
-          break;
-        case '__dirname':
-          src.update(start, end, 'import.meta.dirname');
-          break;
-      }
+        }
+        break;
     }
   }
 };

package/dist/formatters/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/formatters/memberExpression.js

@@ -1,13 +1,15 @@
-export const memberExpression = (nodePath, src, options) => {
-  if (options.type === 'module') {
-    const {
-      node
-    } = nodePath;
-    const {
-      start,
-      end
-    } = node;
-    if (typeof start === 'number' && typeof end === 'number' && node.object.type === 'Identifier' && node.object.name === 'require' && node.property.type === 'Identifier') {
+import { exportsRename } from '../utils.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') {
+      src.update(node.start, node.end, exportsRename);
+      return;
+    }
+    if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'require') {
+      const {
+        start,
+        end
+      } = node;
       const {
         name
       } = node.property;
@@ -15,7 +17,18 @@ export const memberExpression = (nodePath, src, options) => {
       // CommonJS properties of `require`
       switch (name) {
         case 'main':
-          src.update(start, end, 'import.meta');
+          /**
+           * Node.js team still quibbling over import.meta.main ¯\_(ツ)_/¯
+           * @see https://github.com/nodejs/node/pull/32223
+           */
+          if (parent?.type === 'ExpressionStatement') {
+            // This is a standalone expression so remove it to not cause run-time errors.
+            src.remove(start, end);
+          }
+          /**
+           * Transform require.main === module.
+           */
+          if (parent?.type === 'BinaryExpression') {}
           break;
         case 'resolve':
           src.update(start, end, 'import.meta.resolve');

package/dist/formatters/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/formatters/metaProperty.js

@@ -1,42 +1,30 @@
-export const metaProperty = (nodePath, src, options) => {
-  if (options.type === 'commonjs') {
-    const path = nodePath.findParent(path => path.isMemberExpression());
-    if (path) {
-      const {
-        node
-      } = path;
-      const {
-        start,
-        end
-      } = node;
-      if (node.type === 'MemberExpression' && node.property.type === 'Identifier' && typeof start == 'number' && typeof end === 'number') {
-        const name = node.property.name;
-        switch (name) {
-          case 'url':
-            src.update(start, end, 'require("node:url").pathToFileURL(__filename).toString()');
-            break;
-          case 'filename':
-            src.update(start, end, '__filename');
-            break;
-          case 'dirname':
-            src.update(start, end, '__dirname');
-            break;
-          case 'resolve':
-            src.update(start, end, 'require.resolve');
-            break;
-        }
-      }
-    } else {
-      const {
-        node
-      } = nodePath;
+export const metaProperty = (node, parent, src, options) => {
+  if (options.target === 'commonjs') {
+    if (parent?.type !== 'MemberExpression') {
+      // This is a bare `import.meta` expression
       const {
         start,
         end
       } = node;
-      if (node.property.type === 'Identifier' && node.property.name === 'meta' && typeof start === 'number' && typeof end === 'number') {
-        // This is an `import.meta` expression
-        src.update(start, end, 'require.main');
+      src.update(start, end, 'module');
+    }
+    if (parent?.type === 'MemberExpression' && parent.property.type === 'Identifier') {
+      switch (parent.property.name) {
+        case 'url':
+          src.update(parent.start, parent.end, 'require("node:url").pathToFileURL(__filename).href');
+          break;
+        case 'filename':
+          src.update(parent.start, parent.end, '__filename');
+          break;
+        case 'dirname':
+          src.update(parent.start, parent.end, '__dirname');
+          break;
+        case 'resolve':
+          /**
+           * Should this be `require('node:url').pathToFileURL(require.resolve(<parsed specifier>)).href`?
+           */
+          src.update(parent.start, parent.end, 'require.resolve');
+          break;
       }
     }
   }

package/dist/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 };