@fastsprout/reacd-shadcn 0.0.0-stage → 0.2.0

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

package/dist/editor-sdk/identity-plugin.js

@@ -0,0 +1,107 @@
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+import { Transform } from '@tiptap/pm/transform';
+import { z } from 'zod';
+import { EDITOR_POLICY } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { boundedSdkDocument } from '../editor-conversion/budget.js';
+import { EDITOR_SDK_BLOCK_TYPES } from './block-types.js';
+const BLOCKS = new Set(EDITOR_SDK_BLOCK_TYPES);
+const attributesSchema = z.record(z.string(), z.unknown());
+function prepareRepair(document, initial) {
+    if (!boundedSdkDocument(document))
+        return null;
+    const entries = [];
+    let malformed = false;
+    const reserved = new Set();
+    document.descendants((node, position) => {
+        if (malformed)
+            return false;
+        if (!BLOCKS.has(node.type.name))
+            return true;
+        const raw = node.attrs;
+        const parsed = attributesSchema.safeParse(raw);
+        if (!parsed.success) {
+            malformed = true;
+            return false;
+        }
+        const candidate = parsed.data['reacdId'];
+        const id = typeof candidate === 'string' ? candidate : undefined;
+        if (id !== undefined)
+            reserved.add(id);
+        entries.push({ position, attributes: parsed.data, id });
+        return true;
+    });
+    if (malformed)
+        return null;
+    let counter = initial;
+    const seen = new Set();
+    const changes = [];
+    for (const entry of entries) {
+        if (entry.id !== undefined && !seen.has(entry.id)) {
+            seen.add(entry.id);
+            continue;
+        }
+        let id;
+        do {
+            counter += 1n;
+            id = `${EDITOR_POLICY.blockIdPrefix}-${counter}`;
+        } while (reserved.has(id));
+        reserved.add(id);
+        seen.add(id);
+        changes.push({
+            position: entry.position,
+            attributes: Object.freeze({ ...entry.attributes, reacdId: id }),
+        });
+    }
+    if (changes.length > 0) {
+        const preview = new Transform(document);
+        for (const change of changes)
+            preview.setNodeMarkup(change.position, undefined, change.attributes);
+        if (!boundedSdkDocument(preview.doc))
+            return null;
+    }
+    return Object.freeze({ counter, changes: Object.freeze(changes) });
+}
+function advanceCounter(transaction, current, key) {
+    const value = transaction.getMeta(key);
+    return typeof value === 'bigint' && value >= current ? value : current;
+}
+export function createEditorIdentityPlugin({ onRejected, } = {}) {
+    const key = new PluginKey('reacdIdentity');
+    return new Plugin({
+        key,
+        state: {
+            init: () => Object.freeze({ counter: 0n, pending: null }),
+            apply(transaction, previous) {
+                const counter = advanceCounter(transaction, previous.counter, key);
+                return Object.freeze({
+                    counter,
+                    pending: transaction.docChanged
+                        ? prepareRepair(transaction.doc, counter)
+                        : previous.pending,
+                });
+            },
+        },
+        filterTransaction(transaction, state) {
+            if (!transaction.docChanged)
+                return true;
+            const current = key.getState(state);
+            if (current === undefined ||
+                prepareRepair(transaction.doc, advanceCounter(transaction, current.counter, key)) === null) {
+                onRejected?.();
+                return false;
+            }
+            return true;
+        },
+        appendTransaction(transactions, _previous, state) {
+            if (!transactions.some((transaction) => transaction.docChanged))
+                return null;
+            const pending = key.getState(state)?.pending;
+            if (pending == null || pending.changes.length === 0)
+                return null;
+            const transaction = state.tr;
+            for (const change of pending.changes)
+                transaction.setNodeMarkup(change.position, undefined, change.attributes);
+            return transaction.setMeta('addToHistory', false).setMeta(key, pending.counter);
+        },
+    });
+}

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

@@ -0,0 +1,3 @@
+import { Extension } from '@tiptap/core';
+import type { EditorIdentityOptions } from './identity-plugin.js';
+export declare function createEditorIdentity(options?: EditorIdentityOptions): Extension<any, any>;

package/dist/editor-sdk/identity.js

@@ -0,0 +1,28 @@
+import { Extension } from '@tiptap/core';
+import { EDITOR_SDK_BLOCK_TYPES } from './block-types.js';
+import { createEditorIdentityPlugin } from './identity-plugin.js';
+export function createEditorIdentity(options = {}) {
+    return Extension.create({
+        name: 'reacdBlockIdentity',
+        addProseMirrorPlugins() {
+            return [createEditorIdentityPlugin(options)];
+        },
+        addGlobalAttributes() {
+            return [
+                {
+                    types: [...EDITOR_SDK_BLOCK_TYPES],
+                    attributes: {
+                        reacdId: {
+                            default: null,
+                            parseHTML: (element) => element.getAttribute('data-reacd-block'),
+                            renderHTML: (attributes) => {
+                                const id = attributes['reacdId'];
+                                return typeof id === 'string' ? { 'data-reacd-block': id } : {};
+                            },
+                        },
+                    },
+                },
+            ];
+        },
+    });
+}

package/dist/editor-sdk/plain-paste.d.ts

@@ -0,0 +1,3 @@
+import type { JSONContent } from '@tiptap/core';
+import type { Result } from '@fastsprout/reacd/adapter-runtime/core/result.js';
+export declare function buildEditorPlainPaste(text: string, mode?: 'inline' | 'code'): Result<JSONContent[]>;

package/dist/editor-sdk/plain-paste.js

@@ -0,0 +1,66 @@
+import { EDITOR_ERRORS, EDITOR_POLICY, } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { editorTextChunks } from '../editor-conversion/text-chunks.js';
+const PASTE_COST = {
+    arrayValues: 1,
+    textValues: 3,
+    textCharacters: 'typetexttext'.length,
+    breakCharacters: 'typehardBreak'.length,
+};
+const MAX_PARTS = Math.min(EDITOR_POLICY.maxInlines, Math.floor((EDITOR_POLICY.maxValues - PASTE_COST.arrayValues) / PASTE_COST.textValues));
+function failure() {
+    return {
+        success: false,
+        issues: [{ path: 'Editor.value', message: EDITOR_ERRORS.rejected }],
+    };
+}
+function inlinePlan(text) {
+    let breaks = 0;
+    for (const character of text) {
+        if (character === '\n')
+            breaks += 1;
+        if (breaks > MAX_PARTS)
+            return undefined;
+    }
+    const plan = [];
+    let characters = 0;
+    function reserve(part) {
+        const cost = part.type === 'text'
+            ? PASTE_COST.textCharacters + part.to - part.from
+            : PASTE_COST.breakCharacters;
+        if (plan.length >= MAX_PARTS || characters + cost > EDITOR_POLICY.maxCharacters)
+            return false;
+        characters += cost;
+        plan.push(part);
+        return true;
+    }
+    let first = true;
+    for (const line of text.split('\n')) {
+        if (!first && !reserve({ type: 'hardBreak' }))
+            return undefined;
+        first = false;
+        for (const chunk of editorTextChunks(line))
+            if (!reserve({ type: 'text', source: line, ...chunk }))
+                return undefined;
+    }
+    return plan;
+}
+export function buildEditorPlainPaste(text, mode = 'inline') {
+    if (text.length > EDITOR_POLICY.maxCharacters)
+        return failure();
+    const normalized = text.replace(/\r\n?/g, '\n');
+    if (normalized.length === 0)
+        return { success: true, data: [] };
+    if (mode === 'code')
+        return normalized.length > EDITOR_POLICY.maxTextLength
+            ? failure()
+            : { success: true, data: [{ type: 'text', text: normalized }] };
+    const plan = inlinePlan(normalized);
+    if (plan === undefined)
+        return failure();
+    return {
+        success: true,
+        data: plan.map((part) => part.type === 'hardBreak'
+            ? { type: 'hardBreak' }
+            : { type: 'text', text: part.source.slice(part.from, part.to) }),
+    };
+}

package/dist/editor-sdk/resources.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from '@tiptap/core';
+export declare function createEditorResources(): {
+    capture(editor: Editor): void;
+    dispose(): void;
+};

package/dist/editor-sdk/resources.js

@@ -0,0 +1,14 @@
+export function createEditorResources() {
+    const editors = new Set();
+    return {
+        capture(editor) {
+            editors.add(editor);
+            editor.on('destroy', () => { editors.delete(editor); });
+        },
+        dispose() {
+            for (const editor of editors)
+                editor.destroy();
+            editors.clear();
+        },
+    };
+}

package/dist/editor-sdk/select-block.d.ts

@@ -0,0 +1,2 @@
+import type { Editor } from '@tiptap/core';
+export declare function selectSdkBlock(editor: Editor, id: string): boolean;

package/dist/editor-sdk/select-block.js

@@ -0,0 +1,31 @@
+import { EDITOR_NATIVE_POLICY } from '@fastsprout/reacd/adapter-runtime/core/editor-native-policy.js';
+export function selectSdkBlock(editor, id) {
+    let target;
+    editor.state.doc.descendants((node, position) => {
+        if (target !== undefined || node.attrs['reacdId'] !== id)
+            return target === undefined;
+        if (node.isTextblock) {
+            target = {
+                position: position + EDITOR_NATIVE_POLICY.nodeOpeningSize,
+                text: true,
+            };
+            return false;
+        }
+        node.descendants((child, offset) => {
+            if (target !== undefined || !child.isTextblock)
+                return target === undefined;
+            target = {
+                position: position + offset + EDITOR_NATIVE_POLICY.nodeOpeningSize * 2,
+                text: true,
+            };
+            return false;
+        });
+        target ??= { position, text: false };
+        return false;
+    });
+    if (target === undefined)
+        return false;
+    return target.text
+        ? editor.chain().focus().setTextSelection(target.position).run()
+        : editor.chain().focus().setNodeSelection(target.position).run();
+}

package/dist/editor-sdk/selection-mapping.d.ts

@@ -0,0 +1,9 @@
+import type { Node } from '@tiptap/pm/model';
+import type { Selection } from '@tiptap/pm/state';
+import type { EditorSelection } from '@fastsprout/reacd/adapter-runtime/core/editor-document.js';
+import type { Result } from '@fastsprout/reacd/adapter-runtime/core/result.js';
+export declare function sdkSelectionToDomain(document: Node, selection: Pick<Selection, 'anchor' | 'head'>): EditorSelection | undefined;
+export declare function domainSelectionToSdk(document: Node, selection: EditorSelection): Result<{
+    readonly anchor: number;
+    readonly head: number;
+}>;

package/dist/editor-sdk/selection-mapping.js

@@ -0,0 +1,92 @@
+import { editorPositionSchema } from '@fastsprout/reacd/adapter-runtime/schema/editor/document/index.js';
+import { stateKeySchema } from '@fastsprout/reacd/adapter-runtime/schema/state/shared/definition.js';
+import { boundedSdkDocument } from '../editor-conversion/budget.js';
+const EDITABLE_TYPES = new Set(['paragraph', 'heading', 'codeBlock']);
+const POSITION_POLICY = {
+    openingTokenSize: 1,
+    path: 'Editor.selection',
+    invalid: 'Editor selection must resolve to editable blocks and valid logical offsets.',
+};
+function editableBlocks(document) {
+    if (!boundedSdkDocument(document))
+        return undefined;
+    try {
+        const blocks = [];
+        const ids = new Set();
+        let duplicate = false;
+        document.descendants((node, position) => {
+            if (!EDITABLE_TYPES.has(node.type.name))
+                return true;
+            const raw = node.attrs['reacdId'];
+            const id = stateKeySchema.safeParse(raw);
+            if (!id.success)
+                return false;
+            if (ids.has(id.data)) {
+                duplicate = true;
+                return false;
+            }
+            ids.add(id.data);
+            const start = position + POSITION_POLICY.openingTokenSize;
+            blocks.push({ id: id.data, start, end: start + node.content.size });
+            return false;
+        });
+        if (duplicate)
+            return undefined;
+        const first = blocks.shift();
+        return first === undefined ? undefined : [first, ...blocks];
+    }
+    catch {
+        return undefined;
+    }
+}
+function nearest(blocks, point) {
+    let chosen = blocks[0];
+    let offset = 0;
+    let distance = Infinity;
+    for (const block of blocks) {
+        const snapped = Math.min(block.end, Math.max(block.start, point));
+        const currentDistance = Math.abs(point - snapped);
+        if (currentDistance < distance) {
+            chosen = block;
+            offset = snapped - block.start;
+            distance = currentDistance;
+        }
+    }
+    return Object.freeze({ blockId: chosen.id, offset });
+}
+function nativePoint(document, value) {
+    return Number.isInteger(value) && value >= 0 && value <= document.content.size;
+}
+export function sdkSelectionToDomain(document, selection) {
+    const blocks = editableBlocks(document);
+    if (blocks === undefined ||
+        !nativePoint(document, selection.anchor) ||
+        !nativePoint(document, selection.head))
+        return undefined;
+    return Object.freeze({
+        anchor: nearest(blocks, selection.anchor),
+        focus: nearest(blocks, selection.head),
+    });
+}
+function resolve(blocks, point) {
+    const parsed = editorPositionSchema.safeParse(point);
+    if (!parsed.success)
+        return undefined;
+    const block = blocks.find((candidate) => candidate.id === parsed.data.blockId);
+    if (block === undefined || parsed.data.offset > block.end - block.start)
+        return undefined;
+    return block.start + parsed.data.offset;
+}
+export function domainSelectionToSdk(document, selection) {
+    const blocks = editableBlocks(document);
+    if (blocks !== undefined) {
+        const anchor = resolve(blocks, selection.anchor);
+        const head = resolve(blocks, selection.focus);
+        if (anchor !== undefined && head !== undefined)
+            return { success: true, data: Object.freeze({ anchor, head }) };
+    }
+    return {
+        success: false,
+        issues: [{ path: POSITION_POLICY.path, message: POSITION_POLICY.invalid }],
+    };
+}

package/dist/editor-sdk/structural-selection.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from '@tiptap/pm/model';
+import type { Selection } from '@tiptap/pm/state';
+export declare function selectedSdkBlockId(selection: Selection): string | undefined;
+export declare function sdkBlockPosition(document: Node, id: string): number | undefined;

package/dist/editor-sdk/structural-selection.js

@@ -0,0 +1,21 @@
+import { NodeSelection } from '@tiptap/pm/state';
+import { stateKeySchema } from '@fastsprout/reacd/adapter-runtime/schema/state/shared/definition.js';
+export function selectedSdkBlockId(selection) {
+    if (!(selection instanceof NodeSelection))
+        return undefined;
+    const parsed = stateKeySchema.safeParse(selection.node.attrs['reacdId']);
+    return parsed.success ? parsed.data : undefined;
+}
+export function sdkBlockPosition(document, id) {
+    let found;
+    document.descendants((node, position) => {
+        if (found !== undefined)
+            return false;
+        if (node.attrs['reacdId'] === id) {
+            found = position;
+            return false;
+        }
+        return true;
+    });
+    return found;
+}

package/dist/editor-suggestion-menu/editor-suggestion-menu.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { EditorSuggestionMenuProps } from '@fastsprout/reacd/adapter-runtime/components/editor-suggestion-menu/index.js';
+export declare function ShadcnEditorSuggestionMenu(properties: EditorSuggestionMenuProps): import("react").JSX.Element;

package/dist/editor-suggestion-menu/editor-suggestion-menu.adapter.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useEditorMenu } from '../editor-menu/use-editor-menu.js';
+import { EditorMenuPanel } from '../editor-menu/menu-panel.js';
+export function ShadcnEditorSuggestionMenu(properties) {
+    const items = useMemo(() => properties.items.map((item) => ({
+        ...item,
+        kind: 'suggestion',
+        value: { command: item.command },
+    })), [properties.items]);
+    const menu = useEditorMenu('suggestion', items, properties.disabled);
+    return _jsx(EditorMenuPanel, { label: properties.label, ...menu });
+}

package/dist/editor-toolbar/editor-toolbar.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { EditorToolbarProps } from '@fastsprout/reacd/adapter-runtime/components/editor-toolbar/index.js';
+export declare function ShadcnEditorToolbar({ label, items, disabled, }: EditorToolbarProps): import("react").JSX.Element;

package/dist/editor-toolbar/editor-toolbar.adapter.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useContext } from 'react';
+import { Toolbar } from '@base-ui/react/toolbar';
+import { EDITOR_COMMAND_LABELS, EDITOR_DEFAULT_COMMANDS, } from '@fastsprout/reacd/adapter-runtime/core/editor-commands.js';
+import { EDITOR_BEHAVIOR, EDITOR_DEFAULTS, EDITOR_ERRORS, } from '@fastsprout/reacd/adapter-runtime/core/editor-policy.js';
+import { EditorScopeContext } from '@fastsprout/reacd/adapter-runtime/renderer/editor/editor-context.js';
+import { Issues } from '@fastsprout/reacd/adapter-runtime/renderer/issues/issues.renderer.js';
+import { Button } from '../vendor/ui/button.js';
+const DEFAULT_ITEMS = EDITOR_DEFAULT_COMMANDS.map((command) => ({ command }));
+const ACTIONS = new Set([
+    'undo',
+    'redo',
+    'separator',
+    'removeLink',
+]);
+function commandValue(item) {
+    return item.command === 'link'
+        ? { command: 'link', href: item.href }
+        : { command: item.command };
+}
+export function ShadcnEditorToolbar({ label = EDITOR_DEFAULTS.toolbarLabel, items = DEFAULT_ITEMS, disabled, }) {
+    const port = useContext(EditorScopeContext);
+    if (port === null)
+        return (_jsx(Issues, { issues: [
+                {
+                    path: 'EditorToolbar',
+                    message: EDITOR_ERRORS.toolbarScope,
+                },
+            ] }));
+    return (_jsx(Toolbar.Root, { className: "reacd-node reacd-editor-toolbar", "aria-label": label, disabled: disabled === true || port.disabled, loopFocus: EDITOR_BEHAVIOR.loopToolbarFocus, children: items.map((item) => {
+            const command = commandValue(item);
+            const active = port.active(command);
+            return (_jsx(Toolbar.Button, { type: "button", "aria-label": item.label ?? EDITOR_COMMAND_LABELS[item.command], "aria-pressed": ACTIONS.has(item.command) ? undefined : active, disabled: disabled === true ||
+                    port.disabled ||
+                    item.disabled === true ||
+                    !port.available(command), focusableWhenDisabled: EDITOR_BEHAVIOR.toolbarDisabledFocusable, render: _jsx(Button, { className: "reacd-button", variant: active ? 'default' : 'outline' }), onClick: () => port.execute(command), children: item.label ?? EDITOR_COMMAND_LABELS[item.command] }, item.command));
+        }) }));
+}

package/dist/element/variants.d.ts

@@ -0,0 +1,5 @@
+export declare const ELEMENT_BUTTON_VARIANTS: {
+    readonly primary: 'default';
+    readonly secondary: 'secondary';
+    readonly danger: 'destructive';
+};

package/dist/element/variants.js

@@ -0,0 +1,5 @@
+export const ELEMENT_BUTTON_VARIANTS = {
+    primary: 'default',
+    secondary: 'secondary',
+    danger: 'destructive',
+};

package/dist/empty/empty.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { EmptyProps } from '@fastsprout/reacd/adapter-runtime/components/empty/empty.js';
+export declare function ShadcnEmpty({ title, description, leading, children, actions, footer, size, variant, loading, loadingLabel, }: EmptyProps): import("react").JSX.Element;

package/dist/empty/empty.adapter.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from 'react';
+import { EMPTY_DEFAULTS } from '@fastsprout/reacd/adapter-runtime/core/empty-policy.js';
+import { SpinnerSurface } from '@fastsprout/reacd/adapter-runtime/renderer/spinner/spinner.renderer.js';
+export function ShadcnEmpty({ title, description, leading, children, actions, footer, size = EMPTY_DEFAULTS.size, variant = EMPTY_DEFAULTS.variant, loading = EMPTY_DEFAULTS.loading, loadingLabel = EMPTY_DEFAULTS.loadingLabel, }) {
+    const id = useId();
+    const titleId = `${id}-title`;
+    const descriptionId = `${id}-description`;
+    return (_jsxs("section", { className: "reacd-node reacd-empty", "data-slot": "empty", "data-size": size, "data-variant": variant, role: "region", "aria-labelledby": titleId, "aria-describedby": description === undefined ? undefined : descriptionId, "data-loading": loading, children: [_jsxs("header", { className: "reacd-empty-header", "data-slot": "empty-header", children: [leading !== undefined && (_jsx("div", { className: "reacd-empty-leading", "data-slot": "empty-media", children: leading })), _jsx("h2", { id: titleId, className: "reacd-empty-title", "data-slot": "empty-title", children: title }), description !== undefined && (_jsx("p", { id: descriptionId, "data-slot": "empty-description", children: description }))] }), loading && _jsx(SpinnerSurface, { label: loadingLabel }), children !== undefined && (_jsx("div", { className: "reacd-empty-content", "data-slot": "empty-content", "aria-busy": loading, children: children })), actions !== undefined && (_jsx("div", { className: "reacd-empty-actions", "data-slot": "empty-actions", children: actions })), footer !== undefined && _jsx("footer", { className: "reacd-empty-footer", children: footer })] }));
+}

package/dist/error/error.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorProps } from '@fastsprout/reacd/adapter-runtime/components/error/error.js';
+export declare function ShadcnError({ statusCode, title, message, children, leading, actions, redirect, recoveryLabel, }: ErrorProps): import("react").JSX.Element;

package/dist/error/error.adapter.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from 'react';
+import { APPLICATION_DEFAULTS } from '@fastsprout/reacd/adapter-runtime/core/application-shell-policy.js';
+export function ShadcnError({ statusCode, title, message, children, leading, actions, redirect, recoveryLabel = APPLICATION_DEFAULTS.recoveryLabel, }) {
+    const id = useId();
+    const titleId = `${id}-error-title`;
+    const messageId = `${id}-error-message`;
+    return (_jsxs("section", { className: "reacd-node reacd-error", role: "region", "aria-labelledby": titleId, "aria-describedby": message === undefined ? undefined : messageId, children: [leading !== undefined && _jsx("div", { children: leading }), _jsx("p", { className: "reacd-error-status", children: statusCode }), _jsx("h2", { id: titleId, children: title }), message !== undefined && _jsx("p", { id: messageId, children: message }), children, _jsxs("div", { className: "reacd-error-actions", children: [actions, redirect !== undefined && (_jsx("a", { className: "reacd-node reacd-button", href: redirect, children: recoveryLabel }))] })] }));
+}

package/dist/field-group/field-group.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { FieldGroupProps } from '@fastsprout/reacd/adapter-runtime/components/field-group/index.js';
+export declare function ShadcnFieldGroup({ label, orientation, children, }: FieldGroupProps): import("react").JSX.Element;

package/dist/field-group/field-group.adapter.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FIELD_GROUP_DEFAULTS } from '@fastsprout/reacd/adapter-runtime/core/field-group-policy.js';
+export function ShadcnFieldGroup({ label, orientation = FIELD_GROUP_DEFAULTS.orientation, children, }) {
+    return (_jsx("div", { className: "reacd-node reacd-field-group", role: "group", "aria-label": label, "data-orientation": orientation, children: children }));
+}

package/dist/file-upload/file-upload.adapter.d.ts

@@ -0,0 +1,2 @@
+import type { FileUploadProps } from '@fastsprout/reacd/adapter-runtime/components/file-upload/index.js';
+export declare function ShadcnFileUpload(props: FileUploadProps): import("react").JSX.Element;