@bytecodealliance/jco 1.10.2 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/jco",
-  "version": "1.10.2",
+  "version": "1.11.0",
   "description": "JavaScript tooling for working with WebAssembly Components",
   "author": "Guy Bedford",
   "bin": {
@@ -38,10 +38,14 @@
     "@typescript-eslint/eslint-plugin": "^8.2.0",
     "@typescript-eslint/parser": "^8.2.0",
     "eslint": "^9.9.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.3",
     "mime": "^4.0.4",
-    "mocha": "^10.7.0",
+    "prettier": "^3.5.3",
     "puppeteer": "^24.0.1",
-    "typescript": "^5.5.4"
+    "smol-toml": "^1.3.1",
+    "typescript": "^5.5.4",
+    "vitest": "^3.0.7"
   },
   "repository": {
     "type": "git",
@@ -61,9 +65,10 @@
     "build": "cargo xtask build debug",
     "build:release": "cargo xtask build release",
     "build:types:preview2-shim": "cargo xtask generate wasi-types",
-    "lint": "eslint -c eslintrc.cjs src/**/*.js packages/*/lib/**/*.js",
-    "test:lts": "mocha -u tdd test/test.js --timeout 240000",
-    "test": "node --experimental-wasm-jspi --stack-trace-limit=100 node_modules/mocha/bin/mocha.js -u tdd test/test.js --timeout 240000",
+    "lint": "eslint -c eslintrc.mjs src/**/*.js packages/*/lib/**/*.js",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "vitest run -c test/vitest.ts",
+    "test:lts": "vitest run -c test/vitest.lts.ts",
     "prepublishOnly": "cargo xtask build release && npm run test"
   },
   "files": [
@@ -75,6 +80,13 @@
     "obj/interfaces"
   ],
   "workspaces": [
+    ".",
+    "examples/components/add",
+    "examples/components/http-hello-world",
+    "examples/components/node-fetch",
+    "examples/components/string-reverse",
+    "examples/components/string-reverse-upper",
+    "examples/components/webidl-book-library",
     "packages/preview2-shim"
   ]
 }

package/src/cmd/componentize.js

@@ -1,23 +1,69 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve, basename } from 'node:path';
+
 import c from 'chalk-template';
 
-export async function componentize (jsSource, opts) {
-  const { componentize: componentizeFn } = await eval('import("@bytecodealliance/componentize-js")');
-  if (opts.disable?.includes('all')) {
-    opts.disable = ['stdio', 'random', 'clocks', 'http'];
-  }
-  const source = await readFile(jsSource, 'utf8');
-  const { component } = await componentizeFn(source, {
-    enableAot: opts.aot,
-    wevalBin: opts.wevalBin,
-    sourceName: basename(jsSource),
-    witPath: resolve(opts.wit),
-    worldName: opts.worldName,
-    disableFeatures: opts.disable,
-    enableFeatures: opts.enable,
-    preview2Adapter: opts.preview2Adapter,
-  });
-  await writeFile(opts.out, component);
-  console.log(c`{green OK} Successfully written {bold ${opts.out}}.`);
+export async function componentize(jsSource, opts) {
+    const { componentize: componentizeFn } = await eval(
+        'import("@bytecodealliance/componentize-js")'
+    );
+    if (opts.disable?.includes('all')) {
+        opts.disable = ['stdio', 'random', 'clocks', 'http'];
+    }
+    const source = await readFile(jsSource, 'utf8');
+
+    const witPath = resolve(opts.wit);
+    const sourceName = basename(jsSource);
+
+    let component;
+    try {
+        const result = await componentizeFn(source, {
+            enableAot: opts.aot,
+            aotMinStackSizeBytes: opts.aotMinStackSizeBytes,
+            wevalBin: opts.wevalBin,
+            sourceName,
+            witPath,
+            worldName: opts.worldName,
+            disableFeatures: opts.disable,
+            enableFeatures: opts.enable,
+            preview2Adapter: opts.preview2Adapter,
+            debugBuild: opts.debugStarlingmonkeyBuild,
+        });
+        component = result.component;
+    } catch (err) {
+        // Detect package resolution issues that usually mean a misconfigured "witPath"
+        if (err.toString().includes('no known packages')) {
+            const isFile = await stat(witPath).then((s) => s.isFile());
+            if (isFile) {
+                const hint = await printWITPathHint(witPath);
+                if (err.message) {
+                    err.message += `\n${hint}`;
+                }
+            }
+        }
+        throw err;
+    }
+
+    await writeFile(opts.out, component);
+
+    console.log(c`{green OK} Successfully written {bold ${opts.out}}.`);
+}
+
+/**
+ * Print a hint about the witPath option that may be incorrect
+ *
+ * @param {string} witPath - witPath option that was used (which is a path that resolves to a file or directory)
+ * @returns {string} user-visible, highlighted output that can be printed
+ */
+async function printWITPathHint(witPath) {
+    const pathMeta = await stat(witPath);
+    let output = '\n';
+    if (!pathMeta.isFile() && !pathMeta.isDirectory()) {
+        output += c`{yellow.bold warning} The supplited WIT path [${witPath}] is neither a file or directory.\n`;
+        return output;
+    }
+    output += c`{yellow.bold warning} Your WIT path option [${witPath}] may be incorrect\n`;
+    output += c`{yellow.bold warning} When using a world with dependencies, you must pass the enclosing WIT folder, not a single file.\n`;
+    output += c`{yellow.bold warning} (e.g. 'wit/', rather than 'wit/component.wit').\n`;
+    return output;
 }

package/src/cmd/opt.js

@@ -1,61 +1,61 @@
-import { $init, tools } from "../../obj/wasm-tools.js";
+import { $init, tools } from '../../obj/wasm-tools.js';
 const { metadataShow, print } = tools;
-import { writeFile } from "fs/promises";
-import { fileURLToPath } from "url";
-import c from "chalk-template";
+import { writeFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import c from 'chalk-template';
 import {
-  readFile,
-  sizeStr,
-  fixedDigitDisplay,
-  table,
-  spawnIOTmp,
-  setShowSpinner,
-  getShowSpinner,
-} from "../common.js";
-import ora from "#ora";
+    readFile,
+    sizeStr,
+    fixedDigitDisplay,
+    table,
+    spawnIOTmp,
+    setShowSpinner,
+    getShowSpinner,
+} from '../common.js';
+import ora from '#ora';
 
 export async function opt(componentPath, opts, program) {
-  await $init;
-  const varIdx = program.parent.rawArgs.indexOf("--");
-  if (varIdx !== -1) opts.optArgs = program.parent.rawArgs.slice(varIdx + 1);
-  const componentBytes = await readFile(componentPath);
+    await $init;
+    const varIdx = program.parent.rawArgs.indexOf('--');
+    if (varIdx !== -1) opts.optArgs = program.parent.rawArgs.slice(varIdx + 1);
+    const componentBytes = await readFile(componentPath);
 
-  if (!opts.quiet) setShowSpinner(true);
-  const optPromise = optimizeComponent(componentBytes, opts);
-  const { component, compressionInfo } = await optPromise;
+    if (!opts.quiet) setShowSpinner(true);
+    const optPromise = optimizeComponent(componentBytes, opts);
+    const { component, compressionInfo } = await optPromise;
 
-  await writeFile(opts.output, component);
+    await writeFile(opts.output, component);
 
-  let totalBeforeBytes = 0,
-    totalAfterBytes = 0;
+    let totalBeforeBytes = 0,
+        totalAfterBytes = 0;
 
-  if (!opts.quiet)
-    console.log(c`
+    if (!opts.quiet)
+        console.log(c`
 {bold Optimized WebAssembly Component Internal Core Modules:}
 
 ${table(
-  [
-    ...compressionInfo.map(({ beforeBytes, afterBytes }, i) => {
-      totalBeforeBytes += beforeBytes;
-      totalAfterBytes += afterBytes;
-      return [
-        ` - Core Module ${i + 1}:  `,
-        sizeStr(beforeBytes),
-        " -> ",
-        c`{cyan ${sizeStr(afterBytes)}} `,
-        `(${fixedDigitDisplay((afterBytes / beforeBytes) * 100, 2)}%)`,
-      ];
-    }),
-    ["", "", "", "", ""],
     [
-      ` = Total:  `,
-      `${sizeStr(totalBeforeBytes)}`,
-      ` => `,
-      c`{cyan ${sizeStr(totalAfterBytes)}} `,
-      `(${fixedDigitDisplay((totalAfterBytes / totalBeforeBytes) * 100, 2)}%)`,
+        ...compressionInfo.map(({ beforeBytes, afterBytes }, i) => {
+            totalBeforeBytes += beforeBytes;
+            totalAfterBytes += afterBytes;
+            return [
+                ` - Core Module ${i + 1}:  `,
+                sizeStr(beforeBytes),
+                ' -> ',
+                c`{cyan ${sizeStr(afterBytes)}} `,
+                `(${fixedDigitDisplay((afterBytes / beforeBytes) * 100, 2)}%)`,
+            ];
+        }),
+        ['', '', '', '', ''],
+        [
+            ` = Total:  `,
+            `${sizeStr(totalBeforeBytes)}`,
+            ` => `,
+            c`{cyan ${sizeStr(totalAfterBytes)}} `,
+            `(${fixedDigitDisplay((totalAfterBytes / totalBeforeBytes) * 100, 2)}%)`,
+        ],
     ],
-  ],
-  [, , , , "right"]
+    [, , , , 'right']
 )}`);
 }
 
@@ -65,12 +65,12 @@ ${table(
  * @returns {number}
  */
 function byteLengthLEB128(val) {
-  let len = 0;
-  do {
-    val >>>= 7;
-    len++;
-  } while (val !== 0);
-  return len;
+    let len = 0;
+    do {
+        val >>>= 7;
+        len++;
+    } while (val !== 0);
+    return len;
 }
 
 /**
@@ -80,165 +80,190 @@ function byteLengthLEB128(val) {
  * @returns {Promise<{ component: Uint8Array, compressionInfo: { beforeBytes: number, afterBytes: number }[] >}
  */
 export async function optimizeComponent(componentBytes, opts) {
-  await $init;
-  const showSpinner = getShowSpinner();
-  let spinner;
-  try {
-    let componentMetadata = metadataShow(componentBytes);
-    componentMetadata.forEach((metadata, index) => {
-        // add index to the metadata object
-        metadata.index = index;
-        const size = metadata.range[1] - metadata.range[0];
-        // compute previous LEB128 encoding length
-        metadata.prevLEBLen = byteLengthLEB128(size);
-    });
-    const coreModules = componentMetadata
-      .filter(({ metaType }) => metaType.tag === "module");
+    await $init;
+    const showSpinner = getShowSpinner();
+    let spinner;
+    try {
+        let componentMetadata = metadataShow(componentBytes);
+        componentMetadata.forEach((metadata, index) => {
+            // add index to the metadata object
+            metadata.index = index;
+            const size = metadata.range[1] - metadata.range[0];
+            // compute previous LEB128 encoding length
+            metadata.prevLEBLen = byteLengthLEB128(size);
+        });
+        const coreModules = componentMetadata.filter(
+            ({ metaType }) => metaType.tag === 'module'
+        );
 
-    // log number of core Wasm modules to be run with wasm-opt
-    let completed = 0;
-    const spinnerText = () =>
-      c`{cyan ${completed} / ${coreModules.length}} Running Binaryen on WebAssembly Component Internal Core Modules \n`;
-    if (showSpinner) {
-      spinner = ora({
-        color: "cyan",
-        spinner: "bouncingBar",
-      }).start();
-      spinner.text = spinnerText();
-    }
+        // log number of core Wasm modules to be run with wasm-opt
+        let completed = 0;
+        const spinnerText = () =>
+            c`{cyan ${completed} / ${coreModules.length}} Running Binaryen on WebAssembly Component Internal Core Modules \n`;
+        if (showSpinner) {
+            spinner = ora({
+                color: 'cyan',
+                spinner: 'bouncingBar',
+            }).start();
+            spinner.text = spinnerText();
+        }
 
-    // gather the options for wasm-opt. optionally, adding the asyncify flag
-    const args = opts?.optArgs ?
-      [...opts.optArgs] :
-      ['-Oz', '--low-memory-unused', '--enable-bulk-memory', '--strip-debug'];
-    if (opts?.asyncify) args.push('--asyncify');
+        // gather the options for wasm-opt. optionally, adding the asyncify flag
+        const args = opts?.optArgs
+            ? [...opts.optArgs]
+            : [
+                  '-Oz',
+                  '--low-memory-unused',
+                  '--enable-bulk-memory',
+                  '--strip-debug',
+              ];
+        if (opts?.asyncify) args.push('--asyncify');
 
+        // process core Wasm modules with wasm-opt
+        await Promise.all(
+            coreModules.map(async (metadata) => {
+                if (metadata.metaType.tag === 'module') {
+                    // store the wasm-opt processed module in the metadata
+                    metadata.optimized = await wasmOpt(
+                        componentBytes.subarray(
+                            metadata.range[0],
+                            metadata.range[1]
+                        ),
+                        args
+                    );
 
-    // process core Wasm modules with wasm-opt
-    await Promise.all(
-      coreModules.map(async (metadata) => {
-        if (metadata.metaType.tag === "module") {
-          // store the wasm-opt processed module in the metadata 
-          metadata.optimized = await wasmOpt(
-            componentBytes.subarray(metadata.range[0], metadata.range[1]),
-            args);
+                    // compute the size change, including the change to
+                    // the LEB128 encoding of the size change
+                    const prevModuleSize =
+                        metadata.range[1] - metadata.range[0];
+                    const newModuleSize = metadata.optimized.byteLength;
+                    metadata.newLEBLen = byteLengthLEB128(newModuleSize);
+                    metadata.sizeChange = newModuleSize - prevModuleSize;
 
-          // compute the size change, including the change to
-          // the LEB128 encoding of the size change
-          const prevModuleSize = metadata.range[1] - metadata.range[0];
-          const newModuleSize = metadata.optimized.byteLength;
-          metadata.newLEBLen = byteLengthLEB128(newModuleSize);
-          metadata.sizeChange = newModuleSize - prevModuleSize;
+                    if (spinner) {
+                        completed++;
+                        spinner.text = spinnerText();
+                    }
+                }
+            })
+        );
 
-          if (spinner) {
-            completed++;
-            spinner.text = spinnerText();
-          }
-        }
-      }));
+        // organize components in modules into tree parent and children
+        const nodes = componentMetadata.slice(1);
+        const getChildren = (parentIndex) => {
+            const children = [];
+            for (let i = 0; i < nodes.length; i++) {
+                const metadata = nodes[i];
+                if (metadata.parentIndex === parentIndex) {
+                    nodes.splice(i, 1); // remove from nodes
+                    i--;
+                    metadata.children = getChildren(metadata.index);
+                    metadata.sizeChange = metadata.children.reduce(
+                        (total, { prevLEBLen, newLEBLen, sizeChange }) => {
+                            return sizeChange
+                                ? total + sizeChange + newLEBLen - prevLEBLen
+                                : total;
+                        },
+                        metadata.sizeChange || 0
+                    );
+                    const prevSize = metadata.range[1] - metadata.range[0];
+                    metadata.newLEBLen = byteLengthLEB128(
+                        prevSize + metadata.sizeChange
+                    );
+                    children.push(metadata);
+                }
+            }
+            return children;
+        };
+        const componentTree = getChildren(0);
 
-    // organize components in modules into tree parent and children
-    const nodes = componentMetadata.slice(1);
-    const getChildren = (parentIndex) => {
-      const children = [];
-      for (let i = 0; i < nodes.length; i++) {
-        const metadata = nodes[i];
-        if (metadata.parentIndex === parentIndex) {
-          nodes.splice(i, 1); // remove from nodes
-          i--;
-          metadata.children = getChildren(metadata.index);
-          metadata.sizeChange = metadata.children
-            .reduce((total, {prevLEBLen, newLEBLen, sizeChange}) => {
-              return sizeChange ?
-                total + sizeChange + newLEBLen - prevLEBLen :
-                total;
+        // compute the total size change in the component binary
+        const sizeChange = componentTree.reduce(
+            (total, { prevLEBLen, newLEBLen, sizeChange }) => {
+                return total + (sizeChange || 0) + newLEBLen - prevLEBLen;
             },
-            metadata.sizeChange || 0);
-          const prevSize = metadata.range[1] - metadata.range[0];
-          metadata.newLEBLen = byteLengthLEB128(prevSize + metadata.sizeChange);
-          children.push(metadata);
-        }
-      }
-      return children;
-    };
-    const componentTree = getChildren(0);
+            0
+        );
+
+        let outComponentBytes = new Uint8Array(
+            componentBytes.byteLength + sizeChange
+        );
+        let nextReadPos = 0,
+            nextWritePos = 0;
 
-    // compute the total size change in the component binary
-    const sizeChange = componentTree
-      .reduce((total, {prevLEBLen, newLEBLen, sizeChange}) => {
-        return total + (sizeChange || 0) + newLEBLen - prevLEBLen;
-      }, 0);
+        const write = ({
+            prevLEBLen,
+            range,
+            optimized,
+            children,
+            sizeChange,
+        }) => {
+            // write from the last read to the LEB byte start
+            outComponentBytes.set(
+                componentBytes.subarray(nextReadPos, range[0] - prevLEBLen),
+                nextWritePos
+            );
+            nextWritePos += range[0] - prevLEBLen - nextReadPos;
 
-    let outComponentBytes = new Uint8Array(
-      componentBytes.byteLength + sizeChange);
-    let nextReadPos = 0, nextWritePos = 0;
+            // write the new LEB bytes
+            let val = range[1] - range[0] + sizeChange;
+            do {
+                const byte = val & 0x7f;
+                val >>>= 7;
+                outComponentBytes[nextWritePos++] =
+                    val === 0 ? byte : byte | 0x80;
+            } while (val !== 0);
 
-    const write = ({prevLEBLen, range, optimized, children, sizeChange}) => {
-      // write from the last read to the LEB byte start
-      outComponentBytes.set(
-        componentBytes.subarray(nextReadPos, range[0] - prevLEBLen),
-        nextWritePos
-      );
-      nextWritePos += range[0] - prevLEBLen - nextReadPos;
+            if (optimized) {
+                // write the core module
+                outComponentBytes.set(optimized, nextWritePos);
+                nextReadPos = range[1];
+                nextWritePos += optimized.byteLength;
+            } else if (children.length > 0) {
+                // write child components / modules
+                nextReadPos = range[0];
+                children.forEach(write);
+            } else {
+                // write component
+                outComponentBytes.set(
+                    componentBytes.subarray(range[0], range[1]),
+                    nextWritePos
+                );
+                nextReadPos = range[1];
+                nextWritePos += range[1] - range[0];
+            }
+        };
 
-      // write the new LEB bytes
-      let val = range[1] - range[0] + sizeChange;
-      do {
-        const byte = val & 0x7f;
-        val >>>= 7;
-        outComponentBytes[nextWritePos++] = val === 0 ? byte : byte | 0x80;
-      } while (val !== 0);
+        // write each top-level component / module
+        componentTree.forEach(write);
 
-      if (optimized) {
-        // write the core module
-        outComponentBytes.set(optimized, nextWritePos);
-        nextReadPos = range[1];
-        nextWritePos += optimized.byteLength;
-      } else if (children.length > 0) {
-        // write child components / modules
-        nextReadPos = range[0];
-        children.forEach(write);
-      } else {
-        // write component
+        // write remaining
         outComponentBytes.set(
-          componentBytes.subarray(range[0], range[1]),
-          nextWritePos
+            componentBytes.subarray(nextReadPos),
+            nextWritePos
         );
-        nextReadPos = range[1];
-        nextWritePos += range[1] - range[0];
-      }
-    };
-
-    // write each top-level component / module
-    componentTree.forEach(write);
 
-    // write remaining
-    outComponentBytes.set(
-      componentBytes.subarray(nextReadPos),
-      nextWritePos
-    );
+        // verify it still parses ok
+        if (!opts?.noVerify) {
+            try {
+                await print(outComponentBytes);
+            } catch (e) {
+                throw new Error(
+                    `Internal error performing optimization.\n${e.message}`
+                );
+            }
+        }
 
-    // verify it still parses ok
-    if (!opts?.noVerify) {
-      try {
-        await print(outComponentBytes);
-      } catch (e) {
-        throw new Error(
-          `Internal error performing optimization.\n${e.message}`
-        );
-      }
+        return {
+            component: outComponentBytes,
+            compressionInfo: coreModules.map(({ range, optimized }) => ({
+                beforeBytes: range[1] - range[0],
+                afterBytes: optimized?.byteLength,
+            })),
+        };
+    } finally {
+        if (spinner) spinner.stop();
     }
-
-    return {
-      component: outComponentBytes,
-      compressionInfo: coreModules.map(({range, optimized}) => ({
-        beforeBytes: range[1] - range[0],
-        afterBytes: optimized?.byteLength,
-      })),
-    };
-  } finally {
-    if (spinner) spinner.stop();
-  }
 }
 
 /**
@@ -247,15 +272,21 @@ export async function optimizeComponent(componentBytes, opts) {
  * @returns {Promise<Uint8Array>}
  */
 async function wasmOpt(source, args) {
-  const wasmOptPath = fileURLToPath(
-    import.meta.resolve("binaryen/bin/wasm-opt")
-  );
+    const wasmOptPath = fileURLToPath(
+        import.meta.resolve('binaryen/bin/wasm-opt')
+    );
+
+    try {
+        return await spawnIOTmp(wasmOptPath, source, [...args, '-o']);
+    } catch (e) {
+        if (e.toString().includes('BasicBlock requested'))
+            return wasmOpt(source, args);
+        throw e;
+    }
+}
 
-  try {
-    return await spawnIOTmp(wasmOptPath, source, [...args, "-o"]);
-  } catch (e) {
-    if (e.toString().includes("BasicBlock requested"))
-      return wasmOpt(source, args);
-    throw e;
-  }
+// see: https://github.com/vitest-dev/vitest/issues/6953#issuecomment-2505310022
+if (typeof __vite_ssr_import_meta__ !== 'undefined') {
+    __vite_ssr_import_meta__.resolve = (path) =>
+        'file://' + globalCreateRequire(import.meta.url).resolve(path);
 }