@abraca/nuxt 0.1.0

package/dist/runtime/extensions/callout.js

@@ -0,0 +1,28 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import CalloutView from "./views/CalloutView.vue";
+export const Callout = Node.create({
+  name: "callout",
+  group: "block",
+  content: "block+",
+  addAttributes() {
+    return {
+      type: { default: "note" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-callout]",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getAttrs: (el) => ({ type: el.getAttribute("data-callout") })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({ "data-callout": HTMLAttributes.type }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CalloutView);
+  }
+});

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

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

package/dist/runtime/extensions/card.js

@@ -0,0 +1,53 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import CardView from "./views/CardView.vue";
+import CardGroupView from "./views/CardGroupView.vue";
+export const Card = Node.create({
+  name: "card",
+  group: "block",
+  content: "block+",
+  addAttributes() {
+    return {
+      title: { default: "" },
+      icon: { default: "" },
+      to: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-card]",
+        getAttrs: (el) => ({
+          title: el.getAttribute("data-title"),
+          icon: el.getAttribute("data-icon"),
+          to: el.getAttribute("data-to")
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-card": "",
+      "data-title": HTMLAttributes.title,
+      "data-icon": HTMLAttributes.icon,
+      "data-to": HTMLAttributes.to
+    }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CardView);
+  }
+});
+export const CardGroup = Node.create({
+  name: "cardGroup",
+  group: "block",
+  content: "card+",
+  parseHTML() {
+    return [{ tag: "div[data-card-group]" }];
+  },
+  renderHTML() {
+    return ["div", { "data-card-group": "" }, 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CardGroupView);
+  }
+});

package/dist/runtime/extensions/code-collapse.d.ts

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

package/dist/runtime/extensions/code-collapse.js

@@ -0,0 +1,32 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import CodeCollapseView from "./views/CodeCollapseView.vue";
+export const CodeCollapse = Node.create({
+  name: "codeCollapse",
+  group: "block",
+  content: "codeBlock",
+  addAttributes() {
+    return {
+      open: { default: false }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-code-collapse]",
+        getAttrs: (el) => ({
+          open: el.getAttribute("data-open") === "true"
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-code-collapse": "",
+      "data-open": HTMLAttributes.open
+    }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CodeCollapseView);
+  }
+});

package/dist/runtime/extensions/code-group.d.ts

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

package/dist/runtime/extensions/code-group.js

@@ -0,0 +1,17 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import CodeGroupView from "./views/CodeGroupView.vue";
+export const CodeGroup = Node.create({
+  name: "codeGroup",
+  group: "block",
+  content: "codeBlock+",
+  parseHTML() {
+    return [{ tag: "div[data-code-group]" }];
+  },
+  renderHTML() {
+    return ["div", mergeAttributes({ "data-code-group": "" }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CodeGroupView);
+  }
+});

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

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

package/dist/runtime/extensions/collapsible.js

@@ -0,0 +1,35 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import CollapsibleView from "./views/CollapsibleView.vue";
+export const Collapsible = Node.create({
+  name: "collapsible",
+  group: "block",
+  content: "block+",
+  addAttributes() {
+    return {
+      label: { default: "Details" },
+      open: { default: false }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-collapsible]",
+        getAttrs: (el) => ({
+          label: el.getAttribute("data-label"),
+          open: el.getAttribute("data-open") === "true"
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-collapsible": "",
+      "data-label": HTMLAttributes.label,
+      "data-open": HTMLAttributes.open
+    }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CollapsibleView);
+  }
+});

package/dist/runtime/extensions/document-header.d.ts

@@ -0,0 +1,11 @@
+import { Node } from '@tiptap/core';
+/**
+ * DocumentHeader — the pinned H1 title node at the top of every doc.
+ *
+ * - Always the first node (enforced by the custom Document schema)
+ * - Cannot be deleted (Backspace at position 0 is swallowed)
+ * - Enter moves cursor to the first body block below the header
+ * - Pasting block content (paragraphs, headings, etc.) is flattened to inline text
+ * - Select-all + typing keeps text in the header with correct cursor placement
+ */
+export declare const DocumentHeader: Node<any, any>;

package/dist/runtime/extensions/document-header.js

@@ -0,0 +1,82 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { Plugin, PluginKey, TextSelection, AllSelection } from "@tiptap/pm/state";
+import { Slice, Fragment } from "@tiptap/pm/model";
+export const DocumentHeader = Node.create({
+  name: "documentHeader",
+  content: "inline*",
+  marks: "",
+  defining: true,
+  parseHTML() {
+    return [{ tag: "h1.document-header" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "h1",
+      mergeAttributes(HTMLAttributes, { class: "document-header" }),
+      0
+    ];
+  },
+  addKeyboardShortcuts() {
+    return {
+      // Enter inside the header → move cursor to the first body block below
+      Enter: ({ editor }) => {
+        const $head = editor.state.selection.$head;
+        if ($head.parent.type.name !== "documentHeader") return false;
+        const headerNode = editor.state.doc.firstChild;
+        if (!headerNode) return false;
+        const insideNextBlock = headerNode.nodeSize + 1;
+        return editor.commands.setTextSelection(insideNextBlock);
+      },
+      // Backspace at the very start of the header → swallow (don't delete the node)
+      Backspace: ({ editor }) => {
+        const { empty, anchor } = editor.state.selection;
+        return empty && anchor === 1;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("documentHeaderPaste"),
+        props: {
+          // When the entire doc is selected (Ctrl+A) and the user types,
+          // replace everything cleanly: put the typed char in the header
+          // and keep the cursor there, instead of letting ProseMirror
+          // misplace it into the body paragraph.
+          handleTextInput: (view, _from, _to, text) => {
+            if (!(view.state.selection instanceof AllSelection)) return false;
+            const { tr, schema } = view.state;
+            const headerType = schema.nodes.documentHeader;
+            const paragraphType = schema.nodes.paragraph;
+            if (!headerType || !paragraphType) return false;
+            const newContent = Fragment.from([
+              headerType.create(null, text ? [schema.text(text)] : []),
+              paragraphType.create()
+            ]);
+            tr.replaceWith(0, tr.doc.content.size, newContent);
+            tr.setSelection(TextSelection.create(tr.doc, 1 + text.length));
+            view.dispatch(tr);
+            return true;
+          },
+          handlePaste: (view, _event, slice) => {
+            const { $head } = view.state.selection;
+            if ($head.parent.type.name !== "documentHeader") return false;
+            const texts = [];
+            slice.content.forEach((node) => {
+              const t = node.textContent;
+              if (t) texts.push(t);
+            });
+            if (!texts.length) return false;
+            const text = texts.join(" ");
+            const { tr, schema } = view.state;
+            const textNode = schema.text(text);
+            const inlineSlice = new Slice(Fragment.from(textNode), 0, 0);
+            tr.replaceSelection(inlineSlice);
+            view.dispatch(tr);
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});

package/dist/runtime/extensions/document-meta.d.ts

@@ -0,0 +1,20 @@
+import { Node } from '@tiptap/core';
+/**
+ * DocumentMeta — the meta-field container between documentHeader and body.
+ *
+ * content: 'inline*' so:
+ *  - the cursor can land inside (enabling the slash menu via '/')
+ *  - metaField inline atoms appear as chips on the same line
+ *  - the Placeholder extension shows "Type '/' to add a property…"
+ *
+ * Keyboard:
+ *  - Backspace at position 0 → swallow (prevent merging up into header)
+ *  - Enter / ArrowDown → jump to first body block
+ *  - ArrowUp → jump to end of documentHeader
+ *
+ * A ProseMirror plugin handles the first body block:
+ *  - Backspace at start → blocked (prevent merge into documentMeta)
+ *  - ArrowUp → explicitly navigates into documentMeta (ProseMirror's
+ *    coordinate-based navigation skips the thin flex row when empty)
+ */
+export declare const DocumentMeta: Node<any, any>;

package/dist/runtime/extensions/document-meta.js

@@ -0,0 +1,121 @@
+import { Node } from "@tiptap/core";
+import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
+export const DocumentMeta = Node.create({
+  name: "documentMeta",
+  content: "inline*",
+  defining: true,
+  parseHTML() {
+    return [{ tag: 'div[data-type="document-meta"]' }];
+  },
+  renderHTML() {
+    return ["div", { "data-type": "document-meta" }, 0];
+  },
+  addKeyboardShortcuts() {
+    return {
+      Backspace: ({ editor }) => {
+        const { $head, empty } = editor.state.selection;
+        if (!empty) return false;
+        for (let d = $head.depth; d >= 0; d--) {
+          if ($head.node(d).type.name !== "documentMeta") continue;
+          return $head.pos === $head.start(d);
+        }
+        return false;
+      },
+      Enter: ({ editor }) => {
+        const { $head } = editor.state.selection;
+        for (let d = $head.depth; d >= 0; d--) {
+          if ($head.node(d).type.name !== "documentMeta") continue;
+          return moveToFirstBodyBlock(editor);
+        }
+        return false;
+      },
+      ArrowDown: ({ editor }) => {
+        const { $head } = editor.state.selection;
+        for (let d = $head.depth; d >= 0; d--) {
+          if ($head.node(d).type.name !== "documentMeta") continue;
+          return moveToFirstBodyBlock(editor);
+        }
+        return false;
+      },
+      ArrowUp: ({ editor }) => {
+        const { $head } = editor.state.selection;
+        for (let d = $head.depth; d >= 0; d--) {
+          if ($head.node(d).type.name !== "documentMeta") continue;
+          const header = editor.state.doc.firstChild;
+          if (!header || header.type.name !== "documentHeader") return false;
+          return editor.commands.setTextSelection(1 + header.content.size);
+        }
+        return false;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("documentMetaGuard"),
+        props: {
+          handleKeyDown(view, event) {
+            const { $head, empty } = view.state.selection;
+            if (!empty) return false;
+            if (event.key === "Backspace") {
+              if ($head.parentOffset !== 0) return false;
+              const index = $head.index($head.depth - 1);
+              if (index === 0) return false;
+              const prevSibling = $head.node($head.depth - 1).child(index - 1);
+              return prevSibling?.type.name === "documentMeta";
+            }
+            if (event.key === "ArrowUp") {
+              const parentType = $head.parent.type.name;
+              if (parentType === "documentMeta" || parentType === "documentHeader") return false;
+              const topIndex = $head.index(0);
+              if (topIndex === 0) return false;
+              const prevTop = $head.node(0).child(topIndex - 1);
+              if (prevTop?.type.name !== "documentMeta") return false;
+              let metaPos = -1;
+              view.state.doc.forEach((node, offset) => {
+                if (node.type.name === "documentMeta") metaPos = offset;
+              });
+              if (metaPos === -1) return false;
+              const metaNode = view.state.doc.nodeAt(metaPos);
+              const targetPos = metaPos + 1 + metaNode.content.size;
+              view.dispatch(view.state.tr.setSelection(
+                TextSelection.create(view.state.doc, targetPos)
+              ));
+              return true;
+            }
+            return false;
+          }
+        }
+      }),
+      new Plugin({
+        key: new PluginKey("documentMetaDedupe"),
+        appendTransaction(transactions, _old, newState) {
+          if (!transactions.some((tr2) => tr2.docChanged)) return null;
+          const metaPositions = [];
+          newState.doc.forEach((node, offset) => {
+            if (node.type.name === "documentMeta") metaPositions.push(offset);
+          });
+          if (metaPositions.length <= 1) return null;
+          const tr = newState.tr;
+          for (let i = metaPositions.length - 1; i >= 1; i--) {
+            const pos = metaPositions[i];
+            const node = newState.doc.nodeAt(pos);
+            if (node) tr.delete(pos, pos + node.nodeSize);
+          }
+          return tr;
+        }
+      })
+    ];
+  }
+});
+function moveToFirstBodyBlock(editor) {
+  const doc = editor.state.doc;
+  let firstBodyPos = -1;
+  doc.forEach((node, offset) => {
+    if (firstBodyPos === -1 && node.type.name !== "documentHeader" && node.type.name !== "documentMeta") {
+      firstBodyPos = offset + 1;
+    }
+  });
+  if (firstBodyPos > 0) return editor.commands.setTextSelection(firstBodyPos);
+  return false;
+}

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

@@ -0,0 +1,6 @@
+import { Node } from '@tiptap/core';
+/**
+ * Custom Document node that enforces `documentHeader documentMeta block+` schema,
+ * so every doc always starts with an editable H1 title node followed by a meta row.
+ */
+export declare const Document: Node<any, any>;

package/dist/runtime/extensions/document.js

@@ -0,0 +1,6 @@
+import { Node } from "@tiptap/core";
+export const Document = Node.create({
+  name: "doc",
+  topNode: true,
+  content: "documentHeader documentMeta block+"
+});

package/dist/runtime/extensions/file-block.d.ts

@@ -0,0 +1,15 @@
+import { Node } from '@tiptap/core';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        fileBlock: {
+            insertFileBlock: (attrs: {
+                uploadId: string;
+                docId: string;
+                filename: string;
+                mimeType: string;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const FileBlock: Node<any, any>;
+export default FileBlock;

package/dist/runtime/extensions/file-block.js

@@ -0,0 +1,34 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import FileNodeViewComponent from "./views/FileNodeView.vue";
+export const FileBlock = Node.create({
+  name: "fileBlock",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      uploadId: { default: null },
+      docId: { default: null },
+      filename: { default: "" },
+      mimeType: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="file-block"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "file-block" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(FileNodeViewComponent);
+  },
+  addCommands() {
+    return {
+      insertFileBlock: (attrs) => ({ commands }) => {
+        return commands.insertContent({ type: this.name, attrs });
+      }
+    };
+  }
+});
+export default FileBlock;

package/dist/runtime/extensions/file-drop.d.ts

@@ -0,0 +1,6 @@
+import { Extension } from '@tiptap/core';
+export interface FileDropOptions {
+    onFiles: (files: File[], pos?: number) => void;
+}
+export declare const FileDrop: Extension<FileDropOptions, any>;
+export default FileDrop;

package/dist/runtime/extensions/file-drop.js

@@ -0,0 +1,65 @@
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+function hasDraggedFiles(event) {
+  return Array.from(event.dataTransfer?.types ?? []).includes("Files");
+}
+export const FileDrop = Extension.create({
+  name: "fileDrop",
+  addOptions() {
+    return { onFiles: () => {
+    } };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    let dragCounter = 0;
+    return [
+      new Plugin({
+        key: new PluginKey("fileDrop"),
+        props: {
+          handleDOMEvents: {
+            dragenter(view, event) {
+              if (!hasDraggedFiles(event)) return false;
+              dragCounter++;
+              view.dom.classList.add("file-drop-active");
+              return false;
+            },
+            dragleave(view) {
+              dragCounter = Math.max(0, dragCounter - 1);
+              if (dragCounter === 0) {
+                view.dom.classList.remove("file-drop-active");
+              }
+              return false;
+            },
+            dragover(_view, event) {
+              if (!hasDraggedFiles(event)) return false;
+              event.preventDefault();
+              event.dataTransfer.dropEffect = "copy";
+              return false;
+            },
+            drop(view, event) {
+              dragCounter = 0;
+              view.dom.classList.remove("file-drop-active");
+              const de = event;
+              const files = Array.from(de.dataTransfer?.files ?? []);
+              if (!files.length) return false;
+              event.preventDefault();
+              const dropPos = view.posAtCoords({ left: de.clientX, top: de.clientY })?.pos;
+              options.onFiles(files, dropPos);
+              return true;
+            },
+            paste(_view, event) {
+              const ce = event;
+              const items = Array.from(ce.clipboardData?.items ?? []);
+              const files = items.filter((item) => item.kind === "file").map((item) => item.getAsFile()).filter((f) => f !== null);
+              if (!files.length) return false;
+              event.preventDefault();
+              options.onFiles(files);
+              return true;
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+export default FileDrop;

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

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

package/dist/runtime/extensions/kbd.js

@@ -0,0 +1,33 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import KbdView from "./views/KbdView.vue";
+export const Kbd = Node.create({
+  name: "kbd",
+  group: "inline",
+  inline: true,
+  atom: true,
+  addAttributes() {
+    return {
+      value: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "kbd[data-kbd]",
+        getAttrs: (el) => ({
+          value: el.getAttribute("data-value") || el.textContent
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["kbd", mergeAttributes({
+      "data-kbd": "",
+      "data-value": HTMLAttributes.value
+    }), HTMLAttributes.value];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(KbdView);
+  }
+});

package/dist/runtime/extensions/prose-icon.d.ts

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

package/dist/runtime/extensions/prose-icon.js

@@ -0,0 +1,33 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import ProseIconView from "./views/ProseIconView.vue";
+export const ProseIcon = Node.create({
+  name: "proseIcon",
+  group: "inline",
+  inline: true,
+  atom: true,
+  addAttributes() {
+    return {
+      name: { default: "i-lucide-star" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span[data-prose-icon]",
+        getAttrs: (el) => ({
+          name: el.getAttribute("data-name")
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes({
+      "data-prose-icon": "",
+      "data-name": HTMLAttributes.name
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ProseIconView);
+  }
+});

package/dist/runtime/extensions/search-highlight.d.ts

@@ -0,0 +1,10 @@
+import { Extension } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+export interface MatchResult {
+    from: number;
+    to: number;
+    contextBefore: string;
+    contextAfter: string;
+}
+export declare function findAllMatches(doc: ProseMirrorNode, term: string): MatchResult[];
+export declare const SearchHighlight: Extension<any, any>;