@abraca/nuxt 0.1.0

package/dist/runtime/composables/useRendererBase.js

@@ -0,0 +1,46 @@
+import { shallowRef, computed, watch, watchEffect } from "vue";
+import { useSmoothedCursors } from "./useYDoc.js";
+import { useChildTree } from "./useChildTree.js";
+export function useRendererBase(props) {
+  const { doc: rootDoc, userName, userColor, publicKeyB64 } = useAbracadabra();
+  const childProviderRef = shallowRef(null);
+  const childDoc = shallowRef(null);
+  watch(
+    () => props.childProvider,
+    (p) => {
+      childProviderRef.value = p;
+      childDoc.value = p?.document ?? null;
+    },
+    { immediate: true }
+  );
+  const { cursors, states, setLocalState } = useSmoothedCursors(childProviderRef, "pos");
+  watchEffect(() => {
+    if (!childProviderRef.value) return;
+    const name = userName.value;
+    const color = userColor.value;
+    const publicKey = publicKeyB64.value;
+    if (name && publicKey) {
+      setLocalState({ user: { name, color, publicKey } });
+    }
+  });
+  const tree = useChildTree(rootDoc, props.docId);
+  const connectedUsers = computed(
+    () => states.value.map((s) => ({
+      clientId: s.clientId,
+      name: s.user?.name ?? "",
+      color: s.user?.color ?? "#888",
+      avatar: s.user?.avatar,
+      publicKey: s.user?.publicKey
+    }))
+  );
+  return {
+    childProviderRef,
+    childDoc,
+    rootDoc,
+    cursors,
+    states,
+    setLocalState,
+    tree,
+    connectedUsers
+  };
+}

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

@@ -0,0 +1,20 @@
+/**
+ * useSearchIndex
+ *
+ * Full-text search over all synced documents. Wraps SearchIndex from @abraca/dabra.
+ * Watches BackgroundSync sync states and re-indexes docs when they sync.
+ * Initialized by the main plugin; destroyed on server switch.
+ */
+interface SearchResult {
+    docId: string;
+    score: number;
+    excerpt?: string;
+}
+export declare function _initSearchIndex(serverOrigin: string): void;
+export declare function _destroySearchIndex(): void;
+export declare function useSearchIndex(): {
+    search: (query: string, limit?: number) => Promise<SearchResult[]>;
+    isReady: import("vue").ComputedRef<boolean>;
+    indexedCount: import("vue").ComputedRef<number>;
+};
+export {};

package/dist/runtime/composables/useSearchIndex.js

@@ -0,0 +1,104 @@
+import { ref, computed, watch } from "vue";
+import * as Y from "yjs";
+let _searchIndex = null;
+const _indexedVersions = /* @__PURE__ */ new Map();
+const _isReady = ref(false);
+const _indexedCount = ref(0);
+let _stopWatcher = null;
+function walkXmlForText(node, texts) {
+  for (const child of node.toArray()) {
+    if (child instanceof Y.XmlText) {
+      const t = child.toString().trim();
+      if (t) texts.push(t);
+    } else if (child instanceof Y.XmlElement) {
+      if (child.nodeName === "fileBlock") {
+        const filename = child.getAttribute("filename");
+        const mimeType = child.getAttribute("mimeType");
+        if (filename) texts.push(filename);
+        if (mimeType) texts.push(mimeType);
+      }
+      walkXmlForText(child, texts);
+    }
+  }
+}
+function extractDocTexts(ydoc, label, meta) {
+  const texts = [];
+  if (label) texts.push(label);
+  if (meta) {
+    const searchableFields = ["subtitle", "note", "url", "status", "geoDescription"];
+    for (const field of searchableFields) {
+      const val = meta[field];
+      if (typeof val === "string" && val.trim()) texts.push(val.trim());
+    }
+    if (Array.isArray(meta.tags)) {
+      const joined = meta.tags.filter((t) => typeof t === "string").join(" ");
+      if (joined) texts.push(joined);
+    }
+  }
+  try {
+    const fragment = ydoc.getXmlFragment("default");
+    walkXmlForText(fragment, texts);
+  } catch {
+  }
+  return texts;
+}
+export function _initSearchIndex(serverOrigin) {
+  import("@abraca/dabra").then(({ SearchIndex }) => {
+    _searchIndex = new SearchIndex(serverOrigin);
+    _isReady.value = true;
+    _indexedVersions.clear();
+    _indexedCount.value = 0;
+    _startWatcher();
+  }).catch(() => {
+  });
+}
+export function _destroySearchIndex() {
+  _stopWatcher?.();
+  _stopWatcher = null;
+  _searchIndex?.destroy();
+  _searchIndex = null;
+  _isReady.value = false;
+  _indexedVersions.clear();
+  _indexedCount.value = 0;
+}
+function _startWatcher() {
+  const { syncStates } = useBackgroundSync();
+  const { provider } = useAbracadabra();
+  const stop = watch(syncStates, async (states) => {
+    if (!_searchIndex) return;
+    const p = provider.value;
+    if (!p) return;
+    for (const [docId, state] of states.entries()) {
+      if (state.status !== "synced") continue;
+      const lastSynced = state.lastSynced ?? 0;
+      if (_indexedVersions.get(docId) === lastSynced) continue;
+      try {
+        const childProvider = await p.loadChild(docId);
+        await childProvider.ready;
+        const rootDoc = p.document;
+        const treeMap = rootDoc.getMap("doc-tree");
+        const entry = treeMap.get(docId);
+        const texts = extractDocTexts(childProvider.document, entry?.label ?? "", entry?.meta);
+        await _searchIndex.index(docId, texts);
+        _indexedVersions.set(docId, lastSynced);
+        _indexedCount.value = _indexedVersions.size;
+      } catch {
+      }
+    }
+  }, { deep: false });
+  _stopWatcher = stop;
+}
+export function useSearchIndex() {
+  return {
+    search: async (query, limit = 15) => {
+      if (!_searchIndex) return [];
+      try {
+        return await _searchIndex.search(query, limit);
+      } catch {
+        return [];
+      }
+    },
+    isReady: computed(() => _isReady.value),
+    indexedCount: computed(() => _indexedCount.value)
+  };
+}

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

@@ -0,0 +1,50 @@
+/**
+ * useTrash
+ *
+ * Document trash management over the 'doc-trash' Y.Map.
+ * Supports moving docs (and descendants) to trash, restoring, permanent delete,
+ * and auto-purge of expired entries.
+ *
+ * Usage:
+ *   const { trashedItems, moveToTrash, restoreFromTrash, emptyTrash } = useTrash()
+ */
+import type { ShallowRef } from 'vue';
+import * as Y from 'yjs';
+export interface TrashEntry {
+    label: string;
+    parentId: string | null;
+    order: number;
+    type?: string;
+    meta?: Record<string, any>;
+    deletedAt: number;
+    deletedBy?: string;
+}
+export declare function useTrash(rootDoc?: ShallowRef<Y.Doc | null>): {
+    trashMap: {
+        data: Record<string, TrashEntry>;
+        lastUpdateLocal: ShallowRef<boolean, boolean>;
+        set: (key: string, value: TrashEntry) => TrashEntry | undefined;
+        remove: (key: string) => void | undefined;
+        clear: () => void | undefined;
+        get: (key: string) => TrashEntry | undefined;
+        yMap: import("vue").ComputedRef<Y.Map<TrashEntry> | null>;
+    };
+    trashedItems: import("vue").ComputedRef<{
+        label: string;
+        parentId: string | null;
+        order: number;
+        type?: string;
+        meta?: Record<string, any>;
+        deletedAt: number;
+        deletedBy?: string;
+        id: string;
+    }[]>;
+    trashedCount: import("vue").ComputedRef<number>;
+    autoPurgeDays: import("vue").Ref<number, number>;
+    setAutoPurgeDays: (days: number) => void;
+    moveToTrash: (docId: string, deletedBy?: string) => void;
+    restoreFromTrash: (docId: string) => void;
+    permanentlyDelete: (docId: string) => void;
+    emptyTrash: () => void;
+    purgeExpired: () => void;
+};

package/dist/runtime/composables/useTrash.js

@@ -0,0 +1,127 @@
+import { computed, ref } from "vue";
+import { useSyncedMap } from "./useYDoc.js";
+const TRASH_SETTINGS_KEY = "abracadabra_trash_settings";
+function loadTrashSettings() {
+  try {
+    const raw = localStorage.getItem(TRASH_SETTINGS_KEY);
+    if (raw) return JSON.parse(raw);
+  } catch {
+  }
+  return { autoPurgeDays: 30 };
+}
+function saveTrashSettings(settings) {
+  try {
+    localStorage.setItem(TRASH_SETTINGS_KEY, JSON.stringify(settings));
+  } catch {
+  }
+}
+export function useTrash(rootDoc) {
+  const { doc: globalDoc, userName } = useAbracadabra();
+  const _doc = rootDoc ?? globalDoc;
+  const trashMap = useSyncedMap(_doc, "doc-trash");
+  const treeMap = useSyncedMap(_doc, "doc-tree");
+  const autoPurgeDays = ref(loadTrashSettings().autoPurgeDays);
+  function setAutoPurgeDays(days) {
+    autoPurgeDays.value = days;
+    saveTrashSettings({ autoPurgeDays: days });
+  }
+  const trashedItems = computed(
+    () => Object.entries(trashMap.data).map(([id, entry]) => ({ id, ...entry })).sort((a, b) => b.deletedAt - a.deletedAt)
+  );
+  const trashedCount = computed(() => Object.keys(trashMap.data).length);
+  function collectDescendants(id) {
+    const result = [id];
+    for (const [cid, entry] of Object.entries(treeMap.data)) {
+      if (entry.parentId === id) result.push(...collectDescendants(cid));
+    }
+    return result;
+  }
+  function moveToTrash(docId, deletedBy) {
+    const doc = _doc.value;
+    if (!doc) return;
+    const now = Date.now();
+    doc.transact(() => {
+      for (const id of collectDescendants(docId)) {
+        const entry = treeMap.get(id);
+        if (!entry) continue;
+        trashMap.set(id, {
+          label: entry.label || "Untitled",
+          parentId: entry.parentId,
+          order: entry.order ?? 0,
+          type: entry.type,
+          meta: entry.meta,
+          deletedAt: now,
+          deletedBy: deletedBy ?? userName.value
+        });
+        treeMap.remove(id);
+      }
+    });
+  }
+  function restoreFromTrash(docId) {
+    const doc = _doc.value;
+    if (!doc) return;
+    const entry = trashMap.get(docId);
+    if (!entry) return;
+    const { deletedAt } = entry;
+    doc.transact(() => {
+      const toRestore = Object.entries(trashMap.data).filter(([, e]) => Math.abs(e.deletedAt - deletedAt) < 1e3);
+      for (const [id, trashEntry] of toRestore) {
+        const parentExists = trashEntry.parentId === null || treeMap.get(trashEntry.parentId) !== void 0 || toRestore.some(([rid]) => rid === trashEntry.parentId);
+        treeMap.set(id, {
+          label: trashEntry.label,
+          parentId: parentExists ? trashEntry.parentId : null,
+          order: trashEntry.order,
+          type: trashEntry.type,
+          meta: trashEntry.meta
+        });
+        trashMap.remove(id);
+      }
+    });
+  }
+  function permanentlyDelete(docId) {
+    trashMap.remove(docId);
+    cleanupIDB(docId);
+  }
+  function emptyTrash() {
+    const doc = _doc.value;
+    if (!doc) return;
+    const ids = Object.keys(trashMap.data);
+    doc.transact(() => {
+      for (const id of ids) trashMap.remove(id);
+    });
+    for (const id of ids) cleanupIDB(id);
+  }
+  function purgeExpired() {
+    if (autoPurgeDays.value <= 0) return;
+    const cutoff = Date.now() - autoPurgeDays.value * 24 * 60 * 60 * 1e3;
+    const expired = Object.entries(trashMap.data).filter(([, e]) => e.deletedAt < cutoff).map(([id]) => id);
+    if (!expired.length) return;
+    const doc = _doc.value;
+    if (!doc) return;
+    doc.transact(() => {
+      for (const id of expired) trashMap.remove(id);
+    });
+    for (const id of expired) cleanupIDB(id);
+  }
+  async function cleanupIDB(docId) {
+    try {
+      const dbs = await indexedDB.databases();
+      for (const db of dbs) {
+        if (db.name?.includes(docId)) indexedDB.deleteDatabase(db.name);
+      }
+    } catch {
+    }
+  }
+  return {
+    trashMap,
+    trashedItems,
+    trashedCount,
+    autoPurgeDays,
+    setAutoPurgeDays,
+    moveToTrash,
+    restoreFromTrash,
+    permanentlyDelete,
+    emptyTrash,
+    purgeExpired
+  };
+}

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

@@ -0,0 +1,51 @@
+import type { VoiceConnectionStatus, VoicePeer } from '../utils/VoiceClient.js';
+import type { VoiceError } from '../utils/voiceErrors.js';
+declare function joinRoom(docId: string): Promise<void>;
+declare function leaveRoom(): void;
+declare function toggleMute(): Promise<void>;
+declare function toggleVideo(): Promise<void>;
+declare function toggleScreen(): Promise<void>;
+declare function togglePeerMute(peerId: string): void;
+declare function setMasterVolume(volume: number): void;
+declare function setPeerVolume(peerId: string, volume: number): void;
+export declare function useVoice(): {
+    voiceStatus: import("vue").Ref<VoiceConnectionStatus, VoiceConnectionStatus>;
+    voiceRoomId: import("vue").Ref<string | null, string | null>;
+    isMuted: import("vue").Ref<boolean, boolean>;
+    isVideoEnabled: import("vue").Ref<boolean, boolean>;
+    isScreenEnabled: import("vue").Ref<boolean, boolean>;
+    voiceError: import("vue").Ref<{
+        code: import("../utils/voiceErrors.js").VoiceErrorCode;
+        message: string;
+    } | null, VoiceError | {
+        code: import("../utils/voiceErrors.js").VoiceErrorCode;
+        message: string;
+    } | null>;
+    localAudioLevel: import("vue").Ref<number, number>;
+    masterVolume: import("vue").Ref<number, number>;
+    peers: import("vue").ShallowRef<Map<string, VoicePeer>, Map<string, VoicePeer>>;
+    audioLevels: import("vue").ShallowRef<Map<string, number>, Map<string, number>>;
+    localVideoStream: import("vue").ShallowRef<MediaStream | null, MediaStream | null>;
+    localScreenStream: import("vue").ShallowRef<MediaStream | null, MediaStream | null>;
+    peerVideoStreams: import("vue").ShallowRef<Map<string, {
+        camera: MediaStream | null;
+        screen: MediaStream | null;
+    }>, Map<string, {
+        camera: MediaStream | null;
+        screen: MediaStream | null;
+    }>>;
+    peerList: import("vue").ComputedRef<VoicePeer[]>;
+    peerCount: import("vue").ComputedRef<number>;
+    anyPeerSpeaking: import("vue").ComputedRef<boolean>;
+    canScreenShare: import("vue").ComputedRef<boolean>;
+    hasAnyVideo: import("vue").ComputedRef<boolean>;
+    joinRoom: typeof joinRoom;
+    leaveRoom: typeof leaveRoom;
+    toggleMute: typeof toggleMute;
+    toggleVideo: typeof toggleVideo;
+    toggleScreen: typeof toggleScreen;
+    togglePeerMute: typeof togglePeerMute;
+    setMasterVolume: typeof setMasterVolume;
+    setPeerVolume: typeof setPeerVolume;
+};
+export {};

package/dist/runtime/composables/useVoice.js

@@ -0,0 +1,220 @@
+import { ref, shallowRef, computed } from "vue";
+import { VoiceClient } from "../utils/VoiceClient.js";
+import { TRANSIENT_ERROR_CODES } from "../utils/voiceErrors.js";
+const voiceStatus = ref("idle");
+const voiceRoomId = ref(null);
+const isMuted = ref(false);
+const isVideoEnabled = ref(false);
+const isScreenEnabled = ref(false);
+const voiceError = ref(null);
+const localAudioLevel = ref(0);
+const masterVolume = ref(1);
+const peers = shallowRef(/* @__PURE__ */ new Map());
+const audioLevels = shallowRef(/* @__PURE__ */ new Map());
+const localVideoStream = shallowRef(null);
+const localScreenStream = shallowRef(null);
+const peerVideoStreams = shallowRef(/* @__PURE__ */ new Map());
+let _client = null;
+const _unbinds = [];
+function _cleanup() {
+  for (const unsub of _unbinds) unsub();
+  _unbinds.length = 0;
+  if (_client) {
+    _client.disconnect();
+    _client = null;
+  }
+  voiceStatus.value = "idle";
+  voiceRoomId.value = null;
+  isMuted.value = false;
+  isVideoEnabled.value = false;
+  isScreenEnabled.value = false;
+  voiceError.value = null;
+  localAudioLevel.value = 0;
+  peers.value = /* @__PURE__ */ new Map();
+  audioLevels.value = /* @__PURE__ */ new Map();
+  localVideoStream.value = null;
+  localScreenStream.value = null;
+  peerVideoStreams.value = /* @__PURE__ */ new Map();
+}
+function _wireEvents(vc) {
+  _unbinds.push(
+    vc.on("statusChange", (s) => {
+      voiceStatus.value = s;
+      if (s === "connected") voiceError.value = null;
+    })
+  );
+  _unbinds.push(
+    vc.on("peerJoined", () => {
+      peers.value = new Map(vc.peers);
+    })
+  );
+  _unbinds.push(
+    vc.on("peerLeft", (peerId) => {
+      peers.value = new Map(vc.peers);
+      const next = new Map(audioLevels.value);
+      next.delete(peerId);
+      audioLevels.value = next;
+      const nextVid = new Map(peerVideoStreams.value);
+      nextVid.delete(peerId);
+      peerVideoStreams.value = nextVid;
+    })
+  );
+  _unbinds.push(
+    vc.on("peerStream", () => {
+      peers.value = new Map(vc.peers);
+    })
+  );
+  _unbinds.push(
+    vc.on("audioLevel", (peerId, level) => {
+      const next = new Map(audioLevels.value);
+      next.set(peerId, level);
+      audioLevels.value = next;
+    })
+  );
+  _unbinds.push(
+    vc.on("localAudioLevel", (level) => {
+      localAudioLevel.value = level;
+    })
+  );
+  _unbinds.push(
+    vc.on("mute", (m) => {
+      isMuted.value = m;
+    })
+  );
+  _unbinds.push(
+    vc.on("remoteMute", () => {
+      peers.value = new Map(vc.peers);
+    })
+  );
+  _unbinds.push(
+    vc.on("videoChange", (enabled) => {
+      isVideoEnabled.value = enabled;
+      localVideoStream.value = vc.localVideoStream;
+    })
+  );
+  _unbinds.push(
+    vc.on("screenChange", (enabled) => {
+      isScreenEnabled.value = enabled;
+      localScreenStream.value = vc.localScreenStream;
+    })
+  );
+  _unbinds.push(
+    vc.on("peerVideoStream", (peerId, stream, kind) => {
+      const next = new Map(peerVideoStreams.value);
+      const entry = next.get(peerId) ?? { camera: null, screen: null };
+      entry[kind] = stream;
+      next.set(peerId, { ...entry });
+      peerVideoStreams.value = next;
+    })
+  );
+  _unbinds.push(
+    vc.on("peerMediaState", () => {
+      peers.value = new Map(vc.peers);
+    })
+  );
+  _unbinds.push(
+    vc.on("peerProfile", () => {
+      peers.value = new Map(vc.peers);
+    })
+  );
+  _unbinds.push(
+    vc.on("error", (err) => {
+      if (TRANSIENT_ERROR_CODES.has(err.code)) {
+        try {
+          const toast = useToast();
+          toast.add({ title: err.message, color: "warning", icon: "i-lucide-alert-triangle" });
+        } catch {
+        }
+      } else {
+        voiceError.value = err;
+      }
+    })
+  );
+}
+async function joinRoom(docId) {
+  if (voiceRoomId.value === docId && (voiceStatus.value === "connected" || voiceStatus.value === "connecting")) {
+    return;
+  }
+  _cleanup();
+  const { client: abClient, currentServerUrl, userName, userColor } = useAbracadabra();
+  const jwt = abClient.value?.token ?? "";
+  if (!jwt) {
+    const { createVoiceError: mkErr, VoiceErrorCode } = await import("../utils/voiceErrors.js");
+    voiceError.value = mkErr(VoiceErrorCode.CONNECT_FAILED, "Not authenticated \u2014 please sign in first");
+    return;
+  }
+  const wsBase = currentServerUrl.value.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+  const signalingUrl = `${wsBase}/ws/${docId}/signaling?token=${jwt}`;
+  voiceRoomId.value = docId;
+  _client = new VoiceClient(signalingUrl);
+  _wireEvents(_client);
+  _client.setProfile(userName.value, userColor.value);
+  await _client.connect();
+}
+function leaveRoom() {
+  _cleanup();
+}
+async function toggleMute() {
+  if (_client) await _client.toggleMute();
+}
+async function toggleVideo() {
+  if (_client) await _client.toggleVideo();
+}
+async function toggleScreen() {
+  if (_client) await _client.toggleScreen();
+}
+function togglePeerMute(peerId) {
+  if (_client) _client.togglePeerMute(peerId);
+}
+function setMasterVolume(volume) {
+  masterVolume.value = volume;
+  if (_client) _client.setMasterVolume(volume);
+}
+function setPeerVolume(peerId, volume) {
+  if (_client) _client.setPeerVolume(peerId, volume);
+}
+const peerList = computed(() => [...peers.value.values()]);
+const peerCount = computed(() => peers.value.size);
+const anyPeerSpeaking = computed(
+  () => [...audioLevels.value.values()].some((l) => l > 0.05)
+);
+const canScreenShare = computed(
+  () => typeof navigator !== "undefined" && !!navigator.mediaDevices?.getDisplayMedia
+);
+const hasAnyVideo = computed(() => {
+  if (isVideoEnabled.value || isScreenEnabled.value) return true;
+  for (const peer of peers.value.values()) {
+    if (peer.remoteVideo || peer.remoteScreen) return true;
+  }
+  return false;
+});
+export function useVoice() {
+  return {
+    voiceStatus,
+    voiceRoomId,
+    isMuted,
+    isVideoEnabled,
+    isScreenEnabled,
+    voiceError,
+    localAudioLevel,
+    masterVolume,
+    peers,
+    audioLevels,
+    localVideoStream,
+    localScreenStream,
+    peerVideoStreams,
+    peerList,
+    peerCount,
+    anyPeerSpeaking,
+    canScreenShare,
+    hasAnyVideo,
+    joinRoom,
+    leaveRoom,
+    toggleMute,
+    toggleVideo,
+    toggleScreen,
+    togglePeerMute,
+    setMasterVolume,
+    setPeerVolume
+  };
+}