requirejs-esm 2.2.1 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "requirejs-esm",
-  "version": "2.2.1",
+  "version": "2.3.1",
   "description": "A RequireJS plugin converting JavaScript modules from ESM to AMD.",
   "author": "Ferdinand Prantl <prantlf@gmail.com>",
   "license": "MIT",
@@ -84,29 +84,29 @@
   },
   "dependencies": {
     "@prantlf/convert-source-map": "^2.0.0",
-    "astring": "^1.8.3",
+    "astring": "^1.8.4",
     "charcodes": "^0.2.0",
-    "commander": "^9.3.0",
-    "meriyah": "^4.2.1",
-    "punycode": "^2.1.1",
+    "commander": "^10.0.1",
+    "meriyah": "^4.3.5",
+    "punycode": "^2.3.0",
     "source-map": "^0.8.0-beta.0",
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
-    "@prantlf/requirejs": "^3.0.0",
-    "@rollup/plugin-commonjs": "^22.0.1",
-    "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.3.0",
-    "@semantic-release/changelog": "^6.0.1",
+    "@prantlf/requirejs": "^3.0.2",
+    "@rollup/plugin-commonjs": "^24.1.0",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.2",
+    "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "c8": "^7.11.3",
-    "eslint": "^8.19.0",
+    "c8": "^7.13.0",
+    "eslint": "^8.40.0",
     "lit-html": "^1",
-    "rollup": "^2.76.0",
+    "rollup": "^3.21.5",
     "tehanu": "^1.0.1",
     "tehanu-repo-coco": "^1.0.0",
     "tehanu-teru": "^1.0.0",
-    "terser": "^5.14.1"
+    "terser": "^5.17.1"
   },
   "keywords": [
     "requirejs-plugin",

package/src/api.d.ts

@@ -19,7 +19,8 @@ declare function detectDefinesOrRequires(ast: object): {
   namespace?: object
   func: object
   name?: object
-  deps?: object[]
+  deps?: object
+  params?: object[]
   factory?: object
   output?: object
   body?: object

package/src/transformer/amd.js

@@ -26,7 +26,7 @@ function detectDefineOrRequireCall(expr) {
   if (func.name === 'define') {
     let index = 0
     let arg = args[index]
-    let name, deps
+    let name, deps, params
     if (arg.type === 'Literal') {
       if (length <= ++index || typeof arg.value !== 'string') return false
       name = arg
@@ -38,23 +38,93 @@ function detectDefineOrRequireCall(expr) {
       arg = args[index]
     }
     if (arg.type === 'FunctionExpression' || arg.type === 'ArrowFunctionExpression') {
-      return { namespace, func, name, deps, factory: arg }
+      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]
-    if (deps.type === 'ArrayExpression' && length >= 2) {
+    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, body }
+        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 }
+  }
+}
+
 // Detects if a program contains statements calling define or require function.
 // Returns information about AMD modules false, { deps } or [{ deps }, ...].
 function detectDefineOrRequire(stat) {