@grame/faustwasm 0.12.2 → 0.13.0

package/src/FaustAudioWorkletNode.ts

@@ -1,13 +1,28 @@
-import { OutputParamHandler, ComputeHandler, PlotHandler, UIHandler, MetadataHandler, FaustBaseWebAudioDsp, IFaustMonoWebAudioDsp, IFaustPolyWebAudioDsp } from "./FaustWebAudioDsp";
-import type { FaustAudioWorkletNodeOptions } from "./FaustAudioWorkletProcessor";
-import type { LooseFaustDspFactory, FaustDspMeta, FaustUIInputItem, FaustUIItem } from "./types";
-import { FaustAudioWorkletNodeCommunicator } from "./FaustAudioWorkletCommunicator";
+import {
+    OutputParamHandler,
+    ComputeHandler,
+    PlotHandler,
+    UIHandler,
+    MetadataHandler,
+    FaustBaseWebAudioDsp,
+    IFaustMonoWebAudioDsp,
+    IFaustPolyWebAudioDsp
+} from './FaustWebAudioDsp';
+import type { FaustAudioWorkletNodeOptions } from './FaustAudioWorkletProcessor';
+import type {
+    LooseFaustDspFactory,
+    FaustDspMeta,
+    FaustUIInputItem,
+    FaustUIItem
+} from './types';
+import { FaustAudioWorkletNodeCommunicator } from './FaustAudioWorkletCommunicator';
 
 /**
  * Base class for Monophonic and Polyphonic AudioWorkletNode
  */
-export class FaustAudioWorkletNode<Poly extends boolean = false> extends (globalThis.AudioWorkletNode || null) {
-
+export class FaustAudioWorkletNode<
+    Poly extends boolean = false
+> extends (globalThis.AudioWorkletNode || null) {
     protected fJSONDsp: FaustDspMeta;
     protected fJSON: string;
     protected fInputsItems: string[];
@@ -20,8 +35,12 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
     #hasAccInput = false;
     #hasGyrInput = false;
 
-    constructor(context: BaseAudioContext, name: string, factory: LooseFaustDspFactory, options: Partial<FaustAudioWorkletNodeOptions<Poly>> = {}) {
-
+    constructor(
+        context: BaseAudioContext,
+        name: string,
+        factory: LooseFaustDspFactory,
+        options: Partial<FaustAudioWorkletNodeOptions<Poly>> = {}
+    ) {
         // Create JSON object
         const JSONObj: FaustDspMeta = JSON.parse(factory.json);
 
@@ -31,8 +50,8 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
             numberOfOutputs: JSONObj.outputs > 0 ? 1 : 0,
             channelCount: Math.max(1, JSONObj.inputs),
             outputChannelCount: [JSONObj.outputs],
-            channelCountMode: "explicit",
-            channelInterpretation: "speakers",
+            channelCountMode: 'explicit',
+            channelInterpretation: 'speakers',
             processorOptions: options.processorOptions,
             ...options
         });
@@ -47,7 +66,13 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         // Parse UI
         this.fInputsItems = [];
         this.fUICallback = (item: FaustUIItem) => {
-            if (item.type === "vslider" || item.type === "hslider" || item.type === "button" || item.type === "checkbox" || item.type === "nentry") {
+            if (
+                item.type === 'vslider' ||
+                item.type === 'hslider' ||
+                item.type === 'button' ||
+                item.type === 'checkbox' ||
+                item.type === 'nentry'
+            ) {
                 // Keep inputs adresses
                 this.fInputsItems.push(item.address);
                 this.fDescriptor.push(item);
@@ -58,34 +83,40 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
                     if (gyr) this.#hasGyrInput = true;
                 });
             }
-        }
+        };
 
         FaustBaseWebAudioDsp.parseUI(this.fJSONDsp.ui, this.fUICallback);
 
         this.fCommunicator = new FaustAudioWorkletNodeCommunicator(this.port);
 
         // Patch it with additional functions
-        this.port.addEventListener("message", this.handleMessageAux);
+        this.port.addEventListener('message', this.handleMessageAux);
         this.port.start();
     }
 
     protected handleMessageAux = (e: MessageEvent) => {
-        if (e.data.type === "param" && this.fOutputHandler) {
+        if (e.data.type === 'param' && this.fOutputHandler) {
             this.fOutputHandler(e.data.path, e.data.value);
-        } else if (e.data.type === "plot" && this.fPlotHandler) {
+        } else if (e.data.type === 'plot' && this.fPlotHandler) {
             this.fPlotHandler(e.data.value, e.data.index, e.data.events);
         }
     };
 
     // Accelerometer and gyroscope handlers
-    private handleDeviceMotion = ({ accelerationIncludingGravity }: DeviceMotionEvent) => {
+    private handleDeviceMotion = ({
+        accelerationIncludingGravity
+    }: DeviceMotionEvent) => {
         const isAndroid: boolean = /Android/i.test(navigator.userAgent);
         if (!accelerationIncludingGravity) return;
         const { x, y, z } = accelerationIncludingGravity;
         this.propagateAcc({ x, y, z }, isAndroid);
     };
 
-    private handleDeviceOrientation = ({ alpha, beta, gamma }: DeviceOrientationEvent) => {
+    private handleDeviceOrientation = ({
+        alpha,
+        beta,
+        gamma
+    }: DeviceOrientationEvent) => {
         this.propagateGyr({ alpha, beta, gamma });
     };
 
@@ -96,29 +127,45 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         if (this.hasAccInput) {
             if (window.DeviceMotionEvent) {
                 // iOS 13+ requires a user gesture to enable DeviceMotionEvent, to be done in the main thread
-                window.addEventListener("devicemotion", this.handleDeviceMotion, true);
+                window.addEventListener(
+                    'devicemotion',
+                    this.handleDeviceMotion,
+                    true
+                );
             } else {
                 // Browser doesn't support DeviceMotionEvent
-                console.log("Cannot set the accelerometer handler.");
+                console.log('Cannot set the accelerometer handler.');
             }
         }
         if (this.hasGyrInput) {
             if (window.DeviceMotionEvent) {
                 // iOS 13+ requires a user gesture to enable DeviceMotionEvent, to be done in the main thread
-                window.addEventListener("deviceorientation", this.handleDeviceOrientation, true);
+                window.addEventListener(
+                    'deviceorientation',
+                    this.handleDeviceOrientation,
+                    true
+                );
             } else {
                 // Browser doesn't support DeviceMotionEvent
-                console.log("Cannot set the gyroscope handler.");
+                console.log('Cannot set the gyroscope handler.');
             }
         }
     }
 
     stopSensors() {
         if (this.hasAccInput) {
-            window.removeEventListener("devicemotion", this.handleDeviceMotion, true);
+            window.removeEventListener(
+                'devicemotion',
+                this.handleDeviceMotion,
+                true
+            );
         }
         if (this.hasGyrInput) {
-            window.removeEventListener("deviceorientation", this.handleDeviceOrientation, true);
+            window.removeEventListener(
+                'deviceorientation',
+                this.handleDeviceOrientation,
+                true
+            );
         }
     }
 
@@ -132,7 +179,7 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         if (this.fOutputHandler) {
             this.fOutputHandler(path, value);
         } else {
-            console.warn("No OutputParamHandler set for this Faust node.");
+            console.warn('No OutputParamHandler set for this Faust node.');
         }
     }
 
@@ -147,9 +194,9 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         this.fPlotHandler = handler;
         // Set PlotHandler on processor side
         if (this.fPlotHandler) {
-            this.port.postMessage({ type: "setPlotHandler", data: true });
+            this.port.postMessage({ type: 'setPlotHandler', data: true });
         } else {
-            this.port.postMessage({ type: "setPlotHandler", data: false });
+            this.port.postMessage({ type: 'setPlotHandler', data: false });
         }
     }
     getPlotHandler(): PlotHandler | null {
@@ -157,7 +204,7 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
     }
 
     setupWamEventHandler() {
-        this.port.postMessage({ type: "setupWamEventHandler" });
+        this.port.postMessage({ type: 'setupWamEventHandler' });
     }
 
     getNumInputs() {
@@ -174,7 +221,9 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
 
     metadata(handler: MetadataHandler) {
         if (this.fJSONDsp.meta) {
-            this.fJSONDsp.meta.forEach(meta => handler(Object.keys(meta)[0], meta[Object.keys(meta)[0]]));
+            this.fJSONDsp.meta.forEach((meta) =>
+                handler(Object.keys(meta)[0], meta[Object.keys(meta)[0]])
+            );
         }
     }
 
@@ -185,74 +234,99 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
         const data2 = data[2];
         if (cmd === 11) this.ctrlChange(channel, data1, data2);
         else if (cmd === 14) this.pitchWheel(channel, data2 * 128.0 + data1);
-        if (cmd === 8 || (cmd === 9 && data2 === 0)) this.keyOff(channel, data1, data2);
+        if (cmd === 8 || (cmd === 9 && data2 === 0))
+            this.keyOff(channel, data1, data2);
         else if (cmd === 9) this.keyOn(channel, data1, data2);
-        else this.port.postMessage({ type: "midi", data: data });
+        else this.port.postMessage({ type: 'midi', data: data });
     }
 
     ctrlChange(channel: number, ctrl: number, value: number) {
-        const e = { type: "ctrlChange", data: [channel, ctrl, value] };
+        const e = { type: 'ctrlChange', data: [channel, ctrl, value] };
         this.port.postMessage(e);
     }
     pitchWheel(channel: number, wheel: number) {
-        const e = { type: "pitchWheel", data: [channel, wheel] };
+        const e = { type: 'pitchWheel', data: [channel, wheel] };
         this.port.postMessage(e);
     }
     keyOn(channel: number, pitch: number, velocity: number) {
-        const e = { type: "keyOn", data: [channel, pitch, velocity] };
+        const e = { type: 'keyOn', data: [channel, pitch, velocity] };
         this.port.postMessage(e);
     }
     keyOff(channel: number, pitch: number, velocity: number) {
-        const e = { type: "keyOff", data: [channel, pitch, velocity] };
+        const e = { type: 'keyOff', data: [channel, pitch, velocity] };
         this.port.postMessage(e);
     }
 
-    get hasAccInput() { return this.#hasAccInput; }
+    get hasAccInput() {
+        return this.#hasAccInput;
+    }
 
-    propagateAcc(accelerationIncludingGravity: NonNullable<DeviceMotionEvent["accelerationIncludingGravity"]>, invert: boolean = false) {
+    propagateAcc(
+        accelerationIncludingGravity: NonNullable<
+            DeviceMotionEvent['accelerationIncludingGravity']
+        >,
+        invert: boolean = false
+    ) {
         if (!accelerationIncludingGravity) return;
         const { x, y, z } = accelerationIncludingGravity;
         this.fCommunicator.setAcc({ x: x!, y: y!, z: z! }, invert);
     }
 
-    get hasGyrInput() { return this.#hasGyrInput; }
+    get hasGyrInput() {
+        return this.#hasGyrInput;
+    }
 
-    propagateGyr(event: Pick<DeviceOrientationEvent, "alpha" | "beta" | "gamma">) {
+    propagateGyr(
+        event: Pick<DeviceOrientationEvent, 'alpha' | 'beta' | 'gamma'>
+    ) {
         if (!event) return;
         const { alpha, beta, gamma } = event;
-        this.fCommunicator.setGyr({ alpha: alpha!, beta: beta!, gamma: gamma! });
+        this.fCommunicator.setGyr({
+            alpha: alpha!,
+            beta: beta!,
+            gamma: gamma!
+        });
     }
 
     setParamValue(path: string, value: number) {
-        const e = { type: "param", data: { path, value } };
+        const e = { type: 'param', data: { path, value } };
         this.port.postMessage(e);
         // Set value on AudioParam (but this is not used on Processor side for now)
         const param = this.parameters.get(path);
         if (param) param.setValueAtTime(value, this.context.currentTime);
-
     }
     getParamValue(path: string) {
         // Get value of AudioParam
         const param = this.parameters.get(path);
-        return (param) ? param.value : 0;
+        return param ? param.value : 0;
     }
 
-    getParams() { return this.fInputsItems; }
-    getMeta() { return this.fJSONDsp; }
-    getJSON() { return JSON.stringify(this.getMeta()); }
-    getUI() { return this.fJSONDsp.ui; }
-    getDescriptors() { return this.fDescriptor; }
+    getParams() {
+        return this.fInputsItems;
+    }
+    getMeta() {
+        return this.fJSONDsp;
+    }
+    getJSON() {
+        return JSON.stringify(this.getMeta());
+    }
+    getUI() {
+        return this.fJSONDsp.ui;
+    }
+    getDescriptors() {
+        return this.fDescriptor;
+    }
 
     start() {
-        this.port.postMessage({ type: "start" });
+        this.port.postMessage({ type: 'start' });
     }
 
     stop() {
-        this.port.postMessage({ type: "stop" });
+        this.port.postMessage({ type: 'stop' });
     }
 
     destroy() {
-        this.port.postMessage({ type: "destroy" });
+        this.port.postMessage({ type: 'destroy' });
         this.port.close();
     }
 }
@@ -260,32 +334,48 @@ export class FaustAudioWorkletNode<Poly extends boolean = false> extends (global
 /**
  * Monophonic AudioWorkletNode
  */
-export class FaustMonoAudioWorkletNode extends FaustAudioWorkletNode<false> implements IFaustMonoWebAudioDsp {
-
+export class FaustMonoAudioWorkletNode
+    extends FaustAudioWorkletNode<false>
+    implements IFaustMonoWebAudioDsp
+{
     onprocessorerror = (e: Event) => {
         // console.error("Error from " + this.fJSONDsp.name + " FaustMonoAudioWorkletNode");
         throw e;
-    }
+    };
 
-    constructor(context: BaseAudioContext, options: Partial<FaustAudioWorkletNodeOptions<false>> & Pick<FaustAudioWorkletNodeOptions<false>, "processorOptions">) {
-        super(context, options.processorOptions.name, options.processorOptions.factory, options);
+    constructor(
+        context: BaseAudioContext,
+        options: Partial<FaustAudioWorkletNodeOptions<false>> &
+            Pick<FaustAudioWorkletNodeOptions<false>, 'processorOptions'>
+    ) {
+        super(
+            context,
+            options.processorOptions.name,
+            options.processorOptions.factory,
+            options
+        );
     }
 }
 
 /**
  * Polyphonic AudioWorkletNode
  */
-export class FaustPolyAudioWorkletNode extends FaustAudioWorkletNode<true> implements IFaustPolyWebAudioDsp {
-
+export class FaustPolyAudioWorkletNode
+    extends FaustAudioWorkletNode<true>
+    implements IFaustPolyWebAudioDsp
+{
     private fJSONEffect: FaustDspMeta | null;
 
     onprocessorerror = (e: Event) => {
         // console.error("Error from " + this.fJSONDsp.name + " FaustPolyAudioWorkletNode");
         throw e;
-    }
-
-    constructor(context: BaseAudioContext, options: Partial<FaustAudioWorkletNodeOptions<true>> & Pick<FaustAudioWorkletNodeOptions<true>, "processorOptions">) {
+    };
 
+    constructor(
+        context: BaseAudioContext,
+        options: Partial<FaustAudioWorkletNodeOptions<true>> &
+            Pick<FaustAudioWorkletNodeOptions<true>, 'processorOptions'>
+    ) {
         super(
             context,
             options.processorOptions.name,
@@ -293,7 +383,9 @@ export class FaustPolyAudioWorkletNode extends FaustAudioWorkletNode<true> imple
             options
         );
 
-        this.fJSONEffect = options.processorOptions.effectFactory ? JSON.parse(options.processorOptions.effectFactory.json) : null;
+        this.fJSONEffect = options.processorOptions.effectFactory
+            ? JSON.parse(options.processorOptions.effectFactory.json)
+            : null;
 
         if (this.fJSONEffect) {
             FaustBaseWebAudioDsp.parseUI(this.fJSONEffect.ui, this.fUICallback);
@@ -302,17 +394,17 @@ export class FaustPolyAudioWorkletNode extends FaustAudioWorkletNode<true> imple
 
     // Public API
     keyOn(channel: number, pitch: number, velocity: number) {
-        const e = { type: "keyOn", data: [channel, pitch, velocity] };
+        const e = { type: 'keyOn', data: [channel, pitch, velocity] };
         this.port.postMessage(e);
     }
 
     keyOff(channel: number, pitch: number, velocity: number) {
-        const e = { type: "keyOff", data: [channel, pitch, velocity] };
+        const e = { type: 'keyOff', data: [channel, pitch, velocity] };
         this.port.postMessage(e);
     }
 
     allNotesOff(hard: boolean) {
-        const e = { type: "ctrlChange", data: [0, 123, 0] };
+        const e = { type: 'ctrlChange', data: [0, 123, 0] };
         this.port.postMessage(e);
     }
 
@@ -321,18 +413,24 @@ export class FaustPolyAudioWorkletNode extends FaustAudioWorkletNode<true> imple
         const e = this.fJSONEffect;
         const r = { ...o };
         if (e) {
-            r.ui = [{
-                type: "tgroup", label: "Sequencer", items: [
-                    { type: "vgroup", label: "Instrument", items: o.ui },
-                    { type: "vgroup", label: "Effect", items: e.ui }
-                ]
-            }];
+            r.ui = [
+                {
+                    type: 'tgroup',
+                    label: 'Sequencer',
+                    items: [
+                        { type: 'vgroup', label: 'Instrument', items: o.ui },
+                        { type: 'vgroup', label: 'Effect', items: e.ui }
+                    ]
+                }
+            ];
         } else {
-            r.ui = [{
-                type: "tgroup", label: "Polyphonic", items: [
-                    { type: "vgroup", label: "Voices", items: o.ui }
-                ]
-            }];
+            r.ui = [
+                {
+                    type: 'tgroup',
+                    label: 'Polyphonic',
+                    items: [{ type: 'vgroup', label: 'Voices', items: o.ui }]
+                }
+            ];
         }
         return r as FaustDspMeta;
     }