@vamos-ui/react 0.0.0-stage → 0.2.0

package/dist/data-table/url-state.js

@@ -0,0 +1,303 @@
+/**
+ * `ListState` ⇄ URL search params. React-free: `parseListState()` runs in a server component so
+ * the first HTML already has the right rows.
+ *
+ * `?q=jane&f=stage.in:proposal|won;value.gte:5000;created.relative:last_30_days&sort=-createdAt,name&page=2&size=50&sv=v_8k2`
+ *
+ * - values are URI-encoded; `|` separates multiple values (`in`, `between`)
+ * - unknown fields / operators and malformed values are dropped silently
+ * - `page` is 1-based in the URL, 0-based in `ListState`
+ * - column widths / visibility are not written (they are preferences, not position)
+ */
+import { clauseId, createListState, fieldOps, isCursorPage, isFilterGroup, opTakesNoValue } from "./types.js";
+const DEFAULT_KEYS = { q: "q", filters: "f", sort: "sort", page: "page", size: "size", cursor: "cursor", view: "sv", density: "density" };
+export function resolveUrlKeys(o = {}) {
+    const keys = { ...DEFAULT_KEYS, ...o.keys };
+    if (!o.prefix)
+        return keys;
+    return Object.fromEntries(Object.entries(keys).map(([k, v]) => [k, o.prefix + v]));
+}
+const decode = (s) => {
+    try {
+        return decodeURIComponent(s.replace(/\+/g, " "));
+    }
+    catch {
+        return s;
+    }
+};
+function readRaw(search) {
+    const s = search.startsWith("?") ? search.slice(1) : search;
+    if (!s)
+        return [];
+    return s
+        .split("&")
+        .filter(Boolean)
+        .map((pair) => {
+        const i = pair.indexOf("=");
+        return i === -1 ? [decode(pair), ""] : [decode(pair.slice(0, i)), pair.slice(i + 1)];
+    });
+}
+const enc = (s) => encodeURIComponent(s);
+/** Filter-string value encoding: also escape the separators the format uses. */
+const encValue = (s) => encodeURIComponent(s);
+/** A decoded parameter value back to the raw form the parser expects (separators unescaped). */
+const reRaw = (v) => encodeURIComponent(v).replace(/%7C/gi, "|").replace(/%3A/gi, ":").replace(/%3B/gi, ";").replace(/%2C/gi, ",");
+/* ------------------------------------------------------------------ */
+/* Filters                                                             */
+/* ------------------------------------------------------------------ */
+function encodeRelative(r) {
+    if (typeof r === "string")
+        return r;
+    return `${r.last}${r.unit[0]}`;
+}
+function decodeRelative(s) {
+    const m = /^(\d{1,3})([dwm])$/.exec(s);
+    if (m)
+        return { last: Number(m[1]), unit: m[2] === "d" ? "day" : m[2] === "w" ? "week" : "month" };
+    return /^[a-z_0-9]+$/.test(s) ? s : null;
+}
+const scalarToString = (v) => (typeof v === "object" && v !== null ? String(v.id ?? "") : String(v));
+/** `stage.in:proposal|won;value.gte:5000` — the `f` parameter. Nested groups are flattened (simple mode). */
+export function encodeFilters(g) {
+    const parts = [];
+    const walk = (group) => {
+        for (const c of group.clauses) {
+            if (isFilterGroup(c)) {
+                walk(c);
+                continue;
+            }
+            const head = `${encValue(c.field)}.${c.op}`;
+            if (opTakesNoValue(c.op)) {
+                parts.push(head);
+                continue;
+            }
+            if (c.value === undefined || c.value === null || c.value === "")
+                continue;
+            let value;
+            if (c.op === "relative")
+                value = encodeRelative(c.value);
+            else if (Array.isArray(c.value))
+                value = c.value.map((v) => encValue(scalarToString(v))).join("|");
+            else
+                value = encValue(scalarToString(c.value));
+            if (!value)
+                continue;
+            parts.push(`${head}:${value}`);
+        }
+    };
+    walk(g);
+    return parts.join(";");
+}
+function coerce(raw, field) {
+    const s = decode(raw);
+    if (!field)
+        return s;
+    if (field.type === "number" || field.type === "percent") {
+        const n = Number(s);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    if (field.type === "currency")
+        return /^-?\d+(\.\d+)?$/.test(s) ? s : undefined;
+    if (field.type === "boolean")
+        return s === "true" ? true : s === "false" ? false : undefined;
+    if (field.type === "date")
+        return /^\d{4}-\d{2}-\d{2}$/.test(s) ? s : undefined;
+    return s;
+}
+/**
+ * Parses the `f` parameter. With `fields`, unknown fields, operators a field does not allow and
+ * malformed values are dropped; without it every syntactically valid clause is kept as text.
+ */
+export function decodeFilters(raw, fields) {
+    const byField = fields ? new Map(fields.map((f) => [f.field, f])) : null;
+    const clauses = [];
+    for (const part of raw.split(";")) {
+        if (!part)
+            continue;
+        const colon = part.indexOf(":");
+        const head = colon === -1 ? part : part.slice(0, colon);
+        const body = colon === -1 ? "" : part.slice(colon + 1);
+        const dot = head.lastIndexOf(".");
+        if (dot <= 0)
+            continue;
+        const field = decode(head.slice(0, dot));
+        const op = head.slice(dot + 1);
+        const def = byField?.get(field);
+        if (byField && (!def || !fieldOps(def).includes(op)))
+            continue;
+        if (opTakesNoValue(op)) {
+            clauses.push({ id: clauseId(), field, op });
+            continue;
+        }
+        if (!body)
+            continue;
+        let value;
+        if (op === "relative") {
+            value = decodeRelative(decode(body));
+        }
+        else if (op === "in" || op === "notIn") {
+            const list = body.split("|").map((v) => decode(v)).filter(Boolean);
+            value = list.length ? list : undefined;
+        }
+        else if (op === "between") {
+            const pair = body.split("|").map((v) => coerce(v, def));
+            value = pair.length === 2 && pair.every((v) => v !== undefined && v !== "") ? pair : undefined;
+        }
+        else {
+            value = coerce(body, def);
+        }
+        if (value === undefined || value === null)
+            continue;
+        clauses.push({ id: clauseId(), field, op, value });
+    }
+    return { logic: "and", clauses };
+}
+/** The owned parameters of a list state, in a stable order. Values are already encoded. */
+export function listStateToParams(state, o = {}) {
+    const k = resolveUrlKeys(o);
+    const d = createListState(o.defaults);
+    const out = [];
+    if (state.q.trim())
+        out.push([k.q, enc(state.q)]);
+    const f = encodeFilters(state.filters);
+    if (f && f !== encodeFilters(d.filters))
+        out.push([k.filters, f]);
+    const sort = state.sort.map((s) => (s.desc ? "-" : "") + encValue(s.id)).join(",");
+    const defSort = d.sort.map((s) => (s.desc ? "-" : "") + encValue(s.id)).join(",");
+    if (sort !== defSort)
+        out.push([k.sort, sort || "none"]);
+    if (isCursorPage(state.page)) {
+        if (state.page.cursor)
+            out.push([k.cursor, enc(state.page.cursor)]);
+    }
+    else if (state.page.index > 0)
+        out.push([k.page, String(state.page.index + 1)]);
+    if (state.page.size !== d.page.size)
+        out.push([k.size, String(state.page.size)]);
+    if (state.view)
+        out.push([k.view, enc(state.view)]);
+    if (o.density && state.density && state.density !== d.density)
+        out.push([k.density, state.density]);
+    return out;
+}
+/**
+ * `ListState` → search string (no leading `?`). Defaults are omitted, so the canonical list has a clean URL.
+ *
+ * ```ts
+ * serializeListState(state, { defaults: { sort: [{ id: "createdAt", desc: true }] } });
+ * // "q=jane&f=stage.in:proposal|won&page=2"
+ * ```
+ */
+export function serializeListState(state, o = {}) {
+    return listStateToParams(state, o)
+        .map(([key, v]) => `${enc(key)}=${v}`)
+        .join("&");
+}
+/**
+ * Replaces the list's own parameters in an existing search string and keeps every other
+ * parameter (`?tab=deals&q=…`) in place.
+ */
+export function mergeListStateIntoSearch(search, state, o = {}) {
+    const k = resolveUrlKeys(o);
+    const owned = new Set(Object.values(k));
+    const kept = readRaw(search).filter(([key]) => !owned.has(key)).map(([key, raw]) => `${enc(key)}=${raw}`);
+    const own = listStateToParams(state, o).map(([key, v]) => `${enc(key)}=${v}`);
+    return [...kept, ...own].join("&");
+}
+/**
+ * Search string (or `URLSearchParams`, or a Next.js `searchParams` object) → `ListState`.
+ * Safe on untrusted input: bad values fall back to the defaults.
+ */
+export function parseListState(input, o = {}) {
+    const k = resolveUrlKeys(o);
+    const base = createListState(o.defaults);
+    let raw;
+    if (typeof input === "string")
+        raw = readRaw(input);
+    else if (input instanceof URLSearchParams)
+        raw = [...input.entries()].map(([key, v]) => [key, reRaw(v)]);
+    else
+        raw = Object.entries(input).flatMap(([key, v]) => v === undefined ? [] : (Array.isArray(v) ? v : [v]).map((x) => [key, reRaw(x)]));
+    const get = (key) => raw.find(([n]) => n === key)?.[1];
+    const state = { ...base, columns: base.columns };
+    const q = get(k.q);
+    if (q !== undefined)
+        state.q = decode(q).slice(0, 500);
+    const f = get(k.filters);
+    if (f !== undefined)
+        state.filters = decodeFilters(f, o.fields);
+    const sort = get(k.sort);
+    if (sort !== undefined) {
+        const list = sort === "none" || sort === "" ? [] : sort.split(",").map((s) => (s.startsWith("-") ? { id: decode(s.slice(1)), desc: true } : { id: decode(s), desc: false }));
+        state.sort = list.filter((s) => s.id && (!o.sortable || o.sortable.includes(s.id)));
+    }
+    let size = base.page.size;
+    const sizeRaw = get(k.size);
+    if (sizeRaw !== undefined) {
+        const n = Number(sizeRaw);
+        if (Number.isInteger(n) && n > 0 && n <= 1000 && (!o.pageSizes || o.pageSizes.includes(n)))
+            size = n;
+    }
+    const cursor = get(k.cursor);
+    if (cursor !== undefined || isCursorPage(base.page)) {
+        state.page = { cursor: cursor ? decode(cursor) : null, size };
+    }
+    else {
+        const p = Number(get(k.page) ?? 1);
+        state.page = { index: Number.isInteger(p) && p > 0 ? p - 1 : 0, size };
+    }
+    const view = get(k.view);
+    if (view !== undefined)
+        state.view = decode(view) || null;
+    const density = get(k.density);
+    if (density === "compact" || density === "comfortable" || density === "spacious")
+        state.density = density;
+    return state;
+}
+/* ------------------------------------------------------------------ */
+/* Adapters                                                            */
+/* ------------------------------------------------------------------ */
+/**
+ * The built-in adapter: `history.replaceState` / `pushState` on the current URL. Works with the
+ * Next.js App Router (`useSearchParams` observes `history` updates). SSR-safe.
+ */
+export function createHistoryAdapter() {
+    return {
+        read: () => (typeof window === "undefined" ? "" : window.location.search),
+        write(search, mode) {
+            if (typeof window === "undefined")
+                return;
+            const url = `${window.location.pathname}${search ? `?${search}` : ""}${window.location.hash}`;
+            if (url === `${window.location.pathname}${window.location.search}${window.location.hash}`)
+                return;
+            if (mode === "push")
+                window.history.pushState(window.history.state, "", url);
+            else
+                window.history.replaceState(window.history.state, "", url);
+        },
+        subscribe(cb) {
+            if (typeof window === "undefined")
+                return () => { };
+            window.addEventListener("popstate", cb);
+            return () => window.removeEventListener("popstate", cb);
+        },
+    };
+}
+/** An in-memory adapter for tests, previews and embedded lists. */
+export function createMemoryAdapter(initial = "") {
+    let search = initial.replace(/^\?/, "");
+    const subs = new Set();
+    return {
+        get search() {
+            return search;
+        },
+        read: () => search,
+        write(next) {
+            search = next;
+        },
+        subscribe(cb) {
+            subs.add(cb);
+            return () => subs.delete(cb);
+        },
+    };
+}

package/dist/data-table/view-state.d.ts

@@ -0,0 +1,16 @@
+/** Saved-view helpers. React-free. */
+import { type ListState, type SavedView, type ViewState } from "./types.js";
+/**
+ * `true` when two view states describe the same list. Order-insensitive for filters and column
+ * visibility; ignores clause ids, page position and column widths under 4 px apart.
+ */
+export declare function viewStateEqual(a: ViewState, b: ViewState): boolean;
+/** The part of a list state a saved view stores. */
+export declare function toViewState(s: ListState): ViewState;
+/** Applies a view to a list state: position resets to the first page, the view becomes active. */
+export declare function applyViewState(current: ListState, view: ViewState | undefined, viewId: string | null, base?: Partial<ListState>): ListState;
+/**
+ * Which view to open on load: URL `sv` → the user's default view → `null` ("All").
+ * A deleted id falls through to the default.
+ */
+export declare function resolveInitialView(views: SavedView[], urlViewId?: string | null): SavedView | null;

package/dist/data-table/view-state.js

@@ -0,0 +1,81 @@
+/** Saved-view helpers. React-free. */
+import { createListState, isCursorPage, isFilterGroup } from "./types.js";
+const canonValue = (v) => (Array.isArray(v) ? v.map(canonValue).map(String).sort() : v && typeof v === "object" ? JSON.stringify(v, Object.keys(v).sort()) : v);
+function canonFilters(g) {
+    const items = g.clauses.map((c) => (isFilterGroup(c) ? canonFilters(c) : JSON.stringify([c.field, c.op, canonValue(c.value)]))).map((x) => (typeof x === "string" ? x : JSON.stringify(x)));
+    items.sort();
+    return { logic: items.length > 1 ? g.logic : "and", items };
+}
+/** Visibility with explicit `true` entries removed (missing = visible). */
+const canonVisible = (v = {}) => Object.keys(v)
+    .filter((k) => v[k] === false)
+    .sort();
+/**
+ * `true` when two view states describe the same list. Order-insensitive for filters and column
+ * visibility; ignores clause ids, page position and column widths under 4 px apart.
+ */
+export function viewStateEqual(a, b) {
+    if ((a.q ?? "").trim() !== (b.q ?? "").trim())
+        return false;
+    if (JSON.stringify(canonFilters(a.filters)) !== JSON.stringify(canonFilters(b.filters)))
+        return false;
+    if (JSON.stringify(a.sort ?? []) !== JSON.stringify(b.sort ?? []))
+        return false;
+    if ((a.density ?? null) !== (b.density ?? null))
+        return false;
+    if ((a.groupBy ?? null) !== (b.groupBy ?? null))
+        return false;
+    if (a.pageSize !== undefined && b.pageSize !== undefined && a.pageSize !== b.pageSize)
+        return false;
+    const ca = a.columns;
+    const cb = b.columns;
+    if (JSON.stringify(canonVisible(ca?.visible)) !== JSON.stringify(canonVisible(cb?.visible)))
+        return false;
+    const orderA = ca?.order ?? [];
+    const orderB = cb?.order ?? [];
+    if (orderA.length && orderB.length && orderA.join() !== orderB.join())
+        return false;
+    if (JSON.stringify(ca?.pinned ?? { start: [], end: [] }) !== JSON.stringify(cb?.pinned ?? { start: [], end: [] }))
+        return false;
+    const sizes = new Set([...Object.keys(ca?.sizing ?? {}), ...Object.keys(cb?.sizing ?? {})]);
+    for (const key of sizes) {
+        const x = ca?.sizing?.[key];
+        const y = cb?.sizing?.[key];
+        if (x !== undefined && y !== undefined && Math.abs(x - y) >= 4)
+            return false;
+    }
+    return true;
+}
+/** The part of a list state a saved view stores. */
+export function toViewState(s) {
+    return { q: s.q || undefined, filters: s.filters, sort: s.sort, columns: s.columns, density: s.density, groupBy: s.groupBy ?? null, pageSize: s.page.size };
+}
+/** Applies a view to a list state: position resets to the first page, the view becomes active. */
+export function applyViewState(current, view, viewId, base) {
+    const reset = createListState(base, current.page.size);
+    const source = view ?? toViewState(reset);
+    const size = source.pageSize ?? current.page.size;
+    return {
+        ...current,
+        q: source.q ?? "",
+        filters: source.filters ?? reset.filters,
+        sort: source.sort ?? reset.sort,
+        columns: { ...reset.columns, ...source.columns, pinned: source.columns?.pinned ?? { start: [], end: [] } },
+        density: source.density ?? reset.density,
+        groupBy: source.groupBy ?? null,
+        page: isCursorPage(current.page) ? { cursor: null, size } : { index: 0, size },
+        view: viewId,
+    };
+}
+/**
+ * Which view to open on load: URL `sv` → the user's default view → `null` ("All").
+ * A deleted id falls through to the default.
+ */
+export function resolveInitialView(views, urlViewId) {
+    if (urlViewId) {
+        const hit = views.find((v) => v.id === urlViewId);
+        if (hit)
+            return hit;
+    }
+    return views.find((v) => v.isDefault) ?? null;
+}

package/dist/editor/_test-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/editor/_test-setup.js

@@ -0,0 +1,33 @@
+// jsdom gaps ProseMirror needs (layout APIs). Imported by the editor tests only.
+const rect = () => ({ x: 0, y: 0, top: 0, left: 0, bottom: 0, right: 0, width: 0, height: 0, toJSON() { } });
+if (typeof Range !== "undefined") {
+    Range.prototype.getBoundingClientRect ??= rect;
+    Range.prototype.getClientRects ??= () => ({ length: 0, item: () => null, [Symbol.iterator]: [][Symbol.iterator] });
+}
+if (typeof document !== "undefined") {
+    document.elementFromPoint ??= () => null;
+    document.caretRangeFromPoint ??= () => null;
+}
+if (typeof window !== "undefined") {
+    window.requestAnimationFrame ??= ((cb) => setTimeout(() => cb(0), 0));
+}
+if (typeof DOMRect === "undefined") {
+    globalThis.DOMRect = class {
+        x;
+        y;
+        width;
+        height;
+        constructor(x = 0, y = 0, width = 0, height = 0) {
+            this.x = x;
+            this.y = y;
+            this.width = width;
+            this.height = height;
+        }
+        get top() { return this.y; }
+        get left() { return this.x; }
+        get bottom() { return this.y + this.height; }
+        get right() { return this.x + this.width; }
+        toJSON() { return {}; }
+    };
+}
+export {};

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

@@ -0,0 +1,137 @@
+import * as React from "react";
+import { type Editor } from "@tiptap/react";
+import { type BlockRegistry } from "../blocks/schema/define-block.js";
+import type { RichDoc } from "../blocks/schema/rich-doc.js";
+import type { VamosDoc } from "../blocks/schema/types.js";
+import type { MediaAdapter } from "../media/types.js";
+import { type BlockEditorLabels } from "./labels.js";
+import { type BlockEditorContextValue, type BlockEditorVariant, type BlockPattern, type ImageUploader, type LinkSuggestion } from "./context.js";
+export interface BlockEditorHandle {
+    focus(): void;
+    /** Inserts a block after the current one. `type` is a text type ("heading-2", "table") or a registry type ("hero"). */
+    insertBlock(type: string, props?: Record<string, unknown>): void;
+    /** The current content as a VamosDoc (not debounced). */
+    getDoc(): VamosDoc;
+    undo(): void;
+    redo(): void;
+    /** Tiptap escape hatch. */
+    editor: Editor | null;
+}
+export interface BlockEditorChangeInfo {
+    wordCount: number;
+    changedBlockIds: string[];
+}
+export interface BlockEditorProps {
+    value?: VamosDoc;
+    defaultValue?: VamosDoc;
+    /** Debounced (300 ms). The editor's own state is the truth while typing. */
+    onChange?: (doc: VamosDoc, info: BlockEditorChangeInfo) => void;
+    /** Blocks available to insert and render. Default: none (text blocks only). */
+    registry?: BlockRegistry;
+    /**
+     * `"document"`: a ~720px reading column (posts, KB) · `"canvas"`: full-width page builder ·
+     * `"rich-text"`: compact field, text blocks only, no inserter or drag handle.
+     */
+    variant?: BlockEditorVariant;
+    /** Rich-text size. Default `"md"`. */
+    size?: "sm" | "md";
+    /** Block types that may be inserted (text types are `paragraph`, `heading`, `list`, `quote`, `code`, `divider`, `table`, `image`). */
+    allowedBlocks?: string[] | ((ctx: {
+        parentType?: string;
+    }) => string[]);
+    patterns?: BlockPattern[];
+    /** Placeholder of an empty editor. Dictionary default: "Type / to add a block". */
+    placeholder?: string;
+    readOnly?: boolean;
+    /** Paste / drop images → upload. Default: the `VamosProvider` media adapter. */
+    media?: MediaAdapter;
+    /** Custom image upload (wins over `media`). */
+    uploadImage?: ImageUploader;
+    /** Internal link suggestions in the link editor. */
+    linkSearch?: (q: string) => Promise<LinkSuggestion[]>;
+    /** Site theme axes for the canvas, so blocks look exactly as they will live. */
+    canvasTheme?: {
+        accent?: string;
+        font?: string;
+        density?: string;
+        theme?: "light" | "dark";
+    };
+    /** Content language (spellcheck, hyphenation, word counting). Default `value.lang` → UI locale. */
+    lang?: string;
+    editorRef?: React.Ref<BlockEditorHandle>;
+    /** Accessible name of the text area. Default "Content". */
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    /** Min / max height of the rich-text field (CSS length). */
+    minHeight?: string;
+    maxHeight?: string;
+    /** Rich-text: show the fixed toolbar. Default true. */
+    toolbar?: boolean;
+    /** Autofocus on mount. */
+    autoFocus?: boolean;
+    labels?: Partial<BlockEditorLabels>;
+    className?: string;
+    /**
+     * Parts to render. Default per variant: content + bubble menu + "/" menu (+ drag handle and
+     * inserter for document/canvas, + toolbar for rich-text). Pass your own composition to add
+     * `BlockInspector`, `BlockEditorOutline` or a custom layout.
+     */
+    children?: React.ReactNode;
+    /** @internal value format used by RichTextEditor. */
+    format?: "doc" | "rich";
+    /** @internal */
+    richValue?: RichDoc;
+    /** @internal */
+    defaultRichValue?: RichDoc;
+    /** @internal */
+    onRichChange?: (doc: RichDoc) => void;
+    /** @internal Field wiring. */
+    a11y?: BlockEditorContextValue["a11y"];
+}
+/**
+ * The block editor: text blocks edited inline, page blocks rendered by the very component the
+ * site uses (via the registry), a "/" inserter, a bubble menu on selection, a drag handle with a
+ * keyboard-equivalent block menu, and a schema-generated inspector. Reads and writes `VamosDoc`.
+ *
+ * ```tsx
+ * <BlockEditor value={doc} onChange={setDoc} registry={siteBlocks} variant="document" />
+ *
+ * <BlockEditor value={doc} onChange={setDoc} registry={siteBlocks}>
+ *   <BlockEditorContent />
+ *   <BlockEditorBubbleMenu />
+ *   <BlockEditorSlashMenu />
+ *   <BlockEditorDragHandle />
+ *   <aside><BlockInspector /></aside>
+ * </BlockEditor>
+ * ```
+ */
+export declare function BlockEditor(props: BlockEditorProps): React.JSX.Element;
+export interface BlockEditorContentProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * The editable canvas. Wears the site theme (`canvasTheme`) and is always `solid`, even inside a
+ * glass admin, for long-text readability and scroll performance.
+ */
+export declare const BlockEditorContent: React.ForwardRefExoticComponent<BlockEditorContentProps & React.RefAttributes<HTMLDivElement>>;
+export interface RichTextEditorProps extends Omit<BlockEditorProps, "value" | "defaultValue" | "onChange" | "variant" | "registry" | "patterns" | "format" | "richValue" | "defaultRichValue" | "onRichChange" | "a11y" | "canvasTheme" | "allowedBlocks"> {
+    /** A RichDoc (the value of `f.rich()` fields): paragraphs, h2–h4, lists, quotes, code, rules. */
+    value?: RichDoc;
+    defaultValue?: RichDoc;
+    /** Debounced (300 ms). */
+    onChange?: (doc: RichDoc) => void;
+    id?: string;
+    invalid?: boolean;
+    required?: boolean;
+    "aria-describedby"?: string;
+}
+/**
+ * Compact rich-text field for notes, comments, CRM activities and HR announcements. Same engine
+ * as BlockEditor (`variant="rich-text"`), RichDoc in and out, Field-aware like Textarea.
+ *
+ * ```tsx
+ * <Field label="Note" hint="Visible to your team only.">
+ *   <RichTextEditor value={note} onChange={setNote} size="sm" minHeight="6rem" />
+ * </Field>
+ * ```
+ */
+export declare function RichTextEditor({ value, defaultValue, onChange, id, invalid, required, "aria-describedby": describedBy, "aria-labelledby": labelledBy, ...rest }: RichTextEditorProps): React.JSX.Element;