@fastsprout/reacd-shadcn 0.0.0-stage → 0.2.0

package/dist/editor-menu/lookup-controller.js

@@ -0,0 +1,83 @@
+import { EDITOR_LOOKUP_POLICY } from '@fastsprout/reacd/adapter-runtime/core/editor-lookup-policy.js';
+import { editorMentionLookupScopeSchema, editorMentionLookupQuerySchema, editorMentionLookupRequestSchema, } from '@fastsprout/reacd/adapter-runtime/schema/editor-mention-menu/lookup.schema.js';
+const EMPTY_ITEMS = Object.freeze([]);
+function closeState(state, ordinal) {
+    return Object.freeze({
+        scope: state.scope,
+        ordinal,
+        current: undefined,
+        accepted: undefined,
+    });
+}
+function errorTransition(state, ordinal, error) {
+    return Object.freeze({
+        state: closeState(state, ordinal),
+        view: Object.freeze({
+            request: undefined,
+            status: 'error',
+            items: EMPTY_ITEMS,
+            error,
+        }),
+    });
+}
+function resultView(request, result) {
+    return Object.freeze({
+        request,
+        status: result?.status ?? 'loading',
+        items: result?.status === 'ready' ? result.items : EMPTY_ITEMS,
+        error: result?.status === 'error' ? result.error : undefined,
+    });
+}
+export function advanceMentionLookup(state, query, result) {
+    const parsedScope = editorMentionLookupScopeSchema.safeParse(state.scope);
+    if (!parsedScope.success)
+        return errorTransition(state, state.ordinal, EDITOR_LOOKUP_POLICY.invalidScopeMessage);
+    const parsedQuery = editorMentionLookupQuerySchema.safeParse(query);
+    if (!parsedQuery.success)
+        return errorTransition(state, state.ordinal, EDITOR_LOOKUP_POLICY.invalidQueryMessage);
+    let ordinal = state.ordinal;
+    let current = state.current;
+    let accepted = state.accepted;
+    let request;
+    if (current === undefined || current.query !== parsedQuery.data) {
+        ordinal += 1n;
+        const generated = editorMentionLookupRequestSchema.safeParse({
+            key: `${parsedScope.data}${EDITOR_LOOKUP_POLICY.keySeparator}${ordinal}`,
+            query: parsedQuery.data,
+        });
+        if (!generated.success)
+            return errorTransition(state, ordinal, EDITOR_LOOKUP_POLICY.invalidRequestMessage);
+        current = generated.data;
+        accepted = undefined;
+        request = current;
+    }
+    if (result !== null &&
+        result.key === current.key &&
+        result.query === current.query &&
+        (result.status !== 'loading' ||
+            accepted === undefined ||
+            accepted.status === 'loading'))
+        accepted = result;
+    return Object.freeze({
+        state: Object.freeze({ scope: state.scope, ordinal, current, accepted }),
+        view: resultView(request, accepted),
+    });
+}
+export function createMentionLookupController(scope) {
+    let state = Object.freeze({
+        scope,
+        ordinal: BigInt(EDITOR_LOOKUP_POLICY.initialOrdinal),
+        current: undefined,
+        accepted: undefined,
+    });
+    return {
+        close() {
+            state = closeState(state, state.ordinal);
+        },
+        update(query, result) {
+            const next = advanceMentionLookup(state, query, result);
+            state = next.state;
+            return next.view;
+        },
+    };
+}

package/dist/editor-menu/menu-panel.d.ts

@@ -0,0 +1,10 @@
+import type { EditorMenuSnapshot } from './menu-store.js';
+interface MenuPanelProps {
+    readonly label: string;
+    readonly listId: string;
+    readonly orphan: boolean;
+    readonly snapshot: EditorMenuSnapshot;
+    readonly choose: (index: number) => void;
+}
+export declare function EditorMenuPanel({ label, listId, orphan, snapshot, choose, }: MenuPanelProps): import("react").JSX.Element | null;
+export {};

package/dist/editor-menu/menu-panel.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EDITOR_MENU_POLICY } from '@fastsprout/reacd/adapter-runtime/core/editor-menu-policy.js';
+import { Issues } from '@fastsprout/reacd/adapter-runtime/renderer/issues/issues.renderer.js';
+export function EditorMenuPanel({ label, listId, orphan, snapshot, choose, }) {
+    if (orphan)
+        return (_jsx(Issues, { issues: [{ path: 'EditorMenu', message: EDITOR_MENU_POLICY.scopeError }] }));
+    if (snapshot === undefined)
+        return null;
+    if ('issues' in snapshot)
+        return _jsx(Issues, { issues: snapshot.issues });
+    const { items, selected, status, error } = snapshot.view;
+    return (_jsxs("div", { className: "reacd-node reacd-editor-menu", children: [_jsx("p", { id: `${listId}-label`, children: label }), _jsx("div", { role: "listbox", id: listId, "aria-labelledby": `${listId}-label`, "aria-busy": status === 'loading', children: items.map((item, index) => (_jsx("button", { type: "button", role: "option", id: `${listId}-${index}`, tabIndex: -1, "aria-selected": index === selected, disabled: item.disabled === true, onMouseDown: (event) => event.preventDefault(), onClick: () => choose(index), children: item.label }, item.kind === 'suggestion'
+                    ? item.value.command
+                    : item.kind === 'mention'
+                        ? item.id
+                        : item.name))) }), status === 'loading' && _jsx("p", { role: "status", children: EDITOR_MENU_POLICY.loading }), status === 'error' && _jsx("p", { role: "alert", children: error }), status === 'ready' && items.length === 0 && (_jsx("p", { role: "status", children: EDITOR_MENU_POLICY.empty }))] }));
+}

package/dist/editor-menu/menu-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from '@tiptap/core';
+import type { EditorMenuLease, EditorMenuRequest } from '@fastsprout/reacd/adapter-runtime/renderer/editor/menu-context.js';
+export declare function mountEditorMenu(editor: Editor, request: EditorMenuRequest, released: () => void): EditorMenuLease;

package/dist/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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;