node-web-audio-api 0.21.4 → 0.21.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## v0.21.5 (23/12/2024)
+
+- Fix: Use module import for `AudioWorklet#addModule`
+- Feat: Resolve `AudioWorkletNode` when installed in `node_modules`
+- Ensure support of `AudioWorkletNode` that use Web Assembly
+
 ## v0.21.4 (16/12/2024)
 
 - Update upstream crate to [v1.1.0](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-110-2024-12-11)

package/js/AudioWorklet.js

@@ -28,40 +28,38 @@ const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch
 /**
  * Retrieve code with different module resolution strategies
  * - file - absolute or relative to cwd path
- * - URL
- * - Blob
+ *
+ * - URL - do not support import within module
+ * - Blob - do not support import within module
  * - fallback: relative to caller site
- *   + in fs
+ *   + in fs - support import within module
  *   + caller site is url - required for wpt, probably no other use case
  */
 const resolveModule = async (moduleUrl) => {
-  let code;
+  let code = null;
+  let absPathname = null;
 
   if (existsSync(moduleUrl)) {
-    const pathname = moduleUrl;
-
-    try {
-      const buffer = await fs.readFile(pathname);
-      code = buffer.toString();
-    } catch (err) {
-      throw new Error(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`);
+    if (path.isAbsolute(moduleUrl)) {
+      absPathname = moduleUrl;
+    } else { // moduleUrl is relative to process.cwd();
+      absPathname = path.join(process.cwd(), moduleUrl);
     }
   } else if (moduleUrl.startsWith('http')) {
     try {
         const res = await fetch(moduleUrl);
         code = await res.text();
       } catch (err) {
-        throw new Error(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`);
+        throw new DOMException(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`, 'AbortError');
       }
   } else if (moduleUrl.startsWith('blob:')) {
     try {
       const blob = resolveObjectURL(moduleUrl);
       code = await blob.text();
     } catch (err) {
-      throw new Error(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`);
+      throw new DOMException(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`, 'AbortError');
     }
   } else {
-    // get caller site from error stack trace
     const callerSite = caller(2);
 
     if (callerSite.startsWith('http')) { // this branch exists for wpt where caller site is an url
@@ -80,27 +78,28 @@ const resolveModule = async (moduleUrl) => {
         const res = await fetch(url);
         code = await res.text();
       } catch (err) {
-        throw new Error(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`);
+        throw new DOMException(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`, 'AbortError');
       }
     } else {
-      const dirname = callerSite.substr(0, callerSite.lastIndexOf(path.sep));
+      // filesystem, relative to caller site or in node_modules
+      const dirname = callerSite.substring(0, callerSite.lastIndexOf(path.sep));
       const absDirname = dirname.replace('file://', '');
       const pathname = path.join(absDirname, moduleUrl);
 
-      if (existsSync(pathname)) {
+      if (existsSync(pathname)) { // relative to caller site
+        absPathname = pathname;
+      } else {
         try {
-          const buffer = await fs.readFile(pathname);
-          code = buffer.toString();
+          // try resolve according to process.cwd()
+          absPathname = require.resolve(moduleUrl, { paths: [process.cwd()] });
         } catch (err) {
-          throw new Error(`Failed to execute 'addModule' on 'AudioWorklet': ${err.message}`);
+          throw new DOMException(`Failed to execute 'addModule' on 'AudioWorklet': Cannot resolve module ${moduleUrl}`, 'AbortError');
         }
-      } else {
-        throw new Error(`Failed to execute 'addModule' on 'AudioWorklet': Cannot resolve module ${moduleUrl}`);
       }
     }
   }
 
-  return code;
+  return { absPathname, code };
 }
 
 class AudioWorklet {
@@ -125,6 +124,9 @@ class AudioWorklet {
   }
 
   #bindEvents() {
+    // @todo
+    // - better error handling, stack trace, etc.
+    // - handle 'node-web-audio-api:worklet:ctor-error' message
     this.#port.on('message', event => {
       switch (event.cmd) {
         case 'node-web-audio-api:worklet:module-added': {
@@ -135,10 +137,9 @@ class AudioWorklet {
           break;
         }
         case 'node-web-audio-api:worklet:add-module-failed': {
-          const { promiseId, ctor, name, message } = event;
+          const { promiseId, err } = event;
           const { reject } = this.#idPromiseMap.get(promiseId);
           this.#idPromiseMap.delete(promiseId);
-          const err = new globalThis[ctor](message, name);
           reject(err);
           break;
         }
@@ -161,7 +162,9 @@ class AudioWorklet {
   }
 
   async addModule(moduleUrl) {
-    const code = await resolveModule(moduleUrl);
+    // @important - `resolveModule` must be called first because it uses `caller`
+    // which will return `null` if this is not in the first line...
+    const resolved = await resolveModule(moduleUrl);
 
     // launch Worker if not exists
     if (!this.#port) {
@@ -187,7 +190,8 @@ class AudioWorklet {
 
       this.#port.postMessage({
         cmd: 'node-web-audio-api:worklet:add-module',
-        code,
+        moduleUrl: resolved.absPathname,
+        code: resolved.code,
         promiseId,
       });
     });

package/js/AudioWorkletGlobalScope.js

@@ -298,7 +298,7 @@ globalThis.registerProcessor = function registerProcessor(name, processorCtor) {
 //   process.stdout.write('closing worklet');
 // });
 
-parentPort.on('message', event => {
+parentPort.on('message', async event => {
   switch (event.cmd) {
     case 'node-web-audio-api:worklet:init': {
       const { workletId, processors, promiseId } = event;
@@ -313,11 +313,18 @@ parentPort.on('message', event => {
       break;
     }
     case 'node-web-audio-api:worklet:add-module': {
-      const { code, promiseId } = event;
-      const func = new Function('AudioWorkletProcessor', 'registerProcessor', code);
+      const { moduleUrl, code, promiseId } = event;
 
       try {
-        func(AudioWorkletProcessor, registerProcessor);
+        // 1. If given module is a "real" file, we can import it as is,
+        // 2. If module is a blob or loaded from an URL, we use the raw text as
+        //    input. In this case, if the module uses `import` it will crash
+        if (moduleUrl !== null) {
+          await import(moduleUrl);
+        } else {
+          await import(`data:text/javascript;base64,${btoa(unescape(encodeURIComponent(code)))}`);
+        }
+
         // send registered param descriptors on main thread and resolve Promise
         parentPort.postMessage({
           cmd: 'node-web-audio-api:worklet:module-added',
@@ -327,9 +334,7 @@ parentPort.on('message', event => {
         parentPort.postMessage({
           cmd: 'node-web-audio-api:worklet:add-module-failed',
           promiseId,
-          ctor: err.constructor.name,
-          name: err.name,
-          message: err.message,
+          err,
         });
       }
       break;
@@ -338,7 +343,7 @@ parentPort.on('message', event => {
       const { name, id, options, port } = event;
       const ctor = nameProcessorCtorMap.get(name);
 
-      // rewrap options of interest for the AudioWorkletNodeBaseClass
+      // re-wrap options of interest for the AudioWorkletNodeBaseClass
       pendingProcessorConstructionData = {
         port,
         numberOfInputs: options.numberOfInputs,
@@ -352,6 +357,7 @@ parentPort.on('message', event => {
         instance = new ctor(options);
       } catch (err) {
         port.postMessage({ cmd: 'node-web-audio-api:worklet:ctor-error', err });
+        return;
       }
 
       pendingProcessorConstructionData = null;

package/js/AudioWorkletNode.js

@@ -222,7 +222,8 @@ module.exports = (jsExport, nativeBinding) => {
       );
 
       this.#port.on('message', msg => {
-        // ErrorEvent named processorerror
+        // Handle 'processorerror' ErrorEvent
+        // cf. https://webaudio.github.io/web-audio-api/#dom-audioworkletnode-onprocessorerror
         switch (msg.cmd) {
           case 'node-web-audio-api:worklet:ctor-error': {
             const message = `Failed to construct '${parsedName}' AudioWorkletProcessor: ${msg.err.message}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-web-audio-api",
-  "version": "0.21.4",
+  "version": "0.21.5",
   "author": "Benjamin Matuszewski",
   "description": "Node.js bindings for web-audio-api-rs using napi-rs",
   "exports": {