requirejs-esm 4.0.0 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "requirejs-esm",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "A RequireJS plugin converting JavaScript modules from ESM to AMD.",
   "author": "Ferdinand Prantl <prantlf@gmail.com>",
   "license": "MIT",
@@ -72,7 +72,7 @@
     "astring": "^1.9.0",
     "charcodes": "^0.2.1",
     "commander": "^14.0.2",
-    "meriyah": "^6.1.4",
+    "meriyah": "^7.0.0",
     "punycode": "^2.3.1",
     "source-map": "^0.8.0-beta.0",
     "tiny-glob": "^0.2.9"
@@ -87,7 +87,7 @@
     "eslint": "^9.39.1",
     "globals": "^16.5.0",
     "lit-html": "^1",
-    "rollup": "^4.53.1",
+    "rollup": "^4.53.3",
     "tehanu": "^1.0.1",
     "tehanu-repo-coco": "^1.0.1",
     "tehanu-teru": "^1.0.1",

package/src/api.d.ts

@@ -7,18 +7,44 @@ 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?: TransformOptions): string
 
 declare function transformAst(ast: object, options?: TransformOptions): { amd?: true, updated?: true }

package/src/plugin.js

@@ -28,7 +28,13 @@ const {
   // 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 = {}
@@ -109,7 +115,13 @@ export default {
           // 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

@@ -18,12 +18,28 @@ export default function transform(text, file, {
   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
+  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, useStrict }
+  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,15 +153,25 @@ export function detectDefinesOrRequires(program) {
 
 // Updates dependency paths to be prefixed by `esm!` or otherwise updated.
 export function updateAmdDeps(amd, options) {
+  let updated = options.onBeforeUpdate?.({
+    ...options,
+    amd
+  })
+
   const { deps } = amd
-  if (!deps) return
+  if (!deps) {
+    afterUpdate()
+    return updated
+  }
 
   const { sourceFileName: parentName } = options
   const { elements } = deps
-  if (!elements.length) return
+  if (!elements.length) {
+    afterUpdate()
+    return updated
+  }
 
   const { resolvePath } = options
-  let updated
   for (const element of elements) {
     if (element.type === 'Literal') {
       const moduleName = element.value
@@ -172,5 +182,26 @@ export function updateAmdDeps(amd, options) {
       }
     }
   }
+
+  afterUpdate()
+
   return updated
+
+  function afterUpdate() {
+    const updatedNow = options.onAfterUpdate?.({
+      ...options,
+      amd
+    })
+    updated ||= updatedNow
+  }
+}
+
+export function callAmdUpdateHooks(amd, options) {
+  options = {
+    ...options,
+    amd
+  }
+  const updatedBefore = options.onBeforeUpdate?.(options)
+  const updatedAfter = options.onAfterUpdate?.(options)
+  return updatedBefore || updatedAfter
 }

package/src/transformer/esm.js

@@ -82,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
 
@@ -343,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') {

package/src/transformer/index.js

@@ -1,4 +1,4 @@
-import { detectDefinesOrRequires, updateAmdDeps } from './amd'
+import { detectDefinesOrRequires, updateAmdDeps, callAmdUpdateHooks } from './amd'
 import { detectImportsAndExports, transformEsmToAmd } from './esm'
 
 export function transformAst(program, options = {}) {
@@ -7,10 +7,11 @@ export function transformAst(program, options = {}) {
   const result = {}
   if (length) {
     result.amd = true
-    if (options.resolvePath) {
-      for (const amd of amds) {
-        result.updated |= updateAmdDeps(amd, options)
-      }
+    for (const amd of amds) {
+      const updated = options.resolvePath
+        ? updateAmdDeps(amd, options)
+        : callAmdUpdateHooks(amd, options)
+      result.updated ||= updated
     }
   } else {
     transformEsmToAmd(program, options)