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

package/dist/format.js

@@ -1,34 +1,142 @@
 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';
+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';
 
 /**
- * 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.
+ * Node added support for import.meta.main.
+ * Added in: v24.2.0, v22.18.0
+ * @see https://nodejs.org/api/esm.html#importmetamain
  */
-const type = moduleType();
-const traverse = typeof _traverse === 'function' || type === 'commonjs' ? _traverse : _traverse.default;
+const format = async (src, ast, opts) => {
+  const code = new MagicString(src);
+  const exportsMeta = {
+    hasExportsBeenReassigned: false,
+    defaultExportValue: undefined,
+    hasDefaultExportBeenReassigned: false,
+    hasDefaultExportBeenAssigned: false
+  };
+  const exportTable = opts.target === 'module' ? await collectCjsExports(ast.program) : null;
+  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();
+        }
+      }
 
-/**
- * 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);
+      /**
+       * 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;
-};
+  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

@@ -0,0 +1,30 @@
+import { walk } from '#walk';
+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.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.js

@@ -1,41 +1,41 @@
-export const identifier = (nodePath, src, options) => {
-  if (options.type === 'module') {
-    const {
-      node
-    } = nodePath;
+import { exportsRename } from '#utils/exports.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.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/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') {
+      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.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.js

@@ -0,0 +1,127 @@
+import { analyze } from 'periscopic';
+
+/**
+ * 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.
+ */
+const isIdentifierName = node => {
+  return node.type === 'Identifier' && typeof node.name === 'string' && node.name !== 'this';
+};
+const scopeCache = new WeakMap();
+const getScopeContext = program => {
+  const cached = scopeCache.get(program);
+  if (cached) {
+    return cached;
+  }
+  const {
+    scope
+  } = analyze(program);
+  const context = {
+    scope
+  };
+  scopeCache.set(program, context);
+  return context;
+};
+
+/**
+ * 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.
+ */
+const identifier = {
+  isNamed: node => {
+    return isIdentifierName(node);
+  },
+  isMetaProperty(ancestors) {
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MetaProperty' || parent.type === 'MemberExpression' && parent.object.type === 'MetaProperty';
+  },
+  isModuleScope(ancestors, includeImports = false) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const program = ancestors[0];
+    if (!identifier.isNamed(node) || identifier.isMetaProperty(ancestors) || parent.type === 'LabeledStatement' || parent.type === 'BreakStatement' || parent.type === 'ContinueStatement') {
+      return false;
+    }
+    if (parent.type === 'ImportSpecifier' || parent.type === 'ImportDefaultSpecifier' || parent.type === 'ImportNamespaceSpecifier') {
+      return includeImports && parent.local.name === node.name;
+    }
+    if (parent.type === 'Property' && parent.key === node && !parent.computed) {
+      return false;
+    }
+    if (parent.type === 'MemberExpression' && parent.property === node && !parent.computed) {
+      return false;
+    }
+    const {
+      scope: rootScope
+    } = getScopeContext(program);
+    const owner = rootScope.find_owner(node.name);
+    if (!owner) {
+      return node.name === 'exports';
+    }
+    return owner === rootScope;
+  },
+  isMemberExpressionRoot(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const grandParent = ancestors[ancestors.length - 3];
+    return parent.type === 'MemberExpression' && parent.object === node && grandParent.type !== 'MemberExpression';
+  },
+  isDeclaration(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return (parent.type === 'VariableDeclarator' || parent.type === 'FunctionDeclaration' || parent.type === 'ClassDeclaration') && parent.id === node;
+  },
+  isClassOrFuncDeclarationId(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return (parent.type === 'ClassDeclaration' || parent.type === 'FunctionDeclaration') && parent.id === node && ancestors.length <= 3;
+  },
+  isVarDeclarationInGlobalScope(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const grandParent = ancestors[ancestors.length - 3];
+    const varBoundScopes = ['ClassDeclaration', 'ClassExpression', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
+    return parent.type === 'VariableDeclarator' && parent.id === node && grandParent.type === 'VariableDeclaration' && grandParent.kind === 'var' && ancestors.every(ancestor => {
+      return !varBoundScopes.includes(ancestor.type);
+    });
+  },
+  isIife(ancestors) {
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'FunctionExpression' && ancestors.some(ancestor => ancestor.type === 'ParenthesizedExpression');
+  },
+  isFunctionExpressionId(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'FunctionExpression' && parent.id === node;
+  },
+  isExportSpecifierAlias(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'ExportSpecifier' && parent.exported === node;
+  },
+  isClassPropertyKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'PropertyDefinition' && parent.key === node;
+  },
+  isMethodDefinitionKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MethodDefinition' && parent.key === node;
+  },
+  isMemberKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MemberExpression' && parent.property === node;
+  },
+  isPropertyKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'Property' && parent.key === node;
+  }
+};
+export { identifier, isIdentifierName };

package/dist/helpers/scope.js

@@ -0,0 +1,7 @@
+const scopes = ['BlockStatement', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassDeclaration', 'ClassExpression', 'ClassBody', 'StaticBlock'];
+const scope = {
+  isScope(node) {
+    return scopes.includes(node.type);
+  }
+};
+export { scopes, scope };

package/dist/identifier.d.ts

@@ -1,5 +1,31 @@
-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';
+/**
+ * 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 };