@abraca/nuxt 1.9.1 → 2.0.1

package/dist/runtime/composables/useResizableWidth.js

@@ -0,0 +1,87 @@
+import { ref, computed, onBeforeUnmount } from "vue";
+import { useCookie } from "#imports";
+export function useResizableWidth(options = {}) {
+  const defaultWidth = options.defaultWidth ?? 672;
+  const minWidth = options.minWidth ?? 320;
+  const maxFraction = options.maxFraction ?? 0.9;
+  const direction = options.direction ?? "left";
+  const sign = direction === "left" ? 1 : -1;
+  const cookie = options.cookieKey ? useCookie(options.cookieKey, { default: () => defaultWidth }) : null;
+  const width = ref(cookie?.value ?? defaultWidth);
+  const isResizing = ref(false);
+  let startX = 0;
+  let startWidth = 0;
+  function clamp(px) {
+    if (!import.meta.client) return px;
+    const maxW = window.innerWidth * maxFraction;
+    return Math.min(maxW, Math.max(minWidth, px));
+  }
+  function persist() {
+    if (cookie) cookie.value = width.value;
+  }
+  function onMouseDown(e) {
+    startX = e.clientX;
+    startWidth = width.value;
+    isResizing.value = true;
+    document.body.style.cursor = "col-resize";
+    document.body.style.userSelect = "none";
+    document.addEventListener("mousemove", onMouseMove);
+    document.addEventListener("mouseup", onMouseUp, { once: true });
+  }
+  function onMouseMove(e) {
+    width.value = clamp(startWidth + sign * (startX - e.clientX));
+  }
+  function onMouseUp() {
+    document.removeEventListener("mousemove", onMouseMove);
+    document.body.style.cursor = "";
+    document.body.style.userSelect = "";
+    isResizing.value = false;
+    persist();
+  }
+  function onTouchStart(e) {
+    const t = e.touches[0];
+    if (!t) return;
+    startX = t.clientX;
+    startWidth = width.value;
+    isResizing.value = true;
+    document.body.style.userSelect = "none";
+    document.addEventListener("touchmove", onTouchMove);
+    document.addEventListener("touchend", onTouchEnd, { once: true });
+  }
+  function onTouchMove(e) {
+    const t = e.touches[0];
+    if (!t) return;
+    width.value = clamp(startWidth + sign * (startX - t.clientX));
+  }
+  function onTouchEnd() {
+    document.removeEventListener("touchmove", onTouchMove);
+    document.body.style.userSelect = "";
+    isResizing.value = false;
+    persist();
+  }
+  function onDoubleClick() {
+    width.value = defaultWidth;
+    persist();
+  }
+  function reset() {
+    width.value = defaultWidth;
+    persist();
+  }
+  const style = computed(() => ({
+    maxWidth: `min(${width.value}px, ${maxFraction * 100}vw)`,
+    width: `min(${width.value}px, ${maxFraction * 100}vw)`
+  }));
+  onBeforeUnmount(() => {
+    document.removeEventListener("mousemove", onMouseMove);
+    document.removeEventListener("touchmove", onTouchMove);
+  });
+  return {
+    width,
+    isResizing,
+    style,
+    onMouseDown,
+    onTouchStart,
+    onDoubleClick,
+    reset
+  };
+}

package/dist/runtime/composables/useServerInfo.d.ts

@@ -7,16 +7,25 @@
  * Usage:
  *   const { serverName, serverVersion, healthy, iceServers, refresh } = useServerInfo()
  */
+import type { ReadyzStatus } from '@abraca/dabra';
 export declare function _initServerInfo(client: any): void;
 export declare function _destroyServerInfo(): void;
 declare function refresh(): Promise<void>;
+/**
+ * Hit `/readyz` — the deep-readiness endpoint. HTTP 200 → status `ready`,
+ * HTTP 503 → status `unready`. The SDK normalizes both into
+ * {@link ReadyzStatus} rather than throwing on 503, since 503 is a valid
+ * "not ready yet" answer (mid-startup, DB pinging, etc.). The last result
+ * stays in `readiness` until the next call.
+ */
+declare function checkReadiness(): Promise<ReadyzStatus | null>;
 export declare function useServerInfo(): {
     /** Server display name. */
     serverName: import("vue").Ref<string | null, string | null>;
     /** Server version string. */
     serverVersion: import("vue").Ref<string | null, string | null>;
-    /** Root/index document ID from server. */
-    indexDocId: import("vue").Ref<string | null, string | null>;
+    /** Reserved server-root document ID. */
+    rootDocId: import("vue").Ref<string | null, string | null>;
     /** Whether the server is healthy. */
     healthy: import("vue").Ref<boolean, boolean>;
     /** ICE servers from server (STUN/TURN). */
@@ -25,7 +34,13 @@ export declare function useServerInfo(): {
     loading: import("vue").Ref<boolean, boolean>;
     /** Last error message. */
     error: import("vue").Ref<string | null, string | null>;
+    /** Last `/readyz` result, or null. */
+    readiness: import("vue").ShallowRef<ReadyzStatus | null, ReadyzStatus | null>;
+    /** Whether a `checkReadiness()` is in flight. */
+    checkingReadiness: import("vue").Ref<boolean, boolean>;
     /** Re-fetch server info. */
     refresh: typeof refresh;
+    /** Hit `/readyz` and update `readiness`. Returns the status (or null on failure). */
+    checkReadiness: typeof checkReadiness;
 };
 export {};

package/dist/runtime/composables/useServerInfo.js

@@ -1,11 +1,13 @@
 import { ref, shallowRef } from "vue";
 const serverName = ref(null);
 const serverVersion = ref(null);
-const indexDocId = ref(null);
+const rootDocId = ref(null);
 const healthy = ref(false);
 const iceServers = shallowRef([]);
 const loading = ref(false);
 const error = ref(null);
+const readiness = shallowRef(null);
+const checkingReadiness = ref(false);
 let _fetched = false;
 let _client = null;
 export function _initServerInfo(client) {
@@ -18,10 +20,12 @@ export function _destroyServerInfo() {
   _fetched = false;
   serverName.value = null;
   serverVersion.value = null;
-  indexDocId.value = null;
+  rootDocId.value = null;
   healthy.value = false;
   iceServers.value = [];
   error.value = null;
+  readiness.value = null;
+  checkingReadiness.value = false;
 }
 async function _fetchAll() {
   if (!_client || loading.value) return;
@@ -40,7 +44,7 @@ async function _fetchAll() {
       const info = infoResult.value;
       serverName.value = info?.name ?? null;
       serverVersion.value = info?.version ?? null;
-      indexDocId.value = info?.index_doc_id ?? null;
+      rootDocId.value = info?.root_doc_id ?? null;
     }
     if (iceResult.status === "fulfilled") {
       iceServers.value = iceResult.value ?? [];
@@ -55,6 +59,20 @@ async function _fetchAll() {
 async function refresh() {
   await _fetchAll();
 }
+async function checkReadiness() {
+  if (!_client) return null;
+  checkingReadiness.value = true;
+  try {
+    const result = await _client.readyz();
+    readiness.value = result;
+    return result;
+  } catch (e) {
+    error.value = e?.message ?? "Failed to check readiness";
+    return null;
+  } finally {
+    checkingReadiness.value = false;
+  }
+}
 export function useServerInfo() {
   if (!_fetched && _client && !loading.value) {
     _fetchAll();
@@ -64,8 +82,8 @@ export function useServerInfo() {
     serverName,
     /** Server version string. */
     serverVersion,
-    /** Root/index document ID from server. */
-    indexDocId,
+    /** Reserved server-root document ID. */
+    rootDocId,
     /** Whether the server is healthy. */
     healthy,
     /** ICE servers from server (STUN/TURN). */
@@ -74,7 +92,13 @@ export function useServerInfo() {
     loading,
     /** Last error message. */
     error,
+    /** Last `/readyz` result, or null. */
+    readiness,
+    /** Whether a `checkReadiness()` is in flight. */
+    checkingReadiness,
     /** Re-fetch server info. */
-    refresh
+    refresh,
+    /** Hit `/readyz` and update `readiness`. Returns the status (or null on failure). */
+    checkReadiness
   };
 }

package/dist/runtime/composables/useServerSearch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * useServerSearch
+ *
+ * Server-side full-text document search. Wraps `client.searchDocs`
+ * (FTS5 on SQLite, tsvector on Postgres). Distinct from
+ * `useDocsSearch` (vendored Nuxt UI docs-site search) and
+ * `useSearchIndex` (client-side IDB trigram index).
+ *
+ * Usage:
+ *   const { results, isSearching, error, search, cancel } = useServerSearch()
+ *   await search('query string', { limit: 20 })
+ */
+import type { DocSearchHit } from '@abraca/dabra';
+declare function cancel(): void;
+declare function search(query: string, opts?: {
+    limit?: number;
+    debounceMs?: number;
+}): Promise<DocSearchHit[]>;
+declare function clear(): void;
+export declare function useServerSearch(): {
+    /** Latest hits (best-first). Empty until `search()` resolves. */
+    results: import("vue").ShallowRef<DocSearchHit[], DocSearchHit[]>;
+    /** Whether a request is in flight. */
+    isSearching: import("vue").Ref<boolean, boolean>;
+    /** Last error message, or null. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** The query string currently driving `results`. */
+    lastQuery: import("vue").Ref<string, string>;
+    /** Run a search. Debounced; consecutive calls cancel earlier ones. */
+    search: typeof search;
+    /** Cancel any in-flight or debounced query. */
+    cancel: typeof cancel;
+    /** Clear results + last error + cancel anything pending. */
+    clear: typeof clear;
+};
+export {};

package/dist/runtime/composables/useServerSearch.js

@@ -0,0 +1,91 @@
+import { ref, shallowRef } from "vue";
+import { useAbracadabra } from "#imports";
+const DEFAULT_DEBOUNCE_MS = 200;
+const results = shallowRef([]);
+const isSearching = ref(false);
+const error = ref(null);
+const lastQuery = ref("");
+let _aborter = null;
+let _debounceTimer = null;
+function cancel() {
+  if (_debounceTimer) {
+    clearTimeout(_debounceTimer);
+    _debounceTimer = null;
+  }
+  if (_aborter) {
+    _aborter.abort();
+    _aborter = null;
+  }
+  isSearching.value = false;
+}
+async function _runSearch(query, opts = {}) {
+  const abra = useAbracadabra();
+  if (!abra.client.value) {
+    results.value = [];
+    return [];
+  }
+  cancel();
+  const aborter = new AbortController();
+  _aborter = aborter;
+  isSearching.value = true;
+  error.value = null;
+  lastQuery.value = query;
+  try {
+    const hits = await abra.client.value.searchDocs(query, { limit: opts.limit });
+    if (aborter.signal.aborted) return [];
+    results.value = hits;
+    return hits;
+  } catch (e) {
+    if (aborter.signal.aborted) return [];
+    error.value = e instanceof Error ? e.message : "Search failed";
+    results.value = [];
+    return [];
+  } finally {
+    if (_aborter === aborter) {
+      _aborter = null;
+      isSearching.value = false;
+    }
+  }
+}
+function search(query, opts = {}) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    cancel();
+    results.value = [];
+    lastQuery.value = "";
+    return Promise.resolve([]);
+  }
+  const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  if (debounceMs <= 0) return _runSearch(trimmed, opts);
+  if (_debounceTimer) clearTimeout(_debounceTimer);
+  return new Promise((resolve) => {
+    _debounceTimer = setTimeout(() => {
+      _debounceTimer = null;
+      _runSearch(trimmed, opts).then(resolve);
+    }, debounceMs);
+  });
+}
+function clear() {
+  cancel();
+  results.value = [];
+  lastQuery.value = "";
+  error.value = null;
+}
+export function useServerSearch() {
+  return {
+    /** Latest hits (best-first). Empty until `search()` resolves. */
+    results,
+    /** Whether a request is in flight. */
+    isSearching,
+    /** Last error message, or null. */
+    error,
+    /** The query string currently driving `results`. */
+    lastQuery,
+    /** Run a search. Debounced; consecutive calls cancel earlier ones. */
+    search,
+    /** Cancel any in-flight or debounced query. */
+    cancel,
+    /** Clear results + last error + cancel anything pending. */
+    clear
+  };
+}

package/dist/runtime/composables/useServerTrash.d.ts

@@ -0,0 +1,67 @@
+/**
+ * useServerTrash
+ *
+ * Server-side soft-delete (K-A) trash drawer. Distinct from the Y.Map-based
+ * client trash in `useTrash`: this one talks to the REST API. Wraps
+ * `client.restoreDoc(id)` and tracks ids the local user has soft-deleted
+ * (via `trackDeletion`) in localStorage so the drawer has something to
+ * show until a `GET /docs?include_deleted=true` endpoint lands.
+ *
+ * Usage:
+ *   const { items, refresh, trackDeletion, restore, forget } = useServerTrash()
+ *   await client.deleteDoc(id); trackDeletion(id, meta)
+ *   await restore(id)
+ */
+import type { DocumentMeta } from '@abraca/dabra';
+export interface ServerTrashEntry {
+    id: string;
+    label: string;
+    parent_id: string | null;
+    kind: string | null;
+    /** When the local user soft-deleted this doc (epoch ms). */
+    deletedAt: number;
+}
+declare function refresh(): Promise<void>;
+declare function trackDeletion(id: string, meta?: {
+    label?: string | null;
+    parent_id?: string | null;
+    kind?: string | null;
+}): void;
+declare function forget(id: string): void;
+declare function restore(id: string): Promise<void>;
+declare function purgeExpired(): Promise<void>;
+export declare function useServerTrash(): {
+    /** Doc metadata for tracked soft-deleted docs (refreshed via `refresh()`). */
+    items: import("vue").ShallowRef<DocumentMeta[], DocumentMeta[]>;
+    /** Local tracking entries (id + cached label, deletedAt). */
+    tracked: import("vue").Ref<{
+        id: string;
+        label: string;
+        parent_id: string | null;
+        kind: string | null;
+        deletedAt: number;
+    }[], ServerTrashEntry[] | {
+        id: string;
+        label: string;
+        parent_id: string | null;
+        kind: string | null;
+        deletedAt: number;
+    }[]>;
+    /** Convenience count. */
+    count: import("vue").ComputedRef<number>;
+    /** Whether `refresh()` is in flight. */
+    isLoading: import("vue").Ref<boolean, boolean>;
+    /** Last error message, or null. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** Re-fetch metadata for every tracked id. Drops entries that 404. */
+    refresh: typeof refresh;
+    /** Record a doc the local user just soft-deleted. */
+    trackDeletion: typeof trackDeletion;
+    /** Forget a tracked entry without restoring (e.g. after permanent delete). */
+    forget: typeof forget;
+    /** Restore a soft-deleted doc and forget the tracking entry. */
+    restore: typeof restore;
+    /** Drop tracked entries older than the retention window (30 days). */
+    purgeExpired: typeof purgeExpired;
+};
+export {};

package/dist/runtime/composables/useServerTrash.js

@@ -0,0 +1,128 @@
+import { computed, ref, shallowRef } from "vue";
+import { useAbracadabra } from "#imports";
+const STORAGE_KEY = "abracadabra_server_trash";
+const RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+const tracked = ref([]);
+const items = shallowRef([]);
+const isLoading = ref(false);
+const error = ref(null);
+let _hydrated = false;
+function loadTracked() {
+  if (typeof localStorage === "undefined") return [];
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    const cutoff = Date.now() - RETENTION_MS;
+    return parsed.filter((e) => e?.id && e.deletedAt > cutoff);
+  } catch {
+    return [];
+  }
+}
+function saveTracked(entries) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(entries));
+  } catch {
+  }
+}
+async function refresh() {
+  const abra = useAbracadabra();
+  const client = abra.client.value;
+  if (!client) {
+    items.value = [];
+    return;
+  }
+  if (!_hydrated) {
+    tracked.value = loadTracked();
+    _hydrated = true;
+  }
+  isLoading.value = true;
+  error.value = null;
+  try {
+    const next = [];
+    const stillValid = [];
+    for (const entry of tracked.value) {
+      try {
+        const meta = await client.getDoc(entry.id);
+        next.push(meta);
+        stillValid.push(entry);
+      } catch {
+      }
+    }
+    items.value = next;
+    if (stillValid.length !== tracked.value.length) {
+      tracked.value = stillValid;
+      saveTracked(stillValid);
+    }
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to load trash";
+  } finally {
+    isLoading.value = false;
+  }
+}
+function trackDeletion(id, meta) {
+  if (!_hydrated) {
+    tracked.value = loadTracked();
+    _hydrated = true;
+  }
+  const without = tracked.value.filter((e) => e.id !== id);
+  const entry = {
+    id,
+    label: meta?.label ?? "Untitled",
+    parent_id: meta?.parent_id ?? null,
+    kind: meta?.kind ?? null,
+    deletedAt: Date.now()
+  };
+  tracked.value = [entry, ...without];
+  saveTracked(tracked.value);
+}
+function forget(id) {
+  tracked.value = tracked.value.filter((e) => e.id !== id);
+  items.value = items.value.filter((m) => m.id !== id);
+  saveTracked(tracked.value);
+}
+async function restore(id) {
+  const abra = useAbracadabra();
+  const client = abra.client.value;
+  if (!client) throw new Error("Not connected");
+  await client.restoreDoc(id);
+  forget(id);
+}
+async function purgeExpired() {
+  const cutoff = Date.now() - RETENTION_MS;
+  const next = tracked.value.filter((e) => e.deletedAt > cutoff);
+  if (next.length === tracked.value.length) return;
+  tracked.value = next;
+  saveTracked(next);
+  await refresh();
+}
+export function useServerTrash() {
+  if (!_hydrated && typeof window !== "undefined") {
+    tracked.value = loadTracked();
+    _hydrated = true;
+  }
+  return {
+    /** Doc metadata for tracked soft-deleted docs (refreshed via `refresh()`). */
+    items,
+    /** Local tracking entries (id + cached label, deletedAt). */
+    tracked,
+    /** Convenience count. */
+    count: computed(() => items.value.length),
+    /** Whether `refresh()` is in flight. */
+    isLoading,
+    /** Last error message, or null. */
+    error,
+    /** Re-fetch metadata for every tracked id. Drops entries that 404. */
+    refresh,
+    /** Record a doc the local user just soft-deleted. */
+    trackDeletion,
+    /** Forget a tracked entry without restoring (e.g. after permanent delete). */
+    forget,
+    /** Restore a soft-deleted doc and forget the tracking entry. */
+    restore,
+    /** Drop tracked entries older than the retention window (30 days). */
+    purgeExpired
+  };
+}

package/dist/runtime/composables/useSheetsClipboard.d.ts

@@ -0,0 +1,42 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { CellAddress, SelectionRange } from './useSheetsSelection.js';
+/**
+ * Manages clipboard operations (copy, cut, paste) for the sheets renderer.
+ * Integrates with the system clipboard using TSV format (compatible with Excel/Google Sheets).
+ */
+export declare function useSheetsClipboard(opts: {
+    activeCell: Ref<CellAddress | null>;
+    normalizedRange: ComputedRef<SelectionRange | null>;
+    getCellValue: (colIdx: number, rowIdx: number) => string;
+    commitCellValue: (colIdx: number, rowIdx: number, value: string) => void;
+    /** Write a cell without triggering formula recalc (for batch ops). Falls back to commitCellValue. */
+    writeCellValue?: (colIdx: number, rowIdx: number, value: string) => void;
+    clearCell: (colIdx: number, rowIdx: number) => void;
+    /** Clear a cell without triggering formula recalc (for batch ops). Falls back to clearCell. */
+    clearCellValue?: (colIdx: number, rowIdx: number) => void;
+    transact: (fn: () => void) => void;
+    /** Recalculate all formulas (called once after batch operations). */
+    recalcFormulas?: () => void;
+    /** Called after a mutating clipboard action (paste, cut-paste) settles.
+     *  Use this to close the undo captureTimeout so the action becomes one undo step. */
+    onCommit?: () => void;
+}): {
+    cutRange: Ref<{
+        startCol: number;
+        startRow: number;
+        endCol: number;
+        endRow: number;
+    } | null, SelectionRange | {
+        startCol: number;
+        startRow: number;
+        endCol: number;
+        endRow: number;
+    } | null>;
+    copy: () => Promise<void>;
+    cut: () => Promise<void>;
+    paste: () => Promise<void>;
+    pasteText: (text: string) => void;
+    onPaste: (e: ClipboardEvent) => void;
+    onCopy: (e: ClipboardEvent) => void;
+    onCut: (e: ClipboardEvent) => void;
+};

package/dist/runtime/composables/useSheetsClipboard.js

@@ -0,0 +1,109 @@
+import { ref } from "vue";
+export function useSheetsClipboard(opts) {
+  const cutRange = ref(null);
+  function getEffectiveRange() {
+    const r = opts.normalizedRange.value;
+    if (r) return r;
+    const a = opts.activeCell.value;
+    if (!a) return null;
+    return { startCol: a.colIdx, startRow: a.rowIdx, endCol: a.colIdx, endRow: a.rowIdx };
+  }
+  function buildTSV(range) {
+    const rows = [];
+    for (let r = range.startRow; r <= range.endRow; r++) {
+      const cells = [];
+      for (let c = range.startCol; c <= range.endCol; c++) {
+        cells.push(opts.getCellValue(c, r));
+      }
+      rows.push(cells.join("	"));
+    }
+    return rows.join("\n");
+  }
+  async function copy() {
+    const range = getEffectiveRange();
+    if (!range) return;
+    const tsv = buildTSV(range);
+    cutRange.value = null;
+    try {
+      await navigator.clipboard.writeText(tsv);
+    } catch {
+    }
+  }
+  async function cut() {
+    const range = getEffectiveRange();
+    if (!range) return;
+    const tsv = buildTSV(range);
+    cutRange.value = { ...range };
+    try {
+      await navigator.clipboard.writeText(tsv);
+    } catch {
+    }
+  }
+  function pasteText(text) {
+    const anchor = opts.activeCell.value;
+    if (!anchor) return;
+    const rows = text.split("\n").filter((line) => line.length > 0);
+    const parsed = rows.map((row) => row.split("	"));
+    const write = opts.writeCellValue ?? opts.commitCellValue;
+    const clear = opts.clearCellValue ?? opts.clearCell;
+    opts.transact(() => {
+      if (cutRange.value) {
+        const cr = cutRange.value;
+        for (let c = cr.startCol; c <= cr.endCol; c++) {
+          for (let r = cr.startRow; r <= cr.endRow; r++) {
+            clear(c, r);
+          }
+        }
+        cutRange.value = null;
+      }
+      for (let r = 0; r < parsed.length; r++) {
+        const row = parsed[r];
+        for (let c = 0; c < row.length; c++) {
+          const value = row[c];
+          write(anchor.colIdx + c, anchor.rowIdx + r, value);
+        }
+      }
+      opts.recalcFormulas?.();
+    });
+    opts.onCommit?.();
+  }
+  async function paste() {
+    try {
+      const text = await navigator.clipboard.readText();
+      if (text) pasteText(text);
+    } catch {
+    }
+  }
+  function onPaste(e) {
+    if (!opts.activeCell.value) return;
+    e.preventDefault();
+    const text = e.clipboardData?.getData("text/plain");
+    if (text) pasteText(text);
+  }
+  function onCopy(e) {
+    const range = getEffectiveRange();
+    if (!range) return;
+    e.preventDefault();
+    const tsv = buildTSV(range);
+    e.clipboardData?.setData("text/plain", tsv);
+    cutRange.value = null;
+  }
+  function onCut(e) {
+    const range = getEffectiveRange();
+    if (!range) return;
+    e.preventDefault();
+    const tsv = buildTSV(range);
+    e.clipboardData?.setData("text/plain", tsv);
+    cutRange.value = { ...range };
+  }
+  return {
+    cutRange,
+    copy,
+    cut,
+    paste,
+    pasteText,
+    onPaste,
+    onCopy,
+    onCut
+  };
+}