lody 0.76.0 → 0.77.0

package/dist/chunks/review-viewer-DRumOFSW.js

@@ -1,80 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile, mkdir, writeFile, rename } from "node:fs/promises";
-import os__default from "node:os";
-import path__default from "node:path";
-import process from "node:process";
-const reviewViewerVersion = "0.76.0";
-const reviewViewerSha256 = "1f06e6a56f50a0f2e72ab32443bccf66dc536395d1cdf67dc511161824fcc0b0";
-const reviewViewerFileName = "standalone.html";
-const DEFAULT_CDN_BASES = ["https://cdn.jsdelivr.net/npm", "https://unpkg.com"];
-function cacheDir() {
-  return path__default.join(os__default.homedir(), ".lody", "code-review-viewer");
-}
-function cachePath() {
-  return path__default.join(cacheDir(), `${reviewViewerVersion}.html`);
-}
-function sha256(buffer) {
-  return createHash("sha256").update(buffer).digest("hex");
-}
-function isUrl(source) {
-  return /^https?:\/\//i.test(source);
-}
-async function loadSource(source) {
-  if (isUrl(source)) {
-    const response = await fetch(source, { signal: AbortSignal.timeout(3e4) });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-    return Buffer.from(await response.arrayBuffer());
-  }
-  return readFile(path__default.resolve(source));
-}
-async function writeCache(buffer) {
-  try {
-    await mkdir(cacheDir(), { recursive: true });
-    const tmp = `${cachePath()}.tmp-${process.pid}`;
-    await writeFile(tmp, buffer);
-    await rename(tmp, cachePath());
-  } catch {
-  }
-}
-async function resolveReviewViewerTemplate() {
-  try {
-    const cached = await readFile(cachePath());
-    if (sha256(cached) === reviewViewerSha256) {
-      return cached.toString("utf8");
-    }
-  } catch {
-  }
-  const override = process.env.LODY_REVIEW_VIEWER?.trim();
-  const sources = override ? [override] : DEFAULT_CDN_BASES.map(
-    (base) => `${base}/lody-code-review-viewer@${reviewViewerVersion}/${reviewViewerFileName}`
-  );
-  const failures = [];
-  for (const source of sources) {
-    try {
-      const buffer = await loadSource(source);
-      const actual = sha256(buffer);
-      if (actual !== reviewViewerSha256) {
-        failures.push(
-          `${source}: sha256 mismatch (expected ${reviewViewerSha256.slice(0, 12)}\u2026, got ${actual.slice(
-            0,
-            12
-          )}\u2026)`
-        );
-        continue;
-      }
-      await writeCache(buffer);
-      return buffer.toString("utf8");
-    } catch (error) {
-      failures.push(`${source}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  throw new Error(
-    `Could not obtain the code-review viewer (lody-code-review-viewer@${reviewViewerVersion}).
-` + failures.map((line) => `  - ${line}`).join("\n") + "\nIf you are offline or behind a firewall, download standalone.html for this version and point LODY_REVIEW_VIEWER at it (a file path or URL)."
-  );
-}
-export {
-  resolveReviewViewerTemplate
-};

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

@@ -1,311 +0,0 @@
-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-DLsklGR5.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-DLsklGR5.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/turn-diff-replay-worker.js

@@ -1,16 +0,0 @@
-let turnDiffReplayWorker;
-let __tla = (async () => {
-  let replayFnPromise = null;
-  turnDiffReplayWorker = async function(input) {
-    replayFnPromise ??= import("./chunks/turn-diff-replay-BUdzlx5r.js").then(async (m) => {
-      await m.__tla;
-      return m;
-    }).then((n) => n.t).then((module) => module.replayTurnDiffText);
-    const replayTurnDiffText = await replayFnPromise;
-    return replayTurnDiffText(input);
-  };
-})();
-export {
-  __tla,
-  turnDiffReplayWorker as default
-};