@apollohg/react-native-rich-text-editor 2.0.0

package/dist/addons.d.ts

@@ -0,0 +1,193 @@
+import { type NormalizedEditorAddons } from './EditorAddonNormalization';
+import type { EditorAddons, CodeHighlightingAddonOptions } from './EditorAddon';
+export { normalizeEditorAddons } from './EditorAddonNormalization';
+export { createMentionsAddon, type EditorAddons } from './EditorAddon';
+import type { EditorMentionTheme } from './EditorTheme';
+import { type SerializedEditorMentionTheme } from './EditorMentionThemeNormalization';
+import type { DocumentJSON, ReadonlyActiveState } from './NativeEditorBridge';
+import { type ResolvedDocumentSchema, type SchemaDefinition, type NodeSpec } from './schemas';
+/** One row offered in the mention suggestion list. */
+export interface MentionSuggestion {
+    /** Identity of this suggestion. Must be unique within the offered list. */
+    key: string;
+    /** Primary text shown in the suggestion row. */
+    title: string;
+    /** Secondary text shown in the suggestion row. */
+    subtitle?: string;
+    /** Text rendered in the document once inserted. Defaults to `title`. */
+    label?: string;
+    /** Extra attributes stored on the inserted mention node, e.g. a user id. */
+    attrs?: Record<string, unknown>;
+}
+/** The mention query under the caret changed. */
+export interface MentionQueryChangeEvent {
+    /** Text typed after the trigger, without the trigger itself. */
+    query: string;
+    /** Trigger character that opened this query. */
+    trigger: string;
+    /** Engine document positions the mention would replace. */
+    range: {
+        anchor: number;
+        head: number;
+    };
+    /** False once the query closed — supply an empty suggestion list. */
+    isActive: boolean;
+    /** Engine document revision the query was computed against. */
+    documentVersion?: string;
+}
+/** A suggestion was inserted into the document. */
+export interface MentionSelectEvent {
+    trigger: string;
+    suggestion: MentionSuggestion;
+    /** The attributes actually written onto the mention node. */
+    attrs: Record<string, unknown>;
+    documentVersion?: string;
+}
+/**
+ * A suggestion is about to be inserted. Passed to
+ * {@link MentionsAddonConfig.resolveSelectionAttrs} and
+ * {@link MentionsAddonConfig.resolveTheme} so the host can decide the node's
+ * attributes and styling from live document context.
+ */
+export interface MentionSelectionAttrsEvent {
+    trigger: string;
+    suggestion: MentionSuggestion;
+    /** Attributes resolved so far — the suggestion's own, plus `label` and `mentionSuggestionChar`. */
+    attrs: Record<string, unknown>;
+    /** Mark attributes active at the insertion point. */
+    markAttrs: ReadonlyActiveState['markAttrs'];
+    /** Engine document positions the mention will replace. */
+    range: {
+        anchor: number;
+        head: number;
+    };
+    documentVersion?: string;
+}
+/** Payload of {@link MentionsAddonConfig.resolveTheme}, carrying the attributes
+ *  `resolveSelectionAttrs` already resolved. */
+export type MentionThemeResolveEvent = MentionSelectionAttrsEvent;
+/**
+ * Mentions for `RichTextEditor`. The schema belongs to the document
+ * handle, so create the handle with {@link withMentionsSchema} applied to
+ * your schema — this config alone does not add the `mention` node.
+ * (`RichTextViewer` adds it for you.)
+ *
+ * The host owns the suggestion list: react to `onQueryChange` by filtering
+ * your own data, then pass the result back through `suggestions`.
+ */
+export interface MentionsAddonConfig {
+    /** Character that opens a mention query. Defaults to `'@'`. */
+    trigger?: string;
+    /** Rows currently offered for the open query. */
+    suggestions?: readonly MentionSuggestion[];
+    /** Default mention styling. See {@link EditorMentionTheme}. */
+    theme?: EditorMentionTheme;
+    /**
+     * Extra attributes merged over the suggestion's own, just before
+     * insertion. Return `null`/`undefined` to keep them unchanged. Throwing
+     * is caught and treated the same way.
+     */
+    resolveSelectionAttrs?: (event: MentionSelectionAttrsEvent) => Record<string, unknown> | null | undefined;
+    /**
+     * Per-mention styling, stored on the inserted node and used in place of
+     * `theme`. Runs after `resolveSelectionAttrs`. A value that is not a
+     * valid {@link EditorMentionTheme} is dropped rather than written into
+     * the document.
+     */
+    resolveTheme?: (event: MentionThemeResolveEvent) => EditorMentionTheme | null | undefined;
+    /** Called whenever the open query changes, including when it closes. */
+    onQueryChange?: (event: MentionQueryChangeEvent) => void;
+    /** Called after a suggestion has been inserted. */
+    onSelect?: (event: MentionSelectEvent) => void;
+}
+export interface SerializedMentionSuggestion {
+    key: string;
+    title: string;
+    subtitle?: string;
+    label: string;
+    attrs: Record<string, unknown>;
+}
+export interface SerializedMentionsAddonConfig {
+    trigger: string;
+    theme?: SerializedEditorMentionTheme;
+    resolveSelectionAttrs?: boolean;
+    resolveTheme?: boolean;
+    suggestions: SerializedMentionSuggestion[];
+}
+export interface SerializedEditorAddons {
+    mentions?: SerializedMentionsAddonConfig;
+    codeHighlighting?: CodeHighlightingAddonOptions;
+}
+/**
+ * The raw addon event the native view emits, before the editor turns it into
+ * the typed {@link MentionsAddonConfig} callbacks. Exported for hosts that
+ * inspect the native stream directly; ordinary use needs `onQueryChange` and
+ * `onSelect` instead.
+ */
+export type EditorAddonEvent = {
+    type: 'mentionsQueryChange';
+    query: string;
+    trigger: string;
+    range: {
+        anchor: number;
+        head: number;
+    };
+    isActive: boolean;
+    documentVersion?: string;
+} | {
+    type: 'mentionsSelectRequest';
+    trigger: string;
+    suggestionKey: string;
+    attrs: Record<string, unknown>;
+    range: {
+        anchor: number;
+        head: number;
+    };
+    documentVersion?: string;
+    updateJson?: string;
+} | {
+    type: 'mentionsSelect';
+    trigger: string;
+    suggestionKey: string;
+    attrs: Record<string, unknown>;
+    documentVersion?: string;
+};
+/** Node name mentions are stored under in the document. */
+export declare const MENTION_NODE_NAME = "mention";
+/**
+ * The mention node spec: a void inline node that round-trips arbitrary
+ * app-defined attributes. Add it through {@link withMentionsSchema} rather
+ * than assembling it by hand.
+ */
+export declare function mentionNodeSpec(): NodeSpec;
+/**
+ * Return `schema` with the mention node added, or `schema` unchanged when it
+ * already declares one. Apply it when creating the document handle for an
+ * editor that uses mentions.
+ *
+ * @example
+ * ```ts
+ * createNativeEditorDocumentHandle({
+ *     initialization: { type: 'localEmpty' },
+ *     schema: withMentionsSchema(defaultSchema),
+ * });
+ * ```
+ */
+export declare function withMentionsSchema(schema: SchemaDefinition): SchemaDefinition;
+export declare function normalizeNativeEditorAddons(addons?: NormalizedEditorAddons): SerializedEditorAddons | undefined;
+export declare function serializeEditorAddons(addons?: EditorAddons): string | undefined;
+export declare function serializeNormalizedEditorAddons(addons?: NormalizedEditorAddons): string | undefined;
+/** Options for {@link buildMentionFragmentJson}. */
+export interface MentionFragmentOptions {
+    /** Append a plain, unmarked space so typing continues after the mention. */
+    trailingSpace?: boolean;
+}
+/**
+ * Build a document fragment holding one mention node, ready for
+ * `insertContentJson`. Use it to insert a mention outside the suggestion
+ * flow — from a picker, say.
+ *
+ * @param attrs Attributes for the mention node, e.g. `{ label, id }`.
+ * @param descriptor Document node name to wrap the fragment in. Defaults to `doc`.
+ */
+export declare function buildMentionFragmentJson(attrs: Record<string, unknown>, descriptor?: Pick<ResolvedDocumentSchema, 'documentNodeName'>, options?: MentionFragmentOptions): DocumentJSON;

package/dist/addons.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MENTION_NODE_NAME = exports.createMentionsAddon = exports.normalizeEditorAddons = void 0;
+exports.mentionNodeSpec = mentionNodeSpec;
+exports.withMentionsSchema = withMentionsSchema;
+exports.normalizeNativeEditorAddons = normalizeNativeEditorAddons;
+exports.serializeEditorAddons = serializeEditorAddons;
+exports.serializeNormalizedEditorAddons = serializeNormalizedEditorAddons;
+exports.buildMentionFragmentJson = buildMentionFragmentJson;
+const EditorAddonNormalization_1 = require("./EditorAddonNormalization");
+var EditorAddonNormalization_2 = require("./EditorAddonNormalization");
+Object.defineProperty(exports, "normalizeEditorAddons", { enumerable: true, get: function () { return EditorAddonNormalization_2.normalizeEditorAddons; } });
+var EditorAddon_1 = require("./EditorAddon");
+Object.defineProperty(exports, "createMentionsAddon", { enumerable: true, get: function () { return EditorAddon_1.createMentionsAddon; } });
+const EditorMentionThemeNormalization_1 = require("./EditorMentionThemeNormalization");
+const schemas_1 = require("./schemas");
+/** Node name mentions are stored under in the document. */
+exports.MENTION_NODE_NAME = 'mention';
+const DEFAULT_MENTION_TRIGGER = '@';
+/**
+ * The mention node spec: a void inline node that round-trips arbitrary
+ * app-defined attributes. Add it through {@link withMentionsSchema} rather
+ * than assembling it by hand.
+ */
+function mentionNodeSpec() {
+    return {
+        name: exports.MENTION_NODE_NAME,
+        content: '',
+        group: 'inline',
+        role: 'inline',
+        isVoid: true,
+        // Mention nodes round-trip arbitrary app-defined metadata (id, kind,
+        // mentionSuggestionChar, mentionTheme, and anything supplied via
+        // MentionSuggestion.attrs / resolveSelectionAttrs) that this fixed
+        // attrs map cannot enumerate. Opt out of the schema-declared-attrs
+        // filter that Rust's set_json ingestion otherwise applies.
+        allowUndeclaredAttrs: true,
+        attrs: {
+            label: { default: null },
+        },
+    };
+}
+/**
+ * Return `schema` with the mention node added, or `schema` unchanged when it
+ * already declares one. Apply it when creating the document handle for an
+ * editor that uses mentions.
+ *
+ * @example
+ * ```ts
+ * createNativeEditorDocumentHandle({
+ *     initialization: { type: 'localEmpty' },
+ *     schema: withMentionsSchema(defaultSchema),
+ * });
+ * ```
+ */
+function withMentionsSchema(schema) {
+    const hasMentionNode = schema.nodes.some((node) => node.name === exports.MENTION_NODE_NAME);
+    if (hasMentionNode) {
+        return schema;
+    }
+    return {
+        ...schema,
+        nodes: [...schema.nodes, mentionNodeSpec()],
+    };
+}
+function normalizeNativeEditorAddons(addons) {
+    if (!addons?.mentions) {
+        return addons?.codeHighlighting ? { codeHighlighting: addons.codeHighlighting } : undefined;
+    }
+    const trigger = addons.mentions.trigger?.trim() || DEFAULT_MENTION_TRIGGER;
+    const suggestions = (addons.mentions.suggestions ?? []).map((suggestion) => {
+        const label = suggestion.label?.trim() || suggestion.title;
+        const attrs = {
+            label,
+            mentionSuggestionChar: trigger,
+            ...(suggestion.attrs ?? {}),
+        };
+        return {
+            key: suggestion.key,
+            title: suggestion.title,
+            subtitle: suggestion.subtitle,
+            label,
+            attrs,
+        };
+    });
+    return {
+        mentions: {
+            trigger,
+            theme: (0, EditorMentionThemeNormalization_1.normalizeEditorMentionTheme)(addons.mentions.theme),
+            ...(typeof addons.mentions.resolveSelectionAttrs === 'function'
+                ? { resolveSelectionAttrs: true }
+                : {}),
+            ...(typeof addons.mentions.resolveTheme === 'function' ? { resolveTheme: true } : {}),
+            suggestions,
+        },
+        ...(addons.codeHighlighting ? { codeHighlighting: addons.codeHighlighting } : {}),
+    };
+}
+function serializeEditorAddons(addons) {
+    return serializeNormalizedEditorAddons((0, EditorAddonNormalization_1.normalizeEditorAddons)(addons));
+}
+function serializeNormalizedEditorAddons(addons) {
+    const normalized = normalizeNativeEditorAddons(addons);
+    return normalized ? JSON.stringify(normalized) : undefined;
+}
+/**
+ * Build a document fragment holding one mention node, ready for
+ * `insertContentJson`. Use it to insert a mention outside the suggestion
+ * flow — from a picker, say.
+ *
+ * @param attrs Attributes for the mention node, e.g. `{ label, id }`.
+ * @param descriptor Document node name to wrap the fragment in. Defaults to `doc`.
+ */
+function buildMentionFragmentJson(attrs, descriptor, options) {
+    return (0, schemas_1.buildDocumentFragmentJson)([
+        {
+            type: exports.MENTION_NODE_NAME,
+            attrs,
+        },
+        ...(options?.trailingSpace ? [{ type: 'text', text: ' ' }] : []),
+    ], descriptor);
+}

package/dist/atomConstants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_ATOM_CHIP_HEIGHT = 32;
+export declare const ATOM_NATIVE_ID_PREFIX = "prose-atom:";
+export declare const ATOM_CONTENT_NATIVE_ID_PREFIX = "prose-atom-content:";

package/dist/atomConstants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATOM_CONTENT_NATIVE_ID_PREFIX = exports.ATOM_NATIVE_ID_PREFIX = exports.DEFAULT_ATOM_CHIP_HEIGHT = void 0;
+exports.DEFAULT_ATOM_CHIP_HEIGHT = 32;
+exports.ATOM_NATIVE_ID_PREFIX = 'prose-atom:';
+exports.ATOM_CONTENT_NATIVE_ID_PREFIX = 'prose-atom-content:';

package/dist/atomInstances.d.ts

@@ -0,0 +1,35 @@
+import type { Selection } from './NativeEditorBridge';
+export { DEFAULT_ATOM_CHIP_HEIGHT } from './atomConstants';
+export interface AtomInstance {
+    key: string;
+    hasStableKey: boolean;
+    nodeType: string;
+    attrs: Readonly<Record<string, unknown>>;
+    docPos: number;
+}
+export interface AtomInstanceCollection {
+    instanceBlocks: AtomInstance[][];
+    instances: AtomInstance[];
+    hasOnlyStableKeys: boolean;
+}
+export declare const NATIVE_VOID_BLOCK_TYPES: ReadonlySet<string>;
+export type AtomUpdateAttrsErrorCode = 'not-applicable' | 'stale-revision' | 'not-ready' | 'engine-error';
+export declare class AtomUpdateAttrsError extends Error {
+    readonly code: AtomUpdateAttrsErrorCode;
+    constructor(code: AtomUpdateAttrsErrorCode, message: string);
+}
+interface AtomRenderElement {
+    readonly type: string;
+    readonly nodeType?: string;
+    readonly docPos?: number;
+    readonly atomId?: string;
+    readonly attrs?: Readonly<Record<string, unknown>>;
+}
+export declare function collectAtomInstanceBlocks(renderBlocks: ReadonlyArray<ReadonlyArray<AtomRenderElement>>, registeredTypes: ReadonlySet<string>): AtomInstanceCollection;
+export declare function collectAtomInstances(renderBlocks: ReadonlyArray<ReadonlyArray<AtomRenderElement>>, registeredTypes: ReadonlySet<string>): AtomInstance[];
+export declare function applyRenderPatch<Element>(previousBlocks: ReadonlyArray<ReadonlyArray<Element>>, patch: {
+    readonly startIndex: number;
+    readonly deleteCount: number;
+    readonly renderBlocks: ReadonlyArray<ReadonlyArray<Element>>;
+}): Array<ReadonlyArray<Element>>;
+export declare function atomSelected(selection: Selection, docPos: number): boolean;

package/dist/atomInstances.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomUpdateAttrsError = exports.NATIVE_VOID_BLOCK_TYPES = exports.DEFAULT_ATOM_CHIP_HEIGHT = void 0;
+exports.collectAtomInstanceBlocks = collectAtomInstanceBlocks;
+exports.collectAtomInstances = collectAtomInstances;
+exports.applyRenderPatch = applyRenderPatch;
+exports.atomSelected = atomSelected;
+var atomConstants_1 = require("./atomConstants");
+Object.defineProperty(exports, "DEFAULT_ATOM_CHIP_HEIGHT", { enumerable: true, get: function () { return atomConstants_1.DEFAULT_ATOM_CHIP_HEIGHT; } });
+exports.NATIVE_VOID_BLOCK_TYPES = new Set([
+    'horizontalRule',
+    'horizontal_rule',
+    'image',
+]);
+class AtomUpdateAttrsError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'AtomUpdateAttrsError';
+        this.code = code;
+    }
+}
+exports.AtomUpdateAttrsError = AtomUpdateAttrsError;
+const EMPTY_ATOM_ATTRS = Object.freeze({});
+function collectAtomInstanceBlocks(renderBlocks, registeredTypes) {
+    const occurrences = new Map();
+    const instanceBlocks = [];
+    const instances = [];
+    let hasOnlyStableKeys = true;
+    for (const block of renderBlocks) {
+        const blockInstances = [];
+        for (const element of block) {
+            if (element.type !== 'voidBlock' ||
+                typeof element.nodeType !== 'string' ||
+                typeof element.docPos !== 'number') {
+                continue;
+            }
+            const occurrence = occurrences.get(element.nodeType) ?? 0;
+            occurrences.set(element.nodeType, occurrence + 1);
+            if (!registeredTypes.has(element.nodeType) &&
+                exports.NATIVE_VOID_BLOCK_TYPES.has(element.nodeType)) {
+                continue;
+            }
+            const hasStableKey = typeof element.atomId === 'string';
+            const instance = {
+                key: hasStableKey ? element.atomId : `${element.nodeType}:${occurrence}`,
+                hasStableKey,
+                nodeType: element.nodeType,
+                attrs: element.attrs ?? EMPTY_ATOM_ATTRS,
+                docPos: element.docPos,
+            };
+            hasOnlyStableKeys && (hasOnlyStableKeys = hasStableKey);
+            blockInstances.push(instance);
+            instances.push(instance);
+        }
+        instanceBlocks.push(blockInstances);
+    }
+    return { instanceBlocks, instances, hasOnlyStableKeys };
+}
+function collectAtomInstances(renderBlocks, registeredTypes) {
+    return collectAtomInstanceBlocks(renderBlocks, registeredTypes).instances;
+}
+function applyRenderPatch(previousBlocks, patch) {
+    return [
+        ...previousBlocks.slice(0, patch.startIndex),
+        ...patch.renderBlocks,
+        ...previousBlocks.slice(patch.startIndex + patch.deleteCount),
+    ];
+}
+function atomSelected(selection, docPos) {
+    if (selection.type === 'all')
+        return true;
+    if (selection.type === 'node')
+        return selection.pos === docPos;
+    const { anchor, head } = selection;
+    if (anchor == null || head == null)
+        return false;
+    const [from, to] = anchor <= head ? [anchor, head] : [head, anchor];
+    return from <= docPos && docPos + 1 <= to;
+}

package/dist/atomPolicy.d.ts

@@ -0,0 +1,4 @@
+export declare const RESERVED_WIRE_NODE_TYPES: ReadonlySet<string>;
+export declare const ATOM_HTML_IDENTIFIER: RegExp;
+export declare const ATOM_HTML_DENIED_TAGS: ReadonlySet<string>;
+export declare const ATOM_HTML_DENIED_ATTRS: ReadonlySet<string>;

package/dist/atomPolicy.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATOM_HTML_DENIED_ATTRS = exports.ATOM_HTML_DENIED_TAGS = exports.ATOM_HTML_IDENTIFIER = exports.RESERVED_WIRE_NODE_TYPES = void 0;
+exports.RESERVED_WIRE_NODE_TYPES = new Set([
+    '__opaque',
+    '__opaque_json',
+    '__skip',
+]);
+exports.ATOM_HTML_IDENTIFIER = /^[a-z][a-z0-9-]*$/;
+exports.ATOM_HTML_DENIED_TAGS = new Set([
+    'script',
+    'style',
+    'iframe',
+    'object',
+    'embed',
+    'link',
+    'meta',
+    'base',
+    'title',
+    'head',
+    'html',
+    'body',
+    'form',
+    'textarea',
+    'select',
+    'option',
+    'button',
+    'area',
+    'br',
+    'col',
+    'hr',
+    'img',
+    'input',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+exports.ATOM_HTML_DENIED_ATTRS = new Set([
+    'style',
+    'srcdoc',
+    'href',
+    'src',
+    'srcset',
+    'action',
+    'formaction',
+]);

package/dist/atomUpdates.d.ts

@@ -0,0 +1,2 @@
+import type { AtomAttrsUpdate } from './atoms';
+export declare function resolveAtomAttrsUpdate(attrs: Readonly<Record<string, unknown>>, update: AtomAttrsUpdate): Record<string, unknown>;

package/dist/atomUpdates.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAtomAttrsUpdate = resolveAtomAttrsUpdate;
+const atomInstances_1 = require("./atomInstances");
+function copyJson(value, ancestors = new Set()) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value !== 'object' || ancestors.has(value) || ancestors.size > 128) {
+        throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'Atom attributes must contain finite JSON values.');
+    }
+    if (!Array.isArray(value) &&
+        Object.getPrototypeOf(value) !== Object.prototype &&
+        Object.getPrototypeOf(value) !== null) {
+        throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'Atom attributes must contain plain JSON objects.');
+    }
+    ancestors.add(value);
+    const result = Array.isArray(value)
+        ? Array.from(value, (entry) => copyJson(entry, ancestors))
+        : Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyJson(entry, ancestors)]));
+    ancestors.delete(value);
+    return Object.freeze(result);
+}
+function resolveAtomAttrsUpdate(attrs, update) {
+    let current = copyJson(attrs);
+    let patch = {};
+    for (const entry of Array.isArray(update) ? update : [update]) {
+        const value = typeof entry === 'function' ? entry(current) : entry;
+        if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+            throw new atomInstances_1.AtomUpdateAttrsError('not-applicable', 'Atom updates must return an attribute object.');
+        }
+        const partial = copyJson(value);
+        patch = { ...patch, ...partial };
+        current = Object.freeze({ ...current, ...partial });
+    }
+    return patch;
+}

package/dist/atoms.d.ts

@@ -0,0 +1,92 @@
+import type { ComponentType } from 'react';
+import type { DocumentJSON } from './NativeEditorBridge';
+import type { AttrSpec, NodeHtmlRules, NodeSpec, ResolvedDocumentSchema, SchemaDefinition } from './schemas';
+export type AtomAttrsUpdate<A = Record<string, unknown>> = Partial<A> | ((current: Readonly<A>) => Partial<A>) | readonly (Partial<A> | ((current: Readonly<A>) => Partial<A>))[];
+export interface AtomEditorActions {
+    select(): Promise<void>;
+    delete(): Promise<void>;
+    focusBefore(): Promise<void>;
+    focusAfter(): Promise<void>;
+}
+export interface AtomComponentProps<A = Record<string, unknown>> {
+    attrs: Readonly<A>;
+    selected: boolean;
+    readOnly: boolean;
+    isViewer: boolean;
+    nodeType: string;
+    updateAttrs: (update: AtomAttrsUpdate<A>) => Promise<void>;
+    interactive: boolean;
+    updatePending: boolean;
+    updateError: Error | null;
+    editor?: AtomEditorActions;
+    setActive: (active: boolean) => void;
+}
+export type AtomComponent<A = Record<string, unknown>> = ComponentType<AtomComponentProps<A>>;
+type JsonAttributeKind<T> = T extends string ? 'string' : T extends number ? 'number' : T extends boolean ? 'boolean' : T extends readonly unknown[] ? 'array' : T extends object ? 'object' : never;
+type AttributeKind<T> = unknown extends T ? AttrSpec['type'] : JsonAttributeKind<NonNullable<T>>;
+type AtomAttributeSpecs<A> = {
+    [K in keyof A]-?: Omit<AttrSpec, 'default' | 'type' | 'enum'> & {
+        default?: A[K];
+        type?: AttributeKind<A[K]>;
+        enum?: readonly A[K][];
+    };
+};
+type WidenDefault<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends readonly (infer Item)[] ? [Item] extends [never] ? unknown[] : WidenDefault<Item>[] : T extends object ? {
+    -readonly [K in keyof T]: WidenDefault<T[K]>;
+} : T;
+type HasDefault<S> = S extends {
+    default: infer D;
+} ? (undefined extends D ? false : true) : false;
+export interface AtomNodeConfig<A = Record<string, unknown>> {
+    name: string;
+    attrs?: AtomAttributeSpecs<A>;
+    html: NodeHtmlRules;
+    component: AtomComponent<A>;
+    estimatedHeight?: number;
+    idAttribute?: string;
+}
+type RequiredKeys<A> = {
+    [K in keyof A]-?: {} extends Pick<A, K> ? never : K;
+}[keyof A];
+export interface AtomNodeDefinition<A = Record<string, unknown>, Input = A> extends Readonly<AtomNodeConfig<A>> {
+    readonly nodeSpec: NodeSpec;
+    buildFragmentJson(...args: RequiredKeys<Input> extends never ? [attrs?: Input, descriptor?: Pick<ResolvedDocumentSchema, 'documentNodeName'>] : [attrs: Input, descriptor?: Pick<ResolvedDocumentSchema, 'documentNodeName'>]): DocumentJSON;
+}
+type AttrValue<S> = S extends {
+    enum: readonly (infer E)[];
+} ? E : S extends {
+    type: 'string';
+} ? string : S extends {
+    type: 'number';
+} ? number : S extends {
+    type: 'boolean';
+} ? boolean : S extends {
+    type: 'object';
+} ? Record<string, unknown> : S extends {
+    type: 'array';
+} ? unknown[] : S extends {
+    default: infer D;
+} ? WidenDefault<D> : unknown;
+export type InferAtomAttrs<S extends Record<string, AttrSpec>> = {
+    -readonly [K in keyof S]: AttrValue<S[K]>;
+};
+type AtomInput<S extends Record<string, AttrSpec>> = {
+    -readonly [K in keyof S as HasDefault<S[K]> extends true ? never : K]: AttrValue<S[K]>;
+} & {
+    -readonly [K in keyof S as HasDefault<S[K]> extends true ? K : never]?: AttrValue<S[K]>;
+};
+export interface SerializedEditorAtoms {
+    nodeTypes: string[];
+    estimatedHeights: Record<string, number>;
+}
+export declare function defineAtomNode<const S extends Record<string, AttrSpec>>(config: Omit<AtomNodeConfig<NoInfer<InferAtomAttrs<S>>>, 'attrs'> & {
+    attrs: S;
+}): AtomNodeDefinition<InferAtomAttrs<S>, AtomInput<S>> & {
+    readonly attrs: S;
+};
+export declare function defineAtomNode<A = Record<string, unknown>>(config: AtomNodeConfig<A> & (string extends keyof A ? {} : {
+    attrs: AtomAttributeSpecs<A>;
+})): AtomNodeDefinition<A, Required<A>>;
+export declare function withAtomsSchema(schema: SchemaDefinition, atoms: readonly AtomNodeDefinition<any>[]): SchemaDefinition;
+export declare function serializeEditorAtoms(atoms?: readonly AtomNodeDefinition<any>[]): string | undefined;
+export {};