@abraca/nuxt 0.3.0 → 1.6.0

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

@@ -0,0 +1,8 @@
+export interface TiptapDragState {
+    html: string;
+    nodeType: string;
+    sourceDocId: string;
+    sourceDocLabel: string;
+    deleteFromSource: () => void;
+}
+export declare function useTiptapDragState(): import("vue").ShallowRef<TiptapDragState | null, TiptapDragState | null>;

package/dist/runtime/composables/useTiptapDragState.js

@@ -0,0 +1,5 @@
+import { shallowRef } from "vue";
+const tiptapDragState = shallowRef(null);
+export function useTiptapDragState() {
+  return tiptapDragState;
+}

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

@@ -14,6 +14,8 @@ export declare function useTouchDrag(opts: {
     onDrop?: (dragId: string, targetId: string) => void;
     /** Called when an item is dropped on a container (cross-container move) */
     onMoveToContainer?: (dragId: string, containerId: string, targetId: string | null) => void;
+    /** Called on every pointermove while over a container (for live previews) */
+    onMoveOverContainer?: (dragId: string, containerId: string, event: PointerEvent) => void;
     /** Called when drag starts */
     onDragStart?: (id: string) => void;
     /** Called when drag ends (always, even if no drop) */

package/dist/runtime/composables/useTouchDrag.js

@@ -127,6 +127,9 @@ export function useTouchDrag(opts) {
     const { id, container } = findTarget(e.clientX, e.clientY);
     dragOverId.value = id && id !== dragId.value ? id : null;
     dragOverContainer.value = container;
+    if (container && dragId.value && opts.onMoveOverContainer) {
+      opts.onMoveOverContainer(dragId.value, container, e);
+    }
     autoScroll(e.clientY);
   }
   function autoScroll(clientY) {

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

@@ -18,6 +18,8 @@ export interface TrashEntry {
     meta?: Record<string, any>;
     deletedAt: number;
     deletedBy?: string;
+    /** Batch ID for grouping items deleted together (for accurate restore). */
+    batchId?: string;
 }
 export declare function useTrash(rootDoc?: ShallowRef<Y.Doc | null>): {
     trashMap: {
@@ -37,6 +39,8 @@ export declare function useTrash(rootDoc?: ShallowRef<Y.Doc | null>): {
         meta?: Record<string, any>;
         deletedAt: number;
         deletedBy?: string;
+        /** Batch ID for grouping items deleted together (for accurate restore). */
+        batchId?: string;
         id: string;
     }[]>;
     trashedCount: import("vue").ComputedRef<number>;

package/dist/runtime/composables/useTrash.js

@@ -1,5 +1,6 @@
 import { computed, ref } from "vue";
 import { useSyncedMap } from "./useYDoc.js";
+import { useAbracadabra } from "./useAbracadabra.js";
 const TRASH_SETTINGS_KEY = "abracadabra_trash_settings";
 function loadTrashSettings() {
   try {
@@ -42,6 +43,7 @@ export function useTrash(rootDoc) {
     const doc = _doc.value;
     if (!doc) return;
     const now = Date.now();
+    const batchId = crypto.randomUUID();
     doc.transact(() => {
       for (const id of collectDescendants(docId)) {
         const entry = treeMap.get(id);
@@ -53,7 +55,8 @@ export function useTrash(rootDoc) {
           type: entry.type,
           meta: entry.meta,
           deletedAt: now,
-          deletedBy: deletedBy ?? userName.value
+          deletedBy: deletedBy ?? userName.value,
+          batchId
         });
         treeMap.remove(id);
       }
@@ -64,9 +67,9 @@ export function useTrash(rootDoc) {
     if (!doc) return;
     const entry = trashMap.get(docId);
     if (!entry) return;
-    const { deletedAt } = entry;
+    const { deletedAt, batchId } = entry;
     doc.transact(() => {
-      const toRestore = Object.entries(trashMap.data).filter(([, e]) => Math.abs(e.deletedAt - deletedAt) < 1e3);
+      const toRestore = Object.entries(trashMap.data).filter(([, e]) => batchId ? e.batchId === batchId : 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, {

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

@@ -0,0 +1,22 @@
+import type { ShallowRef, Ref, InjectionKey } from 'vue';
+import * as Y from 'yjs';
+export interface TreeUndoContext {
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+    undo: () => void;
+    redo: () => void;
+    undoManager: ShallowRef<Y.UndoManager | null>;
+}
+export declare const treeUndoKey: InjectionKey<TreeUndoContext>;
+/**
+ * Creates a Y.UndoManager scoped to the root doc's "doc-tree" and "doc-trash"
+ * Y.Maps. Tracks only local user changes (origin === null) so remote CRDT
+ * updates are never reversed.
+ *
+ * Both maps are tracked because deleteEntry moves items from tree -> trash in a
+ * single transaction — the UndoManager must see both sides to reverse it
+ * atomically.
+ *
+ * Should be called once in the layout and provided via `treeUndoKey`.
+ */
+export declare function useTreeUndoManager(rootDoc: ShallowRef<Y.Doc | null>): TreeUndoContext;

package/dist/runtime/composables/useTreeUndoManager.js

@@ -0,0 +1,45 @@
+import { ref, shallowRef, watch, onBeforeUnmount } from "vue";
+import * as Y from "yjs";
+export const treeUndoKey = Symbol("treeUndo");
+export function useTreeUndoManager(rootDoc) {
+  const undoManager = shallowRef(null);
+  const canUndo = ref(false);
+  const canRedo = ref(false);
+  function updateState() {
+    const um = undoManager.value;
+    canUndo.value = (um?.undoStack.length ?? 0) > 0;
+    canRedo.value = (um?.redoStack.length ?? 0) > 0;
+  }
+  watch(rootDoc, (doc, _oldDoc, onCleanup) => {
+    undoManager.value?.destroy();
+    undoManager.value = null;
+    canUndo.value = false;
+    canRedo.value = false;
+    if (!doc) return;
+    const treeMap = doc.getMap("doc-tree");
+    const trashMap = doc.getMap("doc-trash");
+    const um = new Y.UndoManager([treeMap, trashMap], {
+      trackedOrigins: /* @__PURE__ */ new Set([null]),
+      captureTimeout: 500
+    });
+    um.on("stack-item-added", updateState);
+    um.on("stack-item-popped", updateState);
+    undoManager.value = um;
+    onCleanup(() => {
+      um.off("stack-item-added", updateState);
+      um.off("stack-item-popped", updateState);
+      um.destroy();
+    });
+  }, { immediate: true });
+  onBeforeUnmount(() => {
+    undoManager.value?.destroy();
+    undoManager.value = null;
+  });
+  function undo() {
+    undoManager.value?.undo();
+  }
+  function redo() {
+    undoManager.value?.redo();
+  }
+  return { canUndo, canRedo, undo, redo, undoManager };
+}

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

@@ -0,0 +1,37 @@
+import type { ShallowRef, Ref, ComputedRef, InjectionKey } from 'vue';
+import type { Editor } from '@tiptap/vue-3';
+export interface UndoRedoContext {
+    /** Undo in the currently active context (editor or tree) */
+    undo: () => void;
+    /** Redo in the currently active context (editor or tree) */
+    redo: () => void;
+    /** Tree-specific undo/redo */
+    treeUndo: () => void;
+    treeRedo: () => void;
+    treeCanUndo: Ref<boolean>;
+    treeCanRedo: Ref<boolean>;
+    /** Editor-specific undo/redo */
+    editorUndo: () => void;
+    editorRedo: () => void;
+    editorCanUndo: ComputedRef<boolean>;
+    editorCanRedo: ComputedRef<boolean>;
+    /** Which domain last received focus */
+    activeContext: Ref<'editor' | 'tree'>;
+}
+export declare const undoRedoKey: InjectionKey<UndoRedoContext>;
+/**
+ * Coordinator composable that routes undo/redo to the correct domain:
+ * - TipTap editor focused -> editor's built-in Y.UndoManager
+ * - Otherwise -> tree Y.UndoManager (doc-tree + doc-trash)
+ *
+ * Meta field values (color, dates, tags) live in the tree Y.Map but are edited
+ * via popups inside the TipTap editor. To handle this, we track which domain
+ * had the most recent mutation and use that as a tiebreaker when the editor
+ * has focus — so Cmd+Z after a meta field change undoes the meta change even
+ * though focus returned to the editor.
+ *
+ * Injects the shared tree UndoManager from the layout (via treeUndoKey).
+ * Installs a page-level keydown listener for Cmd+Z / Cmd+Shift+Z when
+ * the TipTap editor does NOT have focus.
+ */
+export declare function useUndoRedo(editor: ShallowRef<Editor | null>): UndoRedoContext;

package/dist/runtime/composables/useUndoRedo.js

@@ -0,0 +1,115 @@
+import { computed, onBeforeUnmount, ref, inject, watch } from "vue";
+import { treeUndoKey } from "./useTreeUndoManager.js";
+export const undoRedoKey = Symbol("undoRedo");
+export function useUndoRedo(editor) {
+  const tree = inject(treeUndoKey);
+  const activeContext = ref("tree");
+  const lastMutatedDomain = ref("editor");
+  const lastUndoDomain = ref(null);
+  function editorHasFocus() {
+    const el = document.activeElement;
+    if (!el) return false;
+    return !!el.closest(".tiptap, .ProseMirror");
+  }
+  function editorUndo() {
+    editor.value?.commands.undo();
+  }
+  function editorRedo() {
+    editor.value?.commands.redo();
+  }
+  const editorCanUndo = computed(() => editor.value?.can().undo() ?? false);
+  const editorCanRedo = computed(() => editor.value?.can().redo() ?? false);
+  function onTreeStackAdded() {
+    lastMutatedDomain.value = "tree";
+  }
+  watch(() => tree.undoManager.value, (um, oldUm) => {
+    oldUm?.off("stack-item-added", onTreeStackAdded);
+    um?.on("stack-item-added", onTreeStackAdded);
+  }, { immediate: true });
+  function onEditorTransaction({ transaction }) {
+    if (transaction.docChanged) {
+      lastMutatedDomain.value = "editor";
+    }
+  }
+  watch(editor, (ed, oldEd) => {
+    oldEd?.off("transaction", onEditorTransaction);
+    ed?.on("transaction", onEditorTransaction);
+  }, { immediate: true });
+  function undo() {
+    if (!editorHasFocus() || !editor.value) {
+      activeContext.value = "tree";
+      lastUndoDomain.value = "tree";
+      tree.undo();
+    } else if (lastMutatedDomain.value === "tree" && tree.canUndo.value) {
+      activeContext.value = "tree";
+      lastUndoDomain.value = "tree";
+      tree.undo();
+      if (!tree.canUndo.value) {
+        lastMutatedDomain.value = "editor";
+      }
+    } else {
+      activeContext.value = "editor";
+      lastUndoDomain.value = "editor";
+      editorUndo();
+    }
+  }
+  function redo() {
+    if (!editorHasFocus() || !editor.value) {
+      activeContext.value = "tree";
+      tree.redo();
+    } else if (lastUndoDomain.value === "tree" && tree.canRedo.value) {
+      activeContext.value = "tree";
+      tree.redo();
+      if (!tree.canRedo.value) {
+        lastUndoDomain.value = null;
+      }
+    } else {
+      activeContext.value = "editor";
+      editorRedo();
+    }
+  }
+  function onKeydown(e) {
+    const mod = e.metaKey || e.ctrlKey;
+    if (!mod) return;
+    if (editorHasFocus()) return;
+    if (e.key === "z") {
+      e.preventDefault();
+      if (e.shiftKey) redo();
+      else undo();
+    } else if (e.key === "y") {
+      e.preventDefault();
+      redo();
+    }
+  }
+  function onFocusIn(e) {
+    const target = e.target;
+    if (target?.closest(".tiptap, .ProseMirror")) {
+      activeContext.value = "editor";
+    } else {
+      activeContext.value = "tree";
+    }
+  }
+  if (import.meta.client) {
+    window.addEventListener("keydown", onKeydown);
+    window.addEventListener("focusin", onFocusIn);
+    onBeforeUnmount(() => {
+      window.removeEventListener("keydown", onKeydown);
+      window.removeEventListener("focusin", onFocusIn);
+      tree.undoManager.value?.off("stack-item-added", onTreeStackAdded);
+      editor.value?.off("transaction", onEditorTransaction);
+    });
+  }
+  return {
+    undo,
+    redo,
+    treeUndo: tree.undo,
+    treeRedo: tree.redo,
+    treeCanUndo: tree.canUndo,
+    treeCanRedo: tree.canRedo,
+    editorUndo,
+    editorRedo,
+    editorCanUndo,
+    editorCanRedo,
+    activeContext
+  };
+}

package/dist/runtime/composables/useVoice.js

@@ -1,6 +1,8 @@
 import { ref, shallowRef, computed } from "vue";
 import { VoiceClient } from "../utils/VoiceClient.js";
 import { TRANSIENT_ERROR_CODES } from "../utils/voiceErrors.js";
+import { useToast } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
 const voiceStatus = ref("idle");
 const voiceRoomId = ref(null);
 const isMuted = ref(false);

package/dist/runtime/composables/useWebRTC.js

@@ -1,5 +1,7 @@
 import { ref, shallowRef, computed } from "vue";
 import { getSdkModule } from "../utils/sdkRef.js";
+import { useToast, useRuntimeConfig } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
 import { _wireFileTransferEvents, _destroyFileTransfer } from "./useFileTransfer.js";
 const webrtcStatus = ref("idle");
 const isConnected = ref(false);

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

@@ -119,4 +119,6 @@ export declare function useWindowManager(): {
     toggleMaximize: (id: string) => void;
     moveWindow: (id: string, x: number, y: number) => void;
     resizeWindow: (id: string, width: number, height: number, x?: number, y?: number) => void;
+    restoreLayout: () => void;
+    clearLayout: () => void;
 };

package/dist/runtime/composables/useWindowManager.js

@@ -1,7 +1,9 @@
 import { reactive, ref, computed } from "vue";
+const LAYOUT_STORAGE_KEY = "abracadabra_window_layout";
 const windows = reactive(/* @__PURE__ */ new Map());
 const topZIndex = ref(30);
 let cascadeOffset = 0;
+let _saveDebounce = null;
 export function useWindowManager() {
   function bringToFront(id) {
     const win = windows.get(id);
@@ -62,12 +64,15 @@ export function useWindowManager() {
       initialTab: opts.initialTab,
       meta: opts.meta
     });
+    _saveLayout();
   }
   function closeWindow(id) {
     windows.delete(id);
+    _saveLayout();
   }
   function closeAll() {
     windows.clear();
+    clearLayout();
   }
   function minimizeWindow(id, target) {
     const win = windows.get(id);
@@ -109,6 +114,7 @@ export function useWindowManager() {
     if (!win || win.isMaximized) return;
     win.x = x;
     win.y = y;
+    _saveLayout();
   }
   function resizeWindow(id, width, height, x, y) {
     const win = windows.get(id);
@@ -117,6 +123,7 @@ export function useWindowManager() {
     win.height = Math.max(height, 200);
     if (x !== void 0) win.x = x;
     if (y !== void 0) win.y = y;
+    _saveLayout();
   }
   const activeWindows = computed(
     () => [...windows.values()].filter((w) => !w.isMinimized).sort((a, b) => a.zIndex - b.zIndex)
@@ -124,6 +131,59 @@ export function useWindowManager() {
   const minimizedWindows = computed(
     () => [...windows.values()].filter((w) => w.isMinimized)
   );
+  function _saveLayout() {
+    if (_saveDebounce) clearTimeout(_saveDebounce);
+    _saveDebounce = setTimeout(() => {
+      try {
+        const layout = [...windows.values()].map((w) => ({
+          id: w.id,
+          docId: w.docId,
+          title: w.title,
+          icon: w.icon,
+          docType: w.docType,
+          channelId: w.channelId,
+          x: w.x,
+          y: w.y,
+          width: w.width,
+          height: w.height,
+          isMinimized: w.isMinimized,
+          isMaximized: w.isMaximized,
+          initialTab: w.initialTab,
+          meta: w.meta
+        }));
+        localStorage.setItem(LAYOUT_STORAGE_KEY, JSON.stringify(layout));
+      } catch {
+      }
+    }, 500);
+  }
+  function restoreLayout() {
+    try {
+      const raw = localStorage.getItem(LAYOUT_STORAGE_KEY);
+      if (!raw) return;
+      const layout = JSON.parse(raw);
+      for (const entry of layout) {
+        if (windows.has(entry.id)) continue;
+        topZIndex.value++;
+        windows.set(entry.id, {
+          ...entry,
+          provider: null,
+          zIndex: topZIndex.value,
+          isFocused: false,
+          prevX: entry.x,
+          prevY: entry.y,
+          prevWidth: entry.width,
+          prevHeight: entry.height
+        });
+      }
+    } catch {
+    }
+  }
+  function clearLayout() {
+    try {
+      localStorage.removeItem(LAYOUT_STORAGE_KEY);
+    } catch {
+    }
+  }
   return {
     windows,
     activeWindows,
@@ -136,6 +196,8 @@ export function useWindowManager() {
     restoreWindow,
     toggleMaximize,
     moveWindow,
-    resizeWindow
+    resizeWindow,
+    restoreLayout,
+    clearLayout
   };
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,63 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import DocEmbedView from "./views/DocEmbedView.vue";
+const EMBED_REGEX = /!\[\[([a-f0-9-]{36})(?:\|[^\]]+)?\]\]/gi;
+export const DocEmbed = Node.create({
+  name: "docEmbed",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      docId: { default: null },
+      collapsed: { default: false },
+      tall: { default: false }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="doc-embed"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "doc-embed" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(DocEmbedView);
+  },
+  addCommands() {
+    return {
+      insertDocEmbed: (attrs) => ({ commands }) => {
+        return commands.insertContent({ type: this.name, attrs });
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const type = this.type;
+    return [
+      new Plugin({
+        key: new PluginKey("docEmbedPaste"),
+        props: {
+          handlePaste(_view, event) {
+            const text = event.clipboardData?.getData("text/plain");
+            if (!text) return false;
+            const matches = [...text.matchAll(EMBED_REGEX)];
+            if (!matches.length) return false;
+            const nodes = matches.map(
+              (m) => type.create({ docId: m[1] })
+            );
+            if (!nodes.length) return false;
+            const { tr } = _view.state;
+            const { from, to } = tr.selection;
+            tr.delete(from, to);
+            nodes.forEach((node, i) => {
+              tr.insert(from + i, node);
+            });
+            _view.dispatch(tr);
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+export default DocEmbed;

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

@@ -0,0 +1,3 @@
+import { Extension } from '@tiptap/core';
+export declare const DocLinkDrop: Extension<any, any>;
+export default DocLinkDrop;

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

@@ -0,0 +1,63 @@
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { DOC_DRAG_MIME } from "../utils/docDragDrop.js";
+import { useDocDragBus } from "../composables/useDocDragBus.js";
+export const DocLinkDrop = Extension.create({
+  name: "docLinkDrop",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("docLinkDrop"),
+        props: {
+          handleDOMEvents: {
+            dragover(_view, event) {
+              const de = event;
+              if (!de.dataTransfer?.types.includes(DOC_DRAG_MIME)) return false;
+              de.preventDefault();
+              de.dataTransfer.dropEffect = de.altKey ? "link" : "copy";
+              return false;
+            },
+            drop(view, event) {
+              const de = event;
+              const raw = de.dataTransfer?.getData(DOC_DRAG_MIME);
+              let data;
+              if (raw) {
+                try {
+                  data = JSON.parse(raw);
+                } catch {
+                  return false;
+                }
+              } else {
+                const bus = useDocDragBus();
+                const state = bus.dragState.value;
+                if (!state || !state.docIds.length) return false;
+                data = { id: state.docIds[0], label: state.labels[0] || "Untitled" };
+                bus.endDrag();
+              }
+              de.preventDefault();
+              const dropPos = view.posAtCoords({ left: de.clientX, top: de.clientY })?.pos;
+              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);
+              } else {
+                const nodeType = schema.nodes.docEmbed;
+                if (!nodeType) return true;
+                const node = nodeType.create({ docId: data.id });
+                const $pos = tr.doc.resolve(dropPos);
+                const insertPos = $pos.depth >= 1 ? $pos.after(1) : tr.doc.content.size;
+                tr.insert(insertPos, node);
+              }
+              view.dispatch(tr);
+              return true;
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+export default DocLinkDrop;

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

@@ -4,7 +4,7 @@ import { Slice, Fragment } from "@tiptap/pm/model";
 export const DocumentHeader = Node.create({
   name: "documentHeader",
   content: "inline*",
-  marks: "",
+  marks: "bold italic code link strike",
   defining: true,
   parseHTML() {
     return [{ tag: "h1.document-header" }];

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

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