@abraca/nuxt 0.1.0

package/dist/runtime/composables/useChildTree.js

@@ -0,0 +1,100 @@
+import { computed } from "vue";
+import { useSyncedMap } from "./useYDoc.js";
+export function useChildTree(rootDoc, parentDocId) {
+  const treeMap = useSyncedMap(rootDoc, "doc-tree");
+  const trashMap = useSyncedMap(rootDoc, "doc-trash");
+  const entries = computed(
+    () => Object.entries(treeMap.data).map(([id, v]) => ({
+      id,
+      label: v.label || "Untitled",
+      parentId: v.parentId ?? null,
+      order: v.order ?? 0,
+      type: v.type,
+      meta: v.meta,
+      createdAt: v.createdAt,
+      updatedAt: v.updatedAt
+    }))
+  );
+  function childrenOf(parentId) {
+    const target = parentId === null ? parentDocId : parentId;
+    return entries.value.filter((e) => e.parentId === target).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  function descendantsOf(id) {
+    const result = [];
+    function collect(pid) {
+      for (const child of childrenOf(pid)) {
+        result.push(child);
+        collect(child.id);
+      }
+    }
+    collect(id);
+    return result;
+  }
+  function createChild(parentId, label, type) {
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    treeMap.set(id, {
+      label,
+      parentId: parentId === null ? parentDocId : parentId,
+      order: now,
+      type,
+      createdAt: now,
+      updatedAt: now
+    });
+    return id;
+  }
+  function moveEntry(id, newParentId, newOrder) {
+    const entry = treeMap.get(id);
+    if (entry) {
+      treeMap.set(id, {
+        ...entry,
+        parentId: newParentId === null ? parentDocId : newParentId,
+        order: newOrder,
+        updatedAt: Date.now()
+      });
+    }
+  }
+  function deleteEntry(id) {
+    const doc = rootDoc.value;
+    if (!doc) return;
+    const now = Date.now();
+    const toDelete = [id, ...descendantsOf(id).map((e) => e.id)];
+    doc.transact(() => {
+      for (const nid of toDelete) {
+        const entry = treeMap.get(nid);
+        if (!entry) continue;
+        trashMap.set(nid, { label: entry.label || "Untitled", parentId: entry.parentId ?? null, order: entry.order ?? 0, type: entry.type, meta: entry.meta, deletedAt: now });
+        treeMap.remove(nid);
+      }
+    });
+  }
+  function renameEntry(id, label) {
+    const entry = treeMap.get(id);
+    if (entry) treeMap.set(id, { ...entry, label, updatedAt: Date.now() });
+  }
+  function updateMeta(id, patch) {
+    const entry = treeMap.get(id);
+    if (!entry) return;
+    treeMap.set(id, { ...entry, meta: { ...entry.meta ?? {}, ...patch }, updatedAt: Date.now() });
+  }
+  function duplicateEntry(id) {
+    const entry = treeMap.get(id);
+    if (!entry) return id;
+    const newId = crypto.randomUUID();
+    treeMap.set(newId, { ...entry, label: (entry.label || "Untitled") + " (copy)", order: Date.now() });
+    return newId;
+  }
+  return {
+    entries,
+    childrenOf,
+    descendantsOf,
+    createChild,
+    moveEntry,
+    deleteEntry,
+    renameEntry,
+    updateMeta,
+    duplicateEntry,
+    treeMap,
+    trashMap
+  };
+}

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

@@ -0,0 +1,58 @@
+/**
+ * useCommandPalette
+ *
+ * ⌘K command palette state and item provider.
+ * Aggregates commands from the plugin registry, the document tree, search results,
+ * and recent documents.
+ *
+ * Usage:
+ *   const { isOpen, searchTerm, toggle, groups } = useCommandPalette()
+ *   <UCommandPalette v-model:open="isOpen" v-model="searchTerm" :groups="groups" />
+ */
+export interface CommandItem {
+    id: string;
+    label: string;
+    icon?: string;
+    suffix?: string;
+    shortcut?: string[];
+    onClick?: () => void;
+    disabled?: boolean;
+}
+export interface CommandGroup {
+    id: string;
+    label?: string;
+    items: CommandItem[];
+}
+export declare function useCommandPalette(): {
+    isOpen: import("vue").Ref<boolean, boolean>;
+    searchTerm: import("vue").Ref<string, string>;
+    groups: import("vue").Ref<{
+        id: string;
+        label?: string | undefined;
+        items: {
+            id: string;
+            label: string;
+            icon?: string | undefined;
+            suffix?: string | undefined;
+            shortcut?: string[] | undefined;
+            onClick?: (() => void) | undefined;
+            disabled?: boolean | undefined;
+        }[];
+    }[], CommandGroup[] | {
+        id: string;
+        label?: string | undefined;
+        items: {
+            id: string;
+            label: string;
+            icon?: string | undefined;
+            suffix?: string | undefined;
+            shortcut?: string[] | undefined;
+            onClick?: (() => void) | undefined;
+            disabled?: boolean | undefined;
+        }[];
+    }[]>;
+    open: (term?: string) => void;
+    close: () => void;
+    toggle: () => void;
+    trackRecentDoc: (docId: string) => void;
+};

package/dist/runtime/composables/useCommandPalette.js

@@ -0,0 +1,94 @@
+import { ref, watch } from "vue";
+import { useLocalStorage } from "@vueuse/core";
+const isOpen = ref(false);
+const searchTerm = ref("");
+export function useCommandPalette() {
+  const { doc, isReady, provider } = useAbracadabra();
+  const registry = usePluginRegistry();
+  const recentDocIds = useLocalStorage("abra_recent_docs", []);
+  function open(term = "") {
+    searchTerm.value = term;
+    isOpen.value = true;
+  }
+  function close() {
+    isOpen.value = false;
+    searchTerm.value = "";
+  }
+  function toggle() {
+    if (isOpen.value) close();
+    else open();
+  }
+  function trackRecentDoc(docId) {
+    recentDocIds.value = [docId, ...recentDocIds.value.filter((x) => x !== docId)].slice(0, 10);
+  }
+  const groups = ref([]);
+  async function _refreshGroups() {
+    if (!isReady.value) {
+      groups.value = [];
+      return;
+    }
+    const q = searchTerm.value.toLowerCase().trim();
+    const result = [];
+    if (doc.value) {
+      try {
+        const treeMap = doc.value.getMap("doc-tree");
+        const entries = [];
+        treeMap.forEach((entry, id) => {
+          if (!entry.label) return;
+          if (q && !entry.label.toLowerCase().includes(q)) return;
+          entries.push({
+            id: `doc:${id}`,
+            label: entry.label,
+            icon: "i-lucide-file-text",
+            suffix: entry.type,
+            onClick: () => {
+              trackRecentDoc(id);
+              navigateTo(`${useRuntimeConfig().public.abracadabra?.docBasePath ?? "/doc"}/${id}`);
+              close();
+            }
+          });
+        });
+        const sorted = q ? entries : entries.filter((e) => recentDocIds.value.includes(e.id.slice(4))).slice(0, 5);
+        if (sorted.length > 0) {
+          result.push({ id: "docs", label: q ? "Documents" : "Recent", items: sorted });
+        }
+      } catch {
+      }
+    }
+    try {
+      const ctx = { doc, provider, abracadabra: useAbracadabra(), searchTerm: searchTerm.value };
+      const pluginGroups = await registry.getAllCommandPaletteItems(ctx);
+      for (const group of pluginGroups) {
+        const filtered = (group.items ?? []).filter((item) => !q || item.label?.toLowerCase().includes(q)).map((item) => ({
+          id: item.id ?? `${group.id ?? "plugin"}:${item.label}`,
+          label: item.label,
+          icon: item.icon,
+          suffix: item.suffix,
+          shortcut: item.shortcut,
+          onClick: () => {
+            item.action?.();
+            close();
+          },
+          disabled: item.disabled
+        }));
+        if (filtered.length > 0) {
+          result.push({ id: group.id ?? "plugin", label: group.label, items: filtered });
+        }
+      }
+    } catch {
+    }
+    groups.value = result;
+  }
+  watch([isOpen, searchTerm, isReady], () => {
+    if (isOpen.value) _refreshGroups();
+  });
+  return {
+    isOpen,
+    searchTerm,
+    groups,
+    open,
+    close,
+    toggle,
+    trackRecentDoc
+  };
+}

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

@@ -0,0 +1,17 @@
+import { type MaybeRef } from 'vue';
+type ConnectionStatusValue = 'disconnected' | 'connecting' | 'connected' | 'offline';
+/**
+ * Maps connection status + synced state to UI-ready label, color, and icon.
+ *
+ * If `status` and `synced` are not provided, reads from `useAbracadabra()` globals.
+ *
+ * Usage:
+ *   const { label, color, icon } = useConnectionStatus()
+ *   const { label, color, icon } = useConnectionStatus(status, synced)
+ */
+export declare function useConnectionStatus(status?: MaybeRef<ConnectionStatusValue | string | undefined>, synced?: MaybeRef<boolean | undefined>): {
+    label: import("vue").ComputedRef<string>;
+    color: import("vue").ComputedRef<"success" | "warning" | "error">;
+    icon: import("vue").ComputedRef<"i-lucide-cloud-check" | "i-lucide-cloud-upload" | "i-lucide-cloud" | "i-lucide-cloud-off">;
+};
+export {};

package/dist/runtime/composables/useConnectionStatus.js

@@ -0,0 +1,37 @@
+import { computed, toValue } from "vue";
+import { useAbraLocale } from "./useAbraLocale.js";
+import { useAbracadabra } from "./useAbracadabra.js";
+export function useConnectionStatus(status, synced) {
+  const locale = useAbraLocale("connectionStatus");
+  const abra = useAbracadabra();
+  const resolvedStatus = computed(() => {
+    if (status !== void 0) return toValue(status) ?? "disconnected";
+    return abra.status?.value ?? "disconnected";
+  });
+  const resolvedSynced = computed(() => {
+    if (synced !== void 0) return toValue(synced) ?? false;
+    return abra.synced?.value ?? false;
+  });
+  const label = computed(() => {
+    const s = resolvedStatus.value;
+    if (s === "connected" && resolvedSynced.value) return locale.connected;
+    if (s === "connected") return locale.syncing;
+    if (s === "connecting") return locale.connecting;
+    return locale.offline;
+  });
+  const color = computed(() => {
+    const s = resolvedStatus.value;
+    if (s === "connected" && resolvedSynced.value) return "success";
+    if (s === "connected") return "warning";
+    if (s === "connecting") return "warning";
+    return "error";
+  });
+  const icon = computed(() => {
+    const s = resolvedStatus.value;
+    if (s === "connected" && resolvedSynced.value) return "i-lucide-cloud-check";
+    if (s === "connected") return "i-lucide-cloud-upload";
+    if (s === "connecting") return "i-lucide-cloud";
+    return "i-lucide-cloud-off";
+  });
+  return { label, color, icon };
+}

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

@@ -0,0 +1,3 @@
+export declare const useDashboard: () => {
+    isNotificationsOpen: import("vue").Ref<boolean, boolean>;
+};

package/dist/runtime/composables/useDashboard.js

@@ -0,0 +1,23 @@
+import { ref, watch } from "vue";
+import { createSharedComposable } from "@vueuse/core";
+const _useDashboard = () => {
+  const route = useRoute();
+  const { toggle } = useCommandPalette();
+  const isNotificationsOpen = ref(false);
+  defineShortcuts({
+    meta_f: () => {
+      toggle();
+    },
+    meta_n: () => {
+      toggle();
+    },
+    n: () => {
+      isNotificationsOpen.value = !isNotificationsOpen.value;
+    }
+  });
+  watch(() => route.fullPath, () => {
+    isNotificationsOpen.value = false;
+  });
+  return { isNotificationsOpen };
+};
+export const useDashboard = createSharedComposable(_useDashboard);

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

@@ -0,0 +1,5 @@
+export declare function useDocExport(): {
+    exportDoc: (id: string, format: "markdown" | "html" | "zip") => Promise<void>;
+    exportDocs: (ids: string[], format?: "md" | "html") => Promise<void>;
+    exportAll: (format?: "md" | "html") => Promise<void>;
+};

package/dist/runtime/composables/useDocExport.js

@@ -0,0 +1,256 @@
+import * as Y from "yjs";
+import { yjsToMarkdown, yjsToHtml } from "../utils/yjsConvert.js";
+function labelToFilename(label) {
+  return label.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "untitled";
+}
+function triggerDownload(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+function collectFileBlocks(el, sourceDocId) {
+  const files = [];
+  for (const child of el.toArray()) {
+    if (child instanceof Y.XmlElement) {
+      if (child.nodeName === "fileBlock") {
+        const uploadId = child.getAttribute("uploadId");
+        const filename = child.getAttribute("filename") ?? "file";
+        const mimeType = child.getAttribute("mimeType") ?? "";
+        const docId = child.getAttribute("docId") ?? sourceDocId;
+        if (uploadId) files.push({ uploadId, docId, filename, mimeType });
+      }
+      files.push(...collectFileBlocks(child, sourceDocId));
+    }
+  }
+  return files;
+}
+function replaceFileMarkers(content, docZipPath, filePathMap, format) {
+  return content.replace(/<!--fileblock:([^:]+):(.+?)-->/g, (_, uploadId, filename) => {
+    const entry = filePathMap.get(uploadId);
+    if (!entry) return `<!-- file: ${filename} -->`;
+    const docDir = docZipPath.includes("/") ? docZipPath.substring(0, docZipPath.lastIndexOf("/")) : "";
+    const depth = docDir ? docDir.split("/").length : 0;
+    const relPath = "../".repeat(depth) + entry.zipPath;
+    if (format === "md") {
+      if (entry.mimeType.startsWith("image/")) return `![${filename}](${relPath})`;
+      return `[${filename}](${relPath})`;
+    } else {
+      const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      const escapedPath = relPath.replace(/"/g, "&quot;");
+      if (entry.mimeType.startsWith("image/")) return `<img src="${escapedPath}" alt="${esc(filename)}">`;
+      return `<a href="${escapedPath}" download>${esc(filename)}</a>`;
+    }
+  });
+}
+export function useDocExport() {
+  const toast = useToast();
+  const { provider, client } = useAbracadabra();
+  function getTreeMap() {
+    const p = provider.value;
+    if (!p?.document) return null;
+    const ymap = p.document.getMap("doc-tree");
+    const result = {};
+    ymap.forEach((v, k) => {
+      result[k] = v;
+    });
+    return result;
+  }
+  function getDescendants(treeMap, rootId) {
+    const result = [];
+    const queue = [rootId];
+    while (queue.length) {
+      const id = queue.shift();
+      result.push(id);
+      for (const [childId, entry] of Object.entries(treeMap)) {
+        if (entry.parentId === id) queue.push(childId);
+      }
+    }
+    return result;
+  }
+  function buildPath(treeMap, id, ext) {
+    const segments = [];
+    let current = id;
+    while (current) {
+      const entry = treeMap[current];
+      if (!entry) break;
+      segments.unshift(labelToFilename(entry.label));
+      current = entry.parentId;
+    }
+    if (segments.length) segments[segments.length - 1] += `.${ext}`;
+    return segments.join("/");
+  }
+  async function loadDoc(id, format) {
+    const p = provider.value;
+    if (!p) throw new Error("no provider");
+    const treeMap = getTreeMap() ?? {};
+    const entry = treeMap[id];
+    if (!entry) throw new Error(`doc ${id} not in tree`);
+    const childProv = await p.loadChild(id);
+    if (!childProv.isSynced) {
+      await new Promise((resolve) => {
+        const done = () => {
+          childProv.off("synced", done);
+          resolve();
+        };
+        childProv.on("synced", done);
+        setTimeout(resolve, 6e3);
+      });
+    }
+    const fragment = childProv.document.getXmlFragment("default");
+    const files = collectFileBlocks(fragment, id);
+    const content = format === "html" ? yjsToHtml(fragment, entry.label) : yjsToMarkdown(fragment, entry.label, entry.meta, entry.type);
+    return { content, files };
+  }
+  async function downloadFiles(files) {
+    const c = client.value;
+    if (!c) return /* @__PURE__ */ new Map();
+    const blobs = /* @__PURE__ */ new Map();
+    const unique = files.filter((f, i, arr) => arr.findIndex((x) => x.uploadId === f.uploadId) === i);
+    await Promise.all(unique.map(async (file) => {
+      try {
+        const blob = await c.getUpload(file.docId, file.uploadId);
+        blobs.set(file.uploadId, blob);
+      } catch (e) {
+        console.warn(`[export] Failed to download file ${file.filename}:`, e);
+      }
+    }));
+    return blobs;
+  }
+  async function exportDoc(id, format) {
+    if (!provider.value) return;
+    const treeMap = getTreeMap() ?? {};
+    const entry = treeMap[id];
+    if (!entry) return;
+    const hasChildren = Object.values(treeMap).some((e) => e.parentId === id);
+    if (format === "zip" || hasChildren) {
+      return exportDocs([id], format === "zip" ? "md" : format);
+    }
+    const fmt = format;
+    const ext = fmt === "md" ? "md" : "html";
+    const toastRef = toast.add({ title: "Exporting\u2026", icon: "i-lucide-loader" });
+    try {
+      const { content, files } = await loadDoc(id, fmt);
+      if (files.length === 0 || !client.value) {
+        toast.remove(toastRef.id);
+        const blob = new Blob([content], { type: "text/plain;charset=utf-8" });
+        triggerDownload(blob, `${labelToFilename(entry.label)}.${ext}`);
+        return;
+      }
+      const filePathMap = /* @__PURE__ */ new Map();
+      const usedNames = /* @__PURE__ */ new Map();
+      for (const file of files) {
+        if (filePathMap.has(file.uploadId)) continue;
+        let name = file.filename;
+        const count = usedNames.get(name) ?? 0;
+        if (count > 0) {
+          const dotIdx = name.lastIndexOf(".");
+          const base = dotIdx > 0 ? name.slice(0, dotIdx) : name;
+          const extPart = dotIdx > 0 ? name.slice(dotIdx) : "";
+          name = `${base}-${count + 1}${extPart}`;
+        }
+        usedNames.set(file.filename, count + 1);
+        filePathMap.set(file.uploadId, { zipPath: `_files/${name}`, mimeType: file.mimeType });
+      }
+      const fileBlobs = await downloadFiles(files);
+      const docPath = `${labelToFilename(entry.label)}.${ext}`;
+      const processed = replaceFileMarkers(content, docPath, filePathMap, fmt);
+      const JSZip = (await import("jszip")).default;
+      const zip = new JSZip();
+      zip.file(docPath, processed);
+      for (const [uploadId, info] of filePathMap) {
+        const blob = fileBlobs.get(uploadId);
+        if (blob) zip.file(info.zipPath, blob);
+      }
+      const zipBlob = await zip.generateAsync({ type: "blob" });
+      toast.remove(toastRef.id);
+      triggerDownload(zipBlob, `${labelToFilename(entry.label)}.zip`);
+      toast.add({ title: "Export complete", icon: "i-lucide-check" });
+    } catch (e) {
+      toast.remove(toastRef.id);
+      toast.add({ title: "Export failed", color: "error", icon: "i-lucide-x" });
+      console.error("[export]", e);
+    }
+  }
+  async function exportDocs(ids, format = "md") {
+    if (!provider.value) return;
+    const treeMap = getTreeMap() ?? {};
+    const ext = format === "md" ? "md" : "html";
+    const toastRef = toast.add({ title: "Exporting\u2026", icon: "i-lucide-loader" });
+    try {
+      const allIds = /* @__PURE__ */ new Set();
+      for (const id of ids) {
+        for (const did of getDescendants(treeMap, id)) allIds.add(did);
+      }
+      const pathMap = /* @__PURE__ */ new Map();
+      for (const id of allIds) {
+        pathMap.set(id, buildPath(treeMap, id, ext));
+      }
+      const contents = /* @__PURE__ */ new Map();
+      const allFiles = [];
+      await Promise.all([...allIds].map(async (id) => {
+        try {
+          const { content, files } = await loadDoc(id, format);
+          contents.set(id, content);
+          allFiles.push(...files);
+        } catch (e) {
+          const entry = treeMap[id];
+          console.warn(`[export] Failed to load doc ${id}:`, e);
+          contents.set(id, format === "md" ? `# ${entry?.label ?? id}
+
+<!-- export error -->` : `<h1>${entry?.label ?? id}</h1>`);
+        }
+      }));
+      const filePathMap = /* @__PURE__ */ new Map();
+      const usedNames = /* @__PURE__ */ new Map();
+      for (const file of allFiles) {
+        if (filePathMap.has(file.uploadId)) continue;
+        let name = file.filename;
+        const count = usedNames.get(name) ?? 0;
+        if (count > 0) {
+          const dotIdx = name.lastIndexOf(".");
+          const base = dotIdx > 0 ? name.slice(0, dotIdx) : name;
+          const extPart = dotIdx > 0 ? name.slice(dotIdx) : "";
+          name = `${base}-${count + 1}${extPart}`;
+        }
+        usedNames.set(file.filename, count + 1);
+        filePathMap.set(file.uploadId, { zipPath: `_files/${name}`, mimeType: file.mimeType });
+      }
+      const fileBlobs = client.value ? await downloadFiles(allFiles) : /* @__PURE__ */ new Map();
+      const JSZip = (await import("jszip")).default;
+      const zip = new JSZip();
+      for (const [id, path] of pathMap) {
+        let content = contents.get(id);
+        if (content) {
+          if (filePathMap.size > 0) content = replaceFileMarkers(content, path, filePathMap, format);
+          zip.file(path, content);
+        }
+      }
+      for (const [uploadId, info] of filePathMap) {
+        const blob2 = fileBlobs.get(uploadId);
+        if (blob2) zip.file(info.zipPath, blob2);
+      }
+      const blob = await zip.generateAsync({ type: "blob" });
+      const zipName = ids.length === 1 ? `${labelToFilename(treeMap[ids[0]]?.label ?? "export")}.zip` : "export.zip";
+      toast.remove(toastRef.id);
+      triggerDownload(blob, zipName);
+      toast.add({ title: "Export complete", icon: "i-lucide-check" });
+    } catch (e) {
+      toast.remove(toastRef.id);
+      toast.add({ title: "Export failed", color: "error", icon: "i-lucide-x" });
+      console.error("[export]", e);
+    }
+  }
+  async function exportAll(format = "md") {
+    const treeMap = getTreeMap() ?? {};
+    const rootIds = Object.entries(treeMap).filter(([, e]) => !e.parentId).map(([id]) => id);
+    if (!rootIds.length) {
+      toast.add({ title: "Nothing to export", icon: "i-lucide-info" });
+      return;
+    }
+    return exportDocs(rootIds, format);
+  }
+  return { exportDoc, exportDocs, exportAll };
+}

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

@@ -0,0 +1,10 @@
+export declare function useDocImport(): {
+    externalDragActive: import("vue").Ref<boolean, boolean>;
+    onDragEnter: (e: DragEvent) => void;
+    onDragLeave: (e: DragEvent) => void;
+    onDragOver: (e: DragEvent) => void;
+    onFileDrop: (e: DragEvent, parentId?: string | null) => Promise<void>;
+    importFiles: (parentId?: string | null) => void;
+    importFolder: (parentId?: string | null) => void;
+    importFile: (file: File, parentId: string | null) => Promise<string>;
+};