@grame/faustwasm 0.15.1 → 0.15.3

package/README.md

@@ -73,6 +73,22 @@ node scripts/faust2wasm.js test/poly.dsp test/out -poly
 ```
 will create a set of files: `index.js`, `dsp-module.wasm`, `dsp-meta.json`, `index.html` (and possibly `effect-module.wasm`, `effect-meta.json`) in the `out` folder.
 
+##### Local include files and `-I`
+
+The CLI runs the Faust compiler inside a WebAssembly in-memory filesystem, so it cannot read your host filesystem directly. To make local `import("something.lib")` work:
+
+- The directory that contains the input `.dsp` is automatically copied into the in-memory FS and added to the compiler include path.
+- Any `-I <dir>` you pass is mirrored into the in-memory FS and added to the include path.
+- Only `.dsp` and `.lib` files are mirrored.
+
+This means you can run the CLI from any working directory as long as your local includes live next to the DSP or are listed with `-I`.
+
+Example:
+
+```bash
+node scripts/faust2wasm.js -I test/includes test/something.dsp test/out
+```
+
 #### Creating a Progressive Web Application (PWA) of a Faust DSP
 
 You can create a standalone Progressive Web Application using the command line:
@@ -365,6 +381,3 @@ Html pages embedding the Faust compiler must be served using https, unless using
 
 ----
 <a href="http://faust.grame.fr"><img src=https://faust.grame.fr/community/logos/img/LOGO_FAUST_COMPLET_ORANGE.png width=200 /></a>
-
-
-

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@grame/faustwasm",
-    "version": "0.15.1",
+    "version": "0.15.3",
     "description": "WebAssembly version of Faust Compiler",
     "main": "dist/cjs/index.js",
     "types": "dist/esm/index.d.ts",

package/scripts/faust2wasm.js

@@ -6,7 +6,7 @@ import { copyWebStandaloneAssets, copyWebPWAAssets, copyWebTemplateAssets } from
 
 const argv = process.argv.slice(2);
 
-if (argv[0] === "-help" || argv[0] === "-h") {
+if (argv.includes("-help") || argv.includes("-h")) {
     console.log(`
 faust2wasm.js <file.dsp> <outputDir> [-poly] [-standalone] [-pwa] [-no-template]
 Generates WebAssembly and metadata JSON files of a given Faust DSP.
@@ -14,23 +14,37 @@ Generates WebAssembly and metadata JSON files of a given Faust DSP.
     process.exit();
 }
 
-const $poly = argv.indexOf("-poly");
-const poly = $poly !== -1;
-if (poly) argv.splice($poly, 1);
-
-const $standalone = argv.indexOf("-standalone");
-const standalone = $standalone !== -1;
-if (standalone) argv.splice($standalone, 1);
-
-const $pwa = argv.indexOf("-pwa");
-const pwa = $pwa !== -1;
-if (pwa) argv.splice($pwa, 1);
-
-const $noTemplate = argv.indexOf("-no-template");
-const noTemplate = $noTemplate !== -1;
-if (noTemplate) argv.splice($noTemplate, 1);
-
-const [inputFile, outputDir, ...argvFaust] = argv;
+const takeFlag = (flag) => {
+    const index = argv.indexOf(flag);
+    if (index === -1) return false;
+    argv.splice(index, 1);
+    return true;
+};
+const poly = takeFlag("-poly");
+const standalone = takeFlag("-standalone");
+const pwa = takeFlag("-pwa");
+const noTemplate = takeFlag("-no-template");
+
+// Allow Faust flags (like -I) anywhere while keeping the first two positionals as input/output.
+const positionals = [];
+const argvFaust = [];
+for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "-I" && argv[i + 1]) {
+        argvFaust.push(arg, argv[i + 1]);
+        i += 1;
+        continue;
+    }
+    if (positionals.length < 2 && !arg.startsWith("-")) {
+        positionals.push(arg);
+        continue;
+    }
+    argvFaust.push(arg);
+}
+const [inputFile, outputDir] = positionals;
+if (!inputFile || !outputDir) {
+    throw new Error("Usage: faust2wasm.js <file.dsp> <outputDir> [faust args...]");
+}
 const fileName = inputFile.split('/').pop();
 if (!fileName) throw new Error("No input DSP file");
 const dspName = fileName.replace(/\.dsp$/, '');

package/src/faust2wasmFiles.js

@@ -38,6 +38,88 @@ const faust2wasmFiles = async (
 
     const fileName = /** @type {string} */ (inputFile.split('/').pop());
     const dspName = fileName.replace(/\.dsp$/, '');
+    // Step 1: get the compiler's in-memory FS (host FS is not visible to WASM).
+    const faustFs = compiler.fs();
+    const inputDir = path.dirname(path.resolve(inputFile));
+    // Step 2: split include flags from other args so we can remap include paths.
+    const parseIncludeArgs = (args) => {
+        const includeDirs = [];
+        const otherArgs = [];
+        for (let i = 0; i < args.length; i += 1) {
+            const arg = args[i];
+            if (arg === '-I' && args[i + 1]) {
+                includeDirs.push(args[i + 1]);
+                i += 1;
+                continue;
+            }
+            otherArgs.push(arg);
+        }
+        return { includeDirs, otherArgs };
+    };
+    // Step 3: helpers to build the in-memory include tree.
+    const ensureFsDir = (dir) => {
+        try {
+            faustFs.mkdirTree(dir);
+        } catch {}
+    };
+    const isFaustSource = (filePath) => {
+        const ext = path.extname(filePath).toLowerCase();
+        return ext === '.lib' || ext === '.dsp';
+    };
+    // Step 4: mirror a host include directory into the in-memory FS.
+    const copyIncludeDirToFs = (srcDir, destDir) => {
+        if (!fs.existsSync(srcDir) || !fs.statSync(srcDir).isDirectory()) return;
+        const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(srcDir, entry.name);
+            const destPath = path.posix.join(destDir, entry.name);
+            if (entry.isDirectory()) {
+                copyIncludeDirToFs(srcPath, destPath);
+                continue;
+            }
+            if (!entry.isFile() || !isFaustSource(srcPath)) continue;
+            ensureFsDir(path.posix.dirname(destPath));
+            faustFs.writeFile(destPath, fs.readFileSync(srcPath));
+        }
+    };
+    // Step 5: parse include args and build a unified include list.
+    const { includeDirs: rawIncludeDirs, otherArgs } = parseIncludeArgs(argv);
+    const includeDirs = [];
+    const seenHostDirs = new Set();
+    const seenFsDirs = new Set();
+    const addIncludeDir = (dir) => {
+        if (!dir) return;
+        const resolved = path.resolve(dir);
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+            if (seenHostDirs.has(resolved)) return;
+            seenHostDirs.add(resolved);
+            includeDirs.push({ type: 'host', path: resolved });
+            return;
+        }
+        if (seenFsDirs.has(dir)) return;
+        seenFsDirs.add(dir);
+        includeDirs.push({ type: 'fs', path: dir });
+    };
+    // Step 6: always include the DSP's directory, then user-provided -I dirs.
+    addIncludeDir(inputDir);
+    rawIncludeDirs.forEach(addIncludeDir);
+    // Step 7: map host include dirs into /faust/user/incN in the in-memory FS.
+    const memfsIncludeDirs = [];
+    let includeIndex = 0;
+    for (const includeDir of includeDirs) {
+        if (includeDir.type === 'fs') {
+            memfsIncludeDirs.push(includeDir.path);
+            continue;
+        }
+        const memfsDir = path.posix.join('/faust', 'user', `inc${includeIndex}`);
+        includeIndex += 1;
+        copyIncludeDirToFs(includeDir.path, memfsDir);
+        memfsIncludeDirs.push(memfsDir);
+    }
+    // Step 8: rewrite argv to use only in-memory include paths.
+    argv.length = 0;
+    memfsIncludeDirs.forEach((dir) => argv.push('-I', dir));
+    argv.push(...otherArgs);
     // Flush to zero to avoid costly denormalized numbers
     argv.push('-ftz', '2');
     const dspModulePath = path.join(outputDir, `dsp-module.wasm`);