@arbidocs/react 0.5.110 → 0.5.112

package/dist/annotations/store.js

@@ -0,0 +1,49 @@
+import { emptyLayer, parseLayer } from "./model.js";
+class AnnotationStoreOfflineError extends Error {
+  constructor(message = "You are offline") {
+    super(message);
+    this.name = "AnnotationStoreOfflineError";
+  }
+}
+function createMemoryStore(now = () => (/* @__PURE__ */ new Date()).toISOString()) {
+  const layers = /* @__PURE__ */ new Map();
+  return {
+    async load(documentId) {
+      const raw = layers.get(documentId);
+      return raw ? parseLayer(JSON.parse(raw)) : emptyLayer(documentId, now());
+    },
+    async save(layer) {
+      layers.set(layer.documentId, JSON.stringify(parseLayer(layer)));
+    }
+  };
+}
+const STORAGE_PREFIX = "arbi:annotations:";
+function createLocalStorageStore(storage = safeLocalStorage(), now = () => (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    async load(documentId) {
+      try {
+        const raw = storage?.getItem(STORAGE_PREFIX + documentId);
+        if (raw) return parseLayer(JSON.parse(raw));
+      } catch {
+      }
+      return emptyLayer(documentId, now());
+    },
+    async save(layer) {
+      if (!storage) throw new Error("storage is not available");
+      storage.setItem(STORAGE_PREFIX + layer.documentId, JSON.stringify(parseLayer(layer)));
+    }
+  };
+}
+function safeLocalStorage() {
+  try {
+    return typeof localStorage === "undefined" ? void 0 : localStorage;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  AnnotationStoreOfflineError,
+  createLocalStorageStore,
+  createMemoryStore
+};
+//# sourceMappingURL=store.js.map

package/dist/annotations/store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/store.ts"],
+  "sourcesContent": ["/**\n * Where a layer is kept. The layer is data about a document, not part of it, so the host decides\n * (backend API, IndexedDB, a file). This package ships an in-memory store and a localStorage\n * store; both validate on load because stored JSON is untrusted. A store shared by several\n * writers (ARBI's server-side markup) also implements the optional members: it may merge on save,\n * pull others' changes, and say whether this user may write at all.\n */\n\nimport { emptyLayer, parseLayer, type AnnotationLayer } from './model'\n\nexport interface AnnotationStore {\n  /** The saved layer, or an empty one for a document that has none yet. */\n  load(documentId: string): Promise<AnnotationLayer>\n  /**\n   * Write a layer. A store with other writers may resolve to what it actually saved \u2014 this layer\n   * merged with theirs (see `mergeLayers`); the caller then rebases its newer edits onto it.\n   */\n  save(layer: AnnotationLayer): Promise<AnnotationLayer | void>\n  /** Others' changes since the last load or save, or null when there are none. */\n  pull?(documentId: string): Promise<AnnotationLayer | null>\n  /** Whether this user may change the layer; false makes it view-only. Known after `load`. */\n  canEdit?(documentId: string): boolean\n}\n\n/** Thrown by a store whose backend cannot be reached: the layer is kept and saved when back. */\nexport class AnnotationStoreOfflineError extends Error {\n  constructor(message = 'You are offline') {\n    super(message)\n    this.name = 'AnnotationStoreOfflineError'\n  }\n}\n\nexport function createMemoryStore(\n  now: () => string = () => new Date().toISOString()\n): AnnotationStore {\n  const layers = new Map<string, string>()\n  return {\n    async load(documentId) {\n      const raw = layers.get(documentId)\n      return raw ? parseLayer(JSON.parse(raw)) : emptyLayer(documentId, now())\n    },\n    async save(layer) {\n      layers.set(layer.documentId, JSON.stringify(parseLayer(layer)))\n    },\n  }\n}\n\nconst STORAGE_PREFIX = 'arbi:annotations:'\n\n/**\n * Per-browser store. Storage can be absent, full or blocked (private windows), so every access is\n * guarded. A saved layer that no longer validates is ignored rather than crashing the viewer.\n */\nexport function createLocalStorageStore(\n  storage: Pick<Storage, 'getItem' | 'setItem'> | undefined = safeLocalStorage(),\n  now: () => string = () => new Date().toISOString()\n): AnnotationStore {\n  return {\n    async load(documentId) {\n      try {\n        const raw = storage?.getItem(STORAGE_PREFIX + documentId)\n        if (raw) return parseLayer(JSON.parse(raw))\n      } catch {\n        // unreadable or invalid: start from an empty layer\n      }\n      return emptyLayer(documentId, now())\n    },\n    async save(layer) {\n      if (!storage) throw new Error('storage is not available')\n      storage.setItem(STORAGE_PREFIX + layer.documentId, JSON.stringify(parseLayer(layer)))\n    },\n  }\n}\n\nfunction safeLocalStorage(): Storage | undefined {\n  try {\n    return typeof localStorage === 'undefined' ? undefined : localStorage\n  } catch {\n    return undefined\n  }\n}\n"],
+  "mappings": "AAQA,SAAS,YAAY,kBAAwC;AAiBtD,MAAM,oCAAoC,MAAM;AAAA,EACrD,YAAY,UAAU,mBAAmB;AACvC,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAEO,SAAS,kBACd,MAAoB,OAAM,oBAAI,KAAK,GAAE,YAAY,GAChC;AACjB,QAAM,SAAS,oBAAI,IAAoB;AACvC,SAAO;AAAA,IACL,MAAM,KAAK,YAAY;AACrB,YAAM,MAAM,OAAO,IAAI,UAAU;AACjC,aAAO,MAAM,WAAW,KAAK,MAAM,GAAG,CAAC,IAAI,WAAW,YAAY,IAAI,CAAC;AAAA,IACzE;AAAA,IACA,MAAM,KAAK,OAAO;AAChB,aAAO,IAAI,MAAM,YAAY,KAAK,UAAU,WAAW,KAAK,CAAC,CAAC;AAAA,IAChE;AAAA,EACF;AACF;AAEA,MAAM,iBAAiB;AAMhB,SAAS,wBACd,UAA4D,iBAAiB,GAC7E,MAAoB,OAAM,oBAAI,KAAK,GAAE,YAAY,GAChC;AACjB,SAAO;AAAA,IACL,MAAM,KAAK,YAAY;AACrB,UAAI;AACF,cAAM,MAAM,SAAS,QAAQ,iBAAiB,UAAU;AACxD,YAAI,IAAK,QAAO,WAAW,KAAK,MAAM,GAAG,CAAC;AAAA,MAC5C,QAAQ;AAAA,MAER;AACA,aAAO,WAAW,YAAY,IAAI,CAAC;AAAA,IACrC;AAAA,IACA,MAAM,KAAK,OAAO;AAChB,UAAI,CAAC,QAAS,OAAM,IAAI,MAAM,0BAA0B;AACxD,cAAQ,QAAQ,iBAAiB,MAAM,YAAY,KAAK,UAAU,WAAW,KAAK,CAAC,CAAC;AAAA,IACtF;AAAA,EACF;AACF;AAEA,SAAS,mBAAwC;AAC/C,MAAI;AACF,WAAO,OAAO,iBAAiB,cAAc,SAAY;AAAA,EAC3D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/annotations/useAnnotationLayer.js

@@ -0,0 +1,306 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  DEFAULT_SETTINGS
+} from "./controller.js";
+import { mergeLayers } from "./merge.js";
+import { emptyLayer } from "./model.js";
+import {
+  applyAction,
+  canRedo as historyCanRedo,
+  canUndo as historyCanUndo,
+  createHistory,
+  redo as historyRedo,
+  undo as historyUndo
+} from "./state.js";
+import { AnnotationStoreOfflineError } from "./store.js";
+const AUTOSAVE_MS = 600;
+const RETRY_MS = 1e4;
+const defaultNow = () => (/* @__PURE__ */ new Date()).toISOString();
+const defaultId = () => globalThis.crypto.randomUUID();
+function rebaseHistory(history, sent, remote) {
+  const onto = (layer) => layer === sent ? remote : mergeLayers({ base: sent, mine: layer, theirs: remote });
+  return {
+    present: onto(history.present),
+    past: history.past.map(onto),
+    future: history.future.map(onto)
+  };
+}
+function useAnnotationLayer({
+  documentId,
+  store,
+  author,
+  autosaveMs = AUTOSAVE_MS,
+  readOnly: readOnlyProp = false,
+  online = true,
+  pullMs = 0,
+  now = defaultNow,
+  makeId = defaultId
+}) {
+  const [history, setHistory] = useState(
+    () => createHistory(emptyLayer(documentId, now()))
+  );
+  const [savedLayer, setSavedLayer] = useState(null);
+  const [status, setStatus] = useState("loading");
+  const [error, setError] = useState(null);
+  const [saving, setSaving] = useState(false);
+  const [offlineFailure, setOfflineFailure] = useState(false);
+  const [storeReadOnly, setStoreReadOnly] = useState(false);
+  const [tool, setToolState] = useState("select");
+  const [settings, setSettingsState] = useState(DEFAULT_SETTINGS);
+  const [selectedId, setSelectedId] = useState(null);
+  const readOnly = readOnlyProp || storeReadOnly;
+  const historyRef = useRef(history);
+  const savedRef = useRef(null);
+  const timerRef = useRef(void 0);
+  const retryRef = useRef(void 0);
+  const savingRef = useRef(false);
+  const docRef = useRef(documentId);
+  const storeRef = useRef(store);
+  storeRef.current = store;
+  const nowRef = useRef(now);
+  nowRef.current = now;
+  const idRef = useRef(makeId);
+  idRef.current = makeId;
+  const readOnlyRef = useRef(readOnly);
+  readOnlyRef.current = readOnly;
+  const onlineRef = useRef(online);
+  onlineRef.current = online;
+  const autosaveMsRef = useRef(autosaveMs);
+  autosaveMsRef.current = autosaveMs;
+  const commit = useCallback((next) => {
+    historyRef.current = next;
+    setHistory(next);
+  }, []);
+  const adoptRemote = useCallback(
+    (sent, remote) => {
+      commit(rebaseHistory(historyRef.current, sent, remote));
+      savedRef.current = remote;
+      setSavedLayer(remote);
+    },
+    [commit]
+  );
+  useEffect(() => {
+    docRef.current = documentId;
+    let cancelled = false;
+    setStatus("loading");
+    setError(null);
+    setSelectedId(null);
+    setSavedLayer(null);
+    setStoreReadOnly(false);
+    savedRef.current = null;
+    commit(createHistory(emptyLayer(documentId, nowRef.current())));
+    storeRef.current.load(documentId).then((layer) => {
+      if (cancelled) return;
+      savedRef.current = layer;
+      setSavedLayer(layer);
+      setStoreReadOnly(storeRef.current.canEdit?.(documentId) === false);
+      commit(createHistory(layer));
+      setStatus("ready");
+    }).catch((e) => {
+      if (cancelled) return;
+      setError(e instanceof Error ? e.message : "The annotations could not be loaded");
+      setStatus("error");
+    });
+    return () => {
+      cancelled = true;
+      clearTimeout(timerRef.current);
+      clearTimeout(retryRef.current);
+      const layer = historyRef.current.present;
+      if (savedRef.current !== null && layer !== savedRef.current && layer.documentId === documentId && !readOnlyRef.current) {
+        storeRef.current.save(layer).catch((e) => console.error("Annotations could not be saved", e));
+      }
+    };
+  }, [documentId, commit]);
+  const save = useCallback(async () => {
+    clearTimeout(timerRef.current);
+    clearTimeout(retryRef.current);
+    const layer = historyRef.current.present;
+    if (layer === savedRef.current || savedRef.current === null) return;
+    if (readOnlyRef.current || savingRef.current) return;
+    if (!onlineRef.current) return;
+    savingRef.current = true;
+    setSaving(true);
+    let failed = false;
+    try {
+      const stored = await storeRef.current.save(layer);
+      if (layer.documentId === docRef.current) {
+        setError(null);
+        setOfflineFailure(false);
+        if (stored && stored !== layer) {
+          adoptRemote(layer, stored);
+        } else {
+          savedRef.current = layer;
+          setSavedLayer(layer);
+        }
+      }
+    } catch (e) {
+      failed = true;
+      if (e instanceof AnnotationStoreOfflineError) {
+        setOfflineFailure(true);
+      } else {
+        setError(e instanceof Error ? e.message : "The annotations could not be saved");
+      }
+      retryRef.current = setTimeout(() => void saveRef.current(), RETRY_MS);
+    } finally {
+      savingRef.current = false;
+      setSaving(false);
+      if (!failed && historyRef.current.present !== savedRef.current) {
+        timerRef.current = setTimeout(() => void saveRef.current(), autosaveMsRef.current);
+      }
+    }
+  }, [adoptRemote]);
+  const saveRef = useRef(save);
+  saveRef.current = save;
+  const present = history.present;
+  const dirty = status === "ready" && present !== savedLayer;
+  useEffect(() => {
+    if (!dirty || !online || readOnly) return;
+    timerRef.current = setTimeout(() => void save(), autosaveMs);
+    return () => clearTimeout(timerRef.current);
+  }, [dirty, present, autosaveMs, save, online, readOnly]);
+  useEffect(() => {
+    if (online) setOfflineFailure(false);
+    if (online && savedRef.current !== null && historyRef.current.present !== savedRef.current) {
+      void save();
+    }
+  }, [online, save]);
+  const pull = useCallback(async () => {
+    const s = storeRef.current;
+    const base = savedRef.current;
+    if (!s.pull || !base || savingRef.current || !onlineRef.current) return;
+    if (historyRef.current.present !== base) return;
+    try {
+      const remote = await s.pull(docRef.current);
+      if (!remote || remote.documentId !== docRef.current || savedRef.current !== base) return;
+      adoptRemote(base, remote);
+    } catch {
+    }
+  }, [adoptRemote]);
+  useEffect(() => {
+    if (!pullMs || status !== "ready") return;
+    const timer = setInterval(() => void pull(), pullMs);
+    const onFocus = () => void pull();
+    window.addEventListener("focus", onFocus);
+    return () => {
+      clearInterval(timer);
+      window.removeEventListener("focus", onFocus);
+    };
+  }, [pullMs, status, pull]);
+  useEffect(() => {
+    const flush = () => void save();
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") flush();
+    };
+    window.addEventListener("pagehide", flush);
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      window.removeEventListener("pagehide", flush);
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, [save]);
+  const dispatch = useCallback(
+    (action) => {
+      if (readOnlyRef.current) return false;
+      try {
+        commit(applyAction(historyRef.current, action));
+        setError(null);
+        return true;
+      } catch (e) {
+        setError(e instanceof Error ? e.message : "The change was rejected");
+        return false;
+      }
+    },
+    [commit]
+  );
+  const stamp = useCallback(
+    (mark) => {
+      const t = nowRef.current();
+      return { ...mark, id: idRef.current(), author, createdAt: t, updatedAt: t };
+    },
+    [author]
+  );
+  const offline = !online || offlineFailure;
+  const controller = useMemo(() => {
+    const exists = (id) => id !== null && present.annotations.some((a) => a.id === id) ? id : null;
+    return {
+      layer: present,
+      status,
+      error,
+      saving,
+      dirty,
+      offline,
+      readOnly,
+      author,
+      tool: readOnly ? "select" : tool,
+      setTool: (next) => {
+        if (readOnly && next !== "select") return;
+        setToolState(next);
+        if (next !== "select") setSelectedId(null);
+      },
+      settings,
+      setSettings: (patch) => setSettingsState((s) => ({ ...s, ...patch, colors: { ...s.colors, ...patch.colors } })),
+      selectedId: exists(selectedId),
+      select: setSelectedId,
+      add: (mark) => {
+        const annotation = stamp(mark);
+        return dispatch({ type: "add", annotation }) ? annotation.id : null;
+      },
+      addMany: (marks) => {
+        const annotations = marks.map(stamp);
+        return dispatch({ type: "addMany", annotations }) ? annotations.map((a) => a.id) : [];
+      },
+      update: (id, patch) => void dispatch({ type: "update", id, patch, now: nowRef.current() }),
+      remove: (id) => void dispatch({ type: "remove", id, now: nowRef.current() }),
+      setRedactionStatus: (ids, next) => void dispatch({
+        type: "setRedactionStatus",
+        ids,
+        status: next,
+        now: nowRef.current(),
+        by: author
+      }),
+      reply: (id, body) => {
+        const t = nowRef.current();
+        void dispatch({
+          type: "reply",
+          id,
+          reply: { id: idRef.current(), author, createdAt: t, body },
+          now: t
+        });
+      },
+      resolve: (id, resolved) => void dispatch({ type: "resolve", id, resolved, now: nowRef.current() }),
+      undo: () => {
+        if (!readOnly) commit(historyUndo(historyRef.current));
+      },
+      redo: () => {
+        if (!readOnly) commit(historyRedo(historyRef.current));
+      },
+      canUndo: !readOnly && historyCanUndo(history),
+      canRedo: !readOnly && historyCanRedo(history),
+      flush: save
+    };
+  }, [
+    present,
+    history,
+    status,
+    error,
+    saving,
+    dirty,
+    offline,
+    readOnly,
+    author,
+    tool,
+    settings,
+    selectedId,
+    stamp,
+    dispatch,
+    commit,
+    save
+  ]);
+  return controller;
+}
+export {
+  AUTOSAVE_MS,
+  RETRY_MS,
+  useAnnotationLayer
+};
+//# sourceMappingURL=useAnnotationLayer.js.map

package/dist/annotations/useAnnotationLayer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/useAnnotationLayer.ts"],
+  "sourcesContent": ["/**\n * Annotation state for one document: loads its layer from a store, applies edits through the pure\n * reducer (so undo/redo is exact), and saves back after a short pause.\n *\n * Edits are applied from a ref, not inside a React state updater, so a mark that fails validation\n * is reported through `error` instead of throwing during render.\n *\n * With a shared store (other people edit the same layer) a save may come back merged with their\n * marks, and `pull` brings in their changes while this user is idle. Either way the remote layer is\n * REBASED in: the edits made here since are replayed on top of it with `mergeLayers`, and so is\n * every undo/redo step, so undoing never removes a colleague's mark or brings back one they deleted.\n */\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport {\n  DEFAULT_SETTINGS,\n  type AnnotationController,\n  type AnnotationTool,\n  type LayerStatus,\n  type NewMark,\n  type ToolSettings,\n} from './controller'\nimport { mergeLayers } from './merge'\nimport { emptyLayer, type Annotation, type AnnotationLayer } from './model'\nimport {\n  applyAction,\n  canRedo as historyCanRedo,\n  canUndo as historyCanUndo,\n  createHistory,\n  redo as historyRedo,\n  undo as historyUndo,\n  type AnnotationAction,\n  type LayerHistory,\n} from './state'\nimport { AnnotationStoreOfflineError, type AnnotationStore } from './store'\n\nexport const AUTOSAVE_MS = 600\n/** After a failed save, try again this much later (while edits are still unsaved). */\nexport const RETRY_MS = 10_000\n\nexport interface UseAnnotationLayerOptions {\n  documentId: string\n  store: AnnotationStore\n  /** Display name recorded as the author of new marks. */\n  author: string\n  autosaveMs?: number\n  /** View only: marks are shown and comments can be read, nothing can be changed. */\n  readOnly?: boolean\n  /** False while the device is offline: edits are kept and saved when it comes back. */\n  online?: boolean\n  /** Ask the store for others' changes this often while idle (0 = never). Needs `store.pull`. */\n  pullMs?: number\n  now?: () => string\n  makeId?: () => string\n}\n\nconst defaultNow = () => new Date().toISOString()\nconst defaultId = () => globalThis.crypto.randomUUID()\n\n/** Replay a history onto a remote layer: `sent` is what the remote layer was made from. */\nfunction rebaseHistory(\n  history: LayerHistory,\n  sent: AnnotationLayer,\n  remote: AnnotationLayer\n): LayerHistory {\n  const onto = (layer: AnnotationLayer) =>\n    layer === sent ? remote : mergeLayers({ base: sent, mine: layer, theirs: remote })\n  return {\n    present: onto(history.present),\n    past: history.past.map(onto),\n    future: history.future.map(onto),\n  }\n}\n\nexport function useAnnotationLayer({\n  documentId,\n  store,\n  author,\n  autosaveMs = AUTOSAVE_MS,\n  readOnly: readOnlyProp = false,\n  online = true,\n  pullMs = 0,\n  now = defaultNow,\n  makeId = defaultId,\n}: UseAnnotationLayerOptions): AnnotationController {\n  const [history, setHistory] = useState<LayerHistory>(() =>\n    createHistory(emptyLayer(documentId, now()))\n  )\n  const [savedLayer, setSavedLayer] = useState<AnnotationLayer | null>(null)\n  const [status, setStatus] = useState<LayerStatus>('loading')\n  const [error, setError] = useState<string | null>(null)\n  const [saving, setSaving] = useState(false)\n  const [offlineFailure, setOfflineFailure] = useState(false)\n  const [storeReadOnly, setStoreReadOnly] = useState(false)\n  const [tool, setToolState] = useState<AnnotationTool>('select')\n  const [settings, setSettingsState] = useState<ToolSettings>(DEFAULT_SETTINGS)\n  const [selectedId, setSelectedId] = useState<string | null>(null)\n  const readOnly = readOnlyProp || storeReadOnly\n\n  const historyRef = useRef(history)\n  const savedRef = useRef<AnnotationLayer | null>(null)\n  const timerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined)\n  const retryRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined)\n  const savingRef = useRef(false)\n  const docRef = useRef(documentId)\n  const storeRef = useRef(store)\n  storeRef.current = store\n  const nowRef = useRef(now)\n  nowRef.current = now\n  const idRef = useRef(makeId)\n  idRef.current = makeId\n  const readOnlyRef = useRef(readOnly)\n  readOnlyRef.current = readOnly\n  const onlineRef = useRef(online)\n  onlineRef.current = online\n  const autosaveMsRef = useRef(autosaveMs)\n  autosaveMsRef.current = autosaveMs\n\n  const commit = useCallback((next: LayerHistory) => {\n    historyRef.current = next\n    setHistory(next)\n  }, [])\n\n  /** Take in a layer the store produced from `sent` (a merged save, or others' changes). */\n  const adoptRemote = useCallback(\n    (sent: AnnotationLayer, remote: AnnotationLayer) => {\n      commit(rebaseHistory(historyRef.current, sent, remote))\n      savedRef.current = remote\n      setSavedLayer(remote)\n    },\n    [commit]\n  )\n\n  // Load when the document changes.\n  useEffect(() => {\n    docRef.current = documentId\n    let cancelled = false\n    setStatus('loading')\n    setError(null)\n    setSelectedId(null)\n    setSavedLayer(null)\n    setStoreReadOnly(false)\n    savedRef.current = null\n    commit(createHistory(emptyLayer(documentId, nowRef.current())))\n    storeRef.current\n      .load(documentId)\n      .then((layer) => {\n        if (cancelled) return\n        savedRef.current = layer\n        setSavedLayer(layer)\n        setStoreReadOnly(storeRef.current.canEdit?.(documentId) === false)\n        commit(createHistory(layer))\n        setStatus('ready')\n      })\n      .catch((e: unknown) => {\n        if (cancelled) return\n        setError(e instanceof Error ? e.message : 'The annotations could not be loaded')\n        setStatus('error')\n      })\n    return () => {\n      cancelled = true\n      // Leaving this document (switching to another, or unmounting): write the edits still waiting\n      // on the autosave timer. Without this they would be silently dropped.\n      clearTimeout(timerRef.current)\n      clearTimeout(retryRef.current)\n      const layer = historyRef.current.present\n      if (\n        savedRef.current !== null &&\n        layer !== savedRef.current &&\n        layer.documentId === documentId &&\n        !readOnlyRef.current\n      ) {\n        storeRef.current\n          .save(layer)\n          .catch((e: unknown) => console.error('Annotations could not be saved', e))\n      }\n    }\n  }, [documentId, commit])\n\n  const save = useCallback(async () => {\n    clearTimeout(timerRef.current)\n    clearTimeout(retryRef.current)\n    const layer = historyRef.current.present\n    // Nothing to write, not loaded yet (never overwrite a layer with the empty placeholder), view\n    // only, or a write already in flight (its completion schedules the next one).\n    if (layer === savedRef.current || savedRef.current === null) return\n    if (readOnlyRef.current || savingRef.current) return\n    if (!onlineRef.current) return // kept; the online effect saves it when the device is back\n    savingRef.current = true\n    setSaving(true)\n    let failed = false\n    try {\n      const stored = await storeRef.current.save(layer)\n      if (layer.documentId === docRef.current) {\n        setError(null)\n        setOfflineFailure(false)\n        if (stored && stored !== layer) {\n          adoptRemote(layer, stored)\n        } else {\n          savedRef.current = layer\n          setSavedLayer(layer)\n        }\n      }\n    } catch (e) {\n      failed = true\n      if (e instanceof AnnotationStoreOfflineError) {\n        setOfflineFailure(true)\n      } else {\n        setError(e instanceof Error ? e.message : 'The annotations could not be saved')\n      }\n      // Try again later; any new edit also tries again.\n      retryRef.current = setTimeout(() => void saveRef.current(), RETRY_MS)\n    } finally {\n      savingRef.current = false\n      setSaving(false)\n      // Edits made while this write was in flight go out next (their own timer found it busy).\n      if (!failed && historyRef.current.present !== savedRef.current) {\n        timerRef.current = setTimeout(() => void saveRef.current(), autosaveMsRef.current)\n      }\n    }\n  }, [adoptRemote])\n  const saveRef = useRef(save)\n  saveRef.current = save\n\n  const present = history.present\n  const dirty = status === 'ready' && present !== savedLayer\n\n  useEffect(() => {\n    if (!dirty || !online || readOnly) return\n    timerRef.current = setTimeout(() => void save(), autosaveMs)\n    return () => clearTimeout(timerRef.current)\n  }, [dirty, present, autosaveMs, save, online, readOnly])\n\n  // Back online: the unsaved edits go out at once.\n  useEffect(() => {\n    if (online) setOfflineFailure(false)\n    if (online && savedRef.current !== null && historyRef.current.present !== savedRef.current) {\n      void save()\n    }\n  }, [online, save])\n\n  // Others' changes, while this user is idle (nothing unsaved, nothing in flight).\n  const pull = useCallback(async () => {\n    const s = storeRef.current\n    const base = savedRef.current\n    if (!s.pull || !base || savingRef.current || !onlineRef.current) return\n    if (historyRef.current.present !== base) return\n    try {\n      const remote = await s.pull(docRef.current)\n      if (!remote || remote.documentId !== docRef.current || savedRef.current !== base) return\n      adoptRemote(base, remote)\n    } catch {\n      // A failed pull changes nothing; the next one (or a save) catches up.\n    }\n  }, [adoptRemote])\n\n  useEffect(() => {\n    if (!pullMs || status !== 'ready') return\n    const timer = setInterval(() => void pull(), pullMs)\n    const onFocus = () => void pull()\n    window.addEventListener('focus', onFocus)\n    return () => {\n      clearInterval(timer)\n      window.removeEventListener('focus', onFocus)\n    }\n  }, [pullMs, status, pull])\n\n  // The tab can close or reload with edits still waiting on the autosave timer, and React's own\n  // cleanup does not run then. Write when the page is being left or hidden (mobile browsers often\n  // fire only the latter). `save` starts the store write synchronously, which is what unload needs.\n  useEffect(() => {\n    const flush = () => void save()\n    const onVisibility = () => {\n      if (document.visibilityState === 'hidden') flush()\n    }\n    window.addEventListener('pagehide', flush)\n    document.addEventListener('visibilitychange', onVisibility)\n    return () => {\n      window.removeEventListener('pagehide', flush)\n      document.removeEventListener('visibilitychange', onVisibility)\n    }\n  }, [save])\n\n  const dispatch = useCallback(\n    (action: AnnotationAction): boolean => {\n      if (readOnlyRef.current) return false\n      try {\n        commit(applyAction(historyRef.current, action))\n        setError(null)\n        return true\n      } catch (e) {\n        setError(e instanceof Error ? e.message : 'The change was rejected')\n        return false\n      }\n    },\n    [commit]\n  )\n\n  const stamp = useCallback(\n    (mark: NewMark): Annotation => {\n      const t = nowRef.current()\n      return { ...mark, id: idRef.current(), author, createdAt: t, updatedAt: t } as Annotation\n    },\n    [author]\n  )\n\n  const offline = !online || offlineFailure\n\n  const controller = useMemo<AnnotationController>(() => {\n    const exists = (id: string | null) =>\n      id !== null && present.annotations.some((a) => a.id === id) ? id : null\n    return {\n      layer: present,\n      status,\n      error,\n      saving,\n      dirty,\n      offline,\n      readOnly,\n      author,\n      tool: readOnly ? 'select' : tool,\n      setTool: (next) => {\n        if (readOnly && next !== 'select') return\n        setToolState(next)\n        if (next !== 'select') setSelectedId(null)\n      },\n      settings,\n      setSettings: (patch) =>\n        setSettingsState((s) => ({ ...s, ...patch, colors: { ...s.colors, ...patch.colors } })),\n      selectedId: exists(selectedId),\n      select: setSelectedId,\n      add: (mark) => {\n        const annotation = stamp(mark)\n        return dispatch({ type: 'add', annotation }) ? annotation.id : null\n      },\n      addMany: (marks) => {\n        const annotations = marks.map(stamp)\n        return dispatch({ type: 'addMany', annotations }) ? annotations.map((a) => a.id) : []\n      },\n      update: (id, patch) => void dispatch({ type: 'update', id, patch, now: nowRef.current() }),\n      remove: (id) => void dispatch({ type: 'remove', id, now: nowRef.current() }),\n      setRedactionStatus: (ids, next) =>\n        void dispatch({\n          type: 'setRedactionStatus',\n          ids,\n          status: next,\n          now: nowRef.current(),\n          by: author,\n        }),\n      reply: (id, body) => {\n        const t = nowRef.current()\n        void dispatch({\n          type: 'reply',\n          id,\n          reply: { id: idRef.current(), author, createdAt: t, body },\n          now: t,\n        })\n      },\n      resolve: (id, resolved) =>\n        void dispatch({ type: 'resolve', id, resolved, now: nowRef.current() }),\n      undo: () => {\n        if (!readOnly) commit(historyUndo(historyRef.current))\n      },\n      redo: () => {\n        if (!readOnly) commit(historyRedo(historyRef.current))\n      },\n      canUndo: !readOnly && historyCanUndo(history),\n      canRedo: !readOnly && historyCanRedo(history),\n      flush: save,\n    }\n  }, [\n    present,\n    history,\n    status,\n    error,\n    saving,\n    dirty,\n    offline,\n    readOnly,\n    author,\n    tool,\n    settings,\n    selectedId,\n    stamp,\n    dispatch,\n    commit,\n    save,\n  ])\n\n  return controller\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/annotations/useAnnotationShortcuts.js

@@ -0,0 +1,31 @@
+import { useEffect } from "react";
+const isEditable = (el) => el instanceof HTMLElement && (el.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName));
+function useAnnotationShortcuts(controller, enabled = true) {
+  useEffect(() => {
+    if (!enabled) return;
+    const onKey = (e) => {
+      if (isEditable(e.target)) return;
+      const mod = e.metaKey || e.ctrlKey;
+      if (mod && e.key.toLowerCase() === "z") {
+        e.preventDefault();
+        if (e.shiftKey) controller.redo();
+        else controller.undo();
+      } else if (mod && e.key.toLowerCase() === "y") {
+        e.preventDefault();
+        controller.redo();
+      } else if ((e.key === "Delete" || e.key === "Backspace") && controller.selectedId) {
+        e.preventDefault();
+        controller.remove(controller.selectedId);
+      } else if (e.key === "Escape") {
+        controller.select(null);
+        controller.setTool("select");
+      }
+    };
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, [controller, enabled]);
+}
+export {
+  useAnnotationShortcuts
+};
+//# sourceMappingURL=useAnnotationShortcuts.js.map

package/dist/annotations/useAnnotationShortcuts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/useAnnotationShortcuts.ts"],
+  "sourcesContent": ["/** Delete, Escape, undo and redo for the annotation layer. */\n\nimport { useEffect } from 'react'\nimport type { AnnotationController } from './controller'\n\nconst isEditable = (el: EventTarget | null) =>\n  el instanceof HTMLElement &&\n  (el.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName))\n\n/** Delete, Escape, undo and redo, ignoring keystrokes meant for a text field. */\nexport function useAnnotationShortcuts(controller: AnnotationController, enabled = true) {\n  useEffect(() => {\n    if (!enabled) return\n    const onKey = (e: KeyboardEvent) => {\n      if (isEditable(e.target)) return\n      const mod = e.metaKey || e.ctrlKey\n      if (mod && e.key.toLowerCase() === 'z') {\n        e.preventDefault()\n        if (e.shiftKey) controller.redo()\n        else controller.undo()\n      } else if (mod && e.key.toLowerCase() === 'y') {\n        e.preventDefault()\n        controller.redo()\n      } else if ((e.key === 'Delete' || e.key === 'Backspace') && controller.selectedId) {\n        e.preventDefault()\n        controller.remove(controller.selectedId)\n      } else if (e.key === 'Escape') {\n        controller.select(null)\n        controller.setTool('select')\n      }\n    }\n    document.addEventListener('keydown', onKey)\n    return () => document.removeEventListener('keydown', onKey)\n  }, [controller, enabled])\n}\n"],
+  "mappings": "AAEA,SAAS,iBAAiB;AAG1B,MAAM,aAAa,CAAC,OAClB,cAAc,gBACb,GAAG,qBAAqB,4BAA4B,KAAK,GAAG,OAAO;AAG/D,SAAS,uBAAuB,YAAkC,UAAU,MAAM;AACvF,YAAU,MAAM;AACd,QAAI,CAAC,QAAS;AACd,UAAM,QAAQ,CAAC,MAAqB;AAClC,UAAI,WAAW,EAAE,MAAM,EAAG;AAC1B,YAAM,MAAM,EAAE,WAAW,EAAE;AAC3B,UAAI,OAAO,EAAE,IAAI,YAAY,MAAM,KAAK;AACtC,UAAE,eAAe;AACjB,YAAI,EAAE,SAAU,YAAW,KAAK;AAAA,YAC3B,YAAW,KAAK;AAAA,MACvB,WAAW,OAAO,EAAE,IAAI,YAAY,MAAM,KAAK;AAC7C,UAAE,eAAe;AACjB,mBAAW,KAAK;AAAA,MAClB,YAAY,EAAE,QAAQ,YAAY,EAAE,QAAQ,gBAAgB,WAAW,YAAY;AACjF,UAAE,eAAe;AACjB,mBAAW,OAAO,WAAW,UAAU;AAAA,MACzC,WAAW,EAAE,QAAQ,UAAU;AAC7B,mBAAW,OAAO,IAAI;AACtB,mBAAW,QAAQ,QAAQ;AAAA,MAC7B;AAAA,IACF;AACA,aAAS,iBAAiB,WAAW,KAAK;AAC1C,WAAO,MAAM,SAAS,oBAAoB,WAAW,KAAK;AAAA,EAC5D,GAAG,CAAC,YAAY,OAAO,CAAC;AAC1B;",
+  "names": []
+}

package/dist/annotations/useTextSelectionMarks.js

@@ -0,0 +1,100 @@
+import { useEffect, useRef } from "react";
+import { usePortalContainer } from "../ui/portal-container.js";
+import { TEXT_TOOLS } from "./controller.js";
+import { extendFocusToPointer, readSelection, selectionToPageMarks } from "./selection-marks.js";
+const PAGE_SELECTOR = "[data-page-number]";
+const TOUCH_SETTLE_MS = 700;
+const MOUSE_SETTLE_MS = 80;
+const STABLE_CHECKS = 3;
+const MAX_SETTLE_ROUNDS = 12;
+function useTextSelectionMarks(controller) {
+  const latest = useRef(controller);
+  latest.current = controller;
+  const pagesDoc = usePortalContainer()?.ownerDocument ?? document;
+  useEffect(() => {
+    let startedOnPage = false;
+    let touchSelecting = false;
+    let settleTimer;
+    const settleTimers = /* @__PURE__ */ new Set();
+    const markSelection = () => {
+      const c = latest.current;
+      const selection = pagesDoc.getSelection();
+      if (!selection || !TEXT_TOOLS.includes(c.tool)) return false;
+      const pages = selectionToPageMarks(readSelection(selection, pagesDoc));
+      if (pages.length === 0) return false;
+      const marks = pages.map(
+        (p) => c.tool === "highlight" ? {
+          kind: "highlight",
+          page: p.page,
+          rects: p.rects,
+          color: c.settings.colors.highlight,
+          text: p.text
+        } : {
+          kind: "redaction",
+          page: p.page,
+          rects: p.rects,
+          reason: c.settings.redactionReason,
+          text: p.text,
+          status: "pending"
+        }
+      );
+      if (c.addMany(marks).length === 0) return false;
+      selection.removeAllRanges();
+      return true;
+    };
+    const onDown = (e) => {
+      startedOnPage = e.target instanceof Element && e.target.closest(PAGE_SELECTOR) !== null;
+      touchSelecting = startedOnPage && e.pointerType === "touch";
+    };
+    const onUp = (e) => {
+      if (!startedOnPage || !TEXT_TOOLS.includes(latest.current.tool)) return;
+      startedOnPage = false;
+      const selection = pagesDoc.getSelection();
+      if (selection && e.pointerType === "mouse") {
+        extendFocusToPointer(selection, { x: e.clientX, y: e.clientY });
+      }
+      let last = selection?.toString() ?? "";
+      let stable = 0;
+      let rounds = 0;
+      const check = () => {
+        const now = pagesDoc.getSelection()?.toString() ?? "";
+        if (now === last) stable++;
+        else {
+          last = now;
+          stable = 0;
+        }
+        if (stable >= STABLE_CHECKS || ++rounds >= MAX_SETTLE_ROUNDS) {
+          if (markSelection()) touchSelecting = false;
+          return;
+        }
+        settleTimers.add(setTimeout(check, MOUSE_SETTLE_MS));
+      };
+      settleTimers.add(setTimeout(check, MOUSE_SETTLE_MS));
+    };
+    const onSelectionChange = () => {
+      if (!touchSelecting || !TEXT_TOOLS.includes(latest.current.tool)) return;
+      clearTimeout(settleTimer);
+      settleTimer = setTimeout(() => {
+        if (markSelection()) touchSelecting = false;
+      }, TOUCH_SETTLE_MS);
+    };
+    pagesDoc.addEventListener("pointerdown", onDown, true);
+    pagesDoc.addEventListener("pointerup", onUp, true);
+    pagesDoc.addEventListener("selectionchange", onSelectionChange);
+    return () => {
+      clearTimeout(settleTimer);
+      settleTimers.forEach(clearTimeout);
+      pagesDoc.removeEventListener("pointerdown", onDown, true);
+      pagesDoc.removeEventListener("pointerup", onUp, true);
+      pagesDoc.removeEventListener("selectionchange", onSelectionChange);
+    };
+  }, [pagesDoc]);
+}
+export {
+  MAX_SETTLE_ROUNDS,
+  MOUSE_SETTLE_MS,
+  STABLE_CHECKS,
+  TOUCH_SETTLE_MS,
+  useTextSelectionMarks
+};
+//# sourceMappingURL=useTextSelectionMarks.js.map

package/dist/annotations/useTextSelectionMarks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/annotations/useTextSelectionMarks.ts"],
+  "sourcesContent": ["/**\n * Turns a text selection made on the page into marks while the highlight or redact-text tool is\n * active. Only a selection that STARTED on a page counts: otherwise text left selected from an\n * earlier gesture would be marked the moment the user clicked a toolbar button.\n *\n * With a mouse the gesture is press, drag, release, so the release marks the selection. A touch\n * selection is different: the user long-presses a word, then drags the handles, and the browser\n * may cancel the pointer instead of releasing it. So for touch the selection is marked once it has\n * stopped changing for a moment. The marks are undoable, and redactions stay pending until reviewed.\n */\n\nimport { useEffect, useRef } from 'react'\nimport { usePortalContainer } from '../ui/portal-container'\nimport { TEXT_TOOLS, type AnnotationController, type NewMark } from './controller'\nimport { extendFocusToPointer, readSelection, selectionToPageMarks } from './selection-marks'\n\nconst PAGE_SELECTOR = '[data-page-number]'\n\n/** How long a touch selection must stay unchanged before it is turned into marks. */\nexport const TOUCH_SETTLE_MS = 700\n\n/**\n * After a mouse release the browser may still be extending the selection (WebKit does, under\n * load), so reading it at once can capture only part of what the user selected: a redaction that\n * under-covers. The release therefore waits until the selection has read the same on\n * STABLE_CHECKS consecutive checks, MOUSE_SETTLE_MS apart, and gives up waiting after\n * MAX_SETTLE_ROUNDS checks so a selection that never stops changing cannot hang the tool.\n */\nexport const MOUSE_SETTLE_MS = 80\nexport const STABLE_CHECKS = 3\nexport const MAX_SETTLE_ROUNDS = 12\n\nexport function useTextSelectionMarks(controller: AnnotationController) {\n  const latest = useRef(controller)\n  latest.current = controller\n  // A viewer popped out to another window renders into that window's document, which has its own\n  // selection and events. Listen to the document the pages are actually in.\n  const pagesDoc = usePortalContainer()?.ownerDocument ?? document\n\n  useEffect(() => {\n    let startedOnPage = false\n    let touchSelecting = false\n    let settleTimer: ReturnType<typeof setTimeout> | undefined\n    const settleTimers = new Set<ReturnType<typeof setTimeout>>()\n\n    /** Mark whatever is selected on the pages. Returns true when marks were made. */\n    const markSelection = (): boolean => {\n      const c = latest.current\n      const selection = pagesDoc.getSelection()\n      if (!selection || !TEXT_TOOLS.includes(c.tool)) return false\n      const pages = selectionToPageMarks(readSelection(selection, pagesDoc))\n      if (pages.length === 0) return false\n      const marks: NewMark[] = pages.map((p) =>\n        c.tool === 'highlight'\n          ? {\n              kind: 'highlight',\n              page: p.page,\n              rects: p.rects,\n              color: c.settings.colors.highlight,\n              text: p.text,\n            }\n          : {\n              kind: 'redaction',\n              page: p.page,\n              rects: p.rects,\n              reason: c.settings.redactionReason,\n              text: p.text,\n              status: 'pending',\n            }\n      )\n      if (c.addMany(marks).length === 0) return false\n      selection.removeAllRanges()\n      return true\n    }\n\n    const onDown = (e: PointerEvent) => {\n      startedOnPage = e.target instanceof Element && e.target.closest(PAGE_SELECTOR) !== null\n      touchSelecting = startedOnPage && e.pointerType === 'touch'\n    }\n\n    const onUp = (e: PointerEvent) => {\n      if (!startedOnPage || !TEXT_TOOLS.includes(latest.current.tool)) return\n      startedOnPage = false\n      const selection = pagesDoc.getSelection()\n      if (selection && e.pointerType === 'mouse') {\n        extendFocusToPointer(selection, { x: e.clientX, y: e.clientY })\n      }\n      // Let the browser finish updating the selection for this gesture first.\n      let last = selection?.toString() ?? ''\n      let stable = 0\n      let rounds = 0\n      const check = () => {\n        const now = pagesDoc.getSelection()?.toString() ?? ''\n        if (now === last) stable++\n        else {\n          last = now\n          stable = 0\n        }\n        if (stable >= STABLE_CHECKS || ++rounds >= MAX_SETTLE_ROUNDS) {\n          if (markSelection()) touchSelecting = false\n          return\n        }\n        settleTimers.add(setTimeout(check, MOUSE_SETTLE_MS))\n      }\n      settleTimers.add(setTimeout(check, MOUSE_SETTLE_MS))\n    }\n\n    const onSelectionChange = () => {\n      if (!touchSelecting || !TEXT_TOOLS.includes(latest.current.tool)) return\n      clearTimeout(settleTimer)\n      settleTimer = setTimeout(() => {\n        if (markSelection()) touchSelecting = false\n      }, TOUCH_SETTLE_MS)\n    }\n\n    pagesDoc.addEventListener('pointerdown', onDown, true)\n    pagesDoc.addEventListener('pointerup', onUp, true)\n    pagesDoc.addEventListener('selectionchange', onSelectionChange)\n    return () => {\n      clearTimeout(settleTimer)\n      settleTimers.forEach(clearTimeout)\n      pagesDoc.removeEventListener('pointerdown', onDown, true)\n      pagesDoc.removeEventListener('pointerup', onUp, true)\n      pagesDoc.removeEventListener('selectionchange', onSelectionChange)\n    }\n  }, [pagesDoc])\n}\n"],
+  "mappings": "AAWA,SAAS,WAAW,cAAc;AAClC,SAAS,0BAA0B;AACnC,SAAS,kBAA2D;AACpE,SAAS,sBAAsB,eAAe,4BAA4B;AAE1E,MAAM,gBAAgB;AAGf,MAAM,kBAAkB;AASxB,MAAM,kBAAkB;AACxB,MAAM,gBAAgB;AACtB,MAAM,oBAAoB;AAE1B,SAAS,sBAAsB,YAAkC;AACtE,QAAM,SAAS,OAAO,UAAU;AAChC,SAAO,UAAU;AAGjB,QAAM,WAAW,mBAAmB,GAAG,iBAAiB;AAExD,YAAU,MAAM;AACd,QAAI,gBAAgB;AACpB,QAAI,iBAAiB;AACrB,QAAI;AACJ,UAAM,eAAe,oBAAI,IAAmC;AAG5D,UAAM,gBAAgB,MAAe;AACnC,YAAM,IAAI,OAAO;AACjB,YAAM,YAAY,SAAS,aAAa;AACxC,UAAI,CAAC,aAAa,CAAC,WAAW,SAAS,EAAE,IAAI,EAAG,QAAO;AACvD,YAAM,QAAQ,qBAAqB,cAAc,WAAW,QAAQ,CAAC;AACrE,UAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,YAAM,QAAmB,MAAM;AAAA,QAAI,CAAC,MAClC,EAAE,SAAS,cACP;AAAA,UACE,MAAM;AAAA,UACN,MAAM,EAAE;AAAA,UACR,OAAO,EAAE;AAAA,UACT,OAAO,EAAE,SAAS,OAAO;AAAA,UACzB,MAAM,EAAE;AAAA,QACV,IACA;AAAA,UACE,MAAM;AAAA,UACN,MAAM,EAAE;AAAA,UACR,OAAO,EAAE;AAAA,UACT,QAAQ,EAAE,SAAS;AAAA,UACnB,MAAM,EAAE;AAAA,UACR,QAAQ;AAAA,QACV;AAAA,MACN;AACA,UAAI,EAAE,QAAQ,KAAK,EAAE,WAAW,EAAG,QAAO;AAC1C,gBAAU,gBAAgB;AAC1B,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,CAAC,MAAoB;AAClC,sBAAgB,EAAE,kBAAkB,WAAW,EAAE,OAAO,QAAQ,aAAa,MAAM;AACnF,uBAAiB,iBAAiB,EAAE,gBAAgB;AAAA,IACtD;AAEA,UAAM,OAAO,CAAC,MAAoB;AAChC,UAAI,CAAC,iBAAiB,CAAC,WAAW,SAAS,OAAO,QAAQ,IAAI,EAAG;AACjE,sBAAgB;AAChB,YAAM,YAAY,SAAS,aAAa;AACxC,UAAI,aAAa,EAAE,gBAAgB,SAAS;AAC1C,6BAAqB,WAAW,EAAE,GAAG,EAAE,SAAS,GAAG,EAAE,QAAQ,CAAC;AAAA,MAChE;AAEA,UAAI,OAAO,WAAW,SAAS,KAAK;AACpC,UAAI,SAAS;AACb,UAAI,SAAS;AACb,YAAM,QAAQ,MAAM;AAClB,cAAM,MAAM,SAAS,aAAa,GAAG,SAAS,KAAK;AACnD,YAAI,QAAQ,KAAM;AAAA,aACb;AACH,iBAAO;AACP,mBAAS;AAAA,QACX;AACA,YAAI,UAAU,iBAAiB,EAAE,UAAU,mBAAmB;AAC5D,cAAI,cAAc,EAAG,kBAAiB;AACtC;AAAA,QACF;AACA,qBAAa,IAAI,WAAW,OAAO,eAAe,CAAC;AAAA,MACrD;AACA,mBAAa,IAAI,WAAW,OAAO,eAAe,CAAC;AAAA,IACrD;AAEA,UAAM,oBAAoB,MAAM;AAC9B,UAAI,CAAC,kBAAkB,CAAC,WAAW,SAAS,OAAO,QAAQ,IAAI,EAAG;AAClE,mBAAa,WAAW;AACxB,oBAAc,WAAW,MAAM;AAC7B,YAAI,cAAc,EAAG,kBAAiB;AAAA,MACxC,GAAG,eAAe;AAAA,IACpB;AAEA,aAAS,iBAAiB,eAAe,QAAQ,IAAI;AACrD,aAAS,iBAAiB,aAAa,MAAM,IAAI;AACjD,aAAS,iBAAiB,mBAAmB,iBAAiB;AAC9D,WAAO,MAAM;AACX,mBAAa,WAAW;AACxB,mBAAa,QAAQ,YAAY;AACjC,eAAS,oBAAoB,eAAe,QAAQ,IAAI;AACxD,eAAS,oBAAoB,aAAa,MAAM,IAAI;AACpD,eAAS,oBAAoB,mBAAmB,iBAAiB;AAAA,IACnE;AAAA,EACF,GAAG,CAAC,QAAQ,CAAC;AACf;",
+  "names": []
+}

package/dist/artifacts/artifact-kind.js

@@ -0,0 +1,19 @@
+function artifactKindFromFileName(fileName) {
+  const ext = (fileName ?? "").toLowerCase().match(/\.[a-z0-9]+$/)?.[0];
+  if (ext === ".html" || ext === ".htm") return "html";
+  if (ext === ".jsx") return "react";
+  return null;
+}
+function artifactKindFromMode(mode) {
+  return mode === "html" || mode === "react" ? mode : null;
+}
+function viewerTabForArtifactMode(mode) {
+  if (mode === "image") return "pdf";
+  return artifactKindFromMode(mode) ? "preview" : "edit";
+}
+export {
+  artifactKindFromFileName,
+  artifactKindFromMode,
+  viewerTabForArtifactMode
+};
+//# sourceMappingURL=artifact-kind.js.map

package/dist/artifacts/artifact-kind.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/artifacts/artifact-kind.ts"],
+  "sourcesContent": ["/**\n * Which live renderer, if any, an artifact maps to. Kept free of heavy imports (no compiler) so the\n * document viewer can use it without pulling the preview code into its bundle.\n *\n * The backend persists an artifact's render mode in the saved file's extension: .html / .jsx are live\n * artifacts; document drafts are stored as .docx and open in the Word editor.\n */\nexport type ArtifactPreviewKind = 'html' | 'react'\n\nexport function artifactKindFromFileName(fileName?: string | null): ArtifactPreviewKind | null {\n  const ext = (fileName ?? '').toLowerCase().match(/\\.[a-z0-9]+$/)?.[0]\n  if (ext === '.html' || ext === '.htm') return 'html'\n  if (ext === '.jsx') return 'react'\n  return null\n}\n\nexport function artifactKindFromMode(mode?: string | null): ArtifactPreviewKind | null {\n  return mode === 'html' || mode === 'react' ? mode : null\n}\n\n/**\n * The viewer tab an artifact opens on: a generated image on its media view ('pdf'), an html/react\n * artifact on its rendered Preview, and a document draft (stored as .docx) in the Word editor.\n */\nexport function viewerTabForArtifactMode(mode?: string | null): 'pdf' | 'preview' | 'edit' {\n  if (mode === 'image') return 'pdf'\n  return artifactKindFromMode(mode) ? 'preview' : 'edit'\n}\n"],
+  "mappings": "AASO,SAAS,yBAAyB,UAAsD;AAC7F,QAAM,OAAO,YAAY,IAAI,YAAY,EAAE,MAAM,cAAc,IAAI,CAAC;AACpE,MAAI,QAAQ,WAAW,QAAQ,OAAQ,QAAO;AAC9C,MAAI,QAAQ,OAAQ,QAAO;AAC3B,SAAO;AACT;AAEO,SAAS,qBAAqB,MAAkD;AACrF,SAAO,SAAS,UAAU,SAAS,UAAU,OAAO;AACtD;AAMO,SAAS,yBAAyB,MAAkD;AACzF,MAAI,SAAS,QAAS,QAAO;AAC7B,SAAO,qBAAqB,IAAI,IAAI,YAAY;AAClD;",
+  "names": []
+}