@pixerate/editor 0.23.0 → 0.24.0

package/dist/persistence/index.cjs

@@ -0,0 +1,676 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunkD6FH2YAXcjs = require('../chunk-D6FH2YAX.cjs');
+
+// src/persistence/recoveryPolicy.ts
+function exponentialBackoff(failures, base = 1e3, max = 3e4) {
+  const exp = Math.min(Math.max(failures - 1, 0), 16);
+  return Math.min(base * 2 ** exp, max);
+}
+function createRecoveryPolicy(options = {}) {
+  const interval = _nullishCoalesce(options.interval, () => ( 5e3));
+  const retryDelay = _nullishCoalesce(options.retryDelay, () => ( (() => interval)));
+  const minWake = interval * 0.01;
+  let lastRevision = null;
+  let lastTime = null;
+  let gap = interval;
+  let ownsDirtyMeta = false;
+  let cleaning = false;
+  let snapshots = 0;
+  let snapshotsAtClean = 0;
+  let failures = 0;
+  const fail = (now) => {
+    failures++;
+    lastRevision = null;
+    lastTime = now;
+    gap = retryDelay(failures);
+  };
+  return {
+    tick(now, revision, savedRevision, tickOptions) {
+      const force = _optionalChain([tickOptions, 'optionalAccess', _ => _.force]) === true;
+      const since = force || lastTime === null ? Infinity : now - lastTime;
+      if (revision !== savedRevision) {
+        if (lastRevision === revision) return { type: "nothing" };
+        if (since >= gap) {
+          lastRevision = revision;
+          lastTime = now;
+          ownsDirtyMeta = true;
+          snapshots++;
+          return { type: "writeSnapshot", revision };
+        }
+        return { type: "wakeAfter", delay: Math.max(gap - since, minWake) };
+      }
+      if (ownsDirtyMeta && !cleaning) {
+        if (lastRevision !== null || since >= gap) {
+          cleaning = true;
+          snapshotsAtClean = snapshots;
+          return { type: "writeClean" };
+        }
+        return { type: "wakeAfter", delay: Math.max(gap - since, minWake) };
+      }
+      return { type: "nothing" };
+    },
+    written(revision, ok, now) {
+      if (ok) {
+        if (lastRevision === revision) {
+          failures = 0;
+          gap = interval;
+        }
+      } else if (lastRevision === revision) {
+        fail(now);
+      }
+    },
+    cleaned(ok, now) {
+      cleaning = false;
+      if (ok) {
+        ownsDirtyMeta = snapshots !== snapshotsAtClean;
+        failures = 0;
+        gap = interval;
+      } else {
+        fail(now);
+      }
+    },
+    get ownsSnapshot() {
+      return ownsDirtyMeta;
+    },
+    get failures() {
+      return failures;
+    }
+  };
+}
+
+// src/persistence/storage.ts
+var StorageUnavailableError = class extends Error {
+  constructor(kind) {
+    super(`${kind} storage is not available in this environment`);
+    this.name = "StorageUnavailableError";
+  }
+};
+var InjectedStorageError = class extends Error {
+  constructor(operation, key) {
+    super(`injected ${operation} failure for "${key}"`);
+    this.name = "InjectedStorageError";
+  }
+};
+function checkFailure(failure, operation, key) {
+  if (!failure) return;
+  const result = failure(operation, key);
+  if (result instanceof Error) throw result;
+  if (result) throw new InjectedStorageError(operation, key);
+}
+function withStorageFailures(inner, failure) {
+  return {
+    kind: inner.kind,
+    get available() {
+      return inner.available;
+    },
+    async get(key) {
+      checkFailure(failure, "get", key);
+      return inner.get(key);
+    },
+    async set(key, value) {
+      checkFailure(failure, "set", key);
+      return inner.set(key, value);
+    },
+    async remove(key) {
+      checkFailure(failure, "remove", key);
+      return inner.remove(key);
+    }
+  };
+}
+function guarded(kind, isAvailable, failure, impl) {
+  const check = (operation, key) => {
+    if (!isAvailable()) throw new StorageUnavailableError(kind);
+    checkFailure(failure, operation, key);
+  };
+  return {
+    kind,
+    get available() {
+      return isAvailable();
+    },
+    async get(key) {
+      check("get", key);
+      return impl.get(key);
+    },
+    async set(key, value) {
+      check("set", key);
+      return impl.set(key, value);
+    },
+    async remove(key) {
+      check("remove", key);
+      return impl.remove(key);
+    }
+  };
+}
+function createMemoryStorage(options = {}) {
+  const entries = new Map(Object.entries(_nullishCoalesce(options.initial, () => ( {}))));
+  const adapter = guarded("memory", () => true, options.failure, {
+    async get(key) {
+      return entries.has(key) ? entries.get(key) : null;
+    },
+    async set(key, value) {
+      entries.set(key, value);
+    },
+    async remove(key) {
+      entries.delete(key);
+    }
+  });
+  return Object.assign(adapter, { entries });
+}
+function detectLocalStorage() {
+  try {
+    const storage = globalThis.localStorage;
+    return storage && typeof storage.getItem === "function" ? storage : void 0;
+  } catch (e2) {
+    return void 0;
+  }
+}
+function isLocalStorageAvailable() {
+  return detectLocalStorage() !== void 0;
+}
+function createLocalStorageAdapter(prefix = "", options = {}) {
+  const storage = _nullishCoalesce(options.storage, () => ( detectLocalStorage()));
+  return guarded("localStorage", () => storage !== void 0, options.failure, {
+    async get(key) {
+      return storage.getItem(prefix + key);
+    },
+    async set(key, value) {
+      storage.setItem(prefix + key, value);
+    },
+    async remove(key) {
+      storage.removeItem(prefix + key);
+    }
+  });
+}
+function detectIndexedDb() {
+  try {
+    const factory = globalThis.indexedDB;
+    return factory && typeof factory.open === "function" ? factory : void 0;
+  } catch (e3) {
+    return void 0;
+  }
+}
+function isIndexedDbAvailable() {
+  return detectIndexedDb() !== void 0;
+}
+var requestToPromise = (request) => new Promise((resolve, reject) => {
+  request.onsuccess = () => resolve(request.result);
+  request.onerror = () => reject(_nullishCoalesce(request.error, () => ( new Error("IndexedDB request failed"))));
+});
+function createIndexedDbAdapter(name = "pixerate-editor", options = {}) {
+  const factory = _nullishCoalesce(options.indexedDB, () => ( detectIndexedDb()));
+  const storeName = _nullishCoalesce(options.store, () => ( "kv"));
+  let dbPromise = null;
+  const open = () => {
+    dbPromise ??= new Promise((resolve, reject) => {
+      const request = factory.open(name, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName);
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => {
+        dbPromise = null;
+        reject(_nullishCoalesce(request.error, () => ( new Error("IndexedDB open failed"))));
+      };
+    });
+    return dbPromise;
+  };
+  const write = async (fn) => {
+    const db = await open();
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(storeName, "readwrite");
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(_nullishCoalesce(tx.error, () => ( new Error("IndexedDB transaction failed"))));
+      tx.onabort = () => reject(_nullishCoalesce(tx.error, () => ( new Error("IndexedDB transaction aborted"))));
+      fn(tx.objectStore(storeName));
+    });
+  };
+  return guarded("indexedDB", () => factory !== void 0, options.failure, {
+    async get(key) {
+      const db = await open();
+      const tx = db.transaction(storeName, "readonly");
+      const value = await requestToPromise(tx.objectStore(storeName).get(key));
+      return typeof value === "string" ? value : null;
+    },
+    set: (key, value) => write((store) => store.put(value, key)),
+    remove: (key) => write((store) => store.delete(key))
+  });
+}
+function detectOpfsRoot() {
+  try {
+    const storage = _optionalChain([globalThis, 'access', _2 => _2.navigator, 'optionalAccess', _3 => _3.storage]);
+    if (storage && typeof storage.getDirectory === "function") {
+      return () => storage.getDirectory();
+    }
+  } catch (e4) {
+  }
+  return void 0;
+}
+function isOpfsAvailable() {
+  return detectOpfsRoot() !== void 0;
+}
+var isNotFound = (error) => !!error && typeof error === "object" && error.name === "NotFoundError";
+function createOpfsAdapter(dir = "pixerate-editor", options = {}) {
+  const getRoot = _nullishCoalesce(options.root, () => ( detectOpfsRoot()));
+  let dirPromise = null;
+  const directory = () => {
+    dirPromise ??= getRoot().then((root) => root.getDirectoryHandle(dir, { create: true }));
+    dirPromise.catch(() => {
+      dirPromise = null;
+    });
+    return dirPromise;
+  };
+  const fileName = (key) => encodeURIComponent(key) || "_";
+  const readFile = async (d, name) => {
+    try {
+      const handle = await d.getFileHandle(name);
+      return await (await handle.getFile()).text();
+    } catch (error) {
+      if (isNotFound(error)) return null;
+      throw error;
+    }
+  };
+  const writeFile = async (d, name, value) => {
+    const handle = await d.getFileHandle(name, { create: true });
+    if (typeof handle.createWritable !== "function") {
+      throw new StorageUnavailableError("opfs (createWritable)");
+    }
+    const writable = await handle.createWritable();
+    await writable.write(value);
+    await writable.close();
+    return handle;
+  };
+  const removeFile = async (d, name) => {
+    try {
+      await d.removeEntry(name);
+    } catch (error) {
+      if (!isNotFound(error)) throw error;
+    }
+  };
+  return guarded("opfs", () => getRoot !== void 0, options.failure, {
+    async get(key) {
+      const d = await directory();
+      const base = fileName(key);
+      const pointer = await readFile(d, `${base}.ptr`);
+      if (pointer === "a" || pointer === "b") return readFile(d, `${base}.${pointer}`);
+      return readFile(d, base);
+    },
+    async set(key, value) {
+      const d = await directory();
+      const base = fileName(key);
+      const pointer = await readFile(d, `${base}.ptr`);
+      if (!options.disableRename && pointer === null) {
+        const tmp = await writeFile(d, `${base}.tmp`, value);
+        if (typeof tmp.move === "function") {
+          await tmp.move(base);
+          return;
+        }
+        await removeFile(d, `${base}.tmp`);
+      }
+      const next = pointer === "a" ? "b" : "a";
+      await writeFile(d, `${base}.${next}`, value);
+      await writeFile(d, `${base}.ptr`, next);
+    },
+    async remove(key) {
+      const d = await directory();
+      const base = fileName(key);
+      for (const name of [`${base}.ptr`, base, `${base}.a`, `${base}.b`, `${base}.tmp`]) {
+        await removeFile(d, name);
+      }
+    }
+  });
+}
+
+// src/persistence/autosave.ts
+var recoveryMetaKey = (key) => `${key}:meta`;
+function formatRecoveryMessage(meta, formatTime = (time) => new Date(time).toLocaleString()) {
+  return typeof meta.time === "number" && Number.isFinite(meta.time) ? `Restore unsaved changes from ${formatTime(meta.time)}?` : "Restore unsaved changes?";
+}
+function createAutosaveController(options) {
+  const {
+    storage,
+    key,
+    getSnapshot,
+    revision,
+    savedRevision,
+    interval = 5e3,
+    debounceMs = 1e3,
+    retryBaseMs = 1e3,
+    retryMaxMs = 3e4
+  } = options;
+  const serialize = _nullishCoalesce(options.serialize, () => ( ((value) => JSON.stringify(value))));
+  const deserialize = _nullishCoalesce(options.deserialize, () => ( ((text) => JSON.parse(text))));
+  const now = _nullishCoalesce(options.now, () => ( (() => Date.now())));
+  const wallClock = _nullishCoalesce(options.wallClock, () => ( (() => Date.now())));
+  const setTimer = _nullishCoalesce(options.setTimeout, () => ( ((fn, ms) => globalThis.setTimeout(fn, ms))));
+  const clearTimer = _nullishCoalesce(options.clearTimeout, () => ( ((handle) => globalThis.clearTimeout(handle))));
+  const metaKey = recoveryMetaKey(key);
+  const policy = createRecoveryPolicy({
+    interval,
+    retryDelay: (failures) => exponentialBackoff(failures, retryBaseMs, retryMaxMs)
+  });
+  let hydrated = options.ready === true;
+  let destroyed = false;
+  let timer = null;
+  let timerDue = Infinity;
+  let inflight = null;
+  let observedRevision = revision();
+  let lastChangeAt = null;
+  let pendingSince = null;
+  let forceNext = false;
+  let info = {
+    status: "idle",
+    error: null,
+    failures: 0,
+    nextAttemptAt: null,
+    lastSavedAt: null,
+    ready: hydrated
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const setInfo = (patch) => {
+    const next = { ...info, ...patch, failures: policy.failures, ready: hydrated };
+    if (next.status === info.status && next.error === info.error && next.failures === info.failures && next.nextAttemptAt === info.nextAttemptAt && next.lastSavedAt === info.lastSavedAt && next.ready === info.ready) {
+      return;
+    }
+    info = next;
+    _optionalChain([options, 'access', _4 => _4.onStatus, 'optionalCall', _5 => _5(info)]);
+    listeners.forEach((listener) => {
+      try {
+        listener(info);
+      } catch (error) {
+        console.error("[autosave] Error in status listener:", error);
+      }
+    });
+  };
+  const cancelTimer = () => {
+    if (timer !== null) clearTimer(timer);
+    timer = null;
+    timerDue = Infinity;
+  };
+  const schedule = (delay) => {
+    if (destroyed) return;
+    const due = now() + Math.max(0, delay);
+    if (timer !== null && timerDue <= due) return;
+    cancelTimer();
+    timerDue = due;
+    timer = setTimer(() => {
+      timer = null;
+      timerDue = Infinity;
+      tick();
+    }, Math.max(0, delay));
+  };
+  const observe = (t) => {
+    const rev = revision();
+    if (rev !== observedRevision) {
+      observedRevision = rev;
+      lastChangeAt = t;
+      pendingSince ??= t;
+    }
+    return rev;
+  };
+  const docName = () => typeof options.name === "function" ? options.name() : options.name;
+  const run = (action, rev) => {
+    if (action.type === "writeSnapshot") {
+      setInfo({ status: "saving", nextAttemptAt: null });
+      inflight = (async () => {
+        let ok = false;
+        let error = null;
+        try {
+          const text = serialize(getSnapshot());
+          await storage.set(key, text);
+          const meta = {
+            dirty: true,
+            revision: action.revision,
+            time: wallClock(),
+            name: docName()
+          };
+          await storage.set(metaKey, JSON.stringify(meta));
+          ok = true;
+        } catch (e) {
+          error = e;
+        }
+        const t = now();
+        policy.written(action.revision, ok, t);
+        inflight = null;
+        if (ok) {
+          if (observedRevision === action.revision) pendingSince = null;
+          setInfo({ status: "saved", error: null, lastSavedAt: t });
+        } else {
+          setInfo({ status: "error", error });
+        }
+        tick();
+      })();
+    } else if (action.type === "writeClean") {
+      setInfo({ status: "saving", nextAttemptAt: null });
+      inflight = (async () => {
+        let ok = false;
+        let error = null;
+        try {
+          await storage.set(metaKey, JSON.stringify({ dirty: false }));
+          ok = true;
+        } catch (e) {
+          error = e;
+        }
+        policy.cleaned(ok, now());
+        inflight = null;
+        if (ok) {
+          if (!policy.ownsSnapshot) await storage.remove(key).catch(() => void 0);
+          setInfo({ status: "saved", error: null });
+        } else {
+          setInfo({ status: "error", error });
+        }
+        tick();
+      })();
+    } else if (action.type === "wakeAfter") {
+      schedule(action.delay);
+      setInfo(
+        info.status === "error" ? { nextAttemptAt: now() + action.delay } : { status: rev !== savedRevision() ? "dirty" : info.status, nextAttemptAt: now() + action.delay }
+      );
+    } else if (rev === savedRevision() && info.status === "dirty") {
+      setInfo({ status: policy.ownsSnapshot ? "dirty" : "idle", nextAttemptAt: null });
+    } else if (rev !== savedRevision() && info.status !== "saved" && info.status !== "error") {
+      setInfo({ status: "dirty" });
+    }
+  };
+  function tick() {
+    if (destroyed || inflight) return;
+    const t = now();
+    const rev = observe(t);
+    const saved = savedRevision();
+    if (!hydrated) {
+      if (rev !== saved) setInfo({ status: "dirty" });
+      return;
+    }
+    const force = forceNext;
+    forceNext = false;
+    if (rev !== saved && !force && info.status !== "error") {
+      const changed = _nullishCoalesce(lastChangeAt, () => ( t));
+      const due = Math.min(changed + debounceMs, (_nullishCoalesce(pendingSince, () => ( changed))) + interval);
+      if (t < due) {
+        setInfo({ status: "dirty", nextAttemptAt: due });
+        schedule(due - t);
+        return;
+      }
+    }
+    run(policy.tick(t, rev, saved, { force }), rev);
+  }
+  const whenIdle = async () => {
+    while (inflight) await inflight;
+  };
+  return {
+    getStatus: () => info,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    notify() {
+      if (destroyed) return;
+      const t = now();
+      const before = observedRevision;
+      const rev = observe(t);
+      const dirty = rev !== savedRevision();
+      if (dirty && rev !== before && info.status !== "error" && !inflight) {
+        setInfo({ status: "dirty" });
+      }
+      if (!hydrated) return;
+      const changed = _nullishCoalesce(lastChangeAt, () => ( t));
+      const due = Math.min(changed + debounceMs, (_nullishCoalesce(pendingSince, () => ( changed))) + interval);
+      schedule(dirty ? due - t : 0);
+    },
+    ready() {
+      if (hydrated || destroyed) return;
+      hydrated = true;
+      setInfo({});
+      schedule(0);
+    },
+    get isReady() {
+      return hydrated;
+    },
+    async flushNow() {
+      if (destroyed || !hydrated) return;
+      await whenIdle();
+      cancelTimer();
+      forceNext = true;
+      tick();
+      await whenIdle();
+    },
+    async markClean() {
+      if (destroyed) return;
+      await whenIdle();
+      cancelTimer();
+      tick();
+      await whenIdle();
+    },
+    async checkRecovery() {
+      if (policy.ownsSnapshot) return null;
+      let meta;
+      try {
+        const metaText = await storage.get(metaKey);
+        if (!metaText) return null;
+        meta = JSON.parse(metaText);
+      } catch (e5) {
+        return null;
+      }
+      if (!meta || meta.dirty !== true) return null;
+      const text = await storage.get(key).catch(() => null);
+      if (text === null) return null;
+      try {
+        return { snapshot: deserialize(text), text, meta };
+      } catch (error) {
+        return { snapshot: void 0, text, meta, error };
+      }
+    },
+    async discardRecovery() {
+      if (policy.ownsSnapshot) return false;
+      await whenIdle();
+      await storage.remove(metaKey);
+      await storage.remove(key);
+      return true;
+    },
+    tick,
+    whenIdle,
+    destroy() {
+      destroyed = true;
+      cancelTimer();
+      listeners.clear();
+    }
+  };
+}
+
+// src/persistence/revisions.ts
+function createRevisionTracker(options = {}) {
+  let revision = 0;
+  let saved = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => listeners.forEach((listener) => {
+    try {
+      listener();
+    } catch (error) {
+      console.error("[autosave] Error in revision listener:", error);
+    }
+  });
+  const syncSaved = () => {
+    if (options.dirty && !options.dirty.dirty) saved = revision;
+  };
+  const unsubscribers = [];
+  if (options.history) {
+    unsubscribers.push(
+      options.history.subscribe(() => {
+        revision++;
+        emit();
+      })
+    );
+  }
+  if (options.dirty) {
+    let first = true;
+    unsubscribers.push(
+      options.dirty.subscribe((dirty) => {
+        if (first) {
+          first = false;
+          if (dirty && revision === saved) revision++;
+          return;
+        }
+        if (dirty && revision === saved) revision++;
+        if (!dirty) saved = revision;
+        emit();
+      })
+    );
+  }
+  return {
+    revision: () => revision,
+    savedRevision: () => {
+      syncSaved();
+      return saved;
+    },
+    bump() {
+      revision++;
+      emit();
+    },
+    markSaved() {
+      saved = revision;
+      emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      unsubscribers.forEach((fn) => fn());
+      unsubscribers.length = 0;
+      listeners.clear();
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.InjectedStorageError = InjectedStorageError; exports.StorageUnavailableError = StorageUnavailableError; exports.createAutosaveController = createAutosaveController; exports.createIndexedDbAdapter = createIndexedDbAdapter; exports.createLoadReport = _chunkD6FH2YAXcjs.createLoadReport; exports.createLocalStorageAdapter = createLocalStorageAdapter; exports.createMemoryStorage = createMemoryStorage; exports.createOpfsAdapter = createOpfsAdapter; exports.createRecoveryPolicy = createRecoveryPolicy; exports.createRevisionTracker = createRevisionTracker; exports.exponentialBackoff = exponentialBackoff; exports.formatRecoveryMessage = formatRecoveryMessage; exports.hasLoadProblems = _chunkD6FH2YAXcjs.hasLoadProblems; exports.isIndexedDbAvailable = isIndexedDbAvailable; exports.isLocalStorageAvailable = isLocalStorageAvailable; exports.isOpfsAvailable = isOpfsAvailable; exports.loadDocument = _chunkD6FH2YAXcjs.loadDocument; exports.loadSections = _chunkD6FH2YAXcjs.loadSections; exports.migrateDocument = _chunkD6FH2YAXcjs.migrateDocument; exports.recoveryMetaKey = recoveryMetaKey; exports.withStorageFailures = withStorageFailures;
+//# sourceMappingURL=index.cjs.map