@abraca/nuxt 1.8.2 → 2.0.0

package/dist/runtime/composables/useSpaces.js

@@ -6,12 +6,11 @@ const error = ref(null);
 export function useSpaces() {
   const abra = useAbracadabra();
   const spaces = computed(() => abra.currentServerSpaces.value ?? []);
-  const spacesEnabled = computed(() => abra.currentServerSpacesEnabled.value ?? false);
   const currentSpace = computed(() => {
     const route = useRoute();
     const docId = route.params.docId;
     if (!docId) return spaces.value[0] ?? null;
-    return spaces.value.find((s) => s.doc_id === docId) ?? null;
+    return spaces.value.find((s) => s.id === docId) ?? null;
   });
   async function refresh() {
     loading.value = true;
@@ -36,7 +35,7 @@ export function useSpaces() {
   async function update(id, opts) {
     error.value = null;
     try {
-      return await abra.updateSpace(id, opts);
+      await abra.updateSpace(id, opts);
     } catch (e) {
       error.value = e.message ?? "Failed to update space";
       throw e;
@@ -63,8 +62,6 @@ export function useSpaces() {
   return {
     /** All spaces on the current server. */
     spaces,
-    /** Whether the current server supports spaces. */
-    spacesEnabled,
     /** The currently active space. */
     currentSpace,
     /** Whether space operations are in progress. */

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

@@ -0,0 +1,22 @@
+/**
+ * useTiptapHistory
+ *
+ * Reactive `{ canUndo, canRedo, undo, redo }` for a TipTap editor instance.
+ * Editor-only — no dependency on `useTreeUndoManager`. If you need coordinated
+ * tree+editor undo, use `useUndoRedo` instead.
+ *
+ * Accepts a Ref<Editor | null> so the editor can change (e.g. doc navigation)
+ * without re-creating the consumer.
+ *
+ * Usage:
+ *   const history = useTiptapHistory(editorRef)
+ *   <UButton :disabled="!history.canUndo.value" @click="history.undo" />
+ */
+import { type MaybeRef } from 'vue';
+import type { Editor } from '@tiptap/vue-3';
+export declare function useTiptapHistory(editor: MaybeRef<Editor | null | undefined>): {
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    undo: () => void;
+    redo: () => void;
+};

package/dist/runtime/composables/useTiptapHistory.js

@@ -0,0 +1,12 @@
+import { computed, unref } from "vue";
+export function useTiptapHistory(editor) {
+  const canUndo = computed(() => !!unref(editor)?.can?.().undo?.());
+  const canRedo = computed(() => !!unref(editor)?.can?.().redo?.());
+  function undo() {
+    unref(editor)?.commands?.undo?.();
+  }
+  function redo() {
+    unref(editor)?.commands?.redo?.();
+  }
+  return { canUndo, canRedo, undo, redo };
+}

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

@@ -0,0 +1,28 @@
+import { type ComputedRef } from 'vue';
+import type { TreeEntry } from './useChildTree.js';
+export interface FlatTreeItem {
+    id: string;
+    entry: TreeEntry;
+    depth: number;
+    hasChildren: boolean;
+    expanded: boolean;
+}
+export interface UseTreeExpansionOptions {
+    storageKey: string;
+    childrenOf: (parentId: string | null) => TreeEntry[];
+}
+/**
+ * Tree expand/collapse state with localStorage persistence and a flat
+ * iterator that lazy-walks only into expanded nodes.
+ *
+ * Ported 1:1 from cou-sh/app/composables/useTreeExpansion.ts.
+ */
+export declare function useTreeExpansion(opts: UseTreeExpansionOptions): {
+    expandedIds: import("vue").ShallowRef<Set<string>, Set<string>>;
+    toggle: (id: string) => void;
+    expand: (id: string) => void;
+    collapse: (id: string) => void;
+    expandMany: (ids: Iterable<string>) => void;
+    collapseAll: () => void;
+    flatItems: ComputedRef<FlatTreeItem[]>;
+};

package/dist/runtime/composables/useTreeExpansion.js

@@ -0,0 +1,94 @@
+import { computed, shallowRef, triggerRef, watch } from "vue";
+export function useTreeExpansion(opts) {
+  function load() {
+    if (!import.meta.client) return /* @__PURE__ */ new Set();
+    try {
+      const raw = localStorage.getItem(opts.storageKey);
+      if (raw) return new Set(JSON.parse(raw));
+    } catch {
+    }
+    return /* @__PURE__ */ new Set();
+  }
+  const expandedIds = shallowRef(load());
+  let saveTimer = null;
+  watch(expandedIds, (ids) => {
+    if (!import.meta.client) return;
+    if (saveTimer) clearTimeout(saveTimer);
+    saveTimer = setTimeout(() => {
+      try {
+        localStorage.setItem(opts.storageKey, JSON.stringify([...ids]));
+      } catch {
+      }
+    }, 300);
+  });
+  function toggle(id) {
+    if (expandedIds.value.has(id)) expandedIds.value.delete(id);
+    else expandedIds.value.add(id);
+    triggerRef(expandedIds);
+  }
+  function expand(id) {
+    if (expandedIds.value.has(id)) return;
+    expandedIds.value.add(id);
+    triggerRef(expandedIds);
+  }
+  function collapse(id) {
+    if (!expandedIds.value.has(id)) return;
+    expandedIds.value.delete(id);
+    triggerRef(expandedIds);
+  }
+  function expandMany(ids) {
+    let changed = false;
+    for (const id of ids) {
+      if (!expandedIds.value.has(id)) {
+        expandedIds.value.add(id);
+        changed = true;
+      }
+    }
+    if (changed) triggerRef(expandedIds);
+  }
+  function collapseAll() {
+    if (!expandedIds.value.size) return;
+    expandedIds.value = /* @__PURE__ */ new Set();
+  }
+  const flatItems = computed(() => {
+    const out = [];
+    const roots = opts.childrenOf(null);
+    const stack = [
+      { items: roots, idx: 0, depth: 0 }
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length) {
+      const frame = stack[stack.length - 1];
+      if (frame.idx >= frame.items.length) {
+        stack.pop();
+        continue;
+      }
+      const node = frame.items[frame.idx++];
+      if (seen.has(node.id)) continue;
+      seen.add(node.id);
+      const children = opts.childrenOf(node.id);
+      const hasChildren = children.length > 0;
+      const expanded = expandedIds.value.has(node.id);
+      out.push({
+        id: node.id,
+        entry: node,
+        depth: frame.depth,
+        hasChildren,
+        expanded
+      });
+      if (hasChildren && expanded) {
+        stack.push({ items: children, idx: 0, depth: frame.depth + 1 });
+      }
+    }
+    return out;
+  });
+  return {
+    expandedIds,
+    toggle,
+    expand,
+    collapse,
+    expandMany,
+    collapseAll,
+    flatItems
+  };
+}

package/dist/runtime/composables/useYDoc.js

@@ -156,6 +156,7 @@ export function useAwarenessOf(provider) {
   const update = () => {
     if (_rafId === null) _rafId = requestAnimationFrame(flush);
   };
+  let _attachedAwareness = null;
   watch(provider, (p, oldP) => {
     if (oldP?.awareness) oldP.awareness.off("change", update);
     if (_rafId !== null) {
@@ -164,11 +165,21 @@ export function useAwarenessOf(provider) {
     }
     if (p?.awareness) {
       p.awareness.on("change", update);
+      _attachedAwareness = p.awareness;
       flush();
+    } else {
+      _attachedAwareness = null;
     }
   }, { immediate: true });
   onBeforeUnmount(() => {
-    if (_rafId !== null) cancelAnimationFrame(_rafId);
+    if (_attachedAwareness) {
+      _attachedAwareness.off("change", update);
+      _attachedAwareness = null;
+    }
+    if (_rafId !== null) {
+      cancelAnimationFrame(_rafId);
+      _rafId = null;
+    }
   });
   const setLocalState = (state) => {
     if (!provider.value) return;

package/dist/runtime/extensions/button.d.ts

@@ -0,0 +1,3 @@
+import { Node } from '@tiptap/core';
+export declare const Button: Node<any, any>;
+export declare const ButtonGroup: Node<any, any>;

package/dist/runtime/extensions/button.js

@@ -0,0 +1,62 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import ButtonView from "./views/ButtonView.vue";
+import ButtonGroupView from "./views/ButtonGroupView.vue";
+export const Button = Node.create({
+  name: "button",
+  group: "block",
+  atom: true,
+  selectable: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      label: { default: "Button" },
+      to: { default: "" },
+      variant: { default: "solid" },
+      color: { default: "primary" },
+      icon: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-component-button]",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAttrs: (el) => ({
+          label: el.getAttribute("data-label") || "Button",
+          to: el.getAttribute("data-to") || "",
+          variant: el.getAttribute("data-variant") || "solid",
+          color: el.getAttribute("data-color") || "primary",
+          icon: el.getAttribute("data-icon") || ""
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-component-button": "",
+      "data-label": HTMLAttributes.label,
+      "data-to": HTMLAttributes.to,
+      "data-variant": HTMLAttributes.variant,
+      "data-color": HTMLAttributes.color,
+      "data-icon": HTMLAttributes.icon
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ButtonView);
+  }
+});
+export const ButtonGroup = Node.create({
+  name: "buttonGroup",
+  group: "block",
+  content: "button+",
+  parseHTML() {
+    return [{ tag: "div[data-button-group]" }];
+  },
+  renderHTML() {
+    return ["div", { "data-button-group": "" }, 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ButtonGroupView);
+  }
+});

package/dist/runtime/extensions/color-swatch.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const ColorSwatch: Node<any, any>;

package/dist/runtime/extensions/color-swatch.js

@@ -0,0 +1,34 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import ColorSwatchView from "./views/ColorSwatchView.vue";
+export const ColorSwatch = Node.create({
+  name: "colorSwatch",
+  group: "inline",
+  inline: true,
+  atom: true,
+  addAttributes() {
+    return {
+      color: { default: "#6366f1" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span[data-color-swatch]",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAttrs: (el) => ({
+          color: el.getAttribute("data-color") || "#6366f1"
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes({
+      "data-color-swatch": "",
+      "data-color": HTMLAttributes.color
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ColorSwatchView);
+  }
+});

package/dist/runtime/extensions/diff.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const Diff: Node<any, any>;

package/dist/runtime/extensions/diff.js

@@ -0,0 +1,40 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import DiffView from "./views/DiffView.vue";
+export const Diff = Node.create({
+  name: "diff",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      before: { default: "" },
+      after: { default: "" },
+      language: { default: "text" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-diff]",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAttrs: (el) => ({
+          before: el.getAttribute("data-before") || "",
+          after: el.getAttribute("data-after") || "",
+          language: el.getAttribute("data-language") || "text"
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-diff": "",
+      "data-before": HTMLAttributes.before,
+      "data-after": HTMLAttributes.after,
+      "data-language": HTMLAttributes.language
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(DiffView);
+  }
+});

package/dist/runtime/extensions/divider.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const Divider: Node<any, any>;

package/dist/runtime/extensions/divider.js

@@ -0,0 +1,33 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import DividerView from "./views/DividerView.vue";
+export const Divider = Node.create({
+  name: "divider",
+  group: "block",
+  atom: true,
+  addAttributes() {
+    return {
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-divider]",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAttrs: (el) => ({
+          label: el.getAttribute("data-label") || ""
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-divider": "",
+      "data-label": HTMLAttributes.label
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(DividerView);
+  }
+});

package/dist/runtime/extensions/doc-embed.js

@@ -12,7 +12,8 @@ export const DocEmbed = Node.create({
     return {
       docId: { default: null },
       collapsed: { default: false },
-      tall: { default: false }
+      tall: { default: false },
+      seamless: { default: false }
     };
   },
   parseHTML() {

package/dist/runtime/extensions/doc-link-drop.js

@@ -39,10 +39,10 @@ export const DocLinkDrop = Extension.create({
               if (dropPos == null) return true;
               const { schema, tr } = view.state;
               if (de.altKey) {
-                const linkMark = schema.marks.link?.create({ href: `/doc/${data.id}` });
-                if (!linkMark) return true;
-                const textNode = schema.text(data.label, [linkMark]);
-                tr.insert(dropPos, textNode);
+                const linkType = schema.nodes.docLink;
+                if (!linkType) return true;
+                const node = linkType.create({ docId: data.id });
+                tr.insert(dropPos, node);
               } else {
                 const nodeType = schema.nodes.docEmbed;
                 if (!nodeType) return true;

package/dist/runtime/extensions/doc-link.d.ts

@@ -0,0 +1,12 @@
+import { Node } from '@tiptap/core';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        docLink: {
+            insertDocLink: (attrs: {
+                docId: string;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const DocLink: Node<any, any>;
+export default DocLink;

package/dist/runtime/extensions/doc-link.js

@@ -0,0 +1,60 @@
+import { Node, mergeAttributes, nodePasteRule, nodeInputRule } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import DocLinkView from "./views/DocLinkView.vue";
+const INLINE_REGEX = /(?<!!)\[\[([a-f0-9-]{36})(?:\|[^\]]+)?\]\]/gi;
+export const DocLink = Node.create({
+  name: "docLink",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      docId: { default: null }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span[data-doc-link]",
+        getAttrs: (el) => ({ docId: el.getAttribute("data-doc-id") })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes({
+      "data-doc-link": "",
+      "data-doc-id": HTMLAttributes.docId
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(DocLinkView);
+  },
+  addCommands() {
+    return {
+      insertDocLink: (attrs) => ({ commands }) => {
+        return commands.insertContent({ type: this.name, attrs });
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      nodeInputRule({
+        find: INLINE_REGEX,
+        type: this.type,
+        getAttributes: (match) => ({ docId: match[1] })
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      nodePasteRule({
+        find: INLINE_REGEX,
+        type: this.type,
+        getAttributes: (match) => ({ docId: match[1] })
+      })
+    ];
+  }
+});
+export default DocLink;

package/dist/runtime/extensions/embed.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const Embed: Node<any, any>;

package/dist/runtime/extensions/embed.js

@@ -0,0 +1,40 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import EmbedView from "./views/EmbedView.vue";
+export const Embed = Node.create({
+  name: "embed",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      src: { default: "" },
+      title: { default: "" },
+      aspectRatio: { default: "16/9" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-embed]",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAttrs: (el) => ({
+          src: el.getAttribute("data-src") || "",
+          title: el.getAttribute("data-title") || "",
+          aspectRatio: el.getAttribute("data-aspect") || "16/9"
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-embed": "",
+      "data-src": HTMLAttributes.src,
+      "data-title": HTMLAttributes.title,
+      "data-aspect": HTMLAttributes.aspectRatio
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(EmbedView);
+  }
+});

package/dist/runtime/extensions/figure.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const Figure: Node<any, any>;

package/dist/runtime/extensions/figure.js

@@ -0,0 +1,49 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import FigureView from "./views/FigureView.vue";
+export const Figure = Node.create({
+  name: "figure",
+  group: "block",
+  atom: true,
+  draggable: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      src: { default: "" },
+      alt: { default: "" },
+      caption: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "figure[data-figure]",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAttrs: (el) => ({
+          src: el.getAttribute("data-src") || el.querySelector("img")?.getAttribute("src") || "",
+          alt: el.getAttribute("data-alt") || el.querySelector("img")?.getAttribute("alt") || "",
+          caption: el.getAttribute("data-caption") || el.querySelector("figcaption")?.textContent || ""
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const attrs = mergeAttributes({
+      "data-figure": "",
+      "data-src": HTMLAttributes.src,
+      "data-alt": HTMLAttributes.alt,
+      "data-caption": HTMLAttributes.caption
+    });
+    const children = [];
+    if (HTMLAttributes.src) {
+      children.push(["img", { src: HTMLAttributes.src, alt: HTMLAttributes.alt || "" }]);
+    }
+    if (HTMLAttributes.caption) {
+      children.push(["figcaption", {}, HTMLAttributes.caption]);
+    }
+    return ["figure", attrs, ...children];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(FigureView);
+  }
+});

package/dist/runtime/extensions/math.d.ts

@@ -0,0 +1,15 @@
+import { Node } from '@tiptap/core';
+/**
+ * Math extensions — block and inline LaTeX rendering.
+ *
+ * The extensions themselves have NO runtime dependency on KaTeX. The peer
+ * dependency lives only in the NodeView components, which try-import KaTeX
+ * lazily and degrade to a raw-LaTeX fallback if it's not installed.
+ *
+ * To enable rich math rendering, the consuming app installs:
+ *   pnpm add katex
+ *   // and somewhere in the app:
+ *   import 'katex/dist/katex.min.css'
+ */
+export declare const MathBlock: Node<any, any>;
+export declare const MathInline: Node<any, any>;