unwasm 0.3.0 → 0.3.2

package/dist/plugin.cjs

@@ -0,0 +1,279 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const node_fs = require('node:fs');
+const pathe = require('pathe');
+const MagicString = require('magic-string');
+const unplugin$1 = require('unplugin');
+const node_crypto = require('node:crypto');
+const tools = require('./tools.cjs');
+require('@webassemblyjs/wasm-parser');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
+
+const UNWASM_EXTERNAL_PREFIX = "\0unwasm:external:";
+const UMWASM_HELPERS_ID = "\0unwasm:helpers";
+function sha1(source) {
+  return node_crypto.createHash("sha1").update(source).digest("hex").slice(0, 16);
+}
+
+const js = String.raw;
+function getWasmBinding(asset, opts) {
+  const envCode = opts.esmImport ? js`
+async function _instantiate(imports) {
+  const _mod = await import("${UNWASM_EXTERNAL_PREFIX}${asset.name}").then(r => r.default || r);
+  return WebAssembly.instantiate(_mod, imports)
+}
+  ` : js`
+import { base64ToUint8Array } from "${UMWASM_HELPERS_ID}";
+
+function _instantiate(imports) {
+  const _data = base64ToUint8Array("${asset.source.toString("base64")}")
+  return WebAssembly.instantiate(_data, imports)
+}
+  `;
+  const canTopAwait = opts.lazy !== true && Object.keys(asset.imports).length === 0;
+  if (canTopAwait) {
+    return js`
+import { getExports } from "${UMWASM_HELPERS_ID}";
+${envCode}
+
+const $exports = getExports(await _instantiate());
+
+${asset.exports.map((name) => `export const ${name} = $exports.${name};`).join("\n")}
+
+export default () => $exports;
+    `;
+  } else {
+    return js`
+import { createLazyWasmModule } from "${UMWASM_HELPERS_ID}";
+${envCode}
+
+const _mod = createLazyWasmModule(_instantiate);
+
+${asset.exports.map((name) => `export const ${name} = _mod.${name};`).join("\n")}
+
+export default _mod;
+    `;
+  }
+}
+function getPluginUtils() {
+  return js`
+export function debug(...args) {
+  console.log('[wasm] [debug]', ...args);
+}
+
+export function getExports(input) {
+  return input?.instance?.exports || input?.exports || input;
+}
+
+export function base64ToUint8Array(str) {
+  const data = atob(str);
+  const size = data.length;
+  const bytes = new Uint8Array(size);
+  for (let i = 0; i < size; i++) {
+    bytes[i] = data.charCodeAt(i);
+  }
+  return bytes;
+}
+
+export function createLazyWasmModule(_instantiator) {
+  const _exports = Object.create(null);
+  let _loaded;
+  let _promise;
+
+  const init = (imports) => {
+    if (_loaded) {
+      return Promise.resolve(exportsProxy);
+    }
+    if (_promise) {
+      return _promise;
+    }
+    return _promise = _instantiator(imports)
+      .then(r => {
+        Object.assign(_exports, getExports(r));
+        _loaded = true;
+        _promise = undefined;
+        return exportsProxy;
+      })
+      .catch(error => {
+        _promise = undefined;
+        console.error('[wasm] [error]', error);
+        throw error;
+      });
+  }
+
+  const exportsProxy = new Proxy(_exports, {
+    get(_, prop) {
+      if (_loaded) {
+        return _exports[prop];
+      }
+      return (...args) => {
+        return _loaded
+          ? _exports[prop]?.(...args)
+          : init().then(() => _exports[prop]?.(...args));
+      };
+    },
+  });
+
+
+  const lazyProxy = new Proxy(() => {}, {
+    get(_, prop) {
+      return exportsProxy[prop];
+    },
+    apply(_, __, args) {
+      return init(args[0])
+    },
+  });
+
+  return lazyProxy;
+}
+  `;
+}
+
+const unplugin = unplugin$1.createUnplugin((opts) => {
+  const assets = /* @__PURE__ */ Object.create(null);
+  const _parseCache = /* @__PURE__ */ Object.create(null);
+  function parse(name, source) {
+    if (_parseCache[name]) {
+      return _parseCache[name];
+    }
+    const parsed = tools.parseWasm(source);
+    const imports = /* @__PURE__ */ Object.create(null);
+    const exports = [];
+    for (const mod of parsed.modules) {
+      exports.push(...mod.exports.map((e) => e.name));
+      for (const imp of mod.imports) {
+        if (!imports[imp.module]) {
+          imports[imp.module] = [];
+        }
+        imports[imp.module].push(imp.name);
+      }
+    }
+    _parseCache[name] = {
+      imports,
+      exports
+    };
+    return _parseCache[name];
+  }
+  return {
+    name: "unwasm",
+    rollup: {
+      async resolveId(id, importer) {
+        if (id === UMWASM_HELPERS_ID) {
+          return id;
+        }
+        if (id.startsWith(UNWASM_EXTERNAL_PREFIX)) {
+          return {
+            id,
+            external: true
+          };
+        }
+        if (id.endsWith(".wasm")) {
+          const r = await this.resolve(id, importer, { skipSelf: true });
+          if (r?.id && r.id !== id) {
+            return {
+              id: r.id.startsWith("file://") ? r.id.slice(7) : r.id,
+              external: false,
+              moduleSideEffects: false
+            };
+          }
+        }
+      },
+      generateBundle() {
+        if (opts.esmImport) {
+          for (const asset of Object.values(assets)) {
+            this.emitFile({
+              type: "asset",
+              source: asset.source,
+              fileName: asset.name
+            });
+          }
+        }
+      }
+    },
+    async load(id) {
+      if (id === UMWASM_HELPERS_ID) {
+        return getPluginUtils();
+      }
+      if (!id.endsWith(".wasm") || !node_fs.existsSync(id)) {
+        return;
+      }
+      this.addWatchFile(id);
+      const buff = await node_fs.promises.readFile(id);
+      return buff.toString("binary");
+    },
+    transform(code, id) {
+      if (!id.endsWith(".wasm")) {
+        return;
+      }
+      const buff = Buffer.from(code, "binary");
+      const name = `wasm/${pathe.basename(id, ".wasm")}-${sha1(buff)}.wasm`;
+      const parsed = parse(name, buff);
+      const asset = assets[name] = {
+        name,
+        id,
+        source: buff,
+        imports: parsed.imports,
+        exports: parsed.exports
+      };
+      return {
+        code: getWasmBinding(asset, opts),
+        map: { mappings: "" }
+      };
+    },
+    renderChunk(code, chunk) {
+      if (!opts.esmImport) {
+        return;
+      }
+      if (!(chunk.moduleIds.some((id) => id.endsWith(".wasm")) || chunk.imports.some((id) => id.endsWith(".wasm"))) || !code.includes(UNWASM_EXTERNAL_PREFIX)) {
+        return;
+      }
+      const s = new MagicString__default(code);
+      const resolveImport = (id) => {
+        if (typeof id !== "string") {
+          return;
+        }
+        const asset = assets[id];
+        if (!asset) {
+          return;
+        }
+        const nestedLevel = chunk.fileName.split("/").length - 1;
+        const relativeId = (nestedLevel ? "../".repeat(nestedLevel) : "./") + asset.name;
+        return {
+          relativeId,
+          asset
+        };
+      };
+      const ReplaceRE = new RegExp(`${UNWASM_EXTERNAL_PREFIX}([^"']+)`, "g");
+      for (const match of code.matchAll(ReplaceRE)) {
+        const resolved = resolveImport(match[1]);
+        const index = match.index;
+        const len = match[0].length;
+        if (!resolved || !index) {
+          console.warn(
+            `Failed to resolve WASM import: ${JSON.stringify(match[1])}`
+          );
+          continue;
+        }
+        s.overwrite(index, index + len, resolved.relativeId);
+      }
+      if (s.hasChanged()) {
+        return {
+          code: s.toString(),
+          map: s.generateMap({ includeContent: true })
+        };
+      }
+    }
+  };
+});
+const rollup = unplugin.rollup;
+const index = {
+  rollup
+};
+
+exports.default = index;
+exports.rollup = rollup;

package/dist/plugin.d.cts

@@ -0,0 +1,25 @@
+import { Plugin } from 'rollup';
+
+interface UnwasmPluginOptions {
+    /**
+     * Directly import the `.wasm` files instead of bundling as base64 string.
+     *
+     * @default false
+     */
+    esmImport?: boolean;
+    /**
+     * Avoid using top level await and always use a proxy.
+     *
+     * Useful for compatibility with environments that don't support top level await.
+     *
+     * @default false
+     */
+    lazy?: boolean;
+}
+
+declare const rollup: (opts: UnwasmPluginOptions) => Plugin;
+declare const _default: {
+    rollup: (opts: UnwasmPluginOptions) => Plugin<any>;
+};
+
+export { type UnwasmPluginOptions, _default as default, rollup };

package/dist/plugin.d.mts

@@ -22,4 +22,4 @@ declare const _default: {
     rollup: (opts: UnwasmPluginOptions) => Plugin<any>;
 };
 
-export { _default as default, rollup };
+export { type UnwasmPluginOptions, _default as default, rollup };

package/dist/plugin.d.ts

@@ -22,4 +22,4 @@ declare const _default: {
     rollup: (opts: UnwasmPluginOptions) => Plugin<any>;
 };
 
-export { _default as default, rollup };
+export { type UnwasmPluginOptions, _default as default, rollup };

package/dist/plugin.mjs

@@ -16,7 +16,7 @@ const js = String.raw;
 function getWasmBinding(asset, opts) {
   const envCode = opts.esmImport ? js`
 async function _instantiate(imports) {
-  const _mod = await import("${UNWASM_EXTERNAL_PREFIX}${asset.id}").then(r => r.default || r);
+  const _mod = await import("${UNWASM_EXTERNAL_PREFIX}${asset.name}").then(r => r.default || r);
   return WebAssembly.instantiate(_mod, imports)
 }
   ` : js`
@@ -37,9 +37,7 @@ const $exports = getExports(await _instantiate());
 
 ${asset.exports.map((name) => `export const ${name} = $exports.${name};`).join("\n")}
 
-export const $init = () => $exports;
-
-export default $exports;
+export default () => $exports;
     `;
   } else {
     return js`
@@ -50,8 +48,6 @@ const _mod = createLazyWasmModule(_instantiate);
 
 ${asset.exports.map((name) => `export const ${name} = _mod.${name};`).join("\n")}
 
-export const $init = _mod.$init.bind(_mod);
-
 export default _mod;
     `;
   }
@@ -198,26 +194,24 @@ const unplugin = createUnplugin((opts) => {
       if (!id.endsWith(".wasm") || !existsSync(id)) {
         return;
       }
-      const source = await promises.readFile(id);
-      const name = `wasm/${basename(id, ".wasm")}-${sha1(source)}.wasm`;
-      const parsed = parse(name, source);
-      assets[id] = {
+      this.addWatchFile(id);
+      const buff = await promises.readFile(id);
+      return buff.toString("binary");
+    },
+    transform(code, id) {
+      if (!id.endsWith(".wasm")) {
+        return;
+      }
+      const buff = Buffer.from(code, "binary");
+      const name = `wasm/${basename(id, ".wasm")}-${sha1(buff)}.wasm`;
+      const parsed = parse(name, buff);
+      const asset = assets[name] = {
         name,
         id,
-        source,
+        source: buff,
         imports: parsed.imports,
         exports: parsed.exports
       };
-      return `export default "UNWASM DUMMY EXPORT";`;
-    },
-    transform(_code, id) {
-      if (!id.endsWith(".wasm")) {
-        return;
-      }
-      const asset = assets[id];
-      if (!asset) {
-        return;
-      }
       return {
         code: getWasmBinding(asset, opts),
         map: { mappings: "" }

package/dist/tools.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const wasmParser = require('@webassemblyjs/wasm-parser');
+
+function parseWasm(source) {
+  const ast = wasmParser.decode(source);
+  const modules = [];
+  for (const body of ast.body) {
+    if (body.type === "Module") {
+      const module = {
+        imports: [],
+        exports: []
+      };
+      modules.push(module);
+      for (const field of body.fields) {
+        if (field.type === "ModuleImport") {
+          module.imports.push({
+            module: field.module,
+            name: field.name,
+            returnType: field.descr?.signature?.results?.[0],
+            params: field.descr.signature.params?.map(
+              (p) => ({
+                id: p.id,
+                type: p.valtype
+              })
+            )
+          });
+        } else if (field.type === "ModuleExport") {
+          module.exports.push({
+            name: field.name,
+            id: field.descr.id.value,
+            type: field.descr.exportType
+          });
+        }
+      }
+    }
+  }
+  return {
+    modules
+  };
+}
+
+exports.parseWasm = parseWasm;

package/dist/tools.d.cts

@@ -0,0 +1,25 @@
+type ParsedWasmModule = {
+    id?: string;
+    imports: ModuleImport[];
+    exports: ModuleExport[];
+};
+type ModuleImport = {
+    module: string;
+    name: string;
+    returnType?: string;
+    params?: {
+        id?: string;
+        type: string;
+    }[];
+};
+type ModuleExport = {
+    name: string;
+    id: string | number;
+    type: "Func" | "Memory";
+};
+type ParseResult = {
+    modules: ParsedWasmModule[];
+};
+declare function parseWasm(source: Buffer | ArrayBuffer): ParseResult;
+
+export { type ModuleExport, type ModuleImport, type ParseResult, type ParsedWasmModule, parseWasm };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unwasm",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "WebAssembly tools for JavaScript",
   "repository": "unjs/unwasm",
   "license": "MIT",
@@ -9,12 +9,24 @@
   "exports": {
     "./examples/*": "./examples/*",
     "./plugin": {
-      "types": "./dist/plugin.d.mts",
-      "import": "./dist/plugin.mjs"
+      "import": {
+        "types": "./dist/plugin.d.mts",
+        "default": "./dist/plugin.mjs"
+      },
+      "require": {
+        "types": "./dist/plugin.d.ts",
+        "default": "./dist/plugin.cjs"
+      }
     },
     "./tools": {
-      "types": "./dist/tools.d.mts",
-      "import": "./dist/tools.mjs"
+      "import": {
+        "types": "./dist/tools.d.mts",
+        "default": "./dist/tools.mjs"
+      },
+      "require": {
+        "types": "./dist/tools.d.ts",
+        "default": "./dist/tools.cjs"
+      }
     }
   },
   "files": [