@abraca/nuxt 2.11.0 → 2.14.0

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

@@ -9,7 +9,7 @@
  * Usage:
  *   const { isOpen, activeTab, openSettings, closeSettings } = useSettingsModal()
  */
-export type SettingsTab = 'profile' | 'connection' | 'spaces' | 'security' | 'invites' | 'members' | 'trash' | 'offline' | 'plugins' | 'admin';
+export type SettingsTab = 'profile' | 'appearance' | 'connection' | 'spaces' | 'security' | 'invites' | 'members' | 'trash' | 'offline' | 'plugins' | 'admin';
 export declare function useSettingsModal(): {
     isOpen: import("vue").WritableComputedRef<boolean, boolean>;
     activeTab: import("vue").WritableComputedRef<SettingsTab, SettingsTab>;

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

@@ -14,7 +14,7 @@ export const DocLinkDrop = Extension.create({
               const de = event;
               if (!de.dataTransfer?.types.includes(DOC_DRAG_MIME)) return false;
               de.preventDefault();
-              de.dataTransfer.dropEffect = de.altKey ? "link" : "copy";
+              de.dataTransfer.dropEffect = de.metaKey || de.ctrlKey ? "link" : "copy";
               return false;
             },
             drop(view, event) {
@@ -38,7 +38,7 @@ export const DocLinkDrop = Extension.create({
               const dropPos = view.posAtCoords({ left: de.clientX, top: de.clientY })?.pos;
               if (dropPos == null) return true;
               const { schema, tr } = view.state;
-              if (de.altKey) {
+              if (de.metaKey || de.ctrlKey) {
                 const linkType = schema.nodes.docLink;
                 if (!linkType) return true;
                 const node = linkType.create({ docId: data.id });

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

@@ -0,0 +1,28 @@
+import { Extension } from '@tiptap/core';
+import type { DocSuggestItem, DocSuggestPopupState } from '../composables/useDocSuggest.js';
+export interface DocSuggestOptions {
+    /** Whole-space doc search (label match + create-on-miss). */
+    search: (query: string) => DocSuggestItem[];
+    /** Commit the chosen item as a doc link or embed over `range`. */
+    onCommit: (item: DocSuggestItem, mode: 'link' | 'embed', range: {
+        from: number;
+        to: number;
+    }, query: string) => void;
+}
+export interface DocSuggestStorage {
+    popup: DocSuggestPopupState;
+}
+/**
+ * Inline `[[` (doc link) and `![[` (doc embed) suggestion popups — the
+ * mention-style counterpart for cross-document references.
+ *
+ * One `@tiptap/suggestion` plugin triggers on `[[`; the leading `!` (when
+ * present) is what distinguishes embed from link. The popup is driven through
+ * `editor.storage.docSuggest.popup` (a per-editor reactive object) which the
+ * `ADocSuggestMenu` component renders — so nested/embedded editors never share
+ * or duplicate one popup.
+ *
+ * Ported from cou-sh/app/extensions/doc-suggest.ts.
+ */
+export declare const DocSuggest: Extension<DocSuggestOptions, DocSuggestStorage>;
+export default DocSuggest;

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

@@ -0,0 +1,85 @@
+import { Extension } from "@tiptap/core";
+import { reactive } from "vue";
+import { Suggestion } from "@tiptap/suggestion";
+import { emptyDocSuggestState } from "../composables/useDocSuggest.js";
+export const DocSuggest = Extension.create({
+  name: "docSuggest",
+  addOptions() {
+    return {
+      search: () => [],
+      onCommit: () => {
+      }
+    };
+  },
+  addStorage() {
+    return { popup: reactive(emptyDocSuggestState()) };
+  },
+  addProseMirrorPlugins() {
+    const reset = () => Object.assign(this.storage.popup, emptyDocSuggestState());
+    return [
+      Suggestion({
+        editor: this.editor,
+        char: "[[",
+        startOfLine: false,
+        allowSpaces: true,
+        allowedPrefixes: null,
+        // allow triggering after `!` and mid-line
+        items: ({ query }) => this.options.search(query),
+        command: () => {
+        },
+        // selection handled via the popup / onKeyDown
+        render: () => {
+          const sync = (props) => {
+            const popup = this.storage.popup;
+            const from = props.range.from;
+            const before = props.editor.state.doc.textBetween(Math.max(0, from - 1), from);
+            const mode = before === "!" ? "embed" : "link";
+            const rect = props.clientRect?.();
+            popup.active = true;
+            popup.mode = mode;
+            popup.query = props.query;
+            popup.items = props.items;
+            popup.index = 0;
+            popup.rect = rect ? { left: rect.left, top: rect.top, bottom: rect.bottom } : null;
+            popup.onSelect = (item) => {
+              const realBefore = props.editor.state.doc.textBetween(Math.max(0, from - 1), from);
+              const realMode = realBefore === "!" ? "embed" : "link";
+              const realFrom = realMode === "embed" ? from - 1 : from;
+              this.options.onCommit(item, realMode, { from: realFrom, to: props.range.to }, props.query);
+              reset();
+            };
+          };
+          return {
+            onStart: sync,
+            onUpdate: sync,
+            onKeyDown: ({ event }) => {
+              const popup = this.storage.popup;
+              const items = popup.items;
+              if (event.key === "Escape") {
+                reset();
+                return true;
+              }
+              if (!items.length) return false;
+              if (event.key === "ArrowDown") {
+                popup.index = (popup.index + 1) % items.length;
+                return true;
+              }
+              if (event.key === "ArrowUp") {
+                popup.index = (popup.index - 1 + items.length) % items.length;
+                return true;
+              }
+              if (event.key === "Enter") {
+                const item = items[popup.index];
+                if (item) popup.onSelect?.(item);
+                return true;
+              }
+              return false;
+            },
+            onExit: () => reset()
+          };
+        }
+      })
+    ];
+  }
+});
+export default DocSuggest;

package/dist/runtime/locale.d.ts

@@ -61,6 +61,10 @@ export interface AbracadabraLocale {
     nodePanel: {
         editorTab: string;
         propertiesTab: string;
+        chatTab: string;
+        settingsTab: string;
+        serverTab: string;
+        openAsFullPage: string;
         close: string;
         icon: string;
         color: string;
@@ -251,6 +255,10 @@ export interface AbracadabraLocale {
             edgeNormal: string;
             edgeThick: string;
             filter: string;
+            scrollBehavior: string;
+            personalSetting: string;
+            scrollPan: string;
+            scrollZoom: string;
         };
         dashboard: {
             addItem: string;

package/dist/runtime/locale.js

@@ -47,6 +47,10 @@ export const DEFAULT_LOCALE = {
   nodePanel: {
     editorTab: "Editor",
     propertiesTab: "Properties",
+    chatTab: "Chat",
+    settingsTab: "Settings",
+    serverTab: "Server",
+    openAsFullPage: "Open as full page",
     close: "Close",
     icon: "Icon",
     color: "Color",
@@ -236,7 +240,11 @@ export const DEFAULT_LOCALE = {
       edgeThin: "Thin",
       edgeNormal: "Normal",
       edgeThick: "Thick",
-      filter: "Filter"
+      filter: "Filter",
+      scrollBehavior: "Scroll behavior",
+      personalSetting: "Personal \u2014 this device only",
+      scrollPan: "Pan",
+      scrollZoom: "Zoom"
     },
     dashboard: {
       addItem: "Add item",

package/dist/runtime/utils/chatContent.d.ts

@@ -24,7 +24,11 @@ export type ParsedMessage = {
     icon?: string;
 };
 export declare function parseMessageContent(content: string): ParsedMessage;
-/** Segment types for rich text rendering */
+/**
+ * Segment types for rich text rendering. Markdown spans (bold/italic/strike/
+ * code) carry their inner `value` as plain text — rendered as styled spans, so
+ * there is NO HTML injection (no `v-html`); the renderer just picks a tag/class.
+ */
 export type TextSegment = {
     type: 'text';
     value: string;
@@ -34,8 +38,22 @@ export type TextSegment = {
 } | {
     type: 'mention';
     name: string;
+} | {
+    type: 'bold';
+    value: string;
+} | {
+    type: 'italic';
+    value: string;
+} | {
+    type: 'strike';
+    value: string;
+} | {
+    type: 'code';
+    value: string;
 };
-/** Split plain text into segments for rich rendering (links, @mentions) */
+/** Split plain text into segments for rich rendering (markdown, links, @mentions). */
 export declare function renderMessageSegments(text: string): TextSegment[];
+/** Whether a plain-text message contains any rich span (markdown/link/mention). */
+export declare function hasRichText(text: string): boolean;
 /** Return a short plain-text preview for any message content string. */
 export declare function previewMessageContent(content: string): string;

package/dist/runtime/utils/chatContent.js

@@ -28,16 +28,32 @@ export function parseMessageContent(content) {
 }
 const URL_RE = /https?:\/\/[^\s<>)"']+/g;
 const MENTION_RE = /@(\w+)/g;
+const CODE_RE = /`([^`\n]+)`/g;
+const BOLD_RE = /\*\*([^*\n]+)\*\*/g;
+const STRIKE_RE = /~~([^~\n]+)~~/g;
+const ITALIC_RE = /\*([^*\n]+)\*|_([^_\n]+)_/g;
 export function renderMessageSegments(text) {
   const segments = [];
   const matches = [];
+  for (const m of text.matchAll(CODE_RE)) {
+    matches.push({ index: m.index, length: m[0].length, segment: { type: "code", value: m[1] } });
+  }
+  for (const m of text.matchAll(BOLD_RE)) {
+    matches.push({ index: m.index, length: m[0].length, segment: { type: "bold", value: m[1] } });
+  }
+  for (const m of text.matchAll(STRIKE_RE)) {
+    matches.push({ index: m.index, length: m[0].length, segment: { type: "strike", value: m[1] } });
+  }
+  for (const m of text.matchAll(ITALIC_RE)) {
+    matches.push({ index: m.index, length: m[0].length, segment: { type: "italic", value: m[1] ?? m[2] } });
+  }
   for (const m of text.matchAll(URL_RE)) {
     matches.push({ index: m.index, length: m[0].length, segment: { type: "link", url: m[0] } });
   }
   for (const m of text.matchAll(MENTION_RE)) {
     matches.push({ index: m.index, length: m[0].length, segment: { type: "mention", name: m[1] } });
   }
-  matches.sort((a, b) => a.index - b.index);
+  matches.sort((a, b) => a.index - b.index || b.length - a.length);
   let cursor = 0;
   for (const m of matches) {
     if (m.index < cursor) continue;
@@ -52,6 +68,9 @@ export function renderMessageSegments(text) {
   }
   return segments.length > 0 ? segments : [{ type: "text", value: text }];
 }
+export function hasRichText(text) {
+  return /@\w+|https?:\/\/|\*\*[^*\n]+\*\*|~~[^~\n]+~~|`[^`\n]+`|\*[^*\n]+\*|_[^_\n]+_/.test(text);
+}
 export function previewMessageContent(content) {
   const parsed = parseMessageContent(content);
   if (parsed.kind === "doc-quote") {

package/dist/runtime/utils/codeHighlightStyle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Atom One — Nuxt UI syntax highlighting.
+ *
+ * Keeps Atom One Dark's familiar token roles but pulls each colour from the
+ * host's Nuxt UI theme tokens (`--ui-*` / `--color-*`), so the code editor
+ * matches the surrounding UI. Every value falls back to the canonical Atom
+ * One hex when the token isn't defined.
+ *
+ * A factory (not a const) because CodeMirror is lazy-loaded — `HighlightStyle`
+ * and the lezer `tags` come from the bundle resolved in `loadCodeMirror.ts`.
+ */
+type HighlightStyleStatic = (typeof import('@codemirror/language'))['HighlightStyle'];
+type TagsObject = (typeof import('@lezer/highlight'))['tags'];
+export declare function buildAtomOneNuxtHighlight(HighlightStyleCtor: HighlightStyleStatic, t: TagsObject): import("@codemirror/language").HighlightStyle;
+export {};

package/dist/runtime/utils/codeHighlightStyle.js

@@ -0,0 +1,34 @@
+export function buildAtomOneNuxtHighlight(HighlightStyleCtor, t) {
+  return HighlightStyleCtor.define([
+    // Comments — dimmed + italic.
+    { tag: [t.comment, t.lineComment, t.blockComment, t.docComment], color: "var(--ui-text-dimmed, #5c6370)", fontStyle: "italic" },
+    // Keywords / storage — brand colour (Atom One purple fallback).
+    { tag: [t.keyword, t.moduleKeyword, t.controlKeyword, t.operatorKeyword, t.definitionKeyword, t.self], color: "var(--ui-primary, #c678dd)" },
+    // Strings + escapes — green.
+    { tag: [t.string, t.special(t.string), t.docString, t.regexp, t.attributeValue], color: "var(--color-green-400, #98c379)" },
+    { tag: [t.escape, t.character], color: "var(--color-cyan-400, #56b6c2)" },
+    // Numbers / constants / booleans — orange.
+    { tag: [t.number, t.integer, t.float, t.bool, t.null, t.atom, t.unit, t.constant(t.name), t.standard(t.name)], color: "var(--color-orange-400, #d19a66)" },
+    // Functions / methods — blue.
+    { tag: [t.function(t.variableName), t.function(t.propertyName), t.labelName, t.macroName], color: "var(--color-blue-400, #61afef)" },
+    // Types / classes / namespaces — amber.
+    { tag: [t.typeName, t.className, t.namespace, t.definition(t.typeName)], color: "var(--color-amber-400, #e5c07b)" },
+    // Properties / attributes / tags — red.
+    { tag: [t.propertyName, t.attributeName, t.tagName], color: "var(--color-red-400, #e06c75)" },
+    // Plain identifiers — body text colour.
+    { tag: [t.variableName, t.definition(t.variableName)], color: "var(--ui-text-highlighted, #abb2bf)" },
+    // Operators — cyan.
+    { tag: [t.operator, t.derefOperator, t.arithmeticOperator, t.logicOperator, t.bitwiseOperator, t.compareOperator, t.updateOperator], color: "var(--color-cyan-400, #56b6c2)" },
+    // Punctuation / brackets — muted.
+    { tag: [t.punctuation, t.separator, t.bracket, t.angleBracket, t.squareBracket, t.paren, t.brace], color: "var(--ui-text-muted, #abb2bf)" },
+    // Meta / annotations — cyan.
+    { tag: [t.meta, t.documentMeta, t.annotation, t.processingInstruction], color: "var(--color-cyan-400, #56b6c2)" },
+    // Markdown / prose niceties.
+    { tag: [t.heading], fontWeight: "600", color: "var(--color-red-400, #e06c75)" },
+    { tag: [t.strong], fontWeight: "600" },
+    { tag: [t.emphasis], fontStyle: "italic" },
+    { tag: [t.strikethrough], textDecoration: "line-through" },
+    { tag: [t.link, t.url], color: "var(--ui-primary, #61afef)", textDecoration: "underline" },
+    { tag: [t.invalid], color: "var(--ui-error, #e06c75)" }
+  ]);
+}

package/dist/runtime/utils/docTypes.js

@@ -138,6 +138,19 @@ export const DOC_TYPES = {
       () => import("../components/renderers/ATableRenderer.vue")
     )
   },
+  sheets: {
+    key: "sheets",
+    label: "Sheets",
+    icon: "i-lucide-grid-3x3",
+    description: "Spreadsheet \u2014 cells, formulas, and formatting in a collaborative grid",
+    available: true,
+    supportsChildren: true,
+    childLabel: "Column",
+    grandchildLabel: "Cell",
+    component: defineDocComponent(
+      () => import("../components/renderers/ASheetsRenderer.client.vue")
+    )
+  },
   outline: {
     key: "outline",
     label: "Outline",
@@ -226,6 +239,24 @@ export const DOC_TYPES = {
       () => import("../components/renderers/AGraphRenderer.vue")
     )
   },
+  chart: {
+    key: "chart",
+    label: "Chart",
+    icon: "i-lucide-bar-chart-3",
+    description: "Charts \u2014 manual data points or aggregation over document trees",
+    available: true,
+    supportsChildren: true,
+    childLabel: "Data Point",
+    grandchildLabel: "Data Point",
+    component: defineDocComponent(
+      () => import("../components/renderers/AChartRenderer.client.vue")
+    ),
+    metaSchema: [
+      { type: "number", key: "number", step: 0.01, label: "Value" },
+      { type: "colorPreset", key: "color", presets: ["#6366f1", "#ec4899", "#f97316", "#22c55e", "#3b82f6", "#a855f7", "#14b8a6", "#eab308"], label: "Color" },
+      { type: "tags", key: "tags", label: "Tags" }
+    ]
+  },
   dashboard: {
     key: "dashboard",
     label: "Dashboard",
@@ -271,6 +302,18 @@ export const DOC_TYPES = {
       { type: "select", key: "slidesTransition", options: ["none", "fade", "slide"], label: "Transition" },
       { type: "colorPreset", key: "color", presets: ["#6366f1", "#ec4899", "#f97316", "#22c55e", "#3b82f6", "#a855f7"], label: "Accent" }
     ]
+  },
+  overview: {
+    key: "overview",
+    label: "Overview",
+    icon: "i-lucide-radar",
+    description: "Space home \u2014 activity, people, stats, and health at a glance",
+    available: true,
+    supportsChildren: true,
+    childLabel: "Page",
+    component: defineDocComponent(
+      () => import("../components/renderers/AOverviewRenderer.vue")
+    )
   }
 };
 export const DEFAULT_DOC_TYPE = DOC_TYPES.doc;

package/dist/runtime/utils/loadCodeMirror.d.ts

@@ -28,5 +28,6 @@ export interface CodeMirrorBundle {
     langVue: typeof import('@codemirror/lang-vue');
     langJson: typeof import('@codemirror/lang-json');
     yCollab: typeof import('y-codemirror.next');
+    lezerHighlight: typeof import('@lezer/highlight');
 }
 export declare function loadCodeMirror(): Promise<CodeMirrorBundle | null>;

package/dist/runtime/utils/loadCodeMirror.js

@@ -17,7 +17,8 @@ export async function loadCodeMirror() {
         "@codemirror/lang-css",
         "@codemirror/lang-vue",
         "@codemirror/lang-json",
-        "y-codemirror.next"
+        "y-codemirror.next",
+        "@lezer/highlight"
       ];
       const [
         view,
@@ -30,7 +31,8 @@ export async function loadCodeMirror() {
         langCss,
         langVue,
         langJson,
-        yCollab
+        yCollab,
+        lezerHighlight
       ] = await Promise.all(names.map((n) => import(
         /* @vite-ignore */
         n
@@ -46,7 +48,8 @@ export async function loadCodeMirror() {
         langCss,
         langVue,
         langJson,
-        yCollab
+        yCollab,
+        lezerHighlight
       };
       return cache;
     } catch {

package/dist/runtime/utils/titleSync.d.ts

@@ -0,0 +1,130 @@
+/**
+ * titleSync — pure decision logic for keeping the H1 documentHeader and the
+ * tree-entry `label` field in agreement, plus a defensive `setHeaderText`.
+ *
+ * The two sources of truth are:
+ *  - the `documentHeader` Y.XmlElement inside the child doc's Y.XmlFragment
+ *    (rendered by TipTap as the H1 at the top of the page);
+ *  - the `label` field on the doc's tree entry in the root provider's treeMap
+ *    (rendered by the sidebar, breadcrumb, browser title, etc.).
+ *
+ * Past regressions in this area lost user titles because:
+ *  - the editor mounted on an empty Y.XmlFragment, y-prosemirror seeded an
+ *    empty documentHeader, then the server snapshot arrived with the real
+ *    title and the local empty got merged in — sometimes winning the
+ *    "canonical pick" inside enforceDocumentShape;
+ *  - the post-sync flow only wrote header → tree on LOCAL updates, so a
+ *    server-delivered title never reflected back into the tree label and the
+ *    sidebar stayed stuck on "Untitled";
+ *  - the tree-label → header watcher unconditionally called
+ *    `setHeaderText(editor, newLabel || '')`, which on a transient
+ *    `newLabel = undefined` would erase the user's title.
+ *
+ * `decideTitleSync` is the canonical answer for "what should I do given the
+ * current state of both sides?", returning one of three actions. It is pure
+ * so it can be exhaustively table-tested.
+ *
+ * `setHeaderText` is the only sanctioned way for the renderer to write into
+ * the documentHeader. It refuses to overwrite a non-empty header with an
+ * empty string unless the caller passes `force: true`.
+ *
+ * Ported 1:1 from cou-sh/app/utils/titleSync.ts.
+ */
+/** Sentinel placeholder label used by the tree when no real label has been set. */
+export declare const UNTITLED = "Untitled";
+/**
+ * The tree label is "empty" — meaning it carries no user-supplied title —
+ * when it's the empty string, null/undefined, or the literal placeholder
+ * `"Untitled"`. The two former cases come from a freshly-created tree row
+ * (no label yet); the latter comes from `useChildTree.renameEntry`
+ * canonicalising a cleared title to `"Untitled"` so the UI never has to
+ * render `null`.
+ */
+export declare function isEmptyTreeLabel(label: string | null | undefined): boolean;
+export type TitleSyncAction = {
+    kind: 'noop';
+} | {
+    kind: 'header-from-tree';
+    text: string;
+} | {
+    kind: 'tree-from-header';
+    label: string;
+};
+export interface TitleSyncInput {
+    /** Text content of the `documentHeader` node (what TipTap renders). */
+    headerText: string;
+    /**
+     * Current tree-entry label, or null/undefined if the entry hasn't loaded.
+     * Caller is expected to fall back to `props.docLabel` before passing in.
+     */
+    treeLabel: string | null | undefined;
+    /**
+     * True when the originating ProseMirror transaction was driven by a Yjs
+     * remote update (i.e. `transaction.getMeta('y-sync$')?.isChangeOrigin`).
+     * Used to disambiguate "the user just typed this" from "the server told
+     * us this".
+     */
+    isRemoteUpdate: boolean;
+    /**
+     * Whether `syncHeader` has already performed its first-mount reconciliation
+     * for this editor instance. Set by the caller; the first call must pass
+     * `false` and every subsequent call must pass `true`.
+     */
+    initialSyncDone: boolean;
+}
+/**
+ * Decide what (if anything) needs to change to keep the header and the tree
+ * label in agreement.
+ *
+ * The truth table — every cell is pinned by `test/title-sync-decision.test.ts`:
+ *
+ *  ┌──────────────┬───────────────────┬───────────────────────────────────────┐
+ *  │ headerText   │ treeLabel         │ result                                │
+ *  ├──────────────┼───────────────────┼───────────────────────────────────────┤
+ *  │ empty        │ empty/Untitled    │ noop (no information either way)      │
+ *  │ same         │ same              │ noop                                  │
+ *  │ has text     │ empty/Untitled    │ tree-from-header (RESCUE — incl.      │
+ *  │              │                   │   remote: server delivered the title  │
+ *  │              │                   │   via the doc fragment, tree needs    │
+ *  │              │                   │   to catch up)                        │
+ *  │ empty        │ has text          │ initial OR remote → header-from-tree  │
+ *  │              │                   │ local + post-initial → tree-from-     │
+ *  │              │                   │   header('Untitled') (user emptied    │
+ *  │              │                   │   the title, so canonicalise)         │
+ *  │ different    │ different         │ initial OR local → tree-from-header   │
+ *  │              │                   │ remote + post-initial → noop (the     │
+ *  │              │                   │   label watcher reconciles header     │
+ *  │              │                   │   from tree if needed)                │
+ *  └──────────────┴───────────────────┴───────────────────────────────────────┘
+ */
+export declare function decideTitleSync(input: TitleSyncInput): TitleSyncAction;
+export interface SetHeaderTextOptions {
+    /**
+     * Allow overwriting a non-empty `documentHeader` with an empty string.
+     * Default `false`. The watcher on the tree label MUST NOT pass `true` — a
+     * transient `newLabel = undefined` during reload would otherwise erase the
+     * user's title. Setting `force: true` is reserved for the explicit "user
+     * emptied the title locally" path.
+     */
+    force?: boolean;
+}
+/**
+ * Replace the inline text content of the first `documentHeader` node in
+ * `ed.state.doc`. Refuses the write when:
+ *  - there is no documentHeader at index 0;
+ *  - the header already has the requested text (cheap no-op);
+ *  - the user's selection is inside the header (an external sync echo must
+ *    never clobber in-flight typing);
+ *  - `text` is empty AND the existing header is non-empty AND `force`
+ *    wasn't passed (the no-destroy invariant).
+ *
+ * Returns `true` if a transaction was dispatched, `false` otherwise. Used
+ * by tests to assert the no-destroy invariant.
+ */
+export declare function setHeaderText(ed: {
+    state: any;
+    view: {
+        dispatch: (tr: any) => void;
+        hasFocus?: () => boolean;
+    };
+}, text: string, opts?: SetHeaderTextOptions): boolean;

package/dist/runtime/utils/titleSync.js

@@ -0,0 +1,53 @@
+import { Fragment } from "@tiptap/pm/model";
+export const UNTITLED = "Untitled";
+export function isEmptyTreeLabel(label) {
+  return !label || label === UNTITLED;
+}
+export function decideTitleSync(input) {
+  const { headerText, treeLabel, isRemoteUpdate, initialSyncDone } = input;
+  const treeEmpty = isEmptyTreeLabel(treeLabel);
+  const headerEmpty = isEmptyTreeLabel(headerText);
+  if (treeEmpty && headerEmpty) return { kind: "noop" };
+  if (!headerEmpty && !treeEmpty && headerText === treeLabel) {
+    return { kind: "noop" };
+  }
+  if (!headerEmpty && treeEmpty) {
+    return { kind: "tree-from-header", label: headerText };
+  }
+  if (headerEmpty && !treeEmpty) {
+    if (!initialSyncDone) {
+      return { kind: "header-from-tree", text: treeLabel };
+    }
+    if (isRemoteUpdate) {
+      return { kind: "header-from-tree", text: treeLabel };
+    }
+    return { kind: "noop" };
+  }
+  if (!initialSyncDone) {
+    return { kind: "tree-from-header", label: headerText };
+  }
+  if (!isRemoteUpdate) {
+    return { kind: "tree-from-header", label: headerText };
+  }
+  return { kind: "noop" };
+}
+export function setHeaderText(ed, text, opts = {}) {
+  const first = ed.state.doc.firstChild;
+  if (!first || first.type.name !== "documentHeader") return false;
+  if (first.textContent === text) return false;
+  const hasFocus = typeof ed.view.hasFocus === "function" ? ed.view.hasFocus() : false;
+  if (hasFocus) {
+    const { $head } = ed.state.selection;
+    if ($head?.parent?.type?.name === "documentHeader") return false;
+  }
+  if (!text && first.textContent && !opts.force) return false;
+  const { tr, schema } = ed.state;
+  const to = 1 + first.content.size;
+  if (text) {
+    tr.replaceWith(1, to, schema.text(text));
+  } else {
+    tr.replaceWith(1, to, Fragment.empty);
+  }
+  ed.view.dispatch(tr);
+  return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/nuxt",
-  "version": "2.11.0",
+  "version": "2.14.0",
   "description": "First-class Nuxt module for the Abracadabra CRDT collaboration platform",
   "repository": "abracadabra/abracadabra-nuxt",
   "license": "MIT",
@@ -69,7 +69,10 @@
     "@tiptap/extension-text-align": "^3.0.0",
     "@tiptap/extension-text-style": "^3.0.0",
     "@tiptap/starter-kit": "^3.0.0",
+    "@tiptap/suggestion": "^3.0.0",
     "@tiptap/vue-3": "^3.0.0",
+    "@unovis/ts": "^1.6.5",
+    "@unovis/vue": "^1.6.5",
     "d3-force": "^3.0.0",
     "jszip": "^3.0.0",
     "lowlight": "^3.0.0",
@@ -131,6 +134,12 @@
     },
     "@tiptap/extension-emoji": {
       "optional": true
+    },
+    "@unovis/vue": {
+      "optional": true
+    },
+    "@unovis/ts": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -163,6 +172,8 @@
     "@types/d3-force": "^3.0.10",
     "@types/node": "latest",
     "@types/ws": "^8.18.1",
+    "@unovis/ts": "^1.6.5",
+    "@unovis/vue": "^1.6.5",
     "@vue/test-utils": "^2.4.10",
     "changelogen": "^0.6.2",
     "d3-force": "^3.0.0",