requirejs-esm 2.1.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "requirejs-esm",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "A RequireJS plugin converting JavaScript modules from ESM to AMD.",
   "author": "Ferdinand Prantl <prantlf@gmail.com>",
   "license": "MIT",
@@ -84,9 +84,9 @@
   },
   "dependencies": {
     "@prantlf/convert-source-map": "^2.0.0",
-    "astring": "^1.8.1",
+    "astring": "^1.8.3",
     "charcodes": "^0.2.0",
-    "commander": "^9.1.0",
+    "commander": "^9.3.0",
     "meriyah": "^4.2.1",
     "punycode": "^2.1.1",
     "source-map": "^0.8.0-beta.0",
@@ -94,19 +94,19 @@
   },
   "devDependencies": {
     "@prantlf/requirejs": "^3.0.0",
-    "@rollup/plugin-commonjs": "^21.0.3",
+    "@rollup/plugin-commonjs": "^22.0.1",
     "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-node-resolve": "^13.3.0",
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/git": "^10.0.1",
-    "c8": "^7.11.0",
-    "eslint": "^8.13.0",
+    "c8": "^7.11.3",
+    "eslint": "^8.19.0",
     "lit-html": "^1",
-    "rollup": "^2.70.1",
-    "tehanu": "^0.2.2",
-    "tehanu-repo-coco": "^0.0.2",
-    "tehanu-teru": "^0.2.2",
-    "terser": "^5.12.1"
+    "rollup": "^2.76.0",
+    "tehanu": "^1.0.1",
+    "tehanu-repo-coco": "^1.0.0",
+    "tehanu-teru": "^1.0.0",
+    "terser": "^5.14.1"
   },
   "keywords": [
     "requirejs-plugin",

package/src/api.d.ts

@@ -12,3 +12,31 @@ type ResolvePath = ((sourcePath: string, currentFile: string, options?: ResolveO
 declare function transform(contents: string, path: string, options?: {
   pluginName?: string /*= 'esm'' */, resolvePath?: ResolvePath,
   sourceMap?: boolean /*= true */ }): string
+
+declare function transformAst(ast: object): { amd?: true, updated?: true }
+
+declare function detectDefinesOrRequires(ast: object): {
+  namespace?: object
+  func: object
+  name?: object
+  deps?: object
+  params?: object[]
+  factory?: object
+  output?: object
+  body?: object
+}[]
+
+declare function detectImportsAndExports(ast: object): {
+  imports: {
+    node: object
+    source: string
+    local?: string
+    specifiers?: { imported: string, local: string }[]
+    export?: true
+  }[]
+  exports: {
+    node: object,
+    default?: true
+    import?: true
+  }[]
+}

package/src/api.js

@@ -1,2 +1,3 @@
 export { resolvePath } from './resolve-path'
 export { default as transform } from './transform'
+export { transformAst, detectDefinesOrRequires, detectImportsAndExports } from './transformer'

package/src/transform.js

@@ -4,7 +4,7 @@ import { parseModule } from 'meriyah'
 import { generate } from 'astring'
 import { SourceMapGenerator } from 'source-map'
 import convert from '@prantlf/convert-source-map'
-import transformModules from './transformer'
+import { transformAst } from './transformer'
 
 export default function transform(text, file, {
   // Allow using a different plugin alias than `esm` in the source code.
@@ -19,9 +19,8 @@ export default function transform(text, file, {
   let ast = parseModule(text, { next: true, loc: true })
 
   const options = { sourceFileName: file, pluginName, resolvePath, originalResolvePath }
-  transformModules(ast, options)
+  const { updated } = transformAst(ast, options)
 
-  const { updated } = options
   let code, map
   if (updated) {
     if (sourceMap === true) {

package/src/transformer/amd.js

@@ -10,11 +10,12 @@ function detectDefineOrRequireCall(expr) {
   if (length === 0) return false
 
   const { callee } = expr
-  let func
+  let namespace, func
   // namespace.define(...)
   if (callee.type === 'MemberExpression') {
     const { object } = callee
     if (object.type !== 'Identifier') return false
+    namespace = object
     func = callee.property
   } else {
     func = callee
@@ -25,9 +26,10 @@ function detectDefineOrRequireCall(expr) {
   if (func.name === 'define') {
     let index = 0
     let arg = args[index]
-    let deps
+    let name, deps, params
     if (arg.type === 'Literal') {
       if (length <= ++index || typeof arg.value !== 'string') return false
+      name = arg
       arg = args[index]
     }
     if (arg.type === 'ArrayExpression') {
@@ -35,15 +37,91 @@ function detectDefineOrRequireCall(expr) {
       if (length <= ++index) return false
       arg = args[index]
     }
-    return (arg.type === 'FunctionExpression' || arg.type === 'ObjectExpression') &&
-      { deps: deps }
+    if (arg.type === 'FunctionExpression' || arg.type === 'ArrowFunctionExpression') {
+      if (!deps) {
+        ({ params, deps } = detectCjsDeps(arg) || {})
+      } else {
+        params = arg.params
+      }
+      return { namespace, func, name, deps, params, factory: arg }
+    }
+    return arg.type === 'ObjectExpression' && { namespace, func, name, deps, output: arg }
   }
 
-  // require([deps], success, error)
+  // require([deps], success, [error])
   if (func.name === 'require') {
-    const deps = args[0]
-    return deps.type === 'ArrayExpression' && length >= 2 &&
-      args[1].type === 'FunctionExpression' && { deps: deps }
+    const arg = args[0]
+    if (arg.type === 'ArrayExpression') {
+      if (length < 2) return false
+      const body = args[1]
+      if (body.type === 'FunctionExpression' || body.type === 'ArrowFunctionExpression') {
+        return { func, deps: arg, params: body.params, body }
+      }
+    } else if (arg.type === 'FunctionExpression' || arg.type === 'ArrowFunctionExpression') {
+      const { params, deps } = detectCjsDeps(arg) || {}
+      return { func, params, deps, body: arg }
+    }
+  }
+}
+
+// Checks if the expression parameters can support CJS-like require calls
+// in the expression body.
+function isCjsExpression(expr) {
+  const { params } = expr;
+  if (!params.length) return false
+  const param = params[0]
+  return param.type === 'Identifier' && param.name === 'require'
+}
+
+// Detects variable declarations with CJS-like require calls and such require
+// calls on the first level of the expression body.
+function detectCjsDeps(expr) {
+  if (!isCjsExpression(expr)) return
+  const params = []
+  const namedDeps = []
+  const unnamedDeps = []
+  for (const statement of expr.body.body || []) {
+    const { type } = statement
+    if (type === 'VariableDeclaration') {
+      for (const declarator of statement.declarations) {
+        const { id } = declarator
+        if (id && id.type === 'Identifier') {
+          const { init } = declarator
+          if (init && init.type === 'CallExpression') {
+            const { callee } = init
+            if (callee.type === 'Identifier' && callee.name === 'require') {
+              const { arguments: args } = init
+              if (args.length === 1) {
+                const arg = args[0]
+                if (arg.type === 'Literal') {
+                  params.push(id)
+                  namedDeps.push(arg)
+                }
+              }
+            }
+          }
+        }
+      }
+    } else if (type === 'ExpressionStatement') {
+      const { expression } = statement
+      if (expression.type === 'CallExpression') {
+        const { callee } = expression
+        if (callee.type === 'Identifier' && callee.name === 'require') {
+          const { arguments: args } = expression
+          if (args.length === 1) {
+            const arg = args[0]
+            if (arg.type === 'Literal') {
+              unnamedDeps.push(arg)
+            }
+          }
+        }
+      }
+    }
+  }
+  let deps = [...namedDeps, ...unnamedDeps]
+  if (deps.length) {
+    deps = { type: 'ArrayExpression', elements: deps }
+    return { params, deps }
   }
 }
 

package/src/transformer/esm.js

@@ -7,6 +7,78 @@ import {
 import { toExpression, replaceLiteral, exportStatement } from './converters'
 import { generateUid, generateUidIdentifier } from './generate-id'
 
+// Detects if a program contains import statements.
+// Returns information about the import statemets [{ node, source, specifiers|local }, ...] or [].
+export function detectImportsAndExports(program) {
+  const { body } = program
+  const { length } = body
+
+  const imports = []
+  const exports = []
+
+  for (let i = 0; i < length; ++i) {
+    const node = body[i]
+
+    // import
+    if (node.type === 'ImportDeclaration') {
+      const { source } = node
+
+      // import "some"
+      if (isAnonymousImport(node)) {
+        imports.push({ node, source })
+      }
+      // import some from "some"
+      // import * as some from "some"
+      else if (isImportDefault(node) || isImportAllAs(node)) {
+        const { local } = node.specifiers[0]
+        imports.push({ node, source, local })
+      }
+      // import {x, y, z} from "xyz"
+      else {
+        const specifiers = node.specifiers.map(({ imported, local }) => ({ imported, local }))
+        imports.push({ node, source, specifiers })
+      }
+    }
+
+    // export default
+    else if (node.type === 'ExportDefaultDeclaration') {
+      exports.push({ node, default: true })
+    }
+
+    // export {x as y}
+    // export var a = 1
+    // export function test() {}
+    // export class Test {}
+    else if (node.type === 'ExportNamedDeclaration') {
+      const { specifiers } = node
+
+      // export var a = 1
+      if (!specifiers.length) {
+        exports.push({ node })
+      } else { // export {x as y}
+        // export { ... } from "module"
+        const { source } = node
+        if (source) {
+          exports.push({ node, source, import: true })
+          const specifiers = node.specifiers.map(({ exported: imported, local }) => ({ imported, local }))
+          imports.push({ node, source, specifiers, export: true })
+        } else {
+          exports.push({ node })
+        }
+      }
+    }
+
+    // export * from "module"
+    if (node.type === 'ExportAllDeclaration') {
+      exports.push({ node, import: true })
+      const { source } = node
+      imports.push({ node, source, export: true })
+    }
+  }
+
+  return { imports, exports }
+}
+
 // Transforms the module format from ESM to AMD.
 export function transformEsmToAmd(program, options) {
   const { body } = program

package/src/transformer/index.js

@@ -1,18 +1,22 @@
 import { detectDefinesOrRequires, updateAmdDeps } from './amd'
-import { transformEsmToAmd } from './esm'
+import { detectImportsAndExports, transformEsmToAmd } from './esm'
 
-export default function transformModules(program, options) {
+export function transformAst(program, options = {}) {
   const amds = detectDefinesOrRequires(program)
   const { length } = amds
+  const result = {}
   if (length) {
-    options.amd = true
+    result.amd = true
     if (options.resolvePath) {
       for (const amd of amds) {
-        options.updated |= updateAmdDeps(amd, options)
+        result.updated |= updateAmdDeps(amd, options)
       }
     }
   } else {
     transformEsmToAmd(program, options)
-    options.updated = true
+    result.updated = true
   }
+  return result
 }
+
+export { detectDefinesOrRequires, detectImportsAndExports }

package/src/transformer/keywords.js

@@ -54,7 +54,7 @@ const reservedWordsStrictSet = new Set(reservedWords.strict)
 const reservedWordsStrictBindSet = new Set(reservedWords.strictBind)
 
 export function isReservedWord(word, inModule) {
-  return inModule && word === 'await' || word === 'enum';
+  return inModule && word === 'await' || word === 'enum'
 }
 
 export function isStrictReservedWord(word, inModule) {