@grame/faustwasm 0.12.2 → 0.13.0

package/src/LibFaust.ts

@@ -1,4 +1,4 @@
-import type { FaustModule, LibFaustWasm, FaustInfoType } from "./types";
+import type { FaustModule, LibFaustWasm, FaustInfoType } from './types';
 
 export interface ILibFaust extends LibFaustWasm {
     module(): FaustModule;
@@ -24,8 +24,18 @@ class LibFaust implements ILibFaust {
     version() {
         return this.fCompiler.version();
     }
-    createDSPFactory(name: string, code: string, args: string, useInternalMemory: boolean) {
-        return this.fCompiler.createDSPFactory(name, code, args, useInternalMemory);
+    createDSPFactory(
+        name: string,
+        code: string,
+        args: string,
+        useInternalMemory: boolean
+    ) {
+        return this.fCompiler.createDSPFactory(
+            name,
+            code,
+            args,
+            useInternalMemory
+        );
     }
     deleteDSPFactory(cFactory: number) {
         return this.fCompiler.deleteDSPFactory(cFactory);
@@ -51,7 +61,6 @@ class LibFaust implements ILibFaust {
     toString() {
         return `LibFaust module: ${this.fModule}, compiler: ${this.fCompiler}`;
     }
-
 }
 
 export default LibFaust;

package/src/SoundfileReader.ts

@@ -1,131 +1,175 @@
-import { FaustBaseWebAudioDsp } from "./FaustWebAudioDsp";
-import type { AudioData, FaustDspMeta, FaustUIItem, LooseFaustDspFactory } from "./types";
-
-/** Read metadata and fetch soundfiles */
-class SoundfileReader {
-
-    // Set the fallback paths
-    static get fallbackPaths() { return [location.href, this.getParentUrl(location.href), location.origin]; }
-
-    /**
-     * Extract the parent URL from an URL.
-     * @param url : the URL
-     * @returns : the parent URL
-     */
-    private static getParentUrl(url: string) {
-        return url.substring(0, url.lastIndexOf('/') + 1);
-    }
-
-    /**
-     * Convert an audio buffer to audio data.
-     * 
-     * @param audioBuffer : the audio buffer to convert
-     * @returns : the audio data
-     */
-    private static toAudioData(audioBuffer: AudioBuffer): AudioData {
-        const { sampleRate, numberOfChannels } = audioBuffer;
-        return {
-            sampleRate,
-            audioBuffer: new Array(numberOfChannels).fill(null).map((v, i) => audioBuffer.getChannelData(i))
-        } as AudioData;
-    }
-
-    /**
-     * Extract the URLs from the metadata.
-     * 
-     * @param dspMeta : the metadata
-     * @returns : the URLs
-     */
-    static findSoundfilesFromMeta(dspMeta: FaustDspMeta): LooseFaustDspFactory["soundfiles"] {
-        const soundfiles: LooseFaustDspFactory["soundfiles"] = {};
-        const callback = (item: FaustUIItem) => {
-            if (item.type === "soundfile") {
-                const urls = FaustBaseWebAudioDsp.splitSoundfileNames(item.url);
-                // soundfiles.map[item.label] = urls;
-                urls.forEach(url => soundfiles[url] = null);
-            }
-        };
-        FaustBaseWebAudioDsp.parseUI(dspMeta.ui, callback);
-        return soundfiles;
-    }
-    /**
-     * Check if the file exists.
-     * 
-     * @param url : the url of the file to check
-     * @returns : true if the file exists, otherwise false
-     */
-    private static async checkFileExists(url: string): Promise<boolean> {
-        try {
-            console.log(`"checkFileExists" url: ${url}`);
-            // Fetch in "HEAD" mode does not properly work with the service-worker.js cache, so use "GET" mode for now
-            //const response = await fetch(url, { method: "HEAD" });
-            const response = await fetch(url);
-            console.log(`"checkFileExists" response.ok: ${response.ok}`);
-            return response.ok; // Will be true if the status code is 200-299
-        } catch (error) {
-            console.error('Fetch error:', error);
-            return false;
-        }
-    }
-
-    /**
-     * Fetch the soundfile.
-     * 
-     * @param url : the url of the soundfile
-     * @param audioCtx : the audio context
-     * @returns : the audio data
-     */
-    private static async fetchSoundfile(url: string, audioCtx: BaseAudioContext): Promise<AudioData> {
-        console.log(`Loading sound file from ${url}`);
-        const response = await fetch(url);
-        if (!response.ok) throw new Error(`Failed to load sound file from ${url}: ${response.statusText}`);
-        // Decode the audio data
-        const arrayBuffer = await response.arrayBuffer();
-        const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);
-        return this.toAudioData(audioBuffer);
-    }
-
-    /**
-     * Load the soundfile.
-     * 
-     * @param filename : the filename
-     * @param metaUrls : the metadata URLs
-     * @param soundfiles : the soundfiles
-     * @param audioCtx : the audio context
-     */
-    private static async loadSoundfile(filename: string, metaUrls: string[], soundfiles: LooseFaustDspFactory["soundfiles"], audioCtx: BaseAudioContext): Promise<void> {
-        if (soundfiles?.[filename]) return;
-        const urlsToCheck = [filename, ...[...metaUrls, ...this.fallbackPaths].map(path => new URL(filename, path.endsWith("/") ? path : `${path}/`).href)];
-        const checkResults = await Promise.all(urlsToCheck.map(url => this.checkFileExists(url)));
-        const successIndex = checkResults.findIndex(r => !!r);
-        if (successIndex === -1) throw new Error(`Failed to load sound file ${filename}, all check failed.`);
-        soundfiles![filename] = await this.fetchSoundfile(urlsToCheck[successIndex], audioCtx);
-    }
-
-    /**
-     * Load the soundfiles, public API.
-     * 
-     * @param dspMeta : the metadata
-     * @param soundfilesIn : the soundfiles
-     * @param audioCtx : the audio context
-     * @returns : the soundfiles
-     */
-    static async loadSoundfiles(dspMeta: FaustDspMeta, soundfilesIn: LooseFaustDspFactory["soundfiles"], audioCtx: BaseAudioContext): Promise<LooseFaustDspFactory["soundfiles"]> {
-        const metaUrls = FaustBaseWebAudioDsp.extractUrlsFromMeta(dspMeta);
-        const soundfiles = this.findSoundfilesFromMeta(dspMeta);
-        for (const id in soundfiles) {
-            if (soundfilesIn?.[id]) {
-                soundfiles[id] = soundfilesIn[id];
-                continue;
-            }
-            try {
-                await this.loadSoundfile(id, metaUrls, soundfiles, audioCtx);
-            } catch (error) {
-                console.error(error);
-            }
-        }
-        return soundfiles;
-    }
-}
-
-export default SoundfileReader;
+import { FaustBaseWebAudioDsp } from './FaustWebAudioDsp';
+import type {
+    AudioData,
+    FaustDspMeta,
+    FaustUIItem,
+    LooseFaustDspFactory
+} from './types';
+
+/** Read metadata and fetch soundfiles */
+class SoundfileReader {
+    // Set the fallback paths
+    static get fallbackPaths() {
+        return [
+            location.href,
+            this.getParentUrl(location.href),
+            location.origin
+        ];
+    }
+
+    /**
+     * Extract the parent URL from an URL.
+     * @param url : the URL
+     * @returns : the parent URL
+     */
+    private static getParentUrl(url: string) {
+        return url.substring(0, url.lastIndexOf('/') + 1);
+    }
+
+    /**
+     * Convert an audio buffer to audio data.
+     *
+     * @param audioBuffer : the audio buffer to convert
+     * @returns : the audio data
+     */
+    private static toAudioData(audioBuffer: AudioBuffer): AudioData {
+        const { sampleRate, numberOfChannels } = audioBuffer;
+        return {
+            sampleRate,
+            audioBuffer: new Array(numberOfChannels)
+                .fill(null)
+                .map((v, i) => audioBuffer.getChannelData(i))
+        } as AudioData;
+    }
+
+    /**
+     * Extract the URLs from the metadata.
+     *
+     * @param dspMeta : the metadata
+     * @returns : the URLs
+     */
+    static findSoundfilesFromMeta(
+        dspMeta: FaustDspMeta
+    ): LooseFaustDspFactory['soundfiles'] {
+        const soundfiles: LooseFaustDspFactory['soundfiles'] = {};
+        const callback = (item: FaustUIItem) => {
+            if (item.type === 'soundfile') {
+                const urls = FaustBaseWebAudioDsp.splitSoundfileNames(item.url);
+                // soundfiles.map[item.label] = urls;
+                urls.forEach((url) => (soundfiles[url] = null));
+            }
+        };
+        FaustBaseWebAudioDsp.parseUI(dspMeta.ui, callback);
+        return soundfiles;
+    }
+    /**
+     * Check if the file exists.
+     *
+     * @param url : the url of the file to check
+     * @returns : true if the file exists, otherwise false
+     */
+    private static async checkFileExists(url: string): Promise<boolean> {
+        try {
+            console.log(`"checkFileExists" url: ${url}`);
+            // Fetch in "HEAD" mode does not properly work with the service-worker.js cache, so use "GET" mode for now
+            //const response = await fetch(url, { method: "HEAD" });
+            const response = await fetch(url);
+            console.log(`"checkFileExists" response.ok: ${response.ok}`);
+            return response.ok; // Will be true if the status code is 200-299
+        } catch (error) {
+            console.error('Fetch error:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Fetch the soundfile.
+     *
+     * @param url : the url of the soundfile
+     * @param audioCtx : the audio context
+     * @returns : the audio data
+     */
+    private static async fetchSoundfile(
+        url: string,
+        audioCtx: BaseAudioContext
+    ): Promise<AudioData> {
+        console.log(`Loading sound file from ${url}`);
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(
+                `Failed to load sound file from ${url}: ${response.statusText}`
+            );
+        // Decode the audio data
+        const arrayBuffer = await response.arrayBuffer();
+        const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);
+        return this.toAudioData(audioBuffer);
+    }
+
+    /**
+     * Load the soundfile.
+     *
+     * @param filename : the filename
+     * @param metaUrls : the metadata URLs
+     * @param soundfiles : the soundfiles
+     * @param audioCtx : the audio context
+     */
+    private static async loadSoundfile(
+        filename: string,
+        metaUrls: string[],
+        soundfiles: LooseFaustDspFactory['soundfiles'],
+        audioCtx: BaseAudioContext
+    ): Promise<void> {
+        if (soundfiles?.[filename]) return;
+        const urlsToCheck = [
+            filename,
+            ...[...metaUrls, ...this.fallbackPaths].map(
+                (path) =>
+                    new URL(filename, path.endsWith('/') ? path : `${path}/`)
+                        .href
+            )
+        ];
+        const checkResults = await Promise.all(
+            urlsToCheck.map((url) => this.checkFileExists(url))
+        );
+        const successIndex = checkResults.findIndex((r) => !!r);
+        if (successIndex === -1)
+            throw new Error(
+                `Failed to load sound file ${filename}, all check failed.`
+            );
+        soundfiles![filename] = await this.fetchSoundfile(
+            urlsToCheck[successIndex],
+            audioCtx
+        );
+    }
+
+    /**
+     * Load the soundfiles, public API.
+     *
+     * @param dspMeta : the metadata
+     * @param soundfilesIn : the soundfiles
+     * @param audioCtx : the audio context
+     * @returns : the soundfiles
+     */
+    static async loadSoundfiles(
+        dspMeta: FaustDspMeta,
+        soundfilesIn: LooseFaustDspFactory['soundfiles'],
+        audioCtx: BaseAudioContext
+    ): Promise<LooseFaustDspFactory['soundfiles']> {
+        const metaUrls = FaustBaseWebAudioDsp.extractUrlsFromMeta(dspMeta);
+        const soundfiles = this.findSoundfilesFromMeta(dspMeta);
+        for (const id in soundfiles) {
+            if (soundfilesIn?.[id]) {
+                soundfiles[id] = soundfilesIn[id];
+                continue;
+            }
+            try {
+                await this.loadSoundfile(id, metaUrls, soundfiles, audioCtx);
+            } catch (error) {
+                console.error(error);
+            }
+        }
+        return soundfiles;
+    }
+}
+
+export default SoundfileReader;

package/src/WavDecoder.ts

@@ -19,12 +19,12 @@ class WavDecoder {
     static decode(buffer: ArrayBuffer, options?: WavDecoderOptions) {
         const dataView = new DataView(buffer);
         const reader = new Reader(dataView);
-        if (reader.string(4) !== "RIFF") {
-            throw new TypeError("Invalid WAV file");
+        if (reader.string(4) !== 'RIFF') {
+            throw new TypeError('Invalid WAV file');
         }
         reader.uint32(); // skip file length
-        if (reader.string(4) !== "WAVE") {
-            throw new TypeError("Invalid WAV file");
+        if (reader.string(4) !== 'WAVE') {
+            throw new TypeError('Invalid WAV file');
         }
         let format: Format | null = null;
         let audioData: {
@@ -36,10 +36,15 @@ class WavDecoder {
         do {
             const chunkType = reader.string(4);
             const chunkSize = reader.uint32();
-            if (chunkType === "fmt ") {
+            if (chunkType === 'fmt ') {
                 format = this.decodeFormat(reader, chunkSize);
-            } else if (chunkType === "data") {
-                audioData = this.decodeData(reader, chunkSize, format as Format, options || {});
+            } else if (chunkType === 'data') {
+                audioData = this.decodeData(
+                    reader,
+                    chunkSize,
+                    format as Format,
+                    options || {}
+                );
             } else {
                 reader.skip(chunkSize);
             }
@@ -48,12 +53,14 @@ class WavDecoder {
     }
     private static decodeFormat(reader: Reader, chunkSize: number) {
         const formats = {
-            0x0001: "lpcm",
-            0x0003: "lpcm"
+            0x0001: 'lpcm',
+            0x0003: 'lpcm'
         };
         const formatId = reader.uint16();
-        if (!formats.hasOwnProperty(formatId)) {
-            throw new TypeError("Unsupported format in WAV file: 0x" + formatId.toString(16));
+        if (!Object.prototype.hasOwnProperty.call(formats, formatId)) {
+            throw new TypeError(
+                'Unsupported format in WAV file: 0x' + formatId.toString(16)
+            );
         }
         const format: Format = {
             formatId: formatId,
@@ -67,14 +74,21 @@ class WavDecoder {
         reader.skip(chunkSize - 16);
         return format;
     }
-    private static decodeData(reader: Reader, chunkSizeIn: number, format: Format, options: WavDecoderOptions) {
+    private static decodeData(
+        reader: Reader,
+        chunkSizeIn: number,
+        format: Format,
+        options: WavDecoderOptions
+    ) {
         const chunkSize = Math.min(chunkSizeIn, reader.remain());
         const length = Math.floor(chunkSize / format.blockSize);
         const numberOfChannels = format.numberOfChannels;
         const sampleRate = format.sampleRate;
         const channelData: Float32Array[] = new Array(numberOfChannels);
         for (let ch = 0; ch < numberOfChannels; ch++) {
-            const AB = options.shared ? (globalThis.SharedArrayBuffer || globalThis.ArrayBuffer) : globalThis.ArrayBuffer;
+            const AB = options.shared
+                ? globalThis.SharedArrayBuffer || globalThis.ArrayBuffer
+                : globalThis.ArrayBuffer;
             const ab = new AB(length * Float32Array.BYTES_PER_ELEMENT);
             channelData[ch] = new Float32Array(ab);
         }
@@ -86,12 +100,20 @@ class WavDecoder {
             channelData
         };
     }
-    private static readPCM(reader: Reader, channelData: Float32Array[], length: number, format: Format, options: WavDecoderOptions) {
+    private static readPCM(
+        reader: Reader,
+        channelData: Float32Array[],
+        length: number,
+        format: Format,
+        options: WavDecoderOptions
+    ) {
         const bitDepth = format.bitDepth;
-        const decoderOption = format.float ? "f" : options.symmetric ? "s" : "";
-        const methodName = "pcm" + bitDepth + decoderOption as `pcm${8 | 16 | 32}${"f" | "s" | ""}`;
+        const decoderOption = format.float ? 'f' : options.symmetric ? 's' : '';
+        const methodName = ('pcm' +
+            bitDepth +
+            decoderOption) as `pcm${8 | 16 | 32}${'f' | 's' | ''}`;
         if (!(reader as any)[methodName]) {
-            throw new TypeError("Not supported bit depth: " + format.bitDepth);
+            throw new TypeError('Not supported bit depth: ' + format.bitDepth);
         }
         const read: () => number = (reader as any)[methodName].bind(reader);
         const numberOfChannels = format.numberOfChannels;
@@ -136,7 +158,7 @@ class Reader {
         return data;
     }
     string(n: number) {
-        let data = "";
+        let data = '';
         for (let i = 0; i < n; i++) {
             data += String.fromCharCode(this.uint8());
         }
@@ -166,7 +188,7 @@ class Reader {
         const x0 = this.dataView.getUint8(this.pos + 0);
         const x1 = this.dataView.getUint8(this.pos + 1);
         const x2 = this.dataView.getUint8(this.pos + 2);
-        const xx = (x0 + (x1 << 8) + (x2 << 16));
+        const xx = x0 + (x1 << 8) + (x2 << 16);
 
         const data = xx > 0x800000 ? xx - 0x1000000 : xx;
         this.pos += 3;
@@ -176,7 +198,7 @@ class Reader {
         const x0 = this.dataView.getUint8(this.pos + 0);
         const x1 = this.dataView.getUint8(this.pos + 1);
         const x2 = this.dataView.getUint8(this.pos + 2);
-        const xx = (x0 + (x1 << 8) + (x2 << 16));
+        const xx = x0 + (x1 << 8) + (x2 << 16);
 
         const data = xx > 0x800000 ? xx - 0x1000000 : xx;
         this.pos += 3;

package/src/WavEncoder.ts

@@ -24,11 +24,12 @@ class WavEncoder {
         const numberOfChannels = audioBuffer.length;
         const length = audioBuffer[0].length;
         const { shared, float } = options;
-        const bitDepth = float ? 32 : ((options.bitDepth | 0) || 16);
+        const bitDepth = float ? 32 : options.bitDepth | 0 || 16;
         const byteDepth = bitDepth >> 3;
         const byteLength = length * numberOfChannels * byteDepth;
-        // eslint-disable-next-line no-undef
-        const AB = shared ? (globalThis.SharedArrayBuffer || globalThis.ArrayBuffer) : globalThis.ArrayBuffer;
+        const AB = shared
+            ? globalThis.SharedArrayBuffer || globalThis.ArrayBuffer
+            : globalThis.ArrayBuffer;
         const ab = new AB((44 + byteLength) * Uint8Array.BYTES_PER_ELEMENT);
         const dataView = new DataView(ab);
         const writer = new Writer(dataView);
@@ -47,11 +48,18 @@ class WavEncoder {
         return ab;
     }
     private static writeHeader(writer: Writer, format: Format) {
-        const { formatId, sampleRate, bitDepth, numberOfChannels, length, byteDepth } = format;
-        writer.string("RIFF");
+        const {
+            formatId,
+            sampleRate,
+            bitDepth,
+            numberOfChannels,
+            length,
+            byteDepth
+        } = format;
+        writer.string('RIFF');
         writer.uint32(writer.dataView.byteLength - 8);
-        writer.string("WAVE");
-        writer.string("fmt ");
+        writer.string('WAVE');
+        writer.string('fmt ');
         writer.uint32(16);
         writer.uint16(formatId);
         writer.uint16(numberOfChannels);
@@ -59,11 +67,15 @@ class WavEncoder {
         writer.uint32(sampleRate * numberOfChannels * byteDepth);
         writer.uint16(numberOfChannels * byteDepth);
         writer.uint16(bitDepth);
-        writer.string("data");
+        writer.string('data');
         writer.uint32(length * numberOfChannels * byteDepth);
         return writer.pos;
     }
-    private static writeData(writer: Writer, audioBuffer: Float32Array[], format: Format) {
+    private static writeData(
+        writer: Writer,
+        audioBuffer: Float32Array[],
+        format: Format
+    ) {
         const { bitDepth, float, length, numberOfChannels, symmetric } = format;
         if (bitDepth === 32 && float) {
             const { dataView, pos } = writer;
@@ -81,14 +93,16 @@ class WavEncoder {
             }
             return;
         }
-        const encoderOption = float ? "f" : symmetric ? "s" : "";
-        const methodName = "pcm" + bitDepth + encoderOption;
+        const encoderOption = float ? 'f' : symmetric ? 's' : '';
+        const methodName = 'pcm' + bitDepth + encoderOption;
 
         if (!(writer as any)[methodName]) {
-            throw new TypeError("Not supported bit depth: " + bitDepth);
+            throw new TypeError('Not supported bit depth: ' + bitDepth);
         }
 
-        const write: (value: number) => void = (writer as any)[methodName].bind(writer);
+        const write: (value: number) => void = (writer as any)[methodName].bind(
+            writer
+        );
 
         for (let i = 0; i < length; i++) {
             for (let j = 0; j < numberOfChannels; j++) {
@@ -126,14 +140,14 @@ class Writer {
         value = Math.max(-1, Math.min(value, +1));
         value = (value * 0.5 + 0.5) * 255;
         value = Math.round(value) | 0;
-        this.dataView.setUint8(this.pos, value/* , true*/);
+        this.dataView.setUint8(this.pos, value /* , true*/);
         this.pos += 1;
     }
     pcm8s(valueIn: number) {
         let value = valueIn;
         value = Math.round(value * 128) + 128;
         value = Math.max(0, Math.min(value, 255));
-        this.dataView.setUint8(this.pos, value/* , true*/);
+        this.dataView.setUint8(this.pos, value /* , true*/);
         this.pos += 1;
     }
     pcm16(valueIn: number) {
@@ -157,9 +171,9 @@ class Writer {
         value = value < 0 ? 0x1000000 + value * 8388608 : value * 8388607;
         value = Math.round(value) | 0;
 
-        const x0 = (value >> 0) & 0xFF;
-        const x1 = (value >> 8) & 0xFF;
-        const x2 = (value >> 16) & 0xFF;
+        const x0 = (value >> 0) & 0xff;
+        const x1 = (value >> 8) & 0xff;
+        const x2 = (value >> 16) & 0xff;
 
         this.dataView.setUint8(this.pos + 0, x0);
         this.dataView.setUint8(this.pos + 1, x1);
@@ -171,9 +185,9 @@ class Writer {
         value = Math.round(value * 8388608);
         value = Math.max(-8388608, Math.min(value, 8388607));
 
-        const x0 = (value >> 0) & 0xFF;
-        const x1 = (value >> 8) & 0xFF;
-        const x2 = (value >> 16) & 0xFF;
+        const x0 = (value >> 0) & 0xff;
+        const x1 = (value >> 8) & 0xff;
+        const x2 = (value >> 16) & 0xff;
 
         this.dataView.setUint8(this.pos + 0, x0);
         this.dataView.setUint8(this.pos + 1, x1);

package/src/copyWebStandaloneAssets.d.ts

@@ -1,5 +1,20 @@
-declare const copyWebStandaloneAssets: (outputDir: string, dspName: string, poly?: boolean, effect?: boolean) => void;
-declare const copyWebPWAAssets: (outputDir: string, dspName: string, poly?: boolean, effect?: boolean) => void;
-declare const copyWebTemplateAssets: (outputDir: string, dspName: string, poly?: boolean, effect?: boolean) => void;
-
-export { copyWebStandaloneAssets, copyWebPWAAssets, copyWebTemplateAssets };
+declare const copyWebStandaloneAssets: (
+    outputDir: string,
+    dspName: string,
+    poly?: boolean,
+    effect?: boolean
+) => void;
+declare const copyWebPWAAssets: (
+    outputDir: string,
+    dspName: string,
+    poly?: boolean,
+    effect?: boolean
+) => void;
+declare const copyWebTemplateAssets: (
+    outputDir: string,
+    dspName: string,
+    poly?: boolean,
+    effect?: boolean
+) => void;
+
+export { copyWebStandaloneAssets, copyWebPWAAssets, copyWebTemplateAssets };