@fastsprout/reacd-shadcn 0.0.0-stage → 0.3.0

package/dist/shared/editor-menu/menu-plugin.js

@@ -0,0 +1,190 @@
+import { PluginKey } from '@tiptap/pm/state';
+import { z } from 'zod';
+import { Suggestion, exitSuggestion } from '@tiptap/suggestion';
+import { EDITOR_MENU_POLICY as P } from '@fastsprout/reacd/adapter-runtime/core/editor-menu-policy.js';
+import { editorCommandChain } from '../editor-sdk/command-chain.js';
+import { canRunSdkCommand } from '../editor-sdk/commands.js';
+const activeSuggestionSchema = z.object({ active: z.literal(true) });
+function insert(editor, range, item) {
+    const chain = editor.chain().focus().deleteRange(range);
+    if (item.kind === 'suggestion')
+        return editorCommandChain(chain, item.value).run();
+    const atom = item.kind === 'mention'
+        ? { type: 'reacdMention', attrs: { id: item.id, label: item.label } }
+        : { type: 'reacdEmoji', attrs: { name: item.name, value: item.value } };
+    return chain.insertContent([atom, { type: 'text', text: P.suffix }]).run();
+}
+export function mountEditorMenu(editor, request, released) {
+    const key = new PluginKey(`reacd-${request.kind}`);
+    let current;
+    let selected = P.initialIndex;
+    let destroyed = false;
+    let revision = 0;
+    function resolved(query) {
+        const remote = request.lookup?.(query);
+        const items = remote?.items ??
+            request
+                .items()
+                .filter((item) => item.label.toLowerCase().includes(query.toLowerCase()))
+                .slice(0, P.maxResults);
+        return {
+            status: remote?.status ?? 'ready',
+            error: remote?.error,
+            items: items
+                .slice(0, P.maxResults)
+                .map((item) => item.kind === 'suggestion' && !canRunSdkCommand(editor, item.value)
+                ? { ...item, disabled: true }
+                : item),
+        };
+    }
+    function clear() {
+        revision += 1;
+        current = undefined;
+        if (!editor.isDestroyed &&
+            editor.view.dom.getAttribute('aria-controls') === request.listId) {
+            for (const name of [
+                'aria-controls',
+                'aria-expanded',
+                'aria-activedescendant',
+                'aria-autocomplete',
+                'aria-busy',
+            ])
+                editor.view.dom.removeAttribute(name);
+        }
+        request.change(undefined);
+    }
+    function publish(next) {
+        if (destroyed || editor.isDestroyed)
+            return;
+        const ticket = ++revision;
+        current = next;
+        const data = resolved(next.query);
+        if (ticket !== revision || destroyed || editor.isDestroyed)
+            return;
+        current = { ...next, items: [...data.items] };
+        if (data.items[selected] === undefined || data.items[selected]?.disabled === true)
+            selected = data.items.findIndex((item) => item.disabled !== true);
+        const input = editor.view.dom;
+        input.setAttribute('aria-controls', request.listId);
+        input.setAttribute('aria-expanded', 'true');
+        input.setAttribute('aria-autocomplete', 'list');
+        input.setAttribute('aria-busy', String(data.status === 'loading'));
+        if (data.items[selected] === undefined)
+            input.removeAttribute('aria-activedescendant');
+        else
+            input.setAttribute('aria-activedescendant', `${request.listId}-${selected}`);
+        request.change(Object.freeze({
+            query: next.query,
+            status: data.status,
+            error: data.error,
+            items: Object.freeze([...data.items]),
+            selected,
+        }));
+    }
+    function close() {
+        if (!destroyed && !editor.isDestroyed)
+            exitSuggestion(editor.view, key);
+    }
+    function choose(index) {
+        const suggestion = current;
+        if (destroyed ||
+            editor.isDestroyed ||
+            !editor.isEditable ||
+            suggestion === undefined)
+            return;
+        const item = suggestion.items[index];
+        if (item === undefined || item.disabled === true)
+            return;
+        suggestion.command(item);
+        close();
+    }
+    function step(suggestion, direction) {
+        const enabled = suggestion.items.flatMap((item, index) => item.disabled === true ? [] : [index]);
+        if (enabled.length > 0) {
+            const next = (enabled.indexOf(selected) + direction + enabled.length) % enabled.length;
+            for (const [position, value] of enabled.entries()) {
+                if (position === next)
+                    selected = value;
+            }
+        }
+        publish(suggestion);
+    }
+    const plugin = Suggestion({
+        editor,
+        pluginKey: key,
+        char: P.triggers[request.kind],
+        allow: ({ state, range }) => editor.isEditable &&
+            range.to - range.from <= P.maxQuery + P.triggers[request.kind].length &&
+            state.selection.$from.parent.type.name !== 'codeBlock',
+        shouldResetDismissed: ({ transaction, match, range }) => {
+            const reverse = transaction.mapping.invert();
+            if (reverse.mapResult(match.range.from).deleted)
+                return true;
+            // DOM diffing can keep the colon while replacing the entire escaped query.
+            const from = reverse.map(range.from, -1) + P.triggers[request.kind].length;
+            const to = reverse.map(range.to);
+            return (to > from &&
+                transaction.mapping.mapResult(from).deleted &&
+                transaction.mapping.mapResult(to, -1).deleted);
+        },
+        items: ({ query }) => [...resolved(query).items],
+        command: ({ editor: active, range, props }) => {
+            insert(active, range, props);
+        },
+        render: () => ({
+            onStart: (next) => {
+                selected = P.initialIndex;
+                publish(next);
+            },
+            onUpdate: (next) => {
+                if (current?.query !== next.query)
+                    selected = P.initialIndex;
+                publish(next);
+            },
+            onExit: () => {
+                if (destroyed)
+                    return;
+                if (editor.isDestroyed ||
+                    !activeSuggestionSchema.safeParse(key.getState(editor.state)).success)
+                    clear();
+            },
+            onKeyDown: ({ event }) => {
+                const suggestion = current;
+                if (editor.isDestroyed || suggestion === undefined || event.isComposing)
+                    return false;
+                if (event.key === 'ArrowDown') {
+                    step(suggestion, 1);
+                    return true;
+                }
+                if (event.key === 'ArrowUp') {
+                    step(suggestion, -1);
+                    return true;
+                }
+                if (event.key === 'Enter') {
+                    choose(selected);
+                    return true;
+                }
+                return false;
+            },
+        }),
+    });
+    editor.registerPlugin(plugin, (registered, plugins) => [registered, ...plugins]);
+    return {
+        choose,
+        close,
+        refresh() {
+            if (current !== undefined && !destroyed && !editor.isDestroyed)
+                publish(current);
+        },
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            clear();
+            if (!editor.isDestroyed) {
+                editor.unregisterPlugin(key);
+            }
+            released();
+        },
+    };
+}

package/dist/shared/editor-menu/menu-port.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from '@tiptap/core';
+import type { EditorMenuPort } from '@fastsprout/reacd/adapter-runtime/renderer/editor/menu-context.js';
+export declare function createEditorMenuPort(editor: Editor | null, disabled: boolean): EditorMenuPort;

package/dist/shared/editor-menu/menu-port.js

@@ -0,0 +1,27 @@
+import { EDITOR_MENU_POLICY } from '@fastsprout/reacd/adapter-runtime/core/editor-menu-policy.js';
+import { mountEditorMenu } from './menu-plugin.js';
+export function createEditorMenuPort(editor, disabled) {
+    const registrations = new Set();
+    return {
+        disabled: disabled || editor === null,
+        mount(request) {
+            if (editor === null || editor.isDestroyed || disabled)
+                return {
+                    success: false,
+                    issues: [{ path: 'EditorMenu', message: EDITOR_MENU_POLICY.scopeError }],
+                };
+            if (registrations.has(request.kind))
+                return {
+                    success: false,
+                    issues: [{ path: 'EditorMenu', message: EDITOR_MENU_POLICY.duplicateError }],
+                };
+            registrations.add(request.kind);
+            return {
+                success: true,
+                data: mountEditorMenu(editor, request, () => {
+                    registrations.delete(request.kind);
+                }),
+            };
+        },
+    };
+}

package/dist/shared/editor-menu/menu-store.d.ts

@@ -0,0 +1,20 @@
+import type { EditorMenuItem, EditorMenuPort, EditorMenuRequest, EditorMenuView } from '@fastsprout/reacd/adapter-runtime/renderer/editor/menu-context.js';
+import type { ValidationIssue } from '@fastsprout/reacd/adapter-runtime/core/render-port.js';
+import type { EditorMentionLookupRequest, EditorMentionLookupResult } from '@fastsprout/reacd/adapter-runtime/schema/editor-mention-menu/lookup.schema.js';
+export interface MentionLookupSource {
+    readonly results: EditorMentionLookupResult | null;
+    readonly onQueryChange: (request: EditorMentionLookupRequest) => void;
+}
+export type EditorMenuSnapshot = {
+    readonly view: EditorMenuView;
+} | {
+    readonly issues: readonly ValidationIssue[];
+} | undefined;
+export declare function createEditorMenuStore(initial: readonly EditorMenuItem[], scope: string): {
+    snapshot: () => EditorMenuSnapshot;
+    serverSnapshot: () => undefined;
+    subscribe(this: void, listener: () => void): () => void;
+    catalog(items: readonly EditorMenuItem[], source: MentionLookupSource | undefined): void;
+    attach(port: EditorMenuPort, options: Pick<EditorMenuRequest, 'kind' | 'listId'>): () => void;
+    choose(index: number): void;
+};

package/dist/shared/editor-menu/menu-store.js

@@ -0,0 +1,92 @@
+import { createMentionLookupController } from './lookup-controller.js';
+export function createEditorMenuStore(initial, scope) {
+    let catalog = initial;
+    let remote;
+    let snapshot;
+    let lease;
+    let attachment;
+    const lookup = createMentionLookupController(scope);
+    const listeners = new Set();
+    function publish(next) {
+        if (snapshot === next)
+            return;
+        snapshot = next;
+        for (const listener of listeners)
+            listener();
+    }
+    function resolve(query) {
+        if (remote === undefined)
+            return undefined;
+        const next = lookup.update(query, remote.results);
+        if (next.request !== undefined)
+            remote.onQueryChange(next.request);
+        return {
+            status: next.status,
+            error: next.error,
+            items: next.items.map((item) => ({ ...item, kind: 'mention' })),
+        };
+    }
+    return {
+        snapshot: () => snapshot,
+        serverSnapshot: () => undefined,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        catalog(items, source) {
+            catalog = items;
+            remote = source;
+            if (source === undefined)
+                lookup.close();
+            lease?.refresh();
+        },
+        attach(port, options) {
+            const owner = Object.freeze({});
+            attachment = owner;
+            lease = undefined;
+            let released = false;
+            const current = () => !released && attachment === owner;
+            const mounted = port.mount({
+                ...options,
+                items: () => (current() ? catalog : []),
+                lookup: (query) => (current() ? resolve(query) : undefined),
+                change: (view) => {
+                    if (!current())
+                        return;
+                    if (view === undefined)
+                        lookup.close();
+                    publish(view === undefined ? undefined : { view });
+                },
+            });
+            if (!mounted.success) {
+                publish({ issues: mounted.issues });
+                return () => {
+                    if (!current())
+                        return;
+                    released = true;
+                    attachment = undefined;
+                    lookup.close();
+                    publish(undefined);
+                };
+            }
+            lease = mounted.data;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                mounted.data.destroy();
+                if (attachment === owner) {
+                    attachment = undefined;
+                    lease = undefined;
+                    lookup.close();
+                    publish(undefined);
+                }
+            };
+        },
+        choose(index) {
+            lease?.choose(index);
+        },
+    };
+}

package/dist/shared/editor-menu/use-editor-menu.d.ts

@@ -0,0 +1,9 @@
+import type { EditorMenuKind } from '@fastsprout/reacd/adapter-runtime/core/editor-menu-policy.js';
+import type { EditorMenuItem } from '@fastsprout/reacd/adapter-runtime/renderer/editor/menu-context.js';
+import type { EditorMenuSnapshot, MentionLookupSource } from './menu-store.js';
+export declare function useEditorMenu(kind: EditorMenuKind, items: readonly EditorMenuItem[], disabled: boolean | undefined, lookup?: MentionLookupSource): {
+    listId: string;
+    orphan: boolean;
+    snapshot: EditorMenuSnapshot;
+    choose: (index: number) => void;
+};

package/dist/shared/editor-menu/use-editor-menu.js

@@ -0,0 +1,21 @@
+import { useContext, useEffect, useId, useLayoutEffect, useState, useSyncExternalStore, } from 'react';
+import { EditorMenuScopeContext } from '@fastsprout/reacd/adapter-runtime/renderer/editor/menu-context.js';
+import { createEditorMenuStore } from './menu-store.js';
+export function useEditorMenu(kind, items, disabled, lookup) {
+    const listId = useId();
+    const port = useContext(EditorMenuScopeContext);
+    const [store] = useState(() => createEditorMenuStore(items, listId));
+    const snapshot = useSyncExternalStore(store.subscribe, store.snapshot, store.serverSnapshot);
+    useLayoutEffect(() => store.catalog(items, lookup), [store, items, lookup]);
+    useEffect(() => {
+        if (port === null || port.disabled || disabled === true)
+            return undefined;
+        return store.attach(port, { kind, listId });
+    }, [port, kind, listId, disabled, store]);
+    return {
+        listId,
+        orphan: port === null,
+        snapshot,
+        choose: (index) => store.choose(index),
+    };
+}

package/dist/shared/editor-sdk/apply-paste.d.ts

@@ -0,0 +1,3 @@
+import type { JSONContent } from '@tiptap/core';
+import type { EditorView } from '@tiptap/pm/view';
+export declare function applyEditorPlainPaste(view: EditorView, content: readonly JSONContent[]): void;

package/dist/shared/editor-sdk/apply-paste.js

@@ -0,0 +1,12 @@
+import { Fragment, Slice } from '@tiptap/pm/model';
+export function applyEditorPlainPaste(view, content) {
+    const marks = view.state.storedMarks ?? view.state.selection.$from.marks();
+    const nodes = content.map((value) => {
+        const node = view.state.schema.nodeFromJSON(value);
+        return node.isText ? node.mark(marks) : node;
+    });
+    view.dispatch(view.state.tr
+        .replaceSelection(new Slice(Fragment.from(nodes), 0, 0))
+        .ensureMarks(marks)
+        .scrollIntoView());
+}

package/dist/shared/editor-sdk/atom-data.d.ts

@@ -0,0 +1,7 @@
+export type EditorAtomKind = 'mention' | 'emoji';
+interface EditorAtomData {
+    text: string;
+    attributes: Record<string, string>;
+}
+export declare function editorAtomData(kind: EditorAtomKind, attributes: unknown): EditorAtomData;
+export {};

package/dist/shared/editor-sdk/atom-data.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { EDITOR_DEFAULTS, EDITOR_POLICY, } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { stateKeySchema } from '@fastsprout/reacd/adapter-runtime/schema/state/shared/definition.js';
+import { labelSchema } from '@fastsprout/reacd/adapter-runtime/schema/shared/values.js';
+const mentionSchema = z.strictObject({ id: stateKeySchema, label: labelSchema });
+const emojiSchema = z.strictObject({
+    name: stateKeySchema,
+    value: z.string().min(1).max(EDITOR_POLICY.maxEmojiLength),
+});
+export function editorAtomData(kind, attributes) {
+    if (kind === 'mention') {
+        const parsed = mentionSchema.safeParse(attributes);
+        if (parsed.success)
+            return {
+                text: `${EDITOR_DEFAULTS.mentionPrefix}${parsed.data.label}`,
+                attributes: {
+                    class: 'reacd-editor-mention',
+                    contenteditable: 'false',
+                    'data-reacd-mention': parsed.data.id,
+                },
+            };
+    }
+    else {
+        const parsed = emojiSchema.safeParse(attributes);
+        if (parsed.success)
+            return {
+                text: parsed.data.value,
+                attributes: {
+                    class: 'reacd-editor-emoji',
+                    contenteditable: 'false',
+                    role: 'img',
+                    'aria-label': parsed.data.name,
+                    'data-reacd-emoji': parsed.data.name,
+                },
+            };
+    }
+    return {
+        text: EDITOR_DEFAULTS.unavailableInline,
+        attributes: { contenteditable: 'false' },
+    };
+}

package/dist/shared/editor-sdk/atoms.d.ts

@@ -0,0 +1,3 @@
+import { Node } from '@tiptap/core';
+import type { EditorAtomKind } from './atom-data.js';
+export declare function createEditorAtom(kind: EditorAtomKind): Node<any, any>;

package/dist/shared/editor-sdk/atoms.js

@@ -0,0 +1,25 @@
+import { Node } from '@tiptap/core';
+import { editorAtomData } from './atom-data.js';
+export function createEditorAtom(kind) {
+    return Node.create({
+        name: kind === 'mention' ? 'reacdMention' : 'reacdEmoji',
+        group: 'inline',
+        inline: true,
+        atom: true,
+        addAttributes() {
+            return kind === 'mention'
+                ? { id: { default: null }, label: { default: null } }
+                : { name: { default: null }, value: { default: null } };
+        },
+        parseHTML() {
+            return [];
+        },
+        renderHTML({ node }) {
+            const data = editorAtomData(kind, node.attrs);
+            return ['span', data.attributes, data.text];
+        },
+        renderText({ node }) {
+            return editorAtomData(kind, node.attrs).text;
+        },
+    });
+}

package/dist/shared/editor-sdk/block-types.d.ts

@@ -0,0 +1 @@
+export declare const EDITOR_SDK_BLOCK_TYPES: readonly ['paragraph', 'heading', 'codeBlock', 'blockquote', 'bulletList', 'orderedList', 'listItem', 'horizontalRule'];

package/dist/shared/editor-sdk/block-types.js

@@ -0,0 +1,10 @@
+export const EDITOR_SDK_BLOCK_TYPES = [
+    'paragraph',
+    'heading',
+    'codeBlock',
+    'blockquote',
+    'bulletList',
+    'orderedList',
+    'listItem',
+    'horizontalRule',
+];

package/dist/shared/editor-sdk/command-chain.d.ts

@@ -0,0 +1,3 @@
+import type { ChainedCommands } from '@tiptap/core';
+import type { EditorCommand } from '@fastsprout/reacd/adapter-runtime/core/editor-commands.js';
+export declare function editorCommandChain(chain: ChainedCommands, command: EditorCommand): ChainedCommands;

package/dist/shared/editor-sdk/command-chain.js

@@ -0,0 +1,25 @@
+import { EDITOR_HEADING_LEVELS } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+const operations = {
+    bold: (chain) => chain.toggleBold(),
+    italic: (chain) => chain.toggleItalic(),
+    strike: (chain) => chain.toggleStrike(),
+    underline: (chain) => chain.toggleUnderline(),
+    code: (chain) => chain.toggleCode(),
+    heading1: (chain) => chain.toggleHeading({ level: EDITOR_HEADING_LEVELS[0] }),
+    heading2: (chain) => chain.toggleHeading({ level: EDITOR_HEADING_LEVELS[1] }),
+    heading3: (chain) => chain.toggleHeading({ level: EDITOR_HEADING_LEVELS[2] }),
+    paragraph: (chain) => chain.setParagraph(),
+    bulletList: (chain) => chain.toggleBulletList(),
+    orderedList: (chain) => chain.toggleOrderedList(),
+    quote: (chain) => chain.toggleBlockquote(),
+    codeBlock: (chain) => chain.toggleCodeBlock(),
+    separator: (chain) => chain.setHorizontalRule(),
+    removeLink: (chain) => chain.unsetLink(),
+    undo: (chain) => chain.undo(),
+    redo: (chain) => chain.redo(),
+};
+export function editorCommandChain(chain, command) {
+    return command.command === 'link'
+        ? chain.setLink({ href: command.href })
+        : operations[command.command](chain);
+}

package/dist/shared/editor-sdk/commands.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from '@tiptap/core';
+import type { EditorCommand } from '@fastsprout/reacd/adapter-runtime/core/editor-commands.js';
+export declare function canRunSdkCommand(editor: Editor, command: EditorCommand): boolean;
+export declare function runSdkCommand(editor: Editor, command: EditorCommand): boolean;
+export declare function sdkCommandActive(editor: Editor, command: EditorCommand): boolean;

package/dist/shared/editor-sdk/commands.js

@@ -0,0 +1,38 @@
+import { EDITOR_HEADING_LEVELS } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { linkSchema } from '@fastsprout/reacd/adapter-runtime/schema/link/link.schema.js';
+import { editorCommandChain } from './command-chain.js';
+const activeTargets = {
+    bold: { name: 'bold' },
+    italic: { name: 'italic' },
+    strike: { name: 'strike' },
+    underline: { name: 'underline' },
+    code: { name: 'code' },
+    heading1: { name: 'heading', attributes: { level: EDITOR_HEADING_LEVELS[0] } },
+    heading2: { name: 'heading', attributes: { level: EDITOR_HEADING_LEVELS[1] } },
+    heading3: { name: 'heading', attributes: { level: EDITOR_HEADING_LEVELS[2] } },
+    paragraph: { name: 'paragraph' },
+    bulletList: { name: 'bulletList' },
+    orderedList: { name: 'orderedList' },
+    quote: { name: 'blockquote' },
+    codeBlock: { name: 'codeBlock' },
+};
+export function canRunSdkCommand(editor, command) {
+    if (editor.isDestroyed ||
+        (command.command === 'link' &&
+            !linkSchema.shape.href.safeParse(command.href).success))
+        return false;
+    return editorCommandChain(editor.can().chain(), command).run();
+}
+export function runSdkCommand(editor, command) {
+    if (!canRunSdkCommand(editor, command))
+        return false;
+    return editorCommandChain(editor.chain().focus(), command).run();
+}
+export function sdkCommandActive(editor, command) {
+    if (editor.isDestroyed)
+        return false;
+    if (command.command === 'link')
+        return editor.isActive('link', { href: command.href });
+    const target = activeTargets[command.command];
+    return target !== undefined && editor.isActive(target.name, target.attributes);
+}

package/dist/shared/editor-sdk/controlled-selection.d.ts

@@ -0,0 +1,2 @@
+import type { EditorSelection } from '@fastsprout/reacd/adapter-runtime/core/editor-document.js';
+export declare function sameEditorSelection(left: EditorSelection | undefined, right: EditorSelection | undefined): boolean;

package/dist/shared/editor-sdk/controlled-selection.js

@@ -0,0 +1,8 @@
+export function sameEditorSelection(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (left.anchor.blockId === right.anchor.blockId &&
+        left.anchor.offset === right.anchor.offset &&
+        left.focus.blockId === right.focus.blockId &&
+        left.focus.offset === right.focus.offset);
+}

package/dist/shared/editor-sdk/extensions.d.ts

@@ -0,0 +1,2 @@
+import type { EditorIdentityOptions } from './identity-plugin.js';
+export declare function createEditorExtensions(options?: EditorIdentityOptions): (import("@tiptap/core").Extension<any, any> | import("@tiptap/core").Extension<import("@tiptap/starter-kit").StarterKitOptions, any> | import("@tiptap/core").Node<any, any>)[];

package/dist/shared/editor-sdk/extensions.js

@@ -0,0 +1,21 @@
+import StarterKit from '@tiptap/starter-kit';
+import { EDITOR_BEHAVIOR, EDITOR_HEADING_LEVELS, } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { createEditorAtom } from './atoms.js';
+import { createEditorIdentity } from './identity.js';
+export function createEditorExtensions(options = {}) {
+    return [
+        StarterKit.configure({
+            trailingNode: EDITOR_BEHAVIOR.trailingParagraph,
+            heading: { levels: [...EDITOR_HEADING_LEVELS] },
+            link: {
+                autolink: EDITOR_BEHAVIOR.autoLink,
+                linkOnPaste: EDITOR_BEHAVIOR.linkOnPaste,
+                openOnClick: EDITOR_BEHAVIOR.openLinks,
+                HTMLAttributes: { target: null, class: null, rel: 'noopener noreferrer' },
+            },
+        }),
+        createEditorIdentity(options),
+        createEditorAtom('mention'),
+        createEditorAtom('emoji'),
+    ];
+}

package/dist/shared/editor-sdk/identity-plugin.d.ts

@@ -0,0 +1,18 @@
+import { Plugin } from '@tiptap/pm/state';
+interface MarkupChange {
+    readonly position: number;
+    readonly attributes: Readonly<Record<string, unknown>>;
+}
+interface RepairPlan {
+    readonly changes: readonly MarkupChange[];
+    readonly counter: bigint;
+}
+interface IdentityState {
+    readonly counter: bigint;
+    readonly pending: RepairPlan | null;
+}
+export interface EditorIdentityOptions {
+    readonly onRejected?: (() => void) | undefined;
+}
+export declare function createEditorIdentityPlugin({ onRejected, }?: EditorIdentityOptions): Plugin<IdentityState>;
+export {};