@abraca/nuxt 0.2.0 → 1.5.0

package/dist/runtime/composables/useEditorToolbar.js

@@ -1,3 +1,6 @@
+import { computed } from "vue";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { usePluginRegistry } from "./usePluginRegistry.js";
 export function useEditorToolbar(options = {}) {
   const registry = usePluginRegistry();
   const abra = useAbracadabra();
@@ -49,7 +52,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/useFavorites.d.ts

@@ -0,0 +1,13 @@
+import type { ShallowRef } from 'vue';
+import type * as Y from 'yjs';
+export declare function useFavorites(rootDoc: ShallowRef<Y.Doc | null>, options?: {
+    readonly?: boolean;
+}): {
+    favorites: import("vue").ComputedRef<string[]>;
+    isFavorite: (id: string) => boolean;
+    addFavorite: (id: string) => void;
+    addFavoriteAt: (id: string, index: number) => void;
+    removeFavorite: (id: string) => void;
+    moveFavorite: (from: number, to: number) => void;
+    toggleFavorite: (id: string) => void;
+};

package/dist/runtime/composables/useFavorites.js

@@ -0,0 +1,42 @@
+import { computed } from "vue";
+import { useSyncedArray } from "./useYDoc.js";
+export function useFavorites(rootDoc, options) {
+  const { list, push, deleteAt, insert } = useSyncedArray(
+    rootDoc,
+    "doc-favorites"
+  );
+  const favorites = computed(() => list.value);
+  function isFavorite(id) {
+    return list.value.includes(id);
+  }
+  function addFavorite(id) {
+    if (options?.readonly) return;
+    if (!isFavorite(id)) push(id);
+  }
+  function removeFavorite(id) {
+    if (options?.readonly) return;
+    const idx = list.value.indexOf(id);
+    if (idx >= 0) deleteAt(idx);
+  }
+  function moveFavorite(from, to) {
+    if (options?.readonly) return;
+    const doc = rootDoc.value;
+    if (!doc) return;
+    const id = list.value[from];
+    if (!id) return;
+    doc.transact(() => {
+      deleteAt(from);
+      insert(to > from ? to - 1 : to, [id]);
+    });
+  }
+  function addFavoriteAt(id, index) {
+    if (options?.readonly) return;
+    if (isFavorite(id)) return;
+    insert(Math.min(index, list.value.length), [id]);
+  }
+  function toggleFavorite(id) {
+    if (isFavorite(id)) removeFavorite(id);
+    else addFavorite(id);
+  }
+  return { favorites, isFavorite, addFavorite, addFavoriteAt, removeFavorite, moveFavorite, toggleFavorite };
+}

package/dist/runtime/composables/useFileIndex.js

@@ -1,5 +1,7 @@
 import { watch } from "vue";
 import * as Y from "yjs";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { useBackgroundSync } from "./useBackgroundSync.js";
 let _fileEntries = /* @__PURE__ */ new Map();
 let _stopWatcher = null;
 function walkXmlForFiles(node, docId, docLabel, results) {
@@ -43,7 +45,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 {};

package/dist/runtime/composables/useFileTransfer.js

@@ -0,0 +1,183 @@
+import { ref, shallowRef } from "vue";
+import { useWebRTC } from "./useWebRTC.js";
+const MAX_COMPLETED_FILES = 50;
+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);
+    const updated = [
+      ...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()
+      }
+    ];
+    while (updated.length > MAX_COMPLETED_FILES) {
+      const evicted = updated.shift();
+      if (evicted) {
+        try {
+          URL.revokeObjectURL(evicted.objectUrl);
+        } catch {
+        }
+      }
+    }
+    completedFiles.value = updated;
+  });
+  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

@@ -1,8 +1,11 @@
 import { ref } from "vue";
+import { navigateTo } from "#imports";
+import { useDocSlugs } from "./useDocSlugs.js";
 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 +21,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/useIdentityDoc.d.ts

@@ -0,0 +1,89 @@
+import type * as Y from 'yjs';
+/**
+ * Initialize the identity doc for the given public key.
+ * Call this once the keystore has provided the account-level public key.
+ * Safe to call multiple times — only the first call initializes.
+ *
+ * @param publicKeyB64 Base64url Ed25519 public key
+ * @param signChallenge Optional signing function for crypto auth with servers
+ * @param opts Optional WebRTC/E2EE config (consuming app provides its own E2EE setup)
+ * @param opts.webrtc WebRTC configuration
+ * @param opts.webrtc.signalingServerUrl URL of the signaling server
+ * @param opts.webrtc.token Function returning a token promise
+ * @param opts.webrtc.e2ee End-to-end encryption keypair
+ * @param opts.webrtc.e2ee.publicKey Public key for E2EE
+ * @param opts.webrtc.e2ee.privateKey Private key for E2EE
+ */
+declare function init(publicKeyB64: string, signChallenge?: (challenge: string) => Promise<string>, opts?: {
+    webrtc?: {
+        signalingServerUrl: string;
+        token: () => Promise<string>;
+        e2ee?: {
+            publicKey: string;
+            privateKey: string;
+        };
+    };
+}): Promise<void>;
+declare function setUserName(name: string): void;
+declare function setUserColor(colorName: string): void;
+declare function setNeutralColor(colorName: string): void;
+declare function setSecurityTier(tier: 'relaxed' | 'standard' | 'paranoid'): void;
+declare function getServers(): Map<string, any>;
+declare function setServer(url: string, entry: any): void;
+declare function removeServer(url: string): void;
+declare function getSpaces(): any[];
+declare function addSpace(space: any): void;
+declare function removeSpace(spaceId: string): void;
+declare function updateSpace(spaceId: string, updates: Record<string, any>): void;
+declare function observeSpaces(callback: (event: any, transaction: any) => void): () => void;
+declare function getDevices(): Map<string, any>;
+declare function getDevice(publicKey: string): any | undefined;
+declare function addDevice(publicKey: string, opts: {
+    deviceName: string;
+    tier?: string;
+    x25519Key?: string;
+    serverUrl?: string;
+    keyId?: string;
+}): void;
+declare function revokeDevice(publicKey: string, revokedBy: string): void;
+declare function observeDevices(callback: (events: any[], transaction: any) => void): () => void;
+declare function connectSyncServer(url: string): void;
+declare function disconnectSyncServer(): void;
+declare function setSyncServerUrl(url: string | null): void;
+declare function getSyncServerUrl(): string | null;
+declare function getDocument(): Y.Doc | null;
+declare function getProvider(): any;
+declare function destroy(): void;
+export declare function useIdentityDoc(): {
+    ready: import("vue").Ref<boolean, boolean>;
+    userName: import("vue").Ref<string, string>;
+    userColorName: import("vue").Ref<string, string>;
+    neutralColorName: import("vue").Ref<string, string>;
+    securityTier: import("vue").Ref<"relaxed" | "standard" | "paranoid", "relaxed" | "standard" | "paranoid">;
+    init: typeof init;
+    destroy: typeof destroy;
+    setUserName: typeof setUserName;
+    setUserColor: typeof setUserColor;
+    setNeutralColor: typeof setNeutralColor;
+    setSecurityTier: typeof setSecurityTier;
+    getServers: typeof getServers;
+    setServer: typeof setServer;
+    removeServer: typeof removeServer;
+    getSpaces: typeof getSpaces;
+    addSpace: typeof addSpace;
+    removeSpace: typeof removeSpace;
+    updateSpace: typeof updateSpace;
+    observeSpaces: typeof observeSpaces;
+    getDevices: typeof getDevices;
+    getDevice: typeof getDevice;
+    addDevice: typeof addDevice;
+    revokeDevice: typeof revokeDevice;
+    observeDevices: typeof observeDevices;
+    connectSyncServer: typeof connectSyncServer;
+    disconnectSyncServer: typeof disconnectSyncServer;
+    setSyncServerUrl: typeof setSyncServerUrl;
+    getSyncServerUrl: typeof getSyncServerUrl;
+    getDocument: typeof getDocument;
+    getProvider: typeof getProvider;
+};
+export {};