lody 0.62.0 → 0.63.1

package/dist/chunks/turn-diff-replay-qRat9u1k.js

@@ -0,0 +1,311 @@
+import { i as imports, g as __wbg_set_wasm, r as rawWasm, e as LoroDoc, E as EphemeralStoreWasm, U as UndoManager, h as callPendingEvents, __tla as __tla_0 } from "./loro_wasm_bg-N-tMVpou.js";
+let EphemeralStore, isContainerId, isContainer, replayTurnDiffText, turnDiffReplay;
+let __tla = Promise.all([
+  (() => {
+    try {
+      return __tla_0;
+    } catch {
+    }
+  })()
+]).then(async () => {
+  const toModuleOrExports = (wasm) => {
+    if (!wasm) return wasm;
+    if (wasm instanceof WebAssembly.Module) return wasm;
+    if (typeof wasm === "object" && "default" in wasm) {
+      return wasm.default ?? wasm;
+    }
+    return wasm;
+  };
+  const wasmModuleOrExports = toModuleOrExports(rawWasm);
+  const finalize = (exports$1) => {
+    __wbg_set_wasm(exports$1);
+    tryStart(imports);
+  };
+  function tryStart(imports2) {
+    if (typeof imports2.__wbindgen_start === "function") {
+      imports2.__wbindgen_start();
+    }
+  }
+  if (wasmModuleOrExports && wasmModuleOrExports.__wbindgen_start) {
+    finalize(wasmModuleOrExports);
+  } else if ("Bun" in globalThis) {
+    let instance;
+    if (wasmModuleOrExports instanceof WebAssembly.Module) {
+      ({ instance } = await WebAssembly.instantiate(wasmModuleOrExports, {
+        "./loro_wasm_bg.js": imports
+      }));
+    } else {
+      const url = Bun.pathToFileURL(wasmModuleOrExports);
+      ({ instance } = await WebAssembly.instantiateStreaming(fetch(url), {
+        "./loro_wasm_bg.js": imports
+      }));
+    }
+    finalize(instance.exports);
+  } else {
+    const wkmod = wasmModuleOrExports instanceof WebAssembly.Module ? wasmModuleOrExports : await import("./loro_wasm_bg-N-tMVpou.js").then(async (m) => {
+      await m.__tla;
+      return m;
+    }).then((n) => n.r);
+    const module = wkmod instanceof WebAssembly.Module ? wkmod : wkmod && wkmod.default || wkmod;
+    let instance;
+    if (module instanceof WebAssembly.Instance) {
+      instance = module;
+    } else if (module instanceof WebAssembly.Module) {
+      instance = await WebAssembly.instantiate(module, {
+        "./loro_wasm_bg.js": imports
+      });
+    } else if (module instanceof ArrayBuffer || ArrayBuffer.isView(module)) {
+      const { instance: inst } = await WebAssembly.instantiate(module, {
+        "./loro_wasm_bg.js": imports
+      });
+      instance = inst;
+    } else if (typeof module === "string" || module instanceof URL) {
+      const response = await fetch(module);
+      const { instance: inst } = await WebAssembly.instantiateStreaming(response, {
+        "./loro_wasm_bg.js": imports
+      });
+      instance = inst;
+    } else {
+      console.error("Unsupported wasm import type:", module);
+      throw new Error("Unsupported wasm import type: " + typeof module);
+    }
+    finalize(instance.exports ?? instance);
+  }
+  const CONTAINER_TYPES = [
+    "Map",
+    "Text",
+    "List",
+    "Tree",
+    "MovableList",
+    "Counter"
+  ];
+  isContainerId = function(s) {
+    return s.startsWith("cid:");
+  };
+  isContainer = function(value) {
+    if (typeof value !== "object" || value == null) {
+      return false;
+    }
+    const p = Object.getPrototypeOf(value);
+    if (p == null || typeof p !== "object" || typeof p["kind"] !== "function") {
+      return false;
+    }
+    return CONTAINER_TYPES.includes(value.kind());
+  };
+  EphemeralStore = class {
+    constructor(timeout = 3e4) {
+      this.inner = new EphemeralStoreWasm(timeout);
+      this.timeout = timeout;
+    }
+    apply(bytes) {
+      this.inner.apply(bytes);
+      this.startTimerIfNotEmpty();
+    }
+    set(key, value) {
+      this.inner.set(key, value);
+      this.startTimerIfNotEmpty();
+    }
+    delete(key) {
+      this.inner.delete(key);
+    }
+    get(key) {
+      return this.inner.get(key);
+    }
+    getAllStates() {
+      return this.inner.getAllStates();
+    }
+    encode(key) {
+      return this.inner.encode(key);
+    }
+    encodeAll() {
+      return this.inner.encodeAll();
+    }
+    keys() {
+      return this.inner.keys();
+    }
+    destroy() {
+      clearInterval(this.timer);
+    }
+    subscribe(listener) {
+      return this.inner.subscribe(listener);
+    }
+    subscribeLocalUpdates(listener) {
+      return this.inner.subscribeLocalUpdates(listener);
+    }
+    startTimerIfNotEmpty() {
+      if (this.inner.isEmpty() || this.timer != null) {
+        return;
+      }
+      this.timer = setInterval(() => {
+        this.inner.removeOutdated();
+        if (this.inner.isEmpty()) {
+          clearInterval(this.timer);
+          this.timer = void 0;
+        }
+      }, this.timeout / 2);
+    }
+  };
+  LoroDoc.prototype.toJsonWithReplacer = function(replacer) {
+    const processed = /* @__PURE__ */ new Set();
+    const doc = this;
+    const m = (key, value) => {
+      if (typeof value === "string") {
+        if (isContainerId(value) && !processed.has(value)) {
+          processed.add(value);
+          const container = doc.getContainerById(value);
+          if (container == null) {
+            throw new Error(`ContainerID not found: ${value}`);
+          }
+          const ans2 = replacer(key, container);
+          if (ans2 === container) {
+            const ans3 = container.getShallowValue();
+            if (typeof ans3 === "object") {
+              return run(ans3);
+            }
+            return ans3;
+          }
+          if (isContainer(ans2)) {
+            throw new Error("Using new container is not allowed in toJsonWithReplacer");
+          }
+          if (typeof ans2 === "object" && ans2 != null) {
+            return run(ans2);
+          }
+          return ans2;
+        }
+      }
+      if (typeof value === "object" && value != null) {
+        return run(value);
+      }
+      const ans = replacer(key, value);
+      if (isContainer(ans)) {
+        throw new Error("Using new container is not allowed in toJsonWithReplacer");
+      }
+      return ans;
+    };
+    const run = (layer2) => {
+      if (Array.isArray(layer2)) {
+        return layer2.map((item, index) => {
+          return m(index, item);
+        }).filter((item) => item !== void 0);
+      }
+      const result = {};
+      for (const [key, value] of Object.entries(layer2)) {
+        const ans = m(key, value);
+        if (ans !== void 0) {
+          result[key] = ans;
+        }
+      }
+      return result;
+    };
+    const layer = doc.getShallowValue();
+    return run(layer);
+  };
+  const CALL_PENDING_EVENTS_WRAPPED = Symbol("loro.callPendingEventsWrapped");
+  function decorateMethod(prototype, method) {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, method);
+    if (!descriptor || typeof descriptor.value !== "function") {
+      return;
+    }
+    const original = descriptor.value;
+    if (original[CALL_PENDING_EVENTS_WRAPPED]) {
+      return;
+    }
+    const wrapped = function(...args) {
+      let result;
+      try {
+        result = original.apply(this, args);
+        return result;
+      } finally {
+        if (result && typeof result.then === "function") {
+          result.finally(() => {
+            callPendingEvents();
+          });
+        } else {
+          callPendingEvents();
+        }
+      }
+    };
+    wrapped[CALL_PENDING_EVENTS_WRAPPED] = true;
+    Object.defineProperty(prototype, method, {
+      ...descriptor,
+      value: wrapped
+    });
+  }
+  function decorateMethods(prototype, methods) {
+    for (const method of methods) {
+      decorateMethod(prototype, method);
+    }
+  }
+  decorateMethods(LoroDoc.prototype, [
+    "setDetachedEditing",
+    "attach",
+    "detach",
+    "fork",
+    "forkAt",
+    "checkoutToLatest",
+    "checkout",
+    "commit",
+    "getCursorPos",
+    "revertTo",
+    "export",
+    "exportJsonUpdates",
+    "exportJsonInIdSpan",
+    "importJsonUpdates",
+    "import",
+    "importUpdateBatch",
+    "importBatch",
+    "travelChangeAncestors",
+    "getChangedContainersIn",
+    "diff",
+    "applyDiff",
+    "setPeerId"
+  ]);
+  decorateMethods(EphemeralStoreWasm.prototype, [
+    "set",
+    "delete",
+    "apply",
+    "removeOutdated"
+  ]);
+  decorateMethods(UndoManager.prototype, [
+    "undo",
+    "redo"
+  ]);
+  function textAtForkedDoc(doc) {
+    const present = doc.getMap("meta").get("present");
+    if (present !== true) {
+      return null;
+    }
+    return doc.getText("text").toString();
+  }
+  replayTurnDiffText = function(input) {
+    try {
+      const doc = new LoroDoc();
+      doc.import(input.snapshot);
+      const oldDoc = doc.forkAt(JSON.parse(input.oldFrontiersJson));
+      const newDoc = doc.forkAt(JSON.parse(input.newFrontiersJson));
+      return {
+        status: "ready",
+        oldText: textAtForkedDoc(oldDoc),
+        newText: textAtForkedDoc(newDoc)
+      };
+    } catch {
+      return {
+        status: "unavailable"
+      };
+    }
+  };
+  turnDiffReplay = Object.freeze(Object.defineProperty({
+    __proto__: null,
+    replayTurnDiffText
+  }, Symbol.toStringTag, {
+    value: "Module"
+  }));
+});
+export {
+  EphemeralStore as E,
+  __tla,
+  isContainerId as a,
+  isContainer as i,
+  replayTurnDiffText as r,
+  turnDiffReplay as t
+};

package/dist/diff-worker.js

@@ -0,0 +1,11 @@
+import { c as computeLineCounts } from "./chunks/diff-line-counts-BLxwWP6r.js";
+import "node:child_process";
+import "node:fs";
+import "node:os";
+import "node:path";
+function diffWorker(input) {
+  return computeLineCounts(input.oldText, input.newText);
+}
+export {
+  diffWorker as default
+};