@abraca/nuxt 0.2.0 → 0.3.0

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

@@ -0,0 +1,58 @@
+/**
+ * useDevicePairing
+ *
+ * Wraps ManualSignaling from @abraca/dabra for serverless device-to-device
+ * WebRTC pairing via blob exchange (QR code, copy-paste, NFC, etc.).
+ *
+ * Standalone composable — not auto-managed by the plugin. Users create and
+ * cancel pairings explicitly.
+ *
+ * Usage:
+ *   const { createOffer, acceptOffer, acceptAnswer, cancelPairing, offerBlob, pairingStatus } = useDevicePairing()
+ *
+ *   // Initiator flow:
+ *   const blob = await createOffer()   // show QR / copy
+ *   await acceptAnswer(answerBlob)      // complete connection
+ *
+ *   // Responder flow:
+ *   const answer = await acceptOffer(offerBlob)  // show QR / copy
+ */
+/**
+ * Initiator: create an offer blob to share with the other device.
+ * Returns the offer blob (also available as offerBlob ref).
+ */
+declare function createOffer(): Promise<any>;
+/**
+ * Responder: accept an offer blob from the initiator.
+ * Returns the answer blob to share back with the initiator.
+ */
+declare function acceptOffer(blob: any): Promise<any>;
+/**
+ * Initiator: accept the answer blob from the responder to complete the connection.
+ */
+declare function acceptAnswer(blob: any): Promise<void>;
+/**
+ * Cancel the current pairing attempt and clean up resources.
+ */
+declare function cancelPairing(): void;
+export declare function useDevicePairing(): {
+    /** Current role in the pairing flow. */
+    pairingRole: import("vue").Ref<"idle" | "initiator" | "responder", "idle" | "initiator" | "responder">;
+    /** Current status of the pairing attempt. */
+    pairingStatus: import("vue").Ref<"idle" | "connected" | "error" | "waiting-for-answer" | "waiting-for-offer", "idle" | "connected" | "error" | "waiting-for-answer" | "waiting-for-offer">;
+    /** The offer blob to display/share (initiator side). */
+    offerBlob: import("vue").ShallowRef<any, any>;
+    /** The answer blob to display/share (responder side). */
+    answerBlob: import("vue").ShallowRef<any, any>;
+    /** Error message if pairing failed. */
+    pairingError: import("vue").Ref<string | null, string | null>;
+    /** Initiator: create an offer blob. */
+    createOffer: typeof createOffer;
+    /** Responder: accept an offer blob and return the answer blob. */
+    acceptOffer: typeof acceptOffer;
+    /** Initiator: accept the answer blob to complete the connection. */
+    acceptAnswer: typeof acceptAnswer;
+    /** Cancel the current pairing attempt. */
+    cancelPairing: typeof cancelPairing;
+};
+export {};

package/dist/runtime/composables/useDevicePairing.js

@@ -0,0 +1,108 @@
+import { ref, shallowRef } from "vue";
+import { getSdkModule } from "../utils/sdkRef.js";
+const pairingRole = ref("idle");
+const pairingStatus = ref("idle");
+const offerBlob = shallowRef(null);
+const answerBlob = shallowRef(null);
+const pairingError = ref(null);
+let _manualSignaling = null;
+async function _resolveIceServers() {
+  const config = useRuntimeConfig();
+  const webrtcConfig = config.public.abracadabra?.webrtc ?? {};
+  if (webrtcConfig.iceServers) return webrtcConfig.iceServers;
+  try {
+    const { client } = useAbracadabra();
+    if (client.value?.getIceServers) {
+      return await client.value.getIceServers();
+    }
+  } catch (e) {
+    if (import.meta.dev) console.debug("[abracadabra] pairing: failed to fetch ICE servers from server:", e);
+  }
+  return [{ urls: "stun:stun.l.google.com:19302" }];
+}
+async function createOffer() {
+  cancelPairing();
+  const sdk = getSdkModule();
+  if (!sdk?.ManualSignaling) throw new Error("SDK not loaded \u2014 cannot create pairing");
+  const { ManualSignaling } = sdk;
+  const iceServers = await _resolveIceServers();
+  _manualSignaling = new ManualSignaling(iceServers);
+  pairingRole.value = "initiator";
+  pairingStatus.value = "waiting-for-answer";
+  pairingError.value = null;
+  try {
+    const blob = await _manualSignaling.createOfferBlob();
+    offerBlob.value = blob;
+    return blob;
+  } catch (e) {
+    pairingError.value = e.message;
+    pairingStatus.value = "error";
+    throw e;
+  }
+}
+async function acceptOffer(blob) {
+  cancelPairing();
+  const sdk = getSdkModule();
+  if (!sdk?.ManualSignaling) throw new Error("SDK not loaded \u2014 cannot create pairing");
+  const { ManualSignaling } = sdk;
+  const iceServers = await _resolveIceServers();
+  _manualSignaling = new ManualSignaling(iceServers);
+  pairingRole.value = "responder";
+  pairingError.value = null;
+  try {
+    const answer = await _manualSignaling.acceptOffer(blob);
+    answerBlob.value = answer;
+    pairingStatus.value = "connected";
+    return answer;
+  } catch (e) {
+    pairingError.value = e.message;
+    pairingStatus.value = "error";
+    throw e;
+  }
+}
+async function acceptAnswer(blob) {
+  if (!_manualSignaling) {
+    throw new Error("No active pairing \u2014 call createOffer() first");
+  }
+  try {
+    await _manualSignaling.acceptAnswer(blob);
+    pairingStatus.value = "connected";
+  } catch (e) {
+    pairingError.value = e.message;
+    pairingStatus.value = "error";
+    throw e;
+  }
+}
+function cancelPairing() {
+  if (_manualSignaling) {
+    _manualSignaling.destroy?.();
+    _manualSignaling = null;
+  }
+  pairingRole.value = "idle";
+  pairingStatus.value = "idle";
+  offerBlob.value = null;
+  answerBlob.value = null;
+  pairingError.value = null;
+}
+export function useDevicePairing() {
+  return {
+    /** Current role in the pairing flow. */
+    pairingRole,
+    /** Current status of the pairing attempt. */
+    pairingStatus,
+    /** The offer blob to display/share (initiator side). */
+    offerBlob,
+    /** The answer blob to display/share (responder side). */
+    answerBlob,
+    /** Error message if pairing failed. */
+    pairingError,
+    /** Initiator: create an offer blob. */
+    createOffer,
+    /** Responder: accept an offer blob and return the answer blob. */
+    acceptOffer,
+    /** Initiator: accept the answer blob to complete the connection. */
+    acceptAnswer,
+    /** Cancel the current pairing attempt. */
+    cancelPairing
+  };
+}

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

@@ -1,3 +1,8 @@
+export declare function labelToFilename(label: string): string;
+export declare function replaceFileMarkers(content: string, docZipPath: string, filePathMap: Map<string, {
+    zipPath: string;
+    mimeType: string;
+}>, format: 'md' | 'html'): string;
 export declare function useDocExport(): {
     exportDoc: (id: string, format: "markdown" | "html" | "zip") => Promise<void>;
     exportDocs: (ids: string[], format?: "md" | "html") => Promise<void>;

package/dist/runtime/composables/useDocExport.js

@@ -1,6 +1,6 @@
 import * as Y from "yjs";
 import { yjsToMarkdown, yjsToHtml } from "../utils/yjsConvert.js";
-function labelToFilename(label) {
+export function labelToFilename(label) {
   return label.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "untitled";
 }
 function triggerDownload(blob, filename) {
@@ -27,7 +27,7 @@ function collectFileBlocks(el, sourceDocId) {
   }
   return files;
 }
-function replaceFileMarkers(content, docZipPath, filePathMap, format) {
+export function replaceFileMarkers(content, docZipPath, filePathMap, format) {
   return content.replace(/<!--fileblock:([^:]+):(.+?)-->/g, (_, uploadId, filename) => {
     const entry = filePathMap.get(uploadId);
     if (!entry) return `<!-- file: ${filename} -->`;

package/dist/runtime/composables/useDocImport.js

@@ -6,6 +6,7 @@ export function useDocImport() {
   const toast = useToast();
   const { provider, client, isReady } = useAbracadabra();
   const { enqueue } = useOfflineUploadQueue();
+  const { getDocUrl } = useDocSlugs();
   const externalDragActive = ref(false);
   let externalDragCounter = 0;
   function getTreeMap() {
@@ -46,7 +47,7 @@ export function useDocImport() {
       const id = await importEntry(entry, parentId);
       if (firstId === null && id !== null) firstId = id;
     }
-    if (firstId) navigateTo(`${useRuntimeConfig().public.abracadabra?.docBasePath ?? "/doc"}/${firstId}`);
+    if (firstId) navigateTo(getDocUrl(firstId));
   }
   function importFiles(parentId = null) {
     const input = document.createElement("input");
@@ -59,7 +60,7 @@ export function useDocImport() {
         const id = await importFile(file, parentId);
         if (firstId === null) firstId = id;
       }
-      if (firstId) navigateTo(`${useRuntimeConfig().public.abracadabra?.docBasePath ?? "/doc"}/${firstId}`);
+      if (firstId) navigateTo(getDocUrl(firstId));
     };
     input.click();
   }
@@ -96,7 +97,7 @@ export function useDocImport() {
         const id = await importFile(file, currentParent);
         if (firstId === null) firstId = id;
       }
-      if (firstId) navigateTo(`${useRuntimeConfig().public.abracadabra?.docBasePath ?? "/doc"}/${firstId}`);
+      if (firstId) navigateTo(getDocUrl(firstId));
     };
     input.click();
   }

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

@@ -0,0 +1,20 @@
+/**
+ * useDocSeo — reactive SEO meta for an Abracadabra document.
+ *
+ * Sets useHead() title and useSeoMeta() og/twitter tags reactively
+ * from the doc-tree metadata and optional SSR render data.
+ */
+import { type MaybeRef } from 'vue';
+export interface DocSeoOptions {
+    /** Site name for og:site_name */
+    siteName?: string;
+    /** Fallback description when none can be extracted */
+    fallbackDescription?: string;
+    /** Title template, e.g. '%s - My Site'. Uses Nuxt's titleTemplate. */
+    titleTemplate?: string | ((title?: string) => string);
+}
+export declare function useDocSeo(docId: MaybeRef<string | null>, options?: DocSeoOptions): {
+    title: import("vue").ComputedRef<any>;
+    description: import("vue").ComputedRef<any>;
+    ogImage: import("vue").ComputedRef<any>;
+};

package/dist/runtime/composables/useDocSeo.js

@@ -0,0 +1,44 @@
+import { computed, unref } from "vue";
+function extractFirstParagraph(html) {
+  if (!html) return void 0;
+  const pMatch = html.match(/<p[^>]*>(.*?)<\/p>/is);
+  const raw = pMatch?.[1] ?? html;
+  const text = raw.replace(/<[^>]+>/g, "").replace(/&[a-z]+;/gi, " ").trim();
+  if (!text) return void 0;
+  return text.length > 160 ? text.slice(0, 157) + "..." : text;
+}
+function extractFirstImage(html) {
+  if (!html) return void 0;
+  const match = html.match(/<img[^>]+src=["']([^"']+)["']/i);
+  return match?.[1] ?? void 0;
+}
+export function useDocSeo(docId, options) {
+  const abra = useAbracadabra();
+  const treeMap = useSyncedMap(abra.doc, "doc-tree");
+  const resolvedId = computed(() => unref(docId) ?? "");
+  const entry = computed(() => resolvedId.value ? treeMap.data[resolvedId.value] : void 0);
+  const { data: renderData } = useFetch(
+    () => resolvedId.value ? `/api/_abracadabra/render/${resolvedId.value}` : null,
+    { key: `seo-${resolvedId.value}`, server: true, lazy: true }
+  );
+  const title = computed(() => entry.value?.label ?? "Untitled");
+  const description = computed(
+    () => entry.value?.meta?.note ?? entry.value?.meta?.description ?? renderData.value?.description ?? extractFirstParagraph(renderData.value?.html) ?? options?.fallbackDescription ?? ""
+  );
+  const ogImage = computed(
+    () => entry.value?.meta?.coverImage ?? renderData.value?.ogImage ?? extractFirstImage(renderData.value?.html) ?? void 0
+  );
+  useHead({
+    title,
+    ...options?.titleTemplate ? { titleTemplate: options.titleTemplate } : {}
+  });
+  useSeoMeta({
+    ogTitle: title,
+    ogDescription: description,
+    ...options?.siteName ? { ogSiteName: options.siteName } : {},
+    ogType: "article",
+    twitterCard: "summary",
+    ...ogImage.value ? { ogImage } : {}
+  });
+  return { title, description, ogImage };
+}

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

@@ -0,0 +1,7 @@
+import { type SlugMap } from '../utils/slugify.js';
+export declare function useDocSlugs(): {
+    slugMap: import("vue").ComputedRef<SlugMap>;
+    getSlug: (docId: string) => string;
+    getDocId: (slug: string) => string | null;
+    getDocUrl: (docId: string) => string;
+};

package/dist/runtime/composables/useDocSlugs.js

@@ -0,0 +1,20 @@
+import { computed } from "vue";
+import { buildSlugMap } from "../utils/slugify.js";
+export function useDocSlugs() {
+  const abra = useAbracadabra();
+  const config = useRuntimeConfig();
+  const docBasePath = config.public?.abracadabra?.docBasePath ?? "/doc";
+  const treeMap = useSyncedMap(abra.doc, "doc-tree");
+  const entries = computed(
+    () => Object.entries(treeMap.data).map(([id, entry]) => ({ id, ...entry }))
+  );
+  const slugMap = computed(() => buildSlugMap(entries.value));
+  const getSlug = (docId) => slugMap.value.idToSlug[docId] ?? docId;
+  const getDocId = (slug) => slugMap.value.slugToId[slug] ?? null;
+  const getDocUrl = (docId) => {
+    const slug = slugMap.value.idToSlug[docId];
+    const path = slug ?? docId;
+    return docBasePath ? `${docBasePath}/${path}` : `/${path}`;
+  };
+  return { slugMap, getSlug, getDocId, getDocUrl };
+}

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

@@ -0,0 +1,34 @@
+/**
+ * useDocTree — reactive access to the Abracadabra document tree.
+ *
+ * Wraps useSyncedMap on the root Y.Doc's 'doc-tree' map and provides
+ * computed navigation helpers: topLevelDocs, firstDocId, navigationItems.
+ * Navigation items use human-readable slug URLs when available.
+ */
+import { type ComputedRef } from 'vue';
+import type { TreeEntry } from '../types.js';
+export interface DocTreeReturn {
+    /** All tree entries with `id` populated from map keys */
+    entries: ComputedRef<(TreeEntry & {
+        trashed?: boolean;
+    })[]>;
+    /** Top-level docs (no parent, not trashed), sorted by order */
+    topLevelDocs: ComputedRef<(TreeEntry & {
+        trashed?: boolean;
+    })[]>;
+    /** ID of the first top-level document, or null */
+    firstDocId: ComputedRef<string | null>;
+    /** Look up a single tree entry by ID */
+    getEntry: (id: string) => TreeEntry | undefined;
+    /** Navigation items with resolved doc-type icons and slug URLs */
+    navigationItems: ComputedRef<{
+        id: string;
+        label: string;
+        to: string;
+        icon: string;
+        type: string;
+    }[]>;
+    /** Raw useSyncedMap return for advanced usage */
+    raw: ReturnType<typeof useSyncedMap>;
+}
+export declare function useDocTree(): DocTreeReturn;

package/dist/runtime/composables/useDocTree.js

@@ -0,0 +1,35 @@
+import { computed } from "vue";
+import { resolveDocType } from "../utils/docTypes.js";
+import { buildSlugMap } from "../utils/slugify.js";
+export function useDocTree() {
+  const abra = useAbracadabra();
+  const config = useRuntimeConfig();
+  const docBasePath = config.public?.abracadabra?.docBasePath ?? "/doc";
+  const treeMap = useSyncedMap(abra.doc, "doc-tree");
+  const entries = computed(
+    () => Object.entries(treeMap.data).map(([id, entry]) => ({ id, ...entry }))
+  );
+  const topLevelDocs = computed(
+    () => entries.value.filter((e) => !e.parentId && !e.trashed).sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+  );
+  const firstDocId = computed(() => topLevelDocs.value[0]?.id ?? null);
+  const getEntry = (id) => {
+    const raw = treeMap.data[id];
+    return raw ? { id, ...raw } : void 0;
+  };
+  const slugMap = computed(() => buildSlugMap(entries.value));
+  const navigationItems = computed(
+    () => topLevelDocs.value.map((e) => {
+      const slug = slugMap.value.idToSlug[e.id];
+      const path = slug ?? e.id;
+      return {
+        id: e.id,
+        label: e.label || "Untitled",
+        to: docBasePath ? `${docBasePath}/${path}` : `/${path}`,
+        icon: resolveDocType(e.type).icon,
+        type: e.type ?? "doc"
+      };
+    })
+  );
+  return { entries, topLevelDocs, firstDocId, getEntry, navigationItems, raw: treeMap };
+}

package/dist/runtime/composables/useEditorDragHandle.js

@@ -55,7 +55,8 @@ export function useEditorDragHandle(pageConfig) {
               a.href = url;
               a.download = filename;
               a.click();
-            } catch {
+            } catch (e) {
+              if (import.meta.dev) console.warn("[abracadabra] drag-handle: failed to download file:", e);
             }
           }
         }

package/dist/runtime/composables/useEditorMentions.js

@@ -19,7 +19,8 @@ export function useEditorMentions(options = {}) {
             });
           }
         }
-      } catch {
+      } catch (e) {
+        if (import.meta.dev) console.warn("[abracadabra] mentions: failed to read awareness states:", e);
       }
     }
     try {
@@ -29,7 +30,8 @@ export function useEditorMentions(options = {}) {
           result.push(...p.staticItems);
         }
       }
-    } catch {
+    } catch (e) {
+      if (import.meta.dev) console.warn("[abracadabra] mentions: failed to load plugin mention providers:", e);
     }
     if (options.extraItems?.length) {
       result.push(...options.extraItems);

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

@@ -15,4 +15,5 @@ export interface UseEditorSuggestionsOptions {
 }
 export declare function useEditorSuggestions(options?: UseEditorSuggestionsOptions): {
     items: any;
+    propertiesOnlyItems: any;
 };

package/dist/runtime/composables/useEditorSuggestions.js

@@ -47,9 +47,16 @@ export function useEditorSuggestions(options = {}) {
       for (const group of pluginGroups) {
         if (group.items?.length) base.push(group.items);
       }
-    } catch {
+    } catch (e) {
+      if (import.meta.dev) console.warn("[abracadabra] suggestions: failed to load plugin suggestions:", e);
     }
     return base;
   });
-  return { items };
+  const propertiesOnlyItems = computed(() => {
+    const group = items.value.find(
+      (g) => g[0]?.type === "label" && g[0]?.label === "Properties"
+    );
+    return group ? [group] : [];
+  });
+  return { items, propertiesOnlyItems };
 }

package/dist/runtime/composables/useEditorToolbar.js

@@ -49,7 +49,8 @@ export function useEditorToolbar(options = {}) {
           base.push(group.items);
         }
       }
-    } catch {
+    } catch (e) {
+      if (import.meta.dev) console.warn("[abracadabra] toolbar: failed to load plugin toolbar items:", e);
     }
     if (options.extraItems?.length) {
       base.push(...options.extraItems);

package/dist/runtime/composables/useFileIndex.js

@@ -43,7 +43,8 @@ function _startWatcher() {
           if (val.docId === docId) _fileEntries.delete(key);
         }
         for (const f of files) _fileEntries.set(f.uploadId, f);
-      } catch {
+      } catch (e) {
+        if (import.meta.dev) console.warn(`[abracadabra] file-index: failed to index doc ${docId}:`, e);
       }
     }
   }, { deep: false });

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

@@ -0,0 +1,112 @@
+/**
+ * useFileTransfer
+ *
+ * Tracks inbound and outbound P2P file transfers over WebRTC data channels.
+ * Events are wired from AbracadabraWebRTC when useWebRTC connects.
+ *
+ * Usage:
+ *   const { inboundTransfers, completedFiles, sendFile, downloadFile } = useFileTransfer()
+ */
+export interface FileTransferMeta {
+    transferId: string;
+    peerId: string;
+    filename: string;
+    mimeType: string;
+    totalSize: number;
+    progress: number;
+    status: 'pending' | 'receiving' | 'sending' | 'complete' | 'error' | 'cancelled';
+}
+export interface CompletedFile {
+    transferId: string;
+    peerId: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    blob: Blob;
+    objectUrl: string;
+    receivedAt: number;
+}
+export declare function _wireFileTransferEvents(rtc: any): void;
+export declare function _destroyFileTransfer(): void;
+declare function sendFile(peerId: string, file: File | Blob, filename: string): Promise<void>;
+declare function downloadFile(transferId: string): void;
+declare function clearCompleted(): void;
+export declare function useFileTransfer(): {
+    /** Active inbound file transfers. */
+    inboundTransfers: import("vue").ShallowRef<Map<string, FileTransferMeta>, Map<string, FileTransferMeta>>;
+    /** Active outbound file transfers. */
+    outboundTransfers: import("vue").ShallowRef<Map<string, FileTransferMeta>, Map<string, FileTransferMeta>>;
+    /** Completed received files (with object URLs for download). */
+    completedFiles: import("vue").Ref<{
+        transferId: string;
+        peerId: string;
+        filename: string;
+        mimeType: string;
+        size: number;
+        blob: {
+            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>;
+            };
+        };
+        objectUrl: string;
+        receivedAt: number;
+    }[], CompletedFile[] | {
+        transferId: string;
+        peerId: string;
+        filename: string;
+        mimeType: string;
+        size: number;
+        blob: {
+            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>;
+            };
+        };
+        objectUrl: string;
+        receivedAt: number;
+    }[]>;
+    /** Send a file to a specific peer. */
+    sendFile: typeof sendFile;
+    /** Trigger browser download for a completed file. */
+    downloadFile: typeof downloadFile;
+    /** Clear all completed transfers and revoke object URLs. */
+    clearCompleted: typeof clearCompleted;
+};
+export {};