@abraca/nuxt 0.2.0 → 1.5.0

package/dist/runtime/composables/useNodePanel.js

@@ -0,0 +1,89 @@
+import { ref } from "vue";
+export function useNodePanel(parentProvider, options) {
+  const syncTimeout = options?.syncTimeout ?? 8e3;
+  const openNodeId = ref(null);
+  const openNodeLabel = ref("");
+  const openNodeProvider = ref(null);
+  const isLoading = ref(false);
+  const loadError = ref(null);
+  let _lastNodeId = null;
+  async function openNode(nodeId, label) {
+    if (!parentProvider.value) return;
+    loadError.value = null;
+    isLoading.value = true;
+    if (openNodeProvider.value && openNodeId.value && openNodeId.value !== nodeId) {
+      try {
+        openNodeProvider.value.detach?.();
+      } catch {
+      }
+      openNodeProvider.value = null;
+    }
+    _lastNodeId = nodeId;
+    try {
+      const childProv = await parentProvider.value.loadChild(nodeId);
+      if (_lastNodeId !== nodeId) return;
+      if (!childProv.isSynced) {
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            childProv.off("synced", onSynced);
+            reject(new Error(`Sync timeout after ${syncTimeout}ms`));
+          }, syncTimeout);
+          function onSynced({ state }) {
+            if (!state) return;
+            clearTimeout(timer);
+            childProv.off("synced", onSynced);
+            resolve();
+          }
+          childProv.on("synced", onSynced);
+        });
+      }
+      if (_lastNodeId !== nodeId) return;
+      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);
+      loadError.value = e?.message || "Failed to load document";
+    } finally {
+      isLoading.value = false;
+    }
+  }
+  function closePanel() {
+    if (openNodeProvider.value) {
+      try {
+        openNodeProvider.value.detach?.();
+      } catch {
+      }
+    }
+    openNodeId.value = null;
+    openNodeLabel.value = "";
+    openNodeProvider.value = null;
+    isLoading.value = false;
+    loadError.value = null;
+    _lastNodeId = null;
+  }
+  function retry() {
+    if (_lastNodeId) {
+      const nodeId = _lastNodeId;
+      const label = openNodeLabel.value || "Untitled";
+      openNode(nodeId, label);
+    }
+  }
+  return {
+    openNodeId,
+    openNodeLabel,
+    openNodeProvider,
+    isLoading,
+    loadError,
+    openNode,
+    closePanel,
+    retry
+  };
+}

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

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export declare function useNodePanelFollow(openNodeId: Ref<string | null>, openNodeLabel: Ref<string>, openNode: (id: string, label: string) => Promise<void>, closePanel: () => void, followingUser: () => string | null | undefined, states: Ref<any[]>, setLocalState: (s: any) => void): void;

package/dist/runtime/composables/useNodePanelFollow.js

@@ -0,0 +1,37 @@
+import { watch, nextTick, onBeforeUnmount } from "vue";
+export function useNodePanelFollow(openNodeId, openNodeLabel, openNode, closePanel, followingUser, states, setLocalState) {
+  let syncingFromFollow = false;
+  let lastAppliedT = 0;
+  watch(openNodeId, (nodeId) => {
+    if (syncingFromFollow || followingUser()) return;
+    setLocalState({
+      nodePanel: {
+        nodeId: nodeId ?? null,
+        label: nodeId ? openNodeLabel.value : null,
+        t: Date.now()
+      }
+    });
+  });
+  watch([followingUser, states], () => {
+    const key = followingUser();
+    if (!key) return;
+    const state = states.value.find((s) => s.user?.publicKey === key);
+    const panel = state?.nodePanel;
+    if (!panel || panel.t <= lastAppliedT) return;
+    lastAppliedT = panel.t;
+    syncingFromFollow = true;
+    if (panel.nodeId) {
+      openNode(panel.nodeId, panel.label ?? "");
+    } else {
+      closePanel();
+    }
+    nextTick(() => {
+      syncingFromFollow = false;
+    });
+  });
+  onBeforeUnmount(() => {
+    if (!syncingFromFollow) {
+      setLocalState({ nodePanel: { nodeId: null, label: null, t: Date.now() } });
+    }
+  });
+}

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

@@ -74,6 +74,7 @@ export declare function useNotifications(): {
         read: boolean;
         createdAt: number;
     }[]>;
+    lastError: import("vue").Ref<string | null, string | null>;
     fetchNotifications: typeof fetchNotifications;
     markRead: typeof markRead;
     markAllRead: typeof markAllRead;

package/dist/runtime/composables/useNotifications.js

@@ -1,5 +1,7 @@
 import { ref, computed } from "vue";
+import { useAbracadabra } from "./useAbracadabra.js";
 const notifications = ref([]);
+const lastError = ref(null);
 let _publicKeyB64 = ref("");
 let pendingToasts = [];
 let toastFlushTimer = null;
@@ -40,6 +42,7 @@ export function _handleStatelessNotification(payload) {
   try {
     const data = JSON.parse(payload);
     if (!data.type?.startsWith("notify:")) return;
+    lastError.value = null;
     switch (data.type) {
       case "notify:history": {
         const incoming = (data.notifications || []).map(parseNotification);
@@ -71,7 +74,9 @@ export function _handleStatelessNotification(payload) {
         break;
       }
     }
-  } catch {
+  } catch (e) {
+    lastError.value = e instanceof Error ? e.message : String(e);
+    console.error("[abracadabra] notifications: failed to handle stateless message:", e);
   }
 }
 function _scheduleToast(notif) {
@@ -117,7 +122,8 @@ function _flushToasts() {
         duration: 5e3
       });
     }
-  }).catch(() => {
+  }).catch((e) => {
+    console.error("[abracadabra] notifications: toast display failed:", e);
   });
 }
 function fetchNotifications(opts) {
@@ -163,6 +169,7 @@ export function useNotifications() {
     notifications,
     unreadCount,
     unreadNotifications,
+    lastError,
     fetchNotifications,
     markRead,
     markAllRead,

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/usePluginRegistry.js

@@ -1,3 +1,4 @@
+import { useNuxtApp } from "#imports";
 export function usePluginRegistry() {
   return useNuxtApp().$abracadabra.registry;
 }

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

@@ -21,7 +21,7 @@ export interface RendererBaseProps {
 export declare function useRendererBase(props: RendererBaseProps): {
     childProviderRef: ShallowRef<any, any>;
     childDoc: ShallowRef<Y.Doc | null, Y.Doc | null>;
-    rootDoc: any;
+    rootDoc: ShallowRef<Y.Doc>;
     cursors: import("vue").Ref<{
         clientId: number;
         x: number;
@@ -183,4 +183,19 @@ export declare function useRendererBase(props: RendererBaseProps): {
         avatar: string | undefined;
         publicKey: any;
     }[]>;
+    containerRef: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    isDropTarget: import("vue").ComputedRef<boolean>;
+    dropIndicator: import("vue").Ref<{
+        parentDocId: string;
+        targetItemId?: string | null | undefined;
+        position?: "before" | "inside" | "after" | undefined;
+        order: number;
+        dropMeta?: Record<string, unknown> | undefined;
+    } | null, import("./useDocDropZone.js").DropZone | {
+        parentDocId: string;
+        targetItemId?: string | null | undefined;
+        position?: "before" | "inside" | "after" | undefined;
+        order: number;
+        dropMeta?: Record<string, unknown> | undefined;
+    } | null>;
 };

package/dist/runtime/composables/useRendererBase.js

@@ -1,6 +1,8 @@
 import { shallowRef, computed, watch, watchEffect } from "vue";
 import { useSmoothedCursors } from "./useYDoc.js";
 import { useChildTree } from "./useChildTree.js";
+import { useDocDropZone } from "./useDocDropZone.js";
+import { useAbracadabra } from "./useAbracadabra.js";
 export function useRendererBase(props) {
   const { doc: rootDoc, userName, userColor, publicKeyB64 } = useAbracadabra();
   const childProviderRef = shallowRef(null);
@@ -24,6 +26,10 @@ export function useRendererBase(props) {
     }
   });
   const tree = useChildTree(rootDoc, props.docId);
+  const { containerRef, isDropTarget, dropIndicator } = useDocDropZone({
+    parentDocId: props.docId,
+    tree
+  });
   const connectedUsers = computed(
     () => states.value.map((s) => ({
       clientId: s.clientId,
@@ -41,6 +47,9 @@ export function useRendererBase(props) {
     states,
     setLocalState,
     tree,
-    connectedUsers
+    connectedUsers,
+    containerRef,
+    isDropTarget,
+    dropIndicator
   };
 }

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

@@ -1,9 +1,12 @@
 import { ref, computed, watch } from "vue";
 import * as Y from "yjs";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { useBackgroundSync } from "./useBackgroundSync.js";
 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 +41,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 +53,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 +66,7 @@ export function _destroySearchIndex() {
   _isReady.value = false;
   _indexedVersions.clear();
   _indexedCount.value = 0;
+  _error.value = null;
 }
 function _startWatcher() {
   const { syncStates } = useBackgroundSync();
@@ -82,7 +89,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 +102,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/useSettingsModal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * useSettingsModal
+ *
+ * Global state for the settings modal — controls which tab is active
+ * and whether the modal is open. Used by the ASettingsModal component
+ * and any code that needs to open settings programmatically (sidebar,
+ * command palette, keyboard shortcuts, etc.).
+ *
+ * Usage:
+ *   const { isOpen, activeTab, openSettings, closeSettings } = useSettingsModal()
+ */
+export type SettingsTab = 'profile' | 'connection' | 'spaces' | 'security' | 'invites' | 'members' | 'trash' | 'offline' | 'plugins' | 'admin';
+export declare function useSettingsModal(): {
+    isOpen: import("vue").WritableComputedRef<boolean, boolean>;
+    activeTab: import("vue").WritableComputedRef<SettingsTab, SettingsTab>;
+    openSettings: (tab?: SettingsTab) => void;
+    closeSettings: () => void;
+};

package/dist/runtime/composables/useSettingsModal.js

@@ -0,0 +1,30 @@
+import { ref, computed } from "vue";
+const _isOpen = ref(false);
+const _activeTab = ref("profile");
+export function useSettingsModal() {
+  const isOpen = computed({
+    get: () => _isOpen.value,
+    set: (v) => {
+      _isOpen.value = v;
+    }
+  });
+  const activeTab = computed({
+    get: () => _activeTab.value,
+    set: (v) => {
+      _activeTab.value = v;
+    }
+  });
+  function openSettings(tab) {
+    if (tab) _activeTab.value = tab;
+    _isOpen.value = true;
+  }
+  function closeSettings() {
+    _isOpen.value = false;
+  }
+  return {
+    isOpen,
+    activeTab,
+    openSettings,
+    closeSettings
+  };
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Slideover registry + swipe-to-close composable.
+ *
+ * `useSlideoverRegistry()` is a shared singleton that tracks all open
+ * slideovers. `useSlideoverSwipe()` auto-registers a slideover component
+ * with the registry when it opens, and unregisters when it closes.
+ *
+ * Ported from cou-sh/app/composables/useSlideoverSwipe.ts.
+ */
+import { type Ref } from 'vue';
+interface SlideoverEntry {
+    id: string;
+    side: 'left' | 'right';
+    close: () => void;
+    priority: number;
+}
+export declare const useSlideoverRegistry: () => {
+    stack: Ref<{
+        id: string;
+        side: "left" | "right";
+        close: () => void;
+        priority: number;
+    }[], SlideoverEntry[] | {
+        id: string;
+        side: "left" | "right";
+        close: () => void;
+        priority: number;
+    }[]>;
+    register: (entry: SlideoverEntry) => void;
+    unregister: (id: string) => void;
+    closeTop: (side?: "left" | "right") => boolean;
+    hasOpen: (side?: "left" | "right") => boolean;
+};
+/**
+ * Auto-register a slideover with the swipe registry.
+ * Call this inside any component that uses USlideover.
+ */
+export declare function useSlideoverSwipe(id: string | (() => string), open: Ref<boolean>, side?: 'left' | 'right'): void;
+export {};

package/dist/runtime/composables/useSlideoverSwipe.js

@@ -0,0 +1,48 @@
+import { ref, watch, onBeforeUnmount } from "vue";
+import { createSharedComposable } from "@vueuse/core";
+const _useSlideoverRegistry = () => {
+  const stack = ref([]);
+  function register(entry) {
+    const idx = stack.value.findIndex((e) => e.id === entry.id);
+    if (idx >= 0) stack.value.splice(idx, 1);
+    stack.value.push(entry);
+  }
+  function unregister(id) {
+    const idx = stack.value.findIndex((e) => e.id === id);
+    if (idx >= 0) stack.value.splice(idx, 1);
+  }
+  function closeTop(side) {
+    const filtered = side ? stack.value.filter((e) => e.side === side) : stack.value;
+    if (filtered.length === 0) return false;
+    const top = filtered.reduce((a, b) => a.priority > b.priority ? a : b);
+    top.close();
+    unregister(top.id);
+    return true;
+  }
+  function hasOpen(side) {
+    if (!side) return stack.value.length > 0;
+    return stack.value.some((e) => e.side === side);
+  }
+  return { stack, register, unregister, closeTop, hasOpen };
+};
+export const useSlideoverRegistry = createSharedComposable(_useSlideoverRegistry);
+export function useSlideoverSwipe(id, open, side = "right") {
+  if (typeof window === "undefined") return;
+  const registry = useSlideoverRegistry();
+  const resolveId = typeof id === "function" ? id : () => id;
+  watch(open, (isOpen) => {
+    if (isOpen) {
+      registry.register({
+        id: resolveId(),
+        side,
+        close: () => {
+          open.value = false;
+        },
+        priority: Date.now()
+      });
+    } else {
+      registry.unregister(resolveId());
+    }
+  }, { immediate: true });
+  onBeforeUnmount(() => registry.unregister(resolveId()));
+}

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,21 @@
+import { computed } from "vue";
+import { isUUID } from "../utils/slugify.js";
+import { useRoute } from "#imports";
+import { useDocSlugs } from "./useDocSlugs.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>;
+};