@loro-dev/flock-wasm 0.1.1 → 0.1.2

package/base64/index.js

@@ -1,5 +1,5 @@
-import { RawFlock, callPendingEvents } from "./wasm";
-import { EventBatcher } from "./event-batcher";
+import { RawFlock, callPendingEvents } from "./wasm.js";
+import { EventBatcher } from "./event-batcher.js";
 export function encodeVersionVector(vector) {
     return encodeVersionVectorBinary(vector);
 }

package/bundler/flock_wasm.js

@@ -1,5 +1,198 @@
-import * as wasm from "./flock_wasm_bg.wasm";
-export * from "./flock_wasm_bg.js";
+import * as wasmModule from "./flock_wasm_bg.wasm";
+import * as wasmBg from "./flock_wasm_bg.js";
 import { __wbg_set_wasm } from "./flock_wasm_bg.js";
-__wbg_set_wasm(wasm);
-wasm.__wbindgen_start();
+
+export * from "./flock_wasm_bg.js";
+
+let wasm;
+let initPromise;
+
+function isRecordLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+
+function toWasmExports(value) {
+  if (value instanceof WebAssembly.Instance) {
+    return value.exports;
+  }
+  if (!isRecordLike(value)) {
+    return undefined;
+  }
+  if (value.memory instanceof WebAssembly.Memory) {
+    return value;
+  }
+  return undefined;
+}
+
+function pickExistingWasmExports(value) {
+  const queue = [value];
+  const seen = new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const exports = toWasmExports(current);
+    if (exports !== undefined) {
+      return exports;
+    }
+    if (!isRecordLike(current)) {
+      continue;
+    }
+    if (seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    if ("default" in current) {
+      queue.push(current.default);
+    }
+    if ("instance" in current) {
+      queue.push(current.instance);
+    }
+    if ("module" in current) {
+      queue.push(current.module);
+    }
+    if ("exports" in current) {
+      queue.push(current.exports);
+    }
+  }
+  return undefined;
+}
+
+function resolveModuleSource(moduleSource) {
+  if (typeof moduleSource !== "string") {
+    return moduleSource;
+  }
+  if (typeof URL !== "function") {
+    return moduleSource;
+  }
+  try {
+    return new URL(moduleSource);
+  } catch (_error) {
+    return new URL(moduleSource, import.meta.url);
+  }
+}
+
+async function readFileUrlBytes(fileUrl) {
+  const { readFile } = await import("node:fs/promises");
+  const { fileURLToPath } = await import("node:url");
+  const filePath = fileURLToPath(fileUrl);
+  return readFile(filePath);
+}
+
+async function instantiateWasm(moduleSource) {
+  if (moduleSource && typeof moduleSource.then === "function") {
+    moduleSource = await moduleSource;
+  }
+
+  const existing = pickExistingWasmExports(moduleSource);
+  if (existing !== undefined) {
+    return existing;
+  }
+
+  // Some bundlers expose wasm assets as namespace objects with a default export.
+  if (isRecordLike(moduleSource)) {
+    const nestedCandidates = [
+      "default",
+      "module_or_path",
+      "module",
+      "wasm",
+      "url",
+    ];
+    for (const key of nestedCandidates) {
+      if (!(key in moduleSource)) {
+        continue;
+      }
+      const nested = moduleSource[key];
+      if (nested === undefined || nested === moduleSource) {
+        continue;
+      }
+      return instantiateWasm(nested);
+    }
+  }
+
+  const imports = { "./flock_wasm_bg.js": wasmBg };
+
+  if (moduleSource instanceof WebAssembly.Module) {
+    return new WebAssembly.Instance(moduleSource, imports).exports;
+  }
+
+  if (
+    moduleSource instanceof ArrayBuffer ||
+    ArrayBuffer.isView(moduleSource)
+  ) {
+    const result = await WebAssembly.instantiate(moduleSource, imports);
+    if (result instanceof WebAssembly.Instance) {
+      return result.exports;
+    }
+    return result.instance.exports;
+  }
+
+  if (
+    typeof Response === "function" &&
+    moduleSource instanceof Response
+  ) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        const responseForStreaming = moduleSource.clone();
+        const streaming = await WebAssembly.instantiateStreaming(
+          responseForStreaming,
+          imports,
+        );
+        return streaming.instance.exports;
+      } catch (_error) {
+        // Fall back to arrayBuffer in runtimes with strict MIME handling.
+      }
+    }
+    const bytes = await moduleSource.arrayBuffer();
+    const result = await WebAssembly.instantiate(bytes, imports);
+    if (result instanceof WebAssembly.Instance) {
+      return result.exports;
+    }
+    return result.instance.exports;
+  }
+
+  if (
+    typeof moduleSource === "string" ||
+    (typeof URL === "function" && moduleSource instanceof URL) ||
+    (typeof Request === "function" && moduleSource instanceof Request)
+  ) {
+    let requestTarget = moduleSource;
+    if (typeof moduleSource === "string") {
+      requestTarget = resolveModuleSource(moduleSource);
+    }
+    if (typeof URL === "function" && requestTarget instanceof URL && requestTarget.protocol === "file:") {
+      const bytes = await readFileUrlBytes(requestTarget);
+      return instantiateWasm(bytes);
+    }
+    if (typeof fetch !== "function") {
+      throw new TypeError("fetch is not available to load the wasm module");
+    }
+    return instantiateWasm(fetch(requestTarget));
+  }
+
+  throw new TypeError("Unsupported wasm module shape for flock-wasm bundler init");
+}
+
+async function __wbg_init(moduleOrExports = wasmModule) {
+  if (wasm !== undefined) {
+    return wasm;
+  }
+  if (initPromise !== undefined) {
+    return initPromise;
+  }
+  initPromise = (async () => {
+    const resolved = await instantiateWasm(moduleOrExports);
+    __wbg_set_wasm(resolved);
+    if (typeof resolved.__wbindgen_start === "function") {
+      resolved.__wbindgen_start();
+    }
+    wasm = resolved;
+    return wasm;
+  })();
+  try {
+    return await initPromise;
+  } catch (error) {
+    initPromise = undefined;
+    throw error;
+  }
+}
+
+export default __wbg_init;

package/bundler/index.js

@@ -1,5 +1,5 @@
-import { RawFlock, callPendingEvents } from "./wasm";
-import { EventBatcher } from "./event-batcher";
+import { RawFlock, callPendingEvents } from "./wasm.js";
+import { EventBatcher } from "./event-batcher.js";
 export function encodeVersionVector(vector) {
     return encodeVersionVectorBinary(vector);
 }

package/nodejs/index.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flock = void 0;
 exports.encodeVersionVector = encodeVersionVector;
 exports.decodeVersionVector = decodeVersionVector;
-const wasm_1 = require("./wasm");
-const event_batcher_1 = require("./event-batcher");
+const wasm_js_1 = require("./wasm.js");
+const event_batcher_js_1 = require("./event-batcher.js");
 function encodeVersionVector(vector) {
     return encodeVersionVectorBinary(vector);
 }
@@ -552,8 +552,8 @@ class Flock {
     nativeSubscriberId;
     eventBatcher;
     constructor(peerId) {
-        this.inner = new wasm_1.RawFlock(normalizePeerId(peerId));
-        this.eventBatcher = new event_batcher_1.EventBatcher({
+        this.inner = new wasm_js_1.RawFlock(normalizePeerId(peerId));
+        this.eventBatcher = new event_batcher_js_1.EventBatcher({
             runtime: defaultEventBatcherRuntime,
             emit: (source, events) => {
                 this.deliverBatch({ source, events });
@@ -565,7 +565,7 @@ class Flock {
         flock.inner = inner;
         flock.listeners = new Set();
         flock.nativeSubscriberId = undefined;
-        flock.eventBatcher = new event_batcher_1.EventBatcher({
+        flock.eventBatcher = new event_batcher_js_1.EventBatcher({
             runtime: defaultEventBatcherRuntime,
             emit: (source, events) => {
                 flock.deliverBatch({ source, events });
@@ -574,11 +574,11 @@ class Flock {
         return flock;
     }
     static fromJson(bundle, peerId) {
-        const inner = wasm_1.RawFlock.fromJson(bundle, normalizePeerId(peerId));
+        const inner = wasm_js_1.RawFlock.fromJson(bundle, normalizePeerId(peerId));
         return Flock.fromInner(inner);
     }
     static fromFile(bytes, peerId) {
-        const inner = wasm_1.RawFlock.fromFile(normalizePeerId(peerId), bytes);
+        const inner = wasm_js_1.RawFlock.fromFile(normalizePeerId(peerId), bytes);
         return Flock.fromInner(inner);
     }
     checkInvariants() {
@@ -816,7 +816,7 @@ class Flock {
             return;
         }
         this.nativeSubscriberId = this.inner.subscribe((payload) => {
-            (0, wasm_1.callPendingEvents)();
+            (0, wasm_js_1.callPendingEvents)();
             const batch = decodeEventBatch(payload);
             this.handleBatch(batch);
         });
@@ -975,7 +975,7 @@ function decorateMethod(prototype, method) {
             if (result && typeof result.then === "function") {
                 void result
                     .finally(() => {
-                    (0, wasm_1.callPendingEvents)();
+                    (0, wasm_js_1.callPendingEvents)();
                 })
                     .catch(() => {
                     // Ignore: this promise is only for triggering pending event draining.
@@ -983,7 +983,7 @@ function decorateMethod(prototype, method) {
                 });
             }
             else {
-                (0, wasm_1.callPendingEvents)();
+                (0, wasm_js_1.callPendingEvents)();
             }
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loro-dev/flock-wasm",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "WASM bindings for flock-rs.",
   "type": "module",
   "sideEffects": false,

package/web/index.js

@@ -1,5 +1,5 @@
-import { RawFlock, callPendingEvents } from "./wasm";
-import { EventBatcher } from "./event-batcher";
+import { RawFlock, callPendingEvents } from "./wasm.js";
+import { EventBatcher } from "./event-batcher.js";
 export function encodeVersionVector(vector) {
     return encodeVersionVectorBinary(vector);
 }