@abraca/nuxt 0.2.0 → 0.3.0

package/dist/runtime/composables/useFileTransfer.js

@@ -0,0 +1,171 @@
+import { ref, shallowRef } from "vue";
+const inboundTransfers = shallowRef(/* @__PURE__ */ new Map());
+const outboundTransfers = shallowRef(/* @__PURE__ */ new Map());
+const completedFiles = ref([]);
+const _unbinds = [];
+export function _wireFileTransferEvents(rtc) {
+  _cleanupFileTransfer();
+  const on = (event, handler) => {
+    rtc.on(event, handler);
+    _unbinds.push(() => rtc.off(event, handler));
+  };
+  on("fileReceiveStart", (data) => {
+    const next = new Map(inboundTransfers.value);
+    next.set(data.transferId, {
+      transferId: data.transferId,
+      peerId: data.peerId,
+      filename: data.filename ?? "unknown",
+      mimeType: data.mimeType ?? "application/octet-stream",
+      totalSize: data.totalSize ?? 0,
+      progress: 0,
+      status: "receiving"
+    });
+    inboundTransfers.value = next;
+  });
+  on("fileReceiveProgress", (data) => {
+    const existing = inboundTransfers.value.get(data.transferId);
+    if (existing) {
+      const next = new Map(inboundTransfers.value);
+      next.set(data.transferId, {
+        ...existing,
+        progress: data.total > 0 ? data.received / data.total : 0
+      });
+      inboundTransfers.value = next;
+    }
+  });
+  on("fileReceiveComplete", (data) => {
+    const next = new Map(inboundTransfers.value);
+    next.delete(data.transferId);
+    inboundTransfers.value = next;
+    const objectUrl = URL.createObjectURL(data.blob);
+    completedFiles.value = [
+      ...completedFiles.value,
+      {
+        transferId: data.transferId,
+        peerId: data.peerId ?? "",
+        filename: data.filename ?? "unknown",
+        mimeType: data.mimeType ?? "application/octet-stream",
+        size: data.blob?.size ?? 0,
+        blob: data.blob,
+        objectUrl,
+        receivedAt: Date.now()
+      }
+    ];
+  });
+  on("fileReceiveError", (data) => {
+    const existing = inboundTransfers.value.get(data.transferId);
+    if (existing) {
+      const next = new Map(inboundTransfers.value);
+      next.set(data.transferId, { ...existing, status: "error" });
+      inboundTransfers.value = next;
+    }
+  });
+  on("fileReceiveCancelled", (data) => {
+    const next = new Map(inboundTransfers.value);
+    next.delete(data.transferId);
+    inboundTransfers.value = next;
+  });
+}
+function _cleanupFileTransfer() {
+  for (const unsub of _unbinds) unsub();
+  _unbinds.length = 0;
+}
+export function _destroyFileTransfer() {
+  _cleanupFileTransfer();
+  inboundTransfers.value = /* @__PURE__ */ new Map();
+  outboundTransfers.value = /* @__PURE__ */ new Map();
+  for (const file of completedFiles.value) {
+    try {
+      URL.revokeObjectURL(file.objectUrl);
+    } catch {
+    }
+  }
+  completedFiles.value = [];
+}
+async function sendFile(peerId, file, filename) {
+  const { sendFile: rtcSendFile } = useWebRTC();
+  const transferId = crypto.randomUUID();
+  const next = new Map(outboundTransfers.value);
+  next.set(transferId, {
+    transferId,
+    peerId,
+    filename,
+    mimeType: file.type || "application/octet-stream",
+    totalSize: file.size,
+    progress: 0,
+    status: "sending"
+  });
+  outboundTransfers.value = next;
+  try {
+    const handle = await rtcSendFile(peerId, file, filename);
+    if (handle) {
+      handle.on?.("progress", (p) => {
+        const existing = outboundTransfers.value.get(transferId);
+        if (existing) {
+          const updated = new Map(outboundTransfers.value);
+          updated.set(transferId, { ...existing, progress: p });
+          outboundTransfers.value = updated;
+        }
+      });
+      handle.on?.("complete", () => {
+        const updated = new Map(outboundTransfers.value);
+        const existing = updated.get(transferId);
+        if (existing) updated.set(transferId, { ...existing, status: "complete", progress: 1 });
+        outboundTransfers.value = updated;
+      });
+      handle.on?.("error", () => {
+        const updated = new Map(outboundTransfers.value);
+        const existing = updated.get(transferId);
+        if (existing) updated.set(transferId, { ...existing, status: "error" });
+        outboundTransfers.value = updated;
+      });
+    }
+  } catch {
+    const updated = new Map(outboundTransfers.value);
+    const existing = updated.get(transferId);
+    if (existing) updated.set(transferId, { ...existing, status: "error" });
+    outboundTransfers.value = updated;
+  }
+}
+function downloadFile(transferId) {
+  const file = completedFiles.value.find((f) => f.transferId === transferId);
+  if (!file) return;
+  const a = document.createElement("a");
+  a.href = file.objectUrl;
+  a.download = file.filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+}
+function clearCompleted() {
+  for (const file of completedFiles.value) {
+    try {
+      URL.revokeObjectURL(file.objectUrl);
+    } catch {
+    }
+  }
+  completedFiles.value = [];
+  const next = /* @__PURE__ */ new Map();
+  for (const [id, transfer] of outboundTransfers.value) {
+    if (transfer.status !== "complete" && transfer.status !== "error") {
+      next.set(id, transfer);
+    }
+  }
+  outboundTransfers.value = next;
+}
+export function useFileTransfer() {
+  return {
+    /** Active inbound file transfers. */
+    inboundTransfers,
+    /** Active outbound file transfers. */
+    outboundTransfers,
+    /** Completed received files (with object URLs for download). */
+    completedFiles,
+    /** Send a file to a specific peer. */
+    sendFile,
+    /** Trigger browser download for a completed file. */
+    downloadFile,
+    /** Clear all completed transfers and revoke object URLs. */
+    clearCompleted
+  };
+}

package/dist/runtime/composables/useFollowUser.js

@@ -3,6 +3,7 @@ const followingUserKey = ref(null);
 let cleanup = null;
 let navLock = false;
 export function useFollowUser() {
+  const { getDocUrl } = useDocSlugs();
   function setFollowing(key, provider, getCurrentDocId) {
     cleanup?.();
     cleanup = null;
@@ -18,7 +19,7 @@ export function useFollowUser() {
           const targetDocId = state.docId;
           if (targetDocId && targetDocId !== getCurrentDocId()) {
             navLock = true;
-            navigateTo(`${useRuntimeConfig().public.abracadabra?.docBasePath ?? "/doc"}/${targetDocId}`);
+            navigateTo(getDocUrl(targetDocId));
             setTimeout(() => {
               navLock = false;
             }, 1e3);

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

@@ -0,0 +1,56 @@
+/**
+ * useInvites
+ *
+ * Focused composable for invite management. Wraps the invite methods
+ * from useAbracadabra() with reactive state for the invite list.
+ *
+ * Usage:
+ *   const { invites, create, revoke, redeem, refresh } = useInvites()
+ */
+export interface Invite {
+    code: string;
+    role: string;
+    uses: number;
+    max_uses: number | null;
+    expires_at: number | null;
+    created_at: number;
+}
+declare function refresh(): Promise<void>;
+declare function create(opts?: {
+    role?: string;
+    maxUses?: number;
+    expiresIn?: number;
+}): Promise<Invite>;
+declare function revoke(code: string): Promise<void>;
+declare function redeem(code: string): Promise<void>;
+export declare function useInvites(): {
+    /** Reactive list of invites. */
+    invites: import("vue").Ref<{
+        code: string;
+        role: string;
+        uses: number;
+        max_uses: number | null;
+        expires_at: number | null;
+        created_at: number;
+    }[], Invite[] | {
+        code: string;
+        role: string;
+        uses: number;
+        max_uses: number | null;
+        expires_at: number | null;
+        created_at: number;
+    }[]>;
+    /** Whether invite list is loading. */
+    loading: import("vue").Ref<boolean, boolean>;
+    /** Last error message. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** Refresh the invite list from server. */
+    refresh: typeof refresh;
+    /** Create a new invite. */
+    create: typeof create;
+    /** Revoke an existing invite by code. */
+    revoke: typeof revoke;
+    /** Redeem an invite code. */
+    redeem: typeof redeem;
+};
+export {};

package/dist/runtime/composables/useInvites.js

@@ -0,0 +1,77 @@
+import { ref } from "vue";
+const invites = ref([]);
+const loading = ref(false);
+const error = ref(null);
+let _fetched = false;
+async function refresh() {
+  const abra = useAbracadabra();
+  if (!abra.client.value) return;
+  loading.value = true;
+  error.value = null;
+  try {
+    const result = await abra.listInvites();
+    invites.value = result ?? [];
+    _fetched = true;
+  } catch (e) {
+    error.value = e.message ?? "Failed to fetch invites";
+  } finally {
+    loading.value = false;
+  }
+}
+async function create(opts) {
+  const abra = useAbracadabra();
+  error.value = null;
+  try {
+    const result = await abra.createInvite(opts);
+    await refresh();
+    return result;
+  } catch (e) {
+    error.value = e.message ?? "Failed to create invite";
+    throw e;
+  }
+}
+async function revoke(code) {
+  const abra = useAbracadabra();
+  error.value = null;
+  try {
+    await abra.revokeInvite(code);
+    invites.value = invites.value.filter((i) => i.code !== code);
+  } catch (e) {
+    error.value = e.message ?? "Failed to revoke invite";
+    throw e;
+  }
+}
+async function redeem(code) {
+  const abra = useAbracadabra();
+  error.value = null;
+  try {
+    await abra.redeemInvite(code);
+  } catch (e) {
+    error.value = e.message ?? "Failed to redeem invite";
+    throw e;
+  }
+}
+export function useInvites() {
+  if (!_fetched && !loading.value) {
+    const abra = useAbracadabra();
+    if (abra.client.value) {
+      refresh();
+    }
+  }
+  return {
+    /** Reactive list of invites. */
+    invites,
+    /** Whether invite list is loading. */
+    loading,
+    /** Last error message. */
+    error,
+    /** Refresh the invite list from server. */
+    refresh,
+    /** Create a new invite. */
+    create,
+    /** Revoke an existing invite by code. */
+    revoke,
+    /** Redeem an invite code. */
+    redeem
+  };
+}

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

@@ -0,0 +1,14 @@
+import type { ShallowRef } from 'vue';
+/**
+ * Manages the state for opening a child document in a slide-over panel.
+ * Loads the child provider, waits for sync, and primes the Y.XmlFragment
+ * so TipTap can initialise without errors.
+ */
+export declare function useNodePanel(parentProvider: ShallowRef<any>): {
+    openNodeId: import("vue").Ref<string | null, string | null>;
+    openNodeLabel: import("vue").Ref<string, string>;
+    openNodeProvider: import("vue").Ref<any, any>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    openNode: (nodeId: string, label: string) => Promise<void>;
+    closePanel: () => void;
+};

package/dist/runtime/composables/useNodePanel.js

@@ -0,0 +1,52 @@
+import { ref } from "vue";
+export function useNodePanel(parentProvider) {
+  const openNodeId = ref(null);
+  const openNodeLabel = ref("");
+  const openNodeProvider = ref(null);
+  const isLoading = ref(false);
+  async function openNode(nodeId, label) {
+    if (!parentProvider.value) return;
+    isLoading.value = true;
+    try {
+      const childProv = await parentProvider.value.loadChild(nodeId);
+      if (!childProv.isSynced) {
+        await new Promise((resolve) => {
+          const done = () => {
+            childProv.off("synced", done);
+            resolve();
+          };
+          childProv.on("synced", done);
+          setTimeout(resolve, 6e3);
+        });
+      }
+      const doc = childProv.document;
+      const frag = doc.getXmlFragment("default");
+      if (!frag._item) {
+        doc.transact(() => {
+          void frag.length;
+        });
+      }
+      openNodeProvider.value = childProv;
+      openNodeLabel.value = label;
+      openNodeId.value = nodeId;
+    } catch (e) {
+      console.error("Failed to load node:", e);
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  function closePanel() {
+    openNodeId.value = null;
+    openNodeLabel.value = "";
+    openNodeProvider.value = null;
+    isLoading.value = false;
+  }
+  return {
+    openNodeId,
+    openNodeLabel,
+    openNodeProvider,
+    isLoading,
+    openNode,
+    closePanel
+  };
+}

package/dist/runtime/composables/useNotifications.js

@@ -71,7 +71,8 @@ export function _handleStatelessNotification(payload) {
         break;
       }
     }
-  } catch {
+  } catch (e) {
+    if (import.meta.dev) console.warn("[abracadabra] notifications: failed to handle stateless message:", e);
   }
 }
 function _scheduleToast(notif) {
@@ -117,7 +118,8 @@ function _flushToasts() {
         duration: 5e3
       });
     }
-  }).catch(() => {
+  }).catch((e) => {
+    if (import.meta.dev) console.debug("[abracadabra] notifications: toast display failed:", e);
   });
 }
 function fetchNotifications(opts) {

package/dist/runtime/composables/usePasskeyAccounts.js

@@ -4,7 +4,8 @@ function loadAccounts() {
   try {
     const raw = localStorage.getItem(ACCOUNTS_KEY);
     return raw ? JSON.parse(raw) : [];
-  } catch {
+  } catch (e) {
+    if (import.meta.dev) console.debug("[abracadabra] passkey: failed to load accounts from localStorage:", e);
     return [];
   }
 }
@@ -18,7 +19,8 @@ export function usePasskeyAccounts() {
   function persist() {
     try {
       localStorage.setItem(ACCOUNTS_KEY, JSON.stringify(accounts.value));
-    } catch {
+    } catch (e) {
+      if (import.meta.dev) console.debug("[abracadabra] passkey: failed to persist accounts:", e);
     }
   }
   function registerAccount(account) {

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

@@ -16,5 +16,6 @@ export declare function useSearchIndex(): {
     search: (query: string, limit?: number) => Promise<SearchResult[]>;
     isReady: import("vue").ComputedRef<boolean>;
     indexedCount: import("vue").ComputedRef<number>;
+    error: import("vue").ComputedRef<string | null>;
 };
 export {};

package/dist/runtime/composables/useSearchIndex.js

@@ -4,6 +4,7 @@ let _searchIndex = null;
 const _indexedVersions = /* @__PURE__ */ new Map();
 const _isReady = ref(false);
 const _indexedCount = ref(0);
+const _error = ref(null);
 let _stopWatcher = null;
 function walkXmlForText(node, texts) {
   for (const child of node.toArray()) {
@@ -38,7 +39,8 @@ function extractDocTexts(ydoc, label, meta) {
   try {
     const fragment = ydoc.getXmlFragment("default");
     walkXmlForText(fragment, texts);
-  } catch {
+  } catch (e) {
+    if (import.meta.dev) console.warn("[abracadabra] search: failed to extract doc texts:", e);
   }
   return texts;
 }
@@ -49,7 +51,9 @@ export function _initSearchIndex(serverOrigin) {
     _indexedVersions.clear();
     _indexedCount.value = 0;
     _startWatcher();
-  }).catch(() => {
+  }).catch((e) => {
+    _error.value = e?.message ?? "Failed to load SearchIndex";
+    if (import.meta.dev) console.warn("[abracadabra] search: failed to load SearchIndex:", e);
   });
 }
 export function _destroySearchIndex() {
@@ -60,6 +64,7 @@ export function _destroySearchIndex() {
   _isReady.value = false;
   _indexedVersions.clear();
   _indexedCount.value = 0;
+  _error.value = null;
 }
 function _startWatcher() {
   const { syncStates } = useBackgroundSync();
@@ -82,7 +87,8 @@ function _startWatcher() {
         await _searchIndex.index(docId, texts);
         _indexedVersions.set(docId, lastSynced);
         _indexedCount.value = _indexedVersions.size;
-      } catch {
+      } catch (e) {
+        if (import.meta.dev) console.warn(`[abracadabra] search: failed to index doc ${docId}:`, e);
       }
     }
   }, { deep: false });
@@ -94,11 +100,13 @@ export function useSearchIndex() {
       if (!_searchIndex) return [];
       try {
         return await _searchIndex.search(query, limit);
-      } catch {
+      } catch (e) {
+        if (import.meta.dev) console.warn("[abracadabra] search: query failed:", e);
         return [];
       }
     },
     isReady: computed(() => _isReady.value),
-    indexedCount: computed(() => _indexedCount.value)
+    indexedCount: computed(() => _indexedCount.value),
+    error: computed(() => _error.value)
   };
 }

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

@@ -0,0 +1,31 @@
+/**
+ * useServerInfo
+ *
+ * Fetches and exposes server health, metadata, and ICE server configuration.
+ * Automatically fetches on first use when client is available.
+ *
+ * Usage:
+ *   const { serverName, serverVersion, healthy, iceServers, refresh } = useServerInfo()
+ */
+export declare function _initServerInfo(client: any): void;
+export declare function _destroyServerInfo(): void;
+declare function refresh(): Promise<void>;
+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>;
+    /** Whether the server is healthy. */
+    healthy: import("vue").Ref<boolean, boolean>;
+    /** ICE servers from server (STUN/TURN). */
+    iceServers: import("vue").ShallowRef<RTCIceServer[], RTCIceServer[]>;
+    /** Whether a fetch is in progress. */
+    loading: import("vue").Ref<boolean, boolean>;
+    /** Last error message. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** Re-fetch server info. */
+    refresh: typeof refresh;
+};
+export {};

package/dist/runtime/composables/useServerInfo.js

@@ -0,0 +1,80 @@
+import { ref, shallowRef } from "vue";
+const serverName = ref(null);
+const serverVersion = ref(null);
+const indexDocId = ref(null);
+const healthy = ref(false);
+const iceServers = shallowRef([]);
+const loading = ref(false);
+const error = ref(null);
+let _fetched = false;
+let _client = null;
+export function _initServerInfo(client) {
+  _client = client;
+  _fetched = false;
+  _fetchAll();
+}
+export function _destroyServerInfo() {
+  _client = null;
+  _fetched = false;
+  serverName.value = null;
+  serverVersion.value = null;
+  indexDocId.value = null;
+  healthy.value = false;
+  iceServers.value = [];
+  error.value = null;
+}
+async function _fetchAll() {
+  if (!_client || loading.value) return;
+  loading.value = true;
+  error.value = null;
+  try {
+    const [healthResult, infoResult, iceResult] = await Promise.allSettled([
+      _client.health(),
+      _client.serverInfo(),
+      _client.getIceServers()
+    ]);
+    if (healthResult.status === "fulfilled") {
+      healthy.value = healthResult.value?.status === "ok" || !!healthResult.value;
+    }
+    if (infoResult.status === "fulfilled") {
+      const info = infoResult.value;
+      serverName.value = info?.name ?? null;
+      serverVersion.value = info?.version ?? null;
+      indexDocId.value = info?.index_doc_id ?? null;
+    }
+    if (iceResult.status === "fulfilled") {
+      iceServers.value = iceResult.value ?? [];
+    }
+    _fetched = true;
+  } catch (e) {
+    error.value = e.message ?? "Failed to fetch server info";
+  } finally {
+    loading.value = false;
+  }
+}
+async function refresh() {
+  await _fetchAll();
+}
+export function useServerInfo() {
+  if (!_fetched && _client && !loading.value) {
+    _fetchAll();
+  }
+  return {
+    /** Server display name. */
+    serverName,
+    /** Server version string. */
+    serverVersion,
+    /** Root/index document ID from server. */
+    indexDocId,
+    /** Whether the server is healthy. */
+    healthy,
+    /** ICE servers from server (STUN/TURN). */
+    iceServers,
+    /** Whether a fetch is in progress. */
+    loading,
+    /** Last error message. */
+    error,
+    /** Re-fetch server info. */
+    refresh
+  };
+}

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

@@ -0,0 +1,6 @@
+export declare function useSlugRoute(): {
+    slugPath: import("vue").ComputedRef<string>;
+    docId: import("vue").ComputedRef<string | null>;
+    isLoading: import("vue").ComputedRef<boolean>;
+    notFound: import("vue").ComputedRef<boolean>;
+};

package/dist/runtime/composables/useSlugRoute.js

@@ -0,0 +1,19 @@
+import { computed } from "vue";
+import { isUUID } from "../utils/slugify.js";
+export function useSlugRoute() {
+  const route = useRoute();
+  const { getDocId, slugMap } = useDocSlugs();
+  const slugPath = computed(() => {
+    const params = route.params.slug;
+    return Array.isArray(params) ? params.join("/") : params ?? "";
+  });
+  const docId = computed(() => {
+    const s = slugPath.value;
+    if (isUUID(s)) return s;
+    return getDocId(s);
+  });
+  const slugMapReady = computed(() => Object.keys(slugMap.value.slugToId).length > 0);
+  const isLoading = computed(() => !isUUID(slugPath.value) && !slugMapReady.value);
+  const notFound = computed(() => !docId.value && slugMapReady.value);
+  return { slugPath, docId, isLoading, notFound };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * useSpaces
+ *
+ * Focused composable for space management. Wraps the space methods
+ * from useAbracadabra() with a cleaner API surface.
+ *
+ * Usage:
+ *   const { spaces, currentSpace, create, switchTo, refresh } = useSpaces()
+ */
+import type { SpaceMeta } from '../types.js';
+export declare function useSpaces(): {
+    /** All spaces on the current server. */
+    spaces: import("vue").ComputedRef<SpaceMeta[]>;
+    /** Whether the current server supports spaces. */
+    spacesEnabled: import("vue").ComputedRef<boolean>;
+    /** The currently active space. */
+    currentSpace: import("vue").ComputedRef<SpaceMeta | null>;
+    /** Whether space operations are in progress. */
+    loading: import("vue").Ref<boolean, boolean>;
+    /** Last error message. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** Refresh spaces list from server. */
+    refresh: () => Promise<void>;
+    /** Create a new space. */
+    create: (opts: {
+        name: string;
+        description?: string;
+        visibility?: SpaceMeta["visibility"];
+        id?: string;
+    }) => Promise<SpaceMeta>;
+    /** Update an existing space. */
+    update: (id: string, opts: Partial<Pick<SpaceMeta, "name" | "description" | "visibility" | "is_hub">>) => Promise<SpaceMeta>;
+    /** Delete a space. */
+    remove: (id: string) => Promise<void>;
+    /** Switch to a different space. */
+    switchTo: (spaceDocId: string) => Promise<void>;
+};