requirejs-esm 3.1.1 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "requirejs-esm",
-  "version": "3.1.1",
+  "version": "4.1.0",
   "description": "A RequireJS plugin converting JavaScript modules from ESM to AMD.",
   "author": "Ferdinand Prantl <prantlf@gmail.com>",
   "license": "MIT",
@@ -33,7 +33,6 @@
     "src"
   ],
   "scripts": {
-    "prepare": "npm run build && npm run demo",
     "build": "node build",
     "demo": "npm run demo:extern && npm run demo:local",
     "demo:extern": "npm run optimize:extern && npm run minify:extern",
@@ -69,30 +68,30 @@
     "statements": 45
   },
   "dependencies": {
-    "@prantlf/convert-source-map": "^2.1.0",
+    "@prantlf/convert-source-map": "^3.0.2",
     "astring": "^1.9.0",
-    "charcodes": "^0.2.0",
-    "commander": "^13.1.0",
-    "meriyah": "^6.0.6",
+    "charcodes": "^0.2.1",
+    "commander": "^14.0.2",
+    "meriyah": "^7.0.0",
     "punycode": "^2.3.1",
     "source-map": "^0.8.0-beta.0",
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
-    "@eslint/js": "^9.26.0",
+    "@eslint/js": "^9.39.1",
     "@prantlf/requirejs": "^3.3.1",
-    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "c8": "^10.1.3",
-    "eslint": "^9.26.0",
-    "globals": "^16.1.0",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
     "lit-html": "^1",
-    "rollup": "^4.40.2",
+    "rollup": "^4.53.3",
     "tehanu": "^1.0.1",
     "tehanu-repo-coco": "^1.0.1",
     "tehanu-teru": "^1.0.1",
-    "terser": "^5.39.1"
+    "terser": "^5.44.1"
   },
   "keywords": [
     "requirejs-plugin",

package/src/api.d.ts

@@ -7,13 +7,47 @@ interface ResolveOptions {
 
 declare function resolvePath(sourcePath: string, currentFile: string, options?: ResolveOptions): string
 
+interface AmdOptions {
+  namespace?: Record<string, unknown>
+  func: Record<string, unknown>
+  name: string
+  deps?: string[]
+  params?: string[]
+  factory?: Record<string, unknown>
+  output?: Record<string, unknown>
+}
+
 type ResolvePath = ((sourcePath: string, currentFile: string, options?: ResolveOptions) => string) | false
+type OnBeforeTransform = (options: OnBeforeTransformOptions) => void
+type OnAfterTransform = (options: OnAfterTransformOptions) => void
+type OnBeforeUpdate = (options: AmdOptions) => boolean
+type OnAfterUpdate = (options: AmdOptions) => boolean
+
+interface TransformAstOptions {
+  pluginName?: string /*= 'esm'' */
+  resolvePath?: ResolvePath
+  useStrict?: boolean /*= true */
+  onBeforeTransform?: OnBeforeTransform
+  onAfterTransform?: OnAfterTransform
+  onBeforeUpdate?: OnBeforeUpdate
+  onAfterUpdate?: OnAfterUpdate
+}
+
+interface TransformOptions extends TransformAstOptions {
+  sourceMap?: boolean /*= true */
+}
+
+interface OnBeforeTransformOptions extends TransformAstOptions {
+  program: Record<string, unknown>
+}
+
+interface OnAfterTransformOptions extends OnBeforeTransformOptions {
+  callbackBody: Record<string, unknown>[]
+}
 
-declare function transform(contents: string, path: string, options?: {
-  pluginName?: string /*= 'esm'' */, resolvePath?: ResolvePath,
-  sourceMap?: boolean /*= true */ }): string
+declare function transform(contents: string, path: string, options?: TransformOptions): string
 
-declare function transformAst(ast: object): { amd?: true, updated?: true }
+declare function transformAst(ast: object, options?: TransformOptions): { amd?: true, updated?: true }
 
 declare function detectDefinesOrRequires(ast: object): {
   namespace?: object

package/src/plugin.js

@@ -20,12 +20,21 @@ const {
   // name with `esm!`, above all.
   resolvePath,
   // ecmaVersion,
+  // Do not insert `"use strict"` expression to the AMD modules. You'd set it
+  // to `false` if your bundler inserts `"use strict"` to the outer scope.
+  useStrict,
   // Boolean or object with booleans { inline, content }.
   sourceMap,
   // Enable console logging.
   verbose,
   // Directory to save a copy of the transformed modules.
-  debugDir
+  debugDir,
+  // ESM transformation callbacks.
+  onBeforeTransform,
+  onAfterTransform,
+  // AMD update callbacks.
+  onBeforeUpdate,
+  onAfterUpdate
 } = typeof module !== 'undefined' && module.config && module.config() || {}
 
 const buildMap = {}
@@ -102,10 +111,17 @@ export default {
           pluginName,
           resolvePath,
           /*ecmaVersion,*/
+          useStrict,
           // Always produce the source maps when transpiling in the browser, otherwise
           // the debugging would me impossible. When building and bundling, check if
           // the source maps were enabled for the output.
-          sourceMap: sourceMap || !isBuild
+          sourceMap: sourceMap || !isBuild,
+          // ESM transformation callbacks.
+          onBeforeTransform,
+          onAfterTransform,
+          // AMD update callbacks.
+          onBeforeUpdate,
+          onAfterUpdate
         }))
         if (!updated) {
           verbose && console.log('esm: retaining', name)

package/src/transform.js

@@ -13,12 +13,33 @@ export default function transform(text, file, {
   // name with `esm!`, above all.
   resolvePath = originalResolvePath,
   // ecmaVersion = 2020,
-  sourceMap
+  // Do not insert `"use strict"` expression to the AMD modules. You'd set it
+  // to `false` if your bundler inserts `"use strict"` to the outer scope.
+  useStrict,
+  // Enable source maps, can be an object with booleans { inline, content }.
+  // If set to true, the object will be set to { inline: true, content: true }.
+  sourceMap,
+  // ESM transformation callbacks.
+  onBeforeTransform,
+  onAfterTransform,
+  // AMD update callbacks.
+  onBeforeUpdate,
+  onAfterUpdate
 } = {}) {
   // const ast = parse(text, { ecmaVersion, sourceType: 'module', locations: true })
   let ast = parseModule(text, { next: true, loc: true })
 
-  const options = { sourceFileName: file, pluginName, resolvePath, originalResolvePath }
+  const options = {
+    sourceFileName: file,
+    pluginName,
+    resolvePath,
+    originalResolvePath,
+    useStrict,
+    onBeforeTransform,
+    onAfterTransform,
+    onBeforeUpdate,
+    onAfterUpdate
+  }
   const { updated } = transformAst(ast, options)
 
   let code, map

package/src/transformer/amd.js

@@ -153,6 +153,8 @@ export function detectDefinesOrRequires(program) {
 
 // Updates dependency paths to be prefixed by `esm!` or otherwise updated.
 export function updateAmdDeps(amd, options) {
+  options.onBeforeUpdate?.(amd)
+
   const { deps } = amd
   if (!deps) return
 
@@ -172,5 +174,8 @@ export function updateAmdDeps(amd, options) {
       }
     }
   }
+
+  updated ||= options.onAfterUpdate?.(amd)
+
   return updated
 }

package/src/transformer/esm.js

@@ -2,7 +2,8 @@ import { isAnonymousImport, isImportDefault, isImportAllAs } from './validators'
 import {
   identifier, memberExpression, objectExpression, arrayExpression, blockStatement,
   variableDeclaration, variableDeclarator, returnStatement, expressionStatement,
-  forInStatement, assignmentExpression, callExpression, functionExpression
+  forInStatement, assignmentExpression, callExpression, functionExpression,
+  literal
 } from './factories'
 import { toExpression, replaceLiteral, exportStatement } from './converters'
 import { generateUid, generateUidIdentifier } from './generate-id'
@@ -81,6 +82,11 @@ export function detectImportsAndExports(program) {
 
 // Transforms the module format from ESM to AMD.
 export function transformEsmToAmd(program, options) {
+  options.onBeforeTransform?.({
+    ...options,
+    program
+  })
+
   const { body } = program
   let { length } = body
 
@@ -342,6 +348,12 @@ export function transformEsmToAmd(program, options) {
 
   buildAmdModule(program, options, importPaths, importVars, namedImports)
 
+  options.onAfterTransform?.({
+    ...options,
+    program,
+    callbackBody: body
+  })
+
   function addExportStatement({ exported, local }) {
     const asName = exported.name
     if (asName !== 'default') {
@@ -385,13 +397,22 @@ function exportCopyLoop(exportsVar, importVar) {
 
 // Wraps a program body of statements into an AMD module.
 function buildAmdModule(program, options, importPaths, importVars, namedImports) {
+  const body = []
+  if (options.useStrict !== false) {
+    body.push(expressionStatement(literal('use strict')))
+  }
+  if (namedImports.length) {
+    body.push(...namedImports)
+  }
+  body.push(...program.body)
+  const bodyStatement = blockStatement(body)
   program.body = [
     expressionStatement(callExpression(
       identifier('define'), importPaths.length ? [
         prepareImportPaths(importPaths, options),
-        functionExpression(importVars, blockStatement(namedImports.concat(program.body)))
+        functionExpression(importVars, bodyStatement)
       ] : [
-        functionExpression([], blockStatement(program.body))
+        functionExpression([], bodyStatement)
       ]))
   ]
 }

package/src/transformer/index.js

@@ -9,7 +9,7 @@ export function transformAst(program, options = {}) {
     result.amd = true
     if (options.resolvePath) {
       for (const amd of amds) {
-        result.updated |= updateAmdDeps(amd, options)
+        result.updated ||= updateAmdDeps(amd, options)
       }
     }
   } else {