@abraca/nuxt 0.1.0

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

@@ -0,0 +1,82 @@
+/**
+ * useNotifications
+ *
+ * Server-pushed notifications via provider.sendStateless().
+ * Wire _handleStatelessNotification() into the provider's onStateless callback
+ * from the main plugin.
+ *
+ * Usage:
+ *   const { notifications, unreadCount, fetchNotifications, markRead } = useNotifications()
+ */
+export type NotificationType = 'chat' | 'agent' | 'mention' | 'system';
+export interface AppNotification {
+    id: string;
+    type: NotificationType;
+    title: string;
+    body: string;
+    icon?: string;
+    link?: string;
+    sourceId?: string;
+    read: boolean;
+    createdAt: number;
+}
+declare let _publicKeyB64: import("vue").Ref<string, string>;
+export declare function _initNotifications(publicKeyB64Ref: typeof _publicKeyB64): void;
+export declare function _destroyNotifications(): void;
+export declare function _handleStatelessNotification(payload: string): void;
+declare function fetchNotifications(opts?: {
+    before?: number;
+    limit?: number;
+    unreadOnly?: boolean;
+}): void;
+declare function markRead(id: string): void;
+declare function markAllRead(): void;
+declare function createNotification(opts: {
+    recipientId: string;
+    type?: NotificationType;
+    title: string;
+    body: string;
+    icon?: string;
+    link?: string;
+    sourceId?: string;
+}): void;
+export declare function useNotifications(): {
+    notifications: import("vue").Ref<{
+        id: string;
+        type: NotificationType;
+        title: string;
+        body: string;
+        icon?: string | undefined;
+        link?: string | undefined;
+        sourceId?: string | undefined;
+        read: boolean;
+        createdAt: number;
+    }[], AppNotification[] | {
+        id: string;
+        type: NotificationType;
+        title: string;
+        body: string;
+        icon?: string | undefined;
+        link?: string | undefined;
+        sourceId?: string | undefined;
+        read: boolean;
+        createdAt: number;
+    }[]>;
+    unreadCount: import("vue").ComputedRef<number>;
+    unreadNotifications: import("vue").ComputedRef<{
+        id: string;
+        type: NotificationType;
+        title: string;
+        body: string;
+        icon?: string | undefined;
+        link?: string | undefined;
+        sourceId?: string | undefined;
+        read: boolean;
+        createdAt: number;
+    }[]>;
+    fetchNotifications: typeof fetchNotifications;
+    markRead: typeof markRead;
+    markAllRead: typeof markAllRead;
+    createNotification: typeof createNotification;
+};
+export {};

package/dist/runtime/composables/useNotifications.js

@@ -0,0 +1,171 @@
+import { ref, computed } from "vue";
+const notifications = ref([]);
+let _publicKeyB64 = ref("");
+let pendingToasts = [];
+let toastFlushTimer = null;
+const TOAST_BATCH_MS = 1500;
+const unreadCount = computed(() => notifications.value.filter((n) => !n.read).length);
+const unreadNotifications = computed(
+  () => notifications.value.filter((n) => !n.read).sort((a, b) => b.createdAt - a.createdAt).slice(0, 10)
+);
+export function _initNotifications(publicKeyB64Ref) {
+  _publicKeyB64 = publicKeyB64Ref;
+  notifications.value = [];
+}
+export function _destroyNotifications() {
+  notifications.value = [];
+  pendingToasts = [];
+  if (toastFlushTimer) clearTimeout(toastFlushTimer);
+  toastFlushTimer = null;
+}
+function parseNotification(data) {
+  return {
+    id: data.id ?? crypto.randomUUID(),
+    type: data.notification_type ?? data.type ?? "system",
+    title: data.title ?? "",
+    body: data.body ?? "",
+    icon: data.icon,
+    link: data.link,
+    sourceId: data.source_id,
+    read: data.read ?? false,
+    createdAt: data.created_at ? new Date(data.created_at).getTime() : Date.now()
+  };
+}
+function isForMe(recipientId) {
+  if (!recipientId) return true;
+  return recipientId === _publicKeyB64.value;
+}
+export function _handleStatelessNotification(payload) {
+  if (!payload.includes('"notify:')) return;
+  try {
+    const data = JSON.parse(payload);
+    if (!data.type?.startsWith("notify:")) return;
+    switch (data.type) {
+      case "notify:history": {
+        const incoming = (data.notifications || []).map(parseNotification);
+        const existingIds = new Set(notifications.value.map((n) => n.id));
+        const merged = [...notifications.value, ...incoming.filter((n) => !existingIds.has(n.id))];
+        notifications.value = merged.sort((a, b) => b.createdAt - a.createdAt);
+        break;
+      }
+      case "notify:new": {
+        const notif = parseNotification(data);
+        if (notif.id && isForMe(data.recipient_id)) {
+          if (!notifications.value.some((n) => n.id === notif.id)) {
+            notifications.value = [notif, ...notifications.value];
+            _scheduleToast(notif);
+          }
+        }
+        break;
+      }
+      case "notify:read_update": {
+        if (!isForMe(data.recipient_id)) break;
+        if (data.all) {
+          notifications.value = notifications.value.map((n) => ({ ...n, read: true }));
+        } else if (data.ids) {
+          const idSet = new Set(data.ids);
+          notifications.value = notifications.value.map(
+            (n) => idSet.has(n.id) ? { ...n, read: true } : n
+          );
+        }
+        break;
+      }
+    }
+  } catch {
+  }
+}
+function _scheduleToast(notif) {
+  pendingToasts.push(notif);
+  if (toastFlushTimer) clearTimeout(toastFlushTimer);
+  toastFlushTimer = setTimeout(_flushToasts, TOAST_BATCH_MS);
+}
+function _flushToasts() {
+  toastFlushTimer = null;
+  if (pendingToasts.length === 0) return;
+  const batch = [...pendingToasts];
+  pendingToasts = [];
+  import("#imports").then(({ useToast, useRouter }) => {
+    const toast = useToast();
+    const router = useRouter();
+    if (batch.length === 1) {
+      const n = batch[0];
+      const body = n.body.length > 80 ? n.body.slice(0, 80) + "\u2026" : n.body;
+      toast.add({
+        id: `notif-${n.id}`,
+        title: n.title,
+        description: body,
+        icon: n.icon || "i-lucide-bell",
+        color: "neutral",
+        duration: 5e3,
+        actions: n.link ? [{
+          label: "View",
+          color: "primary",
+          variant: "subtle",
+          onClick: (e) => {
+            e?.stopPropagation();
+            markRead(n.id);
+            router.push(n.link);
+          }
+        }] : void 0
+      });
+    } else {
+      toast.add({
+        id: `notif-batch-${Date.now()}`,
+        title: `${batch.length} new notifications`,
+        icon: "i-lucide-bell",
+        color: "neutral",
+        duration: 5e3
+      });
+    }
+  }).catch(() => {
+  });
+}
+function fetchNotifications(opts) {
+  const { provider } = useAbracadabra();
+  if (!provider.value) return;
+  provider.value.sendStateless(JSON.stringify({
+    type: "notify:fetch",
+    before: opts?.before,
+    limit: opts?.limit ?? 50,
+    unread_only: opts?.unreadOnly ?? false
+  }));
+}
+function markRead(id) {
+  const { provider } = useAbracadabra();
+  if (provider.value) {
+    provider.value.sendStateless(JSON.stringify({ type: "notify:mark_read", id }));
+  }
+  notifications.value = notifications.value.map((n) => n.id === id ? { ...n, read: true } : n);
+}
+function markAllRead() {
+  const { provider } = useAbracadabra();
+  if (provider.value) {
+    provider.value.sendStateless(JSON.stringify({ type: "notify:mark_all_read" }));
+  }
+  notifications.value = notifications.value.map((n) => ({ ...n, read: true }));
+}
+function createNotification(opts) {
+  const { provider } = useAbracadabra();
+  if (!provider.value) return;
+  provider.value.sendStateless(JSON.stringify({
+    type: "notify:create",
+    recipient_id: opts.recipientId,
+    notification_type: opts.type ?? "system",
+    title: opts.title,
+    body: opts.body,
+    icon: opts.icon,
+    link: opts.link,
+    source_id: opts.sourceId
+  }));
+}
+export function useNotifications() {
+  return {
+    notifications,
+    unreadCount,
+    unreadNotifications,
+    fetchNotifications,
+    markRead,
+    markAllRead,
+    createNotification
+  };
+}

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

@@ -0,0 +1,90 @@
+/**
+ * useOfflineUploadQueue
+ *
+ * Queue for file uploads that fail because the client is offline.
+ * The file blob is stored in FileBlobStore (IDB) under a temporary UUID
+ * so components can render it immediately via getBlobUrl() — no special
+ * fallback needed. When the client reconnects, flushUploads() retries.
+ *
+ * The queue itself is in-memory only; blob data persists in IDB.
+ */
+interface PendingUpload {
+    tempId: string;
+    docId: string;
+    file: File;
+    filename: string;
+}
+declare function enqueue(docId: string, file: File): Promise<{
+    id: string;
+    doc_id: string;
+    filename: string;
+}>;
+declare function flushUploads(client: any, onReplaced: (tempId: string, realId: string, docId: string) => void): Promise<void>;
+export declare function useOfflineUploadQueue(): {
+    pending: import("vue").Ref<Map<string, {
+        tempId: string;
+        docId: string;
+        file: {
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: {
+                (): Promise<ArrayBuffer>;
+                (): Promise<ArrayBuffer>;
+            };
+            bytes: {
+                (): Promise<Uint8Array<ArrayBuffer>>;
+                (): Promise<Uint8Array<ArrayBuffer>>;
+            };
+            slice: {
+                (start?: number, end?: number, contentType?: string): Blob;
+                (start?: number, end?: number, contentType?: string): Blob;
+            };
+            stream: {
+                (): ReadableStream<Uint8Array<ArrayBuffer>>;
+                (): ReadableStream<Uint8Array<ArrayBuffer>>;
+            };
+            text: {
+                (): Promise<string>;
+                (): Promise<string>;
+            };
+        };
+        filename: string;
+    }> & Omit<Map<string, PendingUpload>, keyof Map<any, any>>, Map<string, PendingUpload> | (Map<string, {
+        tempId: string;
+        docId: string;
+        file: {
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: {
+                (): Promise<ArrayBuffer>;
+                (): Promise<ArrayBuffer>;
+            };
+            bytes: {
+                (): Promise<Uint8Array<ArrayBuffer>>;
+                (): Promise<Uint8Array<ArrayBuffer>>;
+            };
+            slice: {
+                (start?: number, end?: number, contentType?: string): Blob;
+                (start?: number, end?: number, contentType?: string): Blob;
+            };
+            stream: {
+                (): ReadableStream<Uint8Array<ArrayBuffer>>;
+                (): ReadableStream<Uint8Array<ArrayBuffer>>;
+            };
+            text: {
+                (): Promise<string>;
+                (): Promise<string>;
+            };
+        };
+        filename: string;
+    }> & Omit<Map<string, PendingUpload>, keyof Map<any, any>>)>;
+    enqueue: typeof enqueue;
+    flushUploads: typeof flushUploads;
+};
+export {};

package/dist/runtime/composables/useOfflineUploadQueue.js

@@ -0,0 +1,33 @@
+import { ref } from "vue";
+import { _getFileBlobStore } from "./useFileBlobStore.js";
+const pending = ref(/* @__PURE__ */ new Map());
+async function enqueue(docId, file) {
+  const tempId = crypto.randomUUID();
+  const store = _getFileBlobStore();
+  if (store) {
+    await store.putBlob(docId, tempId, file, file.name);
+  }
+  pending.value = new Map(pending.value).set(tempId, {
+    tempId,
+    docId,
+    file,
+    filename: file.name
+  });
+  return { id: tempId, doc_id: docId, filename: file.name };
+}
+async function flushUploads(client, onReplaced) {
+  if (pending.value.size === 0) return;
+  for (const [tempId, entry] of pending.value) {
+    try {
+      const meta = await client.upload(entry.docId, entry.file, entry.filename);
+      onReplaced(tempId, meta.id, meta.doc_id);
+      const next = new Map(pending.value);
+      next.delete(tempId);
+      pending.value = next;
+    } catch {
+    }
+  }
+}
+export function useOfflineUploadQueue() {
+  return { pending, enqueue, flushUploads };
+}

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

@@ -0,0 +1,32 @@
+/**
+ * usePasskeyAccounts
+ *
+ * Manages multiple hardware-bound passkey accounts in localStorage.
+ * Useful for account switching between different claimed identities.
+ *
+ * Usage:
+ *   const { accounts, registerAccount, touchAccount } = usePasskeyAccounts()
+ */
+export interface PasskeyAccount {
+    publicKey: string;
+    displayName: string;
+    credentialId: string;
+    claimedAt: number;
+    lastUsedAt: number;
+    colorPrimary?: string;
+    colorNeutral?: string;
+}
+export declare function usePasskeyAccounts(): {
+    accounts: import("vue").ComputedRef<{
+        publicKey: string;
+        displayName: string;
+        credentialId: string;
+        claimedAt: number;
+        lastUsedAt: number;
+        colorPrimary?: string | undefined;
+        colorNeutral?: string | undefined;
+    }[]>;
+    registerAccount: (account: PasskeyAccount) => void;
+    touchAccount: (publicKey: string) => void;
+    removeAccount: (publicKey: string) => void;
+};

package/dist/runtime/composables/usePasskeyAccounts.js

@@ -0,0 +1,46 @@
+import { ref, computed } from "vue";
+const ACCOUNTS_KEY = "abracadabra_passkey_accounts";
+function loadAccounts() {
+  try {
+    const raw = localStorage.getItem(ACCOUNTS_KEY);
+    return raw ? JSON.parse(raw) : [];
+  } catch {
+    return [];
+  }
+}
+const accounts = ref([]);
+let _loaded = false;
+export function usePasskeyAccounts() {
+  if (!_loaded && import.meta.client) {
+    accounts.value = loadAccounts();
+    _loaded = true;
+  }
+  function persist() {
+    try {
+      localStorage.setItem(ACCOUNTS_KEY, JSON.stringify(accounts.value));
+    } catch {
+    }
+  }
+  function registerAccount(account) {
+    const idx = accounts.value.findIndex((a) => a.publicKey === account.publicKey);
+    if (idx >= 0) {
+      accounts.value[idx] = { ...accounts.value[idx], ...account, lastUsedAt: Date.now() };
+    } else {
+      accounts.value = [...accounts.value, { ...account, lastUsedAt: Date.now() }];
+    }
+    persist();
+  }
+  function touchAccount(publicKey) {
+    const a = accounts.value.find((a2) => a2.publicKey === publicKey);
+    if (a) {
+      a.lastUsedAt = Date.now();
+      persist();
+    }
+  }
+  function removeAccount(publicKey) {
+    accounts.value = accounts.value.filter((a) => a.publicKey !== publicKey);
+    persist();
+  }
+  const sorted = computed(() => [...accounts.value].sort((a, b) => b.lastUsedAt - a.lastUsedAt));
+  return { accounts: sorted, registerAccount, touchAccount, removeAccount };
+}

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

@@ -0,0 +1,6 @@
+import type { PluginRegistry } from '../plugin-registry.js';
+/**
+ * Returns the frozen plugin registry.
+ * Call after app boot — the registry is always frozen when components mount.
+ */
+export declare function usePluginRegistry(): PluginRegistry;

package/dist/runtime/composables/usePluginRegistry.js

@@ -0,0 +1,3 @@
+export function usePluginRegistry() {
+  return useNuxtApp().$abracadabra.registry;
+}

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

@@ -0,0 +1,186 @@
+/**
+ * useRendererBase
+ *
+ * Standard setup shared by all non-TipTap renderers (Kanban, Gallery, etc.).
+ * Provides: childDoc, tree (scoped to this page), awareness cursors, connectedUsers.
+ *
+ * Ported from cou-sh/app/composables/useRendererBase.ts
+ */
+import { type ShallowRef } from 'vue';
+import type * as Y from 'yjs';
+export interface RendererBaseProps {
+    docId: string;
+    childProvider: any;
+    docLabel: string;
+    pageTypes?: Array<{
+        key: string;
+        label: string;
+        icon: string;
+    }>;
+}
+export declare function useRendererBase(props: RendererBaseProps): {
+    childProviderRef: ShallowRef<any, any>;
+    childDoc: ShallowRef<Y.Doc | null, Y.Doc | null>;
+    rootDoc: any;
+    cursors: import("vue").Ref<{
+        clientId: number;
+        x: number;
+        y: number;
+        state: {
+            [x: string]: any;
+            clientId: number;
+            user?: {
+                name?: string | undefined;
+                color?: string | undefined;
+                avatar?: string | undefined;
+            } | undefined;
+        };
+    }[], {
+        clientId: number;
+        x: number;
+        y: number;
+        state: import("./useYDoc.js").AwarenessUser;
+    }[] | {
+        clientId: number;
+        x: number;
+        y: number;
+        state: {
+            [x: string]: any;
+            clientId: number;
+            user?: {
+                name?: string | undefined;
+                color?: string | undefined;
+                avatar?: string | undefined;
+            } | undefined;
+        };
+    }[]>;
+    states: import("vue").Ref<{
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    }[], import("./useYDoc.js").AwarenessUser[] | {
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    }[]>;
+    setLocalState: (state: any) => void;
+    tree: {
+        entries: import("vue").ComputedRef<import("./useChildTree.js").TreeEntry[]>;
+        childrenOf: (parentId: string | null) => import("./useChildTree.js").TreeEntry[];
+        descendantsOf: (id: string) => import("./useChildTree.js").TreeEntry[];
+        createChild: (parentId: string | null, label: string, type?: string) => string;
+        moveEntry: (id: string, newParentId: string | null, newOrder: number) => void;
+        deleteEntry: (id: string) => void;
+        renameEntry: (id: string, label: string) => void;
+        updateMeta: (id: string, patch: Partial<import("./useChildTree.js").DocPageMeta>) => void;
+        duplicateEntry: (id: string) => string;
+        treeMap: {
+            data: Record<string, {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                createdAt?: number;
+                updatedAt?: number;
+            }>;
+            lastUpdateLocal: ShallowRef<boolean, boolean>;
+            set: (key: string, value: {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                createdAt?: number;
+                updatedAt?: number;
+            }) => {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                createdAt?: number;
+                updatedAt?: number;
+            } | undefined;
+            remove: (key: string) => void | undefined;
+            clear: () => void | undefined;
+            get: (key: string) => {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                createdAt?: number;
+                updatedAt?: number;
+            } | undefined;
+            yMap: import("vue").ComputedRef<Y.Map<{
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                createdAt?: number;
+                updatedAt?: number;
+            }> | null>;
+        };
+        trashMap: {
+            data: Record<string, {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                deletedAt: number;
+            }>;
+            lastUpdateLocal: ShallowRef<boolean, boolean>;
+            set: (key: string, value: {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                deletedAt: number;
+            }) => {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                deletedAt: number;
+            } | undefined;
+            remove: (key: string) => void | undefined;
+            clear: () => void | undefined;
+            get: (key: string) => {
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                deletedAt: number;
+            } | undefined;
+            yMap: import("vue").ComputedRef<Y.Map<{
+                label: string;
+                parentId: string | null;
+                order: number;
+                type?: string;
+                meta?: import("./useChildTree.js").DocPageMeta;
+                deletedAt: number;
+            }> | null>;
+        };
+    };
+    connectedUsers: import("vue").ComputedRef<{
+        clientId: number;
+        name: string;
+        color: string;
+        avatar: string | undefined;
+        publicKey: any;
+    }[]>;
+};