npm - @grame/faustwasm - Versions diffs - 0.8.2 → 0.9.0 - Mend

@grame/faustwasm 0.8.2 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/assets/standalone/create-node.js +15 -8
package/assets/standalone/faustwasm/index.d.ts +40 -0
package/assets/standalone/faustwasm/index.js +109 -30
package/assets/standalone/faustwasm/index.js.map +2 -2
package/assets/standalone/index-pwa.js +1 -1
package/assets/standalone/service-worker.js +58 -5
package/dist/cjs/index.d.ts +40 -0
package/dist/cjs/index.js +109 -30
package/dist/cjs/index.js.map +2 -2
package/dist/cjs-bundle/index.d.ts +40 -0
package/dist/cjs-bundle/index.js +109 -30
package/dist/cjs-bundle/index.js.map +2 -2
package/dist/esm/index.d.ts +40 -0
package/dist/esm/index.js +109 -30
package/dist/esm/index.js.map +2 -2
package/dist/esm-bundle/index.d.ts +40 -0
package/dist/esm-bundle/index.js +109 -30
package/dist/esm-bundle/index.js.map +2 -2
package/package.json +1 -1
package/src/FaustAudioWorkletNode.ts +10 -0
package/src/FaustAudioWorkletProcessor.ts +16 -0
package/src/FaustOfflineProcessor.ts +2 -0
package/src/FaustScriptProcessorNode.ts +2 -0
package/src/FaustWebAudioDsp.ts +88 -0
package/src/copyWebStandaloneAssets.js +14 -0
package/test/faustlive-wasm/faustwasm/index.d.ts +40 -0
package/test/faustlive-wasm/faustwasm/index.js +109 -30
package/test/faustlive-wasm/faustwasm/index.js.map +2 -2
package/test/midi/create-node.js +177 -0
package/test/midi/dsp-meta.json +133 -0
package/test/midi/dsp-module.wasm +0 -0
package/test/midi/faust-ui/index.css +442 -0
package/test/midi/faust-ui/index.css.map +1 -0
package/test/midi/faust-ui/index.d.ts +1 -0
package/test/midi/faust-ui/index.js +3729 -0
package/test/midi/faust-ui/index.js.map +1 -0
package/test/midi/faustwasm/index.d.ts +1680 -0
package/test/midi/faustwasm/index.js +4884 -0
package/test/midi/faustwasm/index.js.map +7 -0
package/test/midi/icon.png +0 -0
package/test/midi/index.html +76 -0
package/test/midi/index.js +183 -0
package/test/midi/manifest.json +17 -0
package/test/midi/service-worker.js +165 -0
package/test/midi.dsp +8 -1
package/test/organ1/create-node.js +177 -0
package/test/organ1/dsp-meta.json +126 -0
package/test/organ1/dsp-module.wasm +0 -0
package/test/organ1/faust-ui/index.css +442 -0
package/test/organ1/faust-ui/index.css.map +1 -0
package/test/organ1/faust-ui/index.d.ts +1 -0
package/test/organ1/faust-ui/index.js +3729 -0
package/test/organ1/faust-ui/index.js.map +1 -0
package/test/organ1/faustwasm/index.d.ts +1656 -0
package/test/organ1/faustwasm/index.js +4783 -0
package/test/organ1/faustwasm/index.js.map +7 -0
package/test/organ1/icon.png +0 -0
package/test/organ1/index.html +76 -0
package/test/organ1/index.js +203 -0
package/test/organ1/manifest.json +17 -0
package/test/organ1/service-worker.js +181 -0

package/test/organ1/icon.png ADDED Viewed

Binary file

package/test/organ1/index.html ADDED Viewed

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="en">
+<link rel="manifest" href="./manifest.json">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Faust DSP</title>
+    <style>
+        body {
+            color: #b0b0b0;
+            background-color: #1f1f1f;
+            display: flex;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            margin: 0;
+            position: absolute;
+        }
+        main {
+            margin: 20px;
+            display: flex;
+            flex-direction: column;
+            flex: 1 1 100%;
+        }
+        main span {
+            position: relative;
+            display: flex;
+        }
+        main span[hidden] {
+            display: none;
+        }
+        main span span {
+            margin: 0px 10px;
+            flex: 1;
+        }
+        main span select {
+            flex: 2;
+        }
+        #dsp-switch {
+            margin: 20px auto;
+        }
+        #button-dsp {
+            padding: 10px;
+        }
+        #div-faust-ui {
+            flex: 1 1 auto;
+            display: flex;
+            position: relative;
+            flex-direction: column;
+            color: black;
+        }
+    </style>
+    <link rel="stylesheet" href="./faust-ui/index.css">
+</head>
+<body>
+    <main>
+        <div id="div-faust-ui">
+        </div>
+    </main>
+    <script src="./index.js"></script>
+</body>
+</html>

package/test/organ1/index.js ADDED Viewed

@@ -0,0 +1,203 @@
+// Set to > 0 if the DSP is polyphonic
+const FAUST_DSP_VOICES = 0;
+/**
+ * @typedef {import("./faustwasm").FaustAudioWorkletNode} FaustAudioWorkletNode
+ * @typedef {import("./faustwasm").FaustDspMeta} FaustDspMeta
+ * @typedef {import("./faustwasm").FaustUIDescriptor} FaustUIDescriptor
+ * @typedef {import("./faustwasm").FaustUIGroup} FaustUIGroup
+ * @typedef {import("./faustwasm").FaustUIItem} FaustUIItem
+ */
+/**
+ * Registers the service worker.
+ */
+if ("serviceWorker" in navigator) {
+    window.addEventListener("load", () => {
+        navigator.serviceWorker.register("./service-worker.js")
+            .then(reg => {
+                console.log("Service Worker registered", reg);
+                // Listen for updates to the existing service worker
+                reg.addEventListener("updatefound", () => {
+                    const newWorker = reg.installing;
+                    if (newWorker) {
+                        console.log("New Service Worker found...");
+                        newWorker.addEventListener("statechange", () => {
+                            if (newWorker.state === "installed") {
+                                // A new version has finished installing
+                                if (navigator.serviceWorker.controller) {
+                                    // There's already a controlling SW, so this is an update
+                                    console.log("New version installed. Reloading...");
+                                    window.location.reload();
+                                } else {
+                                    // First installation of the service worker
+                                    console.log("Service Worker installed for the first time.");
+                                }
+                            }
+                        });
+                    }
+                });
+            })
+            .catch(err => console.log("Service Worker registration failed", err));
+    });
+}
+/** @type {HTMLDivElement} */
+const $divFaustUI = document.getElementById("div-faust-ui");
+/** @type {typeof AudioContext} */
+const AudioCtx = window.AudioContext || window.webkitAudioContext;
+const audioContext = new AudioCtx({ latencyHint: 0.00001 });
+audioContext.destination.channelInterpretation = "discrete";
+audioContext.suspend();
+// Declare faustNode as a global variable
+let faustNode;
+// Called at load time
+(async () => {
+    // Import the create-node module
+    const { createFaustNode, createFaustUI } = await import("./create-node.js");
+    // To test the ScriptProcessorNode mode
+    // const result = await createFaustNode(audioContext, "osc", FAUST_DSP_VOICES, true, 512);
+    const result = await createFaustNode(audioContext, "osc", FAUST_DSP_VOICES);
+    faustNode = result.faustNode;  // Assign to the global variable
+    if (!faustNode) throw new Error("Faust DSP not compiled");
+    // Create the Faust UI
+    await createFaustUI($divFaustUI, faustNode);
+})();
+// Synchronous function to resume AudioContext, to be called first in the synchronous event listener
+function resumeAudioContext() {
+    if (audioContext.state === 'suspended') {
+        audioContext.resume().then(() => {
+            console.log('AudioContext resumed successfully');
+        }).catch(error => {
+            console.error('Error when resuming AudioContext:', error);
+        });
+    }
+}
+// Function to start MIDI
+function startMIDI() {
+    // Check if the browser supports the Web MIDI API
+    if (navigator.requestMIDIAccess) {
+        navigator.requestMIDIAccess().then(
+            midiAccess => {
+                console.log("MIDI Access obtained.");
+                for (let input of midiAccess.inputs.values()) {
+                    input.onmidimessage = (event) => faustNode.midiMessage(event.data);
+                    console.log(`Connected to input: ${input.name}`);
+                }
+            },
+            () => console.error("Failed to access MIDI devices.")
+        );
+    } else {
+        console.log("Web MIDI API is not supported in this browser.");
+    }
+}
+// Function to stop MIDI
+function stopMIDI() {
+    // Check if the browser supports the Web MIDI API
+    if (navigator.requestMIDIAccess) {
+        navigator.requestMIDIAccess().then(
+            midiAccess => {
+                console.log("MIDI Access obtained.");
+                for (let input of midiAccess.inputs.values()) {
+                    input.onmidimessage = null;
+                    console.log(`Disconnected from input: ${input.name}`);
+                }
+            },
+            () => console.error("Failed to access MIDI devices.")
+        );
+    } else {
+        console.log("Web MIDI API is not supported in this browser.");
+    }
+}
+let sensorHandlersBound = false;
+let midiHandlersBound = false;
+// Function to activate MIDI and Sensors on user interaction
+async function activateMIDISensors() {
+    // Import the create-node module
+    const { connectToAudioInput, requestPermissions } = await import("./create-node.js");
+    // Request permission for sensors
+    await requestPermissions();
+    // Activate sensor listeners
+    if (!sensorHandlersBound) {
+        await faustNode.startSensors();
+        sensorHandlersBound = true;
+    }
+    // Initialize the MIDI setup
+    if (!midiHandlersBound && FAUST_DSP_VOICES > 0) {
+        startMIDI();
+        midiHandlersBound = true;
+    }
+    // Connect the Faust node to the audio output
+    faustNode.connect(audioContext.destination);
+    // Connect the Faust node to the audio input
+    if (faustNode.numberOfInputs > 0) {
+        await connectToAudioInput(audioContext, null, faustNode, null);
+    }
+    // Resume the AudioContext
+    if (audioContext.state === 'suspended') {
+        await audioContext.resume();
+    }
+}
+// Function to suspend AudioContext, deactivate MIDI and Sensors on user interaction
+async function deactivateAudioMIDISensors() {
+    // Suspend the AudioContext
+    if (audioContext.state === 'running') {
+        await audioContext.suspend();
+    }
+    // Deactivate sensor listeners
+    if (sensorHandlersBound) {
+        faustNode.stopSensors();
+        sensorHandlersBound = false;
+    }
+    // Deactivate the MIDI setup
+    if (midiHandlersBound && FAUST_DSP_VOICES > 0) {
+        stopMIDI();
+        midiHandlersBound = false;
+    }
+}
+// Event listener to handle user interaction
+function handleUserInteraction() {
+    // Resume AudioContext synchronously
+    resumeAudioContext();
+    // Launch the activation of MIDI and Sensors
+    activateMIDISensors().catch(error => {
+        console.error('Error when activating audio, MIDI and sensors:', error);
+    });
+}
+// Activate AudioContext, MIDI and Sensors on user interaction
+window.addEventListener('click', handleUserInteraction);
+window.addEventListener('touchstart', handleUserInteraction);
+// Deactivate AudioContext, MIDI and Sensors on user interaction
+window.addEventListener('visibilitychange', function () {
+    if (window.visibilityState === 'hidden') {
+        deactivateAudioMIDISensors();
+    }
+});

package/test/organ1/manifest.json ADDED Viewed

@@ -0,0 +1,17 @@
+{
+  "name": "Faust organ1",
+  "short_name": "organ1",
+  "start_url": "./index.html",
+  "description": "Progressive Web App for organ1",
+  "display": "standalone",
+  "background_color": "#ffffff",
+  "theme_color": "#000000",
+  "orientation": "portrait",
+  "icons": [
+    {
+      "src": "./icon.png",
+      "sizes": "390x390",
+      "type": "image/png"
+    }
+  ]
+}

package/test/organ1/service-worker.js ADDED Viewed

@@ -0,0 +1,181 @@
+/// <reference lib="webworker" />
+// Set to > 0 if the DSP is polyphonic
+const FAUST_DSP_VOICES = 0;
+// Set to true if the DSP has an effect
+const FAUST_DSP_HAS_EFFECT = false;
+const CACHE_NAME = "organ1_20250201-1155"; // Cache name with versioning
+/**
+ * List of essential resources required for the **Mono DSP** version of the application.
+ *
+ * - These files are cached to enable offline functionality and improve loading speed.
+ * - Includes the main HTML, JavaScript, and CSS files required for the app.
+ * - Contains Faust-related files needed for DSP processing.
+ */
+const MONO_RESOURCES = [
+    "./index.html",
+    "./index.js",
+    "./create-node.js",
+    "./faust-ui/index.js",
+    "./faust-ui/index.css",
+    "./faustwasm/index.js",
+    "./dsp-module.wasm",
+    "./dsp-meta.json"
+];
+/**
+ * List of resources for the **Polyphonic DSP** version of the application.
+ *
+ * - Extends the mono resource list by adding a **mixer module**.
+ * - The mixer module is required to handle multiple simultaneous voices used in a polyphonic instrument.
+ */
+const POLY_RESOURCES = [
+    ...MONO_RESOURCES,
+    "./mixer-module.wasm",
+];
+/**
+ * List of resources for the **Polyphonic DSP with Effects** version.
+ *
+ * - Extends the polyphonic resource list by adding an **effect module**.
+ * - The effect module allows applying audio effects to the polyphonic instrument.
+ */
+const POLY_EFFECT_RESOURCES = [
+    ...POLY_RESOURCES,
+    "./effect-module.wasm",
+    "./effect-meta.json",
+];
+/** @type {ServiceWorkerGlobalScope} */
+const serviceWorkerGlobalScope = self;
+/**
+ * Install the service worker, cache essential resources, and prepare for immediate activation.
+ *
+ * - Opens the cache and stores required assets based on the app's configuration.
+ * - Ensures resources are preloaded for offline access.
+ */
+serviceWorkerGlobalScope.addEventListener("install", (event) => {
+    console.log("Service worker installed");
+    // Force activation of the new service worker without waiting
+    serviceWorkerGlobalScope.skipWaiting();
+    event.waitUntil((async () => {
+        const cache = await caches.open(CACHE_NAME);
+        const resources = (FAUST_DSP_VOICES && FAUST_DSP_HAS_EFFECT)
+            ? POLY_EFFECT_RESOURCES
+            : (FAUST_DSP_VOICES ? POLY_RESOURCES : MONO_RESOURCES);
+        try {
+            return cache.addAll(resources);
+        } catch (error) {
+            console.error("Failed to cache resources during install:", error);
+        }
+    })());
+});
+/**
+ * Handles the activation of the Service Worker.
+ *
+ * - Claims control over all clients immediately, bypassing the default behavior that
+ *   requires a page reload before the new service worker takes effect.
+ * - Removes old caches that do not match the current version.
+ * - Once claimed, (optionally) reloads all active window clients to ensure they are
+ *   controlled by the latest version of the service worker.
+ * - This approach ensures that updates to the service worker take effect immediately.
+ */
+serviceWorkerGlobalScope.addEventListener("activate", (event) => {
+    console.log("Service worker activated");
+    event.waitUntil(
+        (async () => {
+            // Clean up old caches that don't match the current CACHE_NAME
+            const cacheNames = await caches.keys();
+            await Promise.all(
+                cacheNames.map((cacheName) => {
+                    if (cacheName !== CACHE_NAME && cacheName.startsWith("organ1_")) {
+                        console.log("Deleting old cache:", cacheName);
+                        return caches.delete(cacheName);
+                    }
+                })
+            );
+            // Take control of all active clients
+            await clients.claim();
+            // Optionally reload all open windows to ensure they're using the new SW
+            const windowClients = await clients.matchAll({ type: "window" });
+            windowClients.forEach((client) => {
+                client.navigate(client.url);
+            });
+        })()
+    );
+});
+/**
+ * Adjusts response headers to enforce Cross-Origin Opener Policy (COOP) and Cross-Origin Embedder Policy (COEP).
+ *
+ * - Ensures that the response is served with `Cross-Origin-Opener-Policy: same-origin`
+ *   and `Cross-Origin-Embedder-Policy: require-corp`.
+ * - Required for enabling **cross-origin isolated** environments in web applications.
+ * - Necessary for features like **SharedArrayBuffer**, WebAssembly threads, and
+ *   high-performance APIs that require isolation.
+ * - Creates a new `Response` object with the modified headers while preserving
+ *   the original response body and status.
+ *
+ * @param {Response} response - The original HTTP response object.
+ * @returns {Response} A new response with updated security headers.
+ */
+const getCrossOriginIsolatedResponse = (response) => {
+    // Modify headers to include COOP & COEP
+    const headers = new Headers(response.headers);
+    headers.set("Cross-Origin-Opener-Policy", "same-origin");
+    headers.set("Cross-Origin-Embedder-Policy", "require-corp");
+    // Create a new response with the modified headers
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+    });
+};
+/**
+ * Intercepts fetch requests and enforces COOP and COEP headers for security.
+ *
+ * - Checks if the requested resource is available in the cache:
+ *   - If found, returns a cached response with `Cross-Origin-Opener-Policy` and `Cross-Origin-Embedder-Policy` headers.
+ *   - If not found, fetches the resource from the network, applies COOP/COEP headers, and caches the response (for GET requests).
+ * - Ensures cross-origin isolation, required for APIs like `SharedArrayBuffer` and WebAssembly threading.
+ * - Handles network errors gracefully by returning a 503 "Service Unavailable" response when needed.
+ *
+ * @param {FetchEvent} event - The fetch event triggered by the browser.
+ */
+serviceWorkerGlobalScope.addEventListener("fetch", (event) => {
+    event.respondWith((async () => {
+        const cache = await caches.open(CACHE_NAME);
+        const cachedResponse = await cache.match(event.request);
+        if (cachedResponse) {
+            return getCrossOriginIsolatedResponse(cachedResponse);
+        } else {
+            try {
+                const fetchResponse = await fetch(event.request);
+                if (event.request.method === "GET" && fetchResponse && fetchResponse.status === 200 && fetchResponse.type === "basic") {
+                    const modifiedResponse = getCrossOriginIsolatedResponse(fetchResponse);
+                    // Store the modified response in the cache
+                    await cache.put(event.request, modifiedResponse.clone());
+                    // Return the modified response to the browser
+                    return modifiedResponse;
+                }
+                return fetchResponse;
+            } catch (error) {
+                console.error("Network access error", error);
+                return new Response("Network error", { status: 503, statusText: "Service Unavailable" });
+            }
+        }
+    })());
+});