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

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { RichTextEditor, type RichTextEditorProps, type RichTextEditorRef, type RichTextEditorCaretRect, type RichTextEditorHeightBehavior, type RichTextEditorToolbarPlacement, type RichTextEditorValueJSONUpdateMode, type RichTextEditorAutoCapitalize, type RichTextEditorKeyboardType, type RichTextEditorAndroidInputOptions, type RichTextEditorFocusPreservingElement, type RichTextEditorFocusPreservingRef, type RichTextEditorFocusPreservingRefs, type RemoteSelectionDecoration, type LinkRequestContext, type ImageRequestContext, NativeRichTextEditor, type NativeRichTextEditorProps, type NativeRichTextEditorRef, type NativeRichTextEditorCaretRect, type NativeRichTextEditorHeightBehavior, type NativeRichTextEditorToolbarPlacement, type NativeRichTextEditorValueJSONUpdateMode, type NativeRichTextEditorAutoCapitalize, type NativeRichTextEditorKeyboardType, type NativeRichTextEditorAndroidInputOptions, type NativeRichTextEditorFocusPreservingElement, type NativeRichTextEditorFocusPreservingRef, type NativeRichTextEditorFocusPreservingRefs, } from './NativeRichTextEditor';
+export type { ExternalTextCompositionEndCause, ExternalTextCompositionEndEvent, ExternalTextCompositionOptions, ExternalTextCompositionSession, } from './ExternalTextComposition';
+export { RichTextViewer, type RichTextViewerProps, type RichTextViewerAddons, type RichTextViewerBaseProps, type RichTextViewerMentionsConfig, type RichTextViewerLinkPressEvent, type RichTextViewerMentionPressEvent, type RichTextViewerErrorEvent, type RichTextViewerAtomAttrsUpdateEvent, NativeProseViewer, type NativeProseViewerProps, type NativeProseViewerAddons, type NativeProseViewerBaseProps, type NativeProseViewerMentionsConfig, type NativeProseViewerLinkPressEvent, type NativeProseViewerMentionPressEvent, type NativeProseViewerErrorEvent, type NativeProseViewerAtomAttrsUpdateEvent, } from './NativeProseViewer';
+export { EditorToolbar, DEFAULT_EDITOR_TOOLBAR_ITEMS, type EditorToolbarProps, type EditorToolbarItem, type EditorToolbarLeafItem, type EditorToolbarGroupChildItem, type EditorToolbarGroupItem, type EditorToolbarGroupPresentation, type EditorToolbarIcon, type EditorToolbarButtonStyle, type EditorToolbarDefaultIconId, type EditorToolbarSFSymbolIcon, type EditorToolbarMaterialIcon, type EditorToolbarCommand, type EditorToolbarHeadingLevel, type EditorToolbarListType, type EditorToolbarItemPlacement, } from './EditorToolbar';
+export type { EditorContentInsets, EditorTheme, EditorTextStyle, EditorLinkTheme, EditorHeadingTheme, EditorListTheme, EditorOrderedListNumberingScheme, EditorOrderedListMarkerTheme, EditorHorizontalRuleTheme, EditorBlockquoteTheme, EditorCodeBlockTheme, EditorMentionTheme, EditorMentionNodeTheme, EditorMentionSuggestionsTheme, EditorMentionSuggestionOptionTheme, EditorToolbarTheme, EditorToolbarAppearance, EditorFontStyle, EditorFontWeight, } from './EditorTheme';
+export { serializeEditorTheme } from './EditorTheme';
+export { EditorStyleSheet } from './EditorStyleSheet';
+export type { EditorStyleProp, EditorStyleMap, EditorTypographyStyle, EditorBorderStyle, EditorPaddingStyle, EditorMarginStyle, EditorSurfaceStyle, EditorBoxStyle, EditorInlineStyle, EditorImageStyle, EditorListStyle, EditorListMarkerStyle, EditorCheckboxAppearance, EditorTaskCheckboxStyle, EditorHorizontalRuleStyle, EditorMentionStyle, } from './EditorStyleSheetTypes';
+export { createMentionsAddon, type EditorAddon, type EditorAddonEntry, type MentionsAddon, type MentionsAddonOptions, type MentionPressEvent, type CodeHighlightingAddon, type CodeHighlightingAddonOptions, } from './EditorAddon';
+export { MENTION_NODE_NAME, mentionNodeSpec, withMentionsSchema, buildMentionFragmentJson, type EditorAddons, type MentionsAddonConfig, type MentionSuggestion, type MentionQueryChangeEvent, type MentionFragmentOptions, type MentionSelectionAttrsEvent, type MentionThemeResolveEvent, type MentionSelectEvent, type EditorAddonEvent, } from './addons';
+export { defineAtomNode, withAtomsSchema, serializeEditorAtoms, type AtomAttrsUpdate, type AtomEditorActions, type InferAtomAttrs, type AtomComponent, type AtomComponentProps, type AtomNodeConfig, type AtomNodeDefinition, type SerializedEditorAtoms, } from './atoms';
+export { AtomUpdateAttrsError, DEFAULT_ATOM_CHIP_HEIGHT, NATIVE_VOID_BLOCK_TYPES, applyRenderPatch, atomSelected, collectAtomInstances, type AtomInstance, type AtomUpdateAttrsErrorCode, } from './atomInstances';
+export { defineSchema, defaultSchema, defaultSchemaSpec, prosemirrorSchema, prosemirrorSchemaSpec, tiptapCompatibleSchema, tiptapCompatibleSchemaSpec, IMAGE_NODE_NAME, imageNodeSpec, withImagesSchema, buildDocumentFragmentJson, buildImageFragmentJson, resolveDocumentDescriptor, type ResolvedDocumentSchema, type SchemaDefinition, type SchemaSpec, type SchemaNodeSpec, type SchemaMarkSpec, type NodeSpec, type NodeHtmlRules, type NodeJSONProjection, type MarkSpec, type AttrSpec, type ParseDOMRule, type DOMOutputSpec, type AttributeDOMOutputSpec, type ImageNodeAttributes, } from './schemas';
+export { createYjsCollaborationController, useYjsCollaboration, type YjsCollaborationOptions, type YjsCollaborationState, type YjsTransportStatus, type LocalAwarenessState, type LocalAwarenessUser, type UseYjsCollaborationResult, type YjsCollaborationController, type YjsCollaborationEditorBindings, } from './YjsCollaboration';
+export { useNativeEditorDocument, type UseNativeEditorDocumentOptions, type UseNativeEditorDocumentReturn, } from './useNativeEditor';
+export type { Selection, ActiveState, ReadonlyActiveState, HistoryState, EditorUpdate, RenderBlocksPatch, NativeEditorAtomicRenderSnapshot, DocumentJSON, CollaborationPeer, } from './NativeEditorBridge';
+export { createNativeEditorDocumentHandle, createNativeEditorLocalAwarenessSelection, type NativeEditorDocumentHandle, type NativeCollaborationProtocolAdapter, type NativeCollaborationProtocolAdapterAction, type NativeCollaborationProtocolAdapterContext, type NativeCollaborationProtocolAdapterEvent, type NativeCollaborationProtocolAdapterResult, type NativeCollaborationProtocolFrame, type NativeCollaborationTransportConfig, type NativeCollaborationTransportDiagnostics, type NativeCollaborationTransportEvent, type NativeEditorLocalAwarenessIntent, type NativeEditorLocalAwarenessSelection, type NativeEditorCreateConfig, type NativeEditorState, type NativeEditorInitialization, type NativeEditorPeerInfo, type NativeEditorRoomSnapshot, type NativeEditorSnapshotMetadata, } from './NativeEditorBridge';
+export { DEFAULT_EDITOR_IMAGE_LOADING_POLICY, HARD_EDITOR_IMAGE_LOADING_POLICY, resolveEditorImageLoadingPolicy, type EditorImageLoadingPolicy, type ResolvedEditorImageLoadingPolicy, } from './ImageLoadingPolicy';
+export { DEFAULT_EDITOR_RESOURCE_LIMITS, HARD_EDITOR_RESOURCE_LIMITS, resolveEditorResourceLimits, type EditorCollaborationLimits, type EditorEditingLimits, type EditorResourceLimits, type ResolvedEditorResourceLimits, } from './ResourceLimits';
+export { NATIVE_EDITOR_BOUNDARY_ERROR_CODES, NATIVE_EDITOR_NON_RETRYABLE_CODES, NativeEditorBoundaryError, NativeEditorErrorBase, NativeEditorEngineBoundaryError, NativeEditorDocumentError, NativeEditorOperationError, NativeEditorLifecycleError, NativeEditorSnapshotError, NativeEditorTransportError, NativeEditorNonRetryableError, parseNativeBoundaryError, type NativeEditorBoundaryErrorCode, type NativeEditorErrorDomain, type NativeEditorError, } from './NativeEditorBoundaryError';
+export type { AtomViewport } from './AtomHost';

package/dist/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeEditorErrorBase = exports.NativeEditorBoundaryError = exports.NATIVE_EDITOR_NON_RETRYABLE_CODES = exports.NATIVE_EDITOR_BOUNDARY_ERROR_CODES = exports.resolveEditorResourceLimits = exports.HARD_EDITOR_RESOURCE_LIMITS = exports.DEFAULT_EDITOR_RESOURCE_LIMITS = exports.resolveEditorImageLoadingPolicy = exports.HARD_EDITOR_IMAGE_LOADING_POLICY = exports.DEFAULT_EDITOR_IMAGE_LOADING_POLICY = exports.createNativeEditorLocalAwarenessSelection = exports.createNativeEditorDocumentHandle = exports.useNativeEditorDocument = exports.useYjsCollaboration = exports.createYjsCollaborationController = exports.resolveDocumentDescriptor = exports.buildImageFragmentJson = exports.buildDocumentFragmentJson = exports.withImagesSchema = exports.imageNodeSpec = exports.IMAGE_NODE_NAME = exports.tiptapCompatibleSchemaSpec = exports.tiptapCompatibleSchema = exports.prosemirrorSchemaSpec = exports.prosemirrorSchema = exports.defaultSchemaSpec = exports.defaultSchema = exports.defineSchema = exports.collectAtomInstances = exports.atomSelected = exports.applyRenderPatch = exports.NATIVE_VOID_BLOCK_TYPES = exports.DEFAULT_ATOM_CHIP_HEIGHT = exports.AtomUpdateAttrsError = exports.serializeEditorAtoms = exports.withAtomsSchema = exports.defineAtomNode = exports.buildMentionFragmentJson = exports.withMentionsSchema = exports.mentionNodeSpec = exports.MENTION_NODE_NAME = exports.createMentionsAddon = exports.EditorStyleSheet = exports.serializeEditorTheme = exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = exports.EditorToolbar = exports.NativeProseViewer = exports.RichTextViewer = exports.NativeRichTextEditor = exports.RichTextEditor = void 0;
+exports.parseNativeBoundaryError = exports.NativeEditorNonRetryableError = exports.NativeEditorTransportError = exports.NativeEditorSnapshotError = exports.NativeEditorLifecycleError = exports.NativeEditorOperationError = exports.NativeEditorDocumentError = exports.NativeEditorEngineBoundaryError = void 0;
+var NativeRichTextEditor_1 = require("./NativeRichTextEditor");
+Object.defineProperty(exports, "RichTextEditor", { enumerable: true, get: function () { return NativeRichTextEditor_1.RichTextEditor; } });
+Object.defineProperty(exports, "NativeRichTextEditor", { enumerable: true, get: function () { return NativeRichTextEditor_1.NativeRichTextEditor; } });
+var NativeProseViewer_1 = require("./NativeProseViewer");
+Object.defineProperty(exports, "RichTextViewer", { enumerable: true, get: function () { return NativeProseViewer_1.RichTextViewer; } });
+Object.defineProperty(exports, "NativeProseViewer", { enumerable: true, get: function () { return NativeProseViewer_1.NativeProseViewer; } });
+var EditorToolbar_1 = require("./EditorToolbar");
+Object.defineProperty(exports, "EditorToolbar", { enumerable: true, get: function () { return EditorToolbar_1.EditorToolbar; } });
+Object.defineProperty(exports, "DEFAULT_EDITOR_TOOLBAR_ITEMS", { enumerable: true, get: function () { return EditorToolbar_1.DEFAULT_EDITOR_TOOLBAR_ITEMS; } });
+var EditorTheme_1 = require("./EditorTheme");
+Object.defineProperty(exports, "serializeEditorTheme", { enumerable: true, get: function () { return EditorTheme_1.serializeEditorTheme; } });
+var EditorStyleSheet_1 = require("./EditorStyleSheet");
+Object.defineProperty(exports, "EditorStyleSheet", { enumerable: true, get: function () { return EditorStyleSheet_1.EditorStyleSheet; } });
+var EditorAddon_1 = require("./EditorAddon");
+Object.defineProperty(exports, "createMentionsAddon", { enumerable: true, get: function () { return EditorAddon_1.createMentionsAddon; } });
+var addons_1 = require("./addons");
+Object.defineProperty(exports, "MENTION_NODE_NAME", { enumerable: true, get: function () { return addons_1.MENTION_NODE_NAME; } });
+Object.defineProperty(exports, "mentionNodeSpec", { enumerable: true, get: function () { return addons_1.mentionNodeSpec; } });
+Object.defineProperty(exports, "withMentionsSchema", { enumerable: true, get: function () { return addons_1.withMentionsSchema; } });
+Object.defineProperty(exports, "buildMentionFragmentJson", { enumerable: true, get: function () { return addons_1.buildMentionFragmentJson; } });
+var atoms_1 = require("./atoms");
+Object.defineProperty(exports, "defineAtomNode", { enumerable: true, get: function () { return atoms_1.defineAtomNode; } });
+Object.defineProperty(exports, "withAtomsSchema", { enumerable: true, get: function () { return atoms_1.withAtomsSchema; } });
+Object.defineProperty(exports, "serializeEditorAtoms", { enumerable: true, get: function () { return atoms_1.serializeEditorAtoms; } });
+var atomInstances_1 = require("./atomInstances");
+Object.defineProperty(exports, "AtomUpdateAttrsError", { enumerable: true, get: function () { return atomInstances_1.AtomUpdateAttrsError; } });
+Object.defineProperty(exports, "DEFAULT_ATOM_CHIP_HEIGHT", { enumerable: true, get: function () { return atomInstances_1.DEFAULT_ATOM_CHIP_HEIGHT; } });
+Object.defineProperty(exports, "NATIVE_VOID_BLOCK_TYPES", { enumerable: true, get: function () { return atomInstances_1.NATIVE_VOID_BLOCK_TYPES; } });
+Object.defineProperty(exports, "applyRenderPatch", { enumerable: true, get: function () { return atomInstances_1.applyRenderPatch; } });
+Object.defineProperty(exports, "atomSelected", { enumerable: true, get: function () { return atomInstances_1.atomSelected; } });
+Object.defineProperty(exports, "collectAtomInstances", { enumerable: true, get: function () { return atomInstances_1.collectAtomInstances; } });
+var schemas_1 = require("./schemas");
+Object.defineProperty(exports, "defineSchema", { enumerable: true, get: function () { return schemas_1.defineSchema; } });
+Object.defineProperty(exports, "defaultSchema", { enumerable: true, get: function () { return schemas_1.defaultSchema; } });
+Object.defineProperty(exports, "defaultSchemaSpec", { enumerable: true, get: function () { return schemas_1.defaultSchemaSpec; } });
+Object.defineProperty(exports, "prosemirrorSchema", { enumerable: true, get: function () { return schemas_1.prosemirrorSchema; } });
+Object.defineProperty(exports, "prosemirrorSchemaSpec", { enumerable: true, get: function () { return schemas_1.prosemirrorSchemaSpec; } });
+Object.defineProperty(exports, "tiptapCompatibleSchema", { enumerable: true, get: function () { return schemas_1.tiptapCompatibleSchema; } });
+Object.defineProperty(exports, "tiptapCompatibleSchemaSpec", { enumerable: true, get: function () { return schemas_1.tiptapCompatibleSchemaSpec; } });
+Object.defineProperty(exports, "IMAGE_NODE_NAME", { enumerable: true, get: function () { return schemas_1.IMAGE_NODE_NAME; } });
+Object.defineProperty(exports, "imageNodeSpec", { enumerable: true, get: function () { return schemas_1.imageNodeSpec; } });
+Object.defineProperty(exports, "withImagesSchema", { enumerable: true, get: function () { return schemas_1.withImagesSchema; } });
+Object.defineProperty(exports, "buildDocumentFragmentJson", { enumerable: true, get: function () { return schemas_1.buildDocumentFragmentJson; } });
+Object.defineProperty(exports, "buildImageFragmentJson", { enumerable: true, get: function () { return schemas_1.buildImageFragmentJson; } });
+Object.defineProperty(exports, "resolveDocumentDescriptor", { enumerable: true, get: function () { return schemas_1.resolveDocumentDescriptor; } });
+var YjsCollaboration_1 = require("./YjsCollaboration");
+Object.defineProperty(exports, "createYjsCollaborationController", { enumerable: true, get: function () { return YjsCollaboration_1.createYjsCollaborationController; } });
+Object.defineProperty(exports, "useYjsCollaboration", { enumerable: true, get: function () { return YjsCollaboration_1.useYjsCollaboration; } });
+var useNativeEditor_1 = require("./useNativeEditor");
+Object.defineProperty(exports, "useNativeEditorDocument", { enumerable: true, get: function () { return useNativeEditor_1.useNativeEditorDocument; } });
+var NativeEditorBridge_1 = require("./NativeEditorBridge");
+Object.defineProperty(exports, "createNativeEditorDocumentHandle", { enumerable: true, get: function () { return NativeEditorBridge_1.createNativeEditorDocumentHandle; } });
+Object.defineProperty(exports, "createNativeEditorLocalAwarenessSelection", { enumerable: true, get: function () { return NativeEditorBridge_1.createNativeEditorLocalAwarenessSelection; } });
+var ImageLoadingPolicy_1 = require("./ImageLoadingPolicy");
+Object.defineProperty(exports, "DEFAULT_EDITOR_IMAGE_LOADING_POLICY", { enumerable: true, get: function () { return ImageLoadingPolicy_1.DEFAULT_EDITOR_IMAGE_LOADING_POLICY; } });
+Object.defineProperty(exports, "HARD_EDITOR_IMAGE_LOADING_POLICY", { enumerable: true, get: function () { return ImageLoadingPolicy_1.HARD_EDITOR_IMAGE_LOADING_POLICY; } });
+Object.defineProperty(exports, "resolveEditorImageLoadingPolicy", { enumerable: true, get: function () { return ImageLoadingPolicy_1.resolveEditorImageLoadingPolicy; } });
+var ResourceLimits_1 = require("./ResourceLimits");
+Object.defineProperty(exports, "DEFAULT_EDITOR_RESOURCE_LIMITS", { enumerable: true, get: function () { return ResourceLimits_1.DEFAULT_EDITOR_RESOURCE_LIMITS; } });
+Object.defineProperty(exports, "HARD_EDITOR_RESOURCE_LIMITS", { enumerable: true, get: function () { return ResourceLimits_1.HARD_EDITOR_RESOURCE_LIMITS; } });
+Object.defineProperty(exports, "resolveEditorResourceLimits", { enumerable: true, get: function () { return ResourceLimits_1.resolveEditorResourceLimits; } });
+var NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+Object.defineProperty(exports, "NATIVE_EDITOR_BOUNDARY_ERROR_CODES", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NATIVE_EDITOR_BOUNDARY_ERROR_CODES; } });
+Object.defineProperty(exports, "NATIVE_EDITOR_NON_RETRYABLE_CODES", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NATIVE_EDITOR_NON_RETRYABLE_CODES; } });
+Object.defineProperty(exports, "NativeEditorBoundaryError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorBoundaryError; } });
+Object.defineProperty(exports, "NativeEditorErrorBase", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorErrorBase; } });
+Object.defineProperty(exports, "NativeEditorEngineBoundaryError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorEngineBoundaryError; } });
+Object.defineProperty(exports, "NativeEditorDocumentError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorDocumentError; } });
+Object.defineProperty(exports, "NativeEditorOperationError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorOperationError; } });
+Object.defineProperty(exports, "NativeEditorLifecycleError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorLifecycleError; } });
+Object.defineProperty(exports, "NativeEditorSnapshotError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorSnapshotError; } });
+Object.defineProperty(exports, "NativeEditorTransportError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorTransportError; } });
+Object.defineProperty(exports, "NativeEditorNonRetryableError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.NativeEditorNonRetryableError; } });
+Object.defineProperty(exports, "parseNativeBoundaryError", { enumerable: true, get: function () { return NativeEditorBoundaryError_1.parseNativeBoundaryError; } });

package/dist/listMarkers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rendered list-marker strings.
+ *
+ * CROSS-LAYER CONTRACT: these values must match the Rust core
+ * (rust/editor-core/src/render/mod.rs: task_list_marker_string /
+ * list_marker_string — pinned by marker_strings_are_the_cross_layer_contract
+ * in render_test.rs), Android (LayoutConstants.TASK_LIST_MARKER_* /
+ * UNORDERED_LIST_BULLET), and iOS (RenderBridge.listMarkerString). The
+ * marker's scalar length feeds position mapping; a mismatch corrupts
+ * selection and IME edits.
+ */
+export declare const TASK_LIST_MARKER_CHECKED = "\u2611 ";
+export declare const TASK_LIST_MARKER_UNCHECKED = "\u2610 ";
+export declare const UNORDERED_LIST_MARKER = "\u2022 ";
+export declare function orderedListMarker(index: number): string;

package/dist/listMarkers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNORDERED_LIST_MARKER = exports.TASK_LIST_MARKER_UNCHECKED = exports.TASK_LIST_MARKER_CHECKED = void 0;
+exports.orderedListMarker = orderedListMarker;
+/**
+ * Rendered list-marker strings.
+ *
+ * CROSS-LAYER CONTRACT: these values must match the Rust core
+ * (rust/editor-core/src/render/mod.rs: task_list_marker_string /
+ * list_marker_string — pinned by marker_strings_are_the_cross_layer_contract
+ * in render_test.rs), Android (LayoutConstants.TASK_LIST_MARKER_* /
+ * UNORDERED_LIST_BULLET), and iOS (RenderBridge.listMarkerString). The
+ * marker's scalar length feeds position mapping; a mismatch corrupts
+ * selection and IME edits.
+ */
+exports.TASK_LIST_MARKER_CHECKED = '☑ ';
+exports.TASK_LIST_MARKER_UNCHECKED = '☐ ';
+exports.UNORDERED_LIST_MARKER = '• ';
+function orderedListMarker(index) {
+    return `${index}. `;
+}

package/dist/schemaDefinition.d.ts

@@ -0,0 +1,143 @@
+import { type AtomNodeDefinition } from './atoms';
+/** Declaration of one node or mark attribute. */
+export interface AttrSpec {
+    /** Value used when the attribute is absent. Omit to make the attribute required. */
+    default?: unknown;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    enum?: readonly unknown[];
+    min?: number;
+    max?: number;
+}
+/** Static DOM output supported by the native HTML serializer. */
+export type DOMOutputSpec = readonly [tag: string] | readonly [tag: string, content: 0];
+/** Declarative DOM rule supported by the native HTML parser. */
+export interface ParseDOMRule {
+    tag: string;
+    attrs?: Record<string, unknown>;
+}
+/** Select a DOM output from one declared node attribute. */
+export interface AttributeDOMOutputSpec {
+    switchOn: string;
+    cases: Readonly<Record<string, DOMOutputSpec>>;
+}
+/** JSON representation projected from one native node variant. */
+export interface NodeJSONProjection {
+    type: string;
+    attrs?: Record<string, unknown>;
+}
+/** Declarative HTML parsing and serialization rules for a void node. */
+export interface NodeHtmlRules {
+    tag: string;
+    staticAttrs?: Record<string, string>;
+    attrMap?: Record<string, string>;
+}
+/** Declaration of one node type in a {@link SchemaDefinition}. */
+export interface NodeSpec {
+    /** Native node type name. `json` may expose a different public document type. */
+    name: string;
+    /** ProseMirror-style content expression, e.g. `'block+'`, `'inline*'`, or `''` for a leaf. */
+    content: string;
+    /** Content group this node belongs to, e.g. `'block'` or `'inline'`. */
+    group?: string;
+    /** Attributes this node declares. Undeclared attributes are filtered out on
+     *  ingestion unless `allowUndeclaredAttrs` is set. */
+    attrs?: Record<string, AttrSpec>;
+    /**
+     * How the engine treats this node: `'doc'`, `'textBlock'`, `'list'`,
+     * `'listItem'`, `'text'`, `'hardBreak'`, `'inline'`, or `'block'`. Any
+     * unrecognized value is treated as `'block'`. Exactly one node must use
+     * `'doc'`. An ordered list is a `'list'` node whose name contains
+     * `ordered`.
+     */
+    role: string;
+    /** Tag used when serializing this node to HTML. */
+    htmlTag?: string;
+    /** Declarative HTML rules used for lossless void-node round trips. */
+    html?: NodeHtmlRules;
+    /** Whether the node holds no content of its own (an image or rule, say). */
+    isVoid?: boolean;
+    /** Whether collapsed backspace may remove this void block from an adjacent caret. */
+    deletableOnBackspace?: boolean;
+    /**
+     * Opt-in escape hatch: when `true`, JSON ingestion (`set_json` /
+     * `insert_content_json`) admits attrs on this node that are not declared
+     * in `attrs`, instead of filtering them out. Default `false`. Intended
+     * for node types with an intentional pass-through-metadata contract
+     * (e.g. the mention node — see `mentionNodeSpec()` in addons.ts).
+     */
+    allowUndeclaredAttrs?: boolean;
+    /** Public JSON representation when it differs from the native node name. */
+    json?: NodeJSONProjection;
+}
+/** Declaration of one mark type in a {@link SchemaDefinition}. */
+export interface MarkSpec {
+    /** Mark type name, as it appears in document JSON. */
+    name: string;
+    /** Attributes this mark declares. */
+    attrs?: Record<string, AttrSpec>;
+    /** Mark names that cannot coexist with this one on the same text range. */
+    excludes?: string;
+    /**
+     * Serializer tag for a custom mark. Native accepts only the inert allowlist:
+     * span, strong, em, u, s, code, a, sub, sup, mark.
+     */
+    htmlTag?: 'span' | 'strong' | 'em' | 'u' | 's' | 'code' | 'a' | 'sub' | 'sup' | 'mark';
+    /**
+     * Opt-in escape hatch: when `true`, JSON ingestion (`set_json` /
+     * `insert_content_json`) admits attrs on this mark that are not declared
+     * in `attrs`, instead of filtering them out. Default `false`. Mirrors
+     * `NodeSpec.allowUndeclaredAttrs` for mark types with an intentional
+     * pass-through-metadata contract.
+     */
+    allowUndeclaredAttrs?: boolean;
+}
+/**
+ * The node and mark types a document may contain. Fixed when the document
+ * handle is created (`NativeEditorCreateConfig.schema`), or per render for
+ * `RichTextViewer`. Start from {@link defaultSchema},
+ * {@link prosemirrorSchema}, or {@link tiptapCompatibleSchema} rather than
+ * assembling one from scratch.
+ */
+export interface SchemaDefinition {
+    /** Node types. Exactly one must have `role: 'doc'`. */
+    nodes: NodeSpec[];
+    /** Mark types. */
+    marks: MarkSpec[];
+}
+/** Keyed node declaration accepted by {@link defineSchema}. */
+export interface SchemaNodeSpec {
+    content?: string;
+    group?: string;
+    attrs?: Record<string, AttrSpec>;
+    /** Native semantic role. Common `doc`, `paragraph`, and `text` shapes are inferred. */
+    role?: NodeSpec['role'] | 'heading';
+    parseDOM?: readonly ParseDOMRule[];
+    toDOM?: DOMOutputSpec | AttributeDOMOutputSpec;
+    html?: NodeHtmlRules;
+    isVoid?: boolean;
+    deletableOnBackspace?: boolean;
+    allowUndeclaredAttrs?: boolean;
+}
+/** Keyed mark declaration accepted by {@link defineSchema}. */
+export interface SchemaMarkSpec {
+    attrs?: Record<string, AttrSpec>;
+    excludes?: string;
+    parseDOM?: readonly ParseDOMRule[];
+    toDOM?: DOMOutputSpec;
+    allowUndeclaredAttrs?: boolean;
+}
+/** ProseMirror-shaped authoring schema compiled for the native engine. */
+export interface SchemaSpec {
+    nodes: Readonly<Record<string, SchemaNodeSpec>>;
+    marks?: Readonly<Record<string, SchemaMarkSpec>>;
+    atoms?: readonly AtomNodeDefinition<any>[];
+}
+export declare const ALLOWED_MARK_HTML_TAGS: Set<string>;
+export declare function outputTag(spec: DOMOutputSpec): string;
+export declare function appendGroup(group: string | undefined, name: string): string;
+export declare function schemaNodeRole(name: string, node: SchemaNodeSpec): string;
+export declare function caseAttributeValue(key: string, attribute: string, tag: string, parseDOM: readonly ParseDOMRule[] | undefined, defaultValue: unknown): unknown;
+export declare function validateAttributeDOMRules(name: string, switched: AttributeDOMOutputSpec, parseDOM: readonly ParseDOMRule[] | undefined, defaultValue: unknown): void;
+export declare function staticDOMTag(kind: 'node' | 'mark', name: string, parseDOM: readonly ParseDOMRule[] | undefined, toDOM: DOMOutputSpec | undefined): string | undefined;
+/** Compile a keyed, ProseMirror-shaped schema into the serializable native form. */
+export declare function defineSchema(spec: SchemaSpec): SchemaDefinition;

package/dist/schemaDefinition.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_MARK_HTML_TAGS = void 0;
+exports.outputTag = outputTag;
+exports.appendGroup = appendGroup;
+exports.schemaNodeRole = schemaNodeRole;
+exports.caseAttributeValue = caseAttributeValue;
+exports.validateAttributeDOMRules = validateAttributeDOMRules;
+exports.staticDOMTag = staticDOMTag;
+exports.defineSchema = defineSchema;
+const atoms_1 = require("./atoms");
+const atomPolicy_1 = require("./atomPolicy");
+exports.ALLOWED_MARK_HTML_TAGS = new Set([
+    'span',
+    'strong',
+    'em',
+    'u',
+    's',
+    'code',
+    'a',
+    'sub',
+    'sup',
+    'mark',
+]);
+function outputTag(spec) {
+    return spec[0];
+}
+function appendGroup(group, name) {
+    const groups = group?.split(/\s+/).filter(Boolean) ?? [];
+    if (!groups.includes(name))
+        groups.push(name);
+    return groups.join(' ');
+}
+function schemaNodeRole(name, node) {
+    if (node.role != null)
+        return node.role === 'heading' ? 'textBlock' : node.role;
+    if (name === 'doc')
+        return 'doc';
+    if (name === 'text')
+        return 'text';
+    if (node.content === 'inline*' && node.group?.split(/\s+/).includes('block')) {
+        return 'textBlock';
+    }
+    if (node.group?.split(/\s+/).includes('inline'))
+        return 'inline';
+    return 'block';
+}
+function caseAttributeValue(key, attribute, tag, parseDOM, defaultValue) {
+    const rule = parseDOM?.find((candidate) => candidate.tag === tag &&
+        candidate.attrs != null &&
+        String(candidate.attrs[attribute]) === key);
+    if (rule?.attrs && Object.prototype.hasOwnProperty.call(rule.attrs, attribute)) {
+        return rule.attrs[attribute];
+    }
+    if (typeof defaultValue === 'number')
+        return Number(key);
+    if (typeof defaultValue === 'boolean')
+        return key === 'true';
+    return key;
+}
+function validateAttributeDOMRules(name, switched, parseDOM, defaultValue) {
+    const cases = Object.entries(switched.cases);
+    let discriminatorType = typeof defaultValue === 'string' ||
+        typeof defaultValue === 'number' ||
+        typeof defaultValue === 'boolean'
+        ? typeof defaultValue
+        : undefined;
+    if (discriminatorType == null && parseDOM != null) {
+        const parsedTypes = parseDOM.map((rule) => {
+            const value = rule.attrs?.[switched.switchOn];
+            return typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean'
+                ? typeof value
+                : undefined;
+        });
+        const firstType = parsedTypes[0];
+        if (firstType != null && parsedTypes.every((type) => type === firstType)) {
+            discriminatorType = firstType;
+        }
+    }
+    if (discriminatorType == null) {
+        throw new Error(`node '${name}' DOM discriminator '${switched.switchOn}' must have a scalar type`);
+    }
+    if (parseDOM == null) {
+        const validCases = cases.every(([caseKey]) => {
+            if (discriminatorType === 'number') {
+                return /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(caseKey);
+            }
+            return discriminatorType !== 'boolean' || caseKey === 'true' || caseKey === 'false';
+        });
+        if (!validCases) {
+            throw new Error(`node '${name}' DOM discriminator '${switched.switchOn}' must use ${discriminatorType} values`);
+        }
+        return;
+    }
+    const matchesCase = ([caseKey, output]) => parseDOM.filter((rule) => rule.tag === outputTag(output) &&
+        rule.attrs != null &&
+        Object.prototype.hasOwnProperty.call(rule.attrs, switched.switchOn) &&
+        String(rule.attrs[switched.switchOn]) === caseKey).length === 1;
+    if (parseDOM.length !== cases.length || !cases.every(matchesCase)) {
+        throw new Error(`node '${name}' DOM parse rules must map one-to-one with '${switched.switchOn}' output cases`);
+    }
+    if (discriminatorType != null &&
+        parseDOM.some((rule) => rule.attrs != null && typeof rule.attrs[switched.switchOn] !== discriminatorType)) {
+        throw new Error(`node '${name}' DOM discriminator '${switched.switchOn}' must use ${discriminatorType} values`);
+    }
+}
+function staticDOMTag(kind, name, parseDOM, toDOM) {
+    if ((parseDOM?.length ?? 0) > 1) {
+        throw new Error(`${kind} '${name}' has multiple static DOM parse rules`);
+    }
+    const parsed = parseDOM?.[0]?.tag;
+    const serialized = toDOM == null ? undefined : outputTag(toDOM);
+    if (parsed != null && serialized != null && parsed !== serialized) {
+        throw new Error(`${kind} '${name}' parses '${parsed}' but serializes '${serialized}'`);
+    }
+    return serialized ?? parsed;
+}
+/** Compile a keyed, ProseMirror-shaped schema into the serializable native form. */
+function defineSchema(spec) {
+    const nodes = [];
+    const names = new Set();
+    for (const [name, node] of Object.entries(spec.nodes)) {
+        const common = {
+            content: node.content ?? '',
+            ...(node.group == null ? {} : { group: node.group }),
+            ...(node.attrs == null ? {} : { attrs: node.attrs }),
+            role: schemaNodeRole(name, node),
+            ...(node.html == null ? {} : { html: node.html }),
+            ...(node.isVoid == null ? {} : { isVoid: node.isVoid }),
+            ...(node.deletableOnBackspace == null
+                ? {}
+                : { deletableOnBackspace: node.deletableOnBackspace }),
+            ...(node.allowUndeclaredAttrs == null
+                ? {}
+                : { allowUndeclaredAttrs: node.allowUndeclaredAttrs }),
+        };
+        if (node.toDOM != null && !Array.isArray(node.toDOM)) {
+            const switched = node.toDOM;
+            if (atomPolicy_1.RESERVED_WIRE_NODE_TYPES.has(name)) {
+                throw new Error(`node '${name}' uses a reserved wire projection type`);
+            }
+            if (node.attrs == null ||
+                !Object.prototype.hasOwnProperty.call(node.attrs, switched.switchOn)) {
+                throw new Error(`node '${name}' switches on undeclared attribute '${switched.switchOn}'`);
+            }
+            if (Object.keys(switched.cases).length === 0) {
+                throw new Error(`node '${name}' has no DOM output cases`);
+            }
+            const discriminatorDefault = node.attrs[switched.switchOn]?.default;
+            validateAttributeDOMRules(name, switched, node.parseDOM, discriminatorDefault);
+            const { attrs: _attrs, ...variantCommon } = common;
+            for (const [caseKey, output] of Object.entries(switched.cases)) {
+                const tag = outputTag(output);
+                if (names.has(tag))
+                    throw new Error(`schema produces duplicate native node '${tag}'`);
+                names.add(tag);
+                const { [switched.switchOn]: _discriminator, ...variantAttrs } = node.attrs ?? {};
+                nodes.push({
+                    name: tag,
+                    ...variantCommon,
+                    group: appendGroup(node.group, name),
+                    ...(Object.keys(variantAttrs).length === 0 ? {} : { attrs: variantAttrs }),
+                    htmlTag: tag,
+                    json: {
+                        type: name,
+                        attrs: {
+                            [switched.switchOn]: caseAttributeValue(caseKey, switched.switchOn, tag, node.parseDOM, discriminatorDefault),
+                        },
+                    },
+                });
+            }
+            continue;
+        }
+        if (names.has(name))
+            throw new Error(`schema produces duplicate native node '${name}'`);
+        names.add(name);
+        const tag = staticDOMTag('node', name, node.parseDOM, node.toDOM);
+        nodes.push({
+            name,
+            ...common,
+            ...(tag == null ? {} : { htmlTag: tag }),
+        });
+    }
+    const marks = Object.entries(spec.marks ?? {}).map(([name, mark]) => {
+        const tag = staticDOMTag('mark', name, mark.parseDOM, mark.toDOM);
+        const normalizedTag = tag?.toLowerCase();
+        if (normalizedTag != null && !exports.ALLOWED_MARK_HTML_TAGS.has(normalizedTag)) {
+            throw new Error(`mark '${name}' has disallowed HTML tag '${tag}'`);
+        }
+        return {
+            name,
+            ...(mark.attrs == null ? {} : { attrs: mark.attrs }),
+            ...(mark.excludes == null ? {} : { excludes: mark.excludes }),
+            ...(normalizedTag == null ? {} : { htmlTag: normalizedTag }),
+            ...(mark.allowUndeclaredAttrs == null
+                ? {}
+                : { allowUndeclaredAttrs: mark.allowUndeclaredAttrs }),
+        };
+    });
+    const schema = { nodes, marks };
+    return spec.atoms == null || spec.atoms.length === 0
+        ? schema
+        : (0, atoms_1.withAtomsSchema)(schema, spec.atoms);
+}

package/dist/schemaDocument.d.ts

@@ -0,0 +1,17 @@
+import type { DocumentJSON } from './NativeEditorBridge';
+import type { SchemaDefinition } from './schemaDefinition';
+import { type DocumentDescriptorLimits, type ResolvedDocumentSchema } from './schemaPresets';
+export declare function defaultEmptyDocument(schema?: SchemaDefinition, limits?: DocumentDescriptorLimits): DocumentJSON;
+/**
+ * Validate a schema and derive its document node name and empty document,
+ * mirroring what the Rust core does when a handle is created. Use it to build
+ * fragments or empty documents for a custom schema.
+ *
+ * @param schema Defaults to {@link defaultSchema}.
+ * @param limits Schema and document bounds. Defaults to
+ * {@link DEFAULT_EDITOR_RESOURCE_LIMITS}.
+ * @throws NativeEditorBoundaryError `SCHEMA_INVALID` when the schema is
+ * malformed, exceeds its limits, or declares no `role: 'doc'` node.
+ */
+export declare function resolveDocumentDescriptor(schema?: SchemaDefinition, limits?: DocumentDescriptorLimits): ResolvedDocumentSchema;
+export declare function normalizeDocumentJson(doc: DocumentJSON, schemaOrDescriptor?: SchemaDefinition | ResolvedDocumentSchema, limits?: DocumentDescriptorLimits): DocumentJSON;

package/dist/schemaDocument.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultEmptyDocument = defaultEmptyDocument;
+exports.resolveDocumentDescriptor = resolveDocumentDescriptor;
+exports.normalizeDocumentJson = normalizeDocumentJson;
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+const schemaNormalization_1 = require("./schemaNormalization");
+const schemaDocumentConstruction_1 = require("./schemaDocumentConstruction");
+const schemaResolution_1 = require("./schemaResolution");
+const schemaPresets_1 = require("./schemaPresets");
+function defaultEmptyDocument(schema = schemaPresets_1.defaultSchema, limits) {
+    const resolvedLimits = (0, schemaResolution_1.resolveDescriptorLimits)(limits);
+    if (schema.nodes.length > resolvedLimits.maxSchemaNodes) {
+        throw (0, schemaNormalization_1.schemaBoundaryError)(resolvedLimits.maxSchemaNodes, schema.nodes.length);
+    }
+    let expressionBytes = 0;
+    for (const node of schema.nodes) {
+        if (node != null && typeof node.content === 'string') {
+            expressionBytes += (0, schemaNormalization_1.utf8ByteLengthUpTo)(node.content, resolvedLimits.maxSchemaExpressionBytes - expressionBytes);
+            if (expressionBytes > resolvedLimits.maxSchemaExpressionBytes) {
+                throw (0, schemaNormalization_1.schemaBoundaryError)(resolvedLimits.maxSchemaExpressionBytes, expressionBytes);
+            }
+        }
+    }
+    const admissionBudget = (0, schemaResolution_1.createSchemaWorkBudget)(resolvedLimits);
+    const admittedCollections = (0, schemaResolution_1.admitSchemaCollections)(schema, admissionBudget);
+    if (admittedCollections == null) {
+        throw new Error('schema cannot construct a default document: invalid schema collections');
+    }
+    return (0, schemaDocumentConstruction_1.constructDefaultEmptyDocument)(schema, resolvedLimits, admittedCollections);
+}
+/**
+ * Validate a schema and derive its document node name and empty document,
+ * mirroring what the Rust core does when a handle is created. Use it to build
+ * fragments or empty documents for a custom schema.
+ *
+ * @param schema Defaults to {@link defaultSchema}.
+ * @param limits Schema and document bounds. Defaults to
+ * {@link DEFAULT_EDITOR_RESOURCE_LIMITS}.
+ * @throws NativeEditorBoundaryError `SCHEMA_INVALID` when the schema is
+ * malformed, exceeds its limits, or declares no `role: 'doc'` node.
+ */
+function resolveDocumentDescriptor(schema, limits) {
+    const resolvedLimits = (0, schemaResolution_1.resolveDescriptorLimits)(limits);
+    const resolvedSchema = (0, schemaResolution_1.resolveDocumentSchema)(schema, resolvedLimits);
+    const documentNode = resolvedSchema.nodes.find((node) => node.role === 'doc');
+    if (!documentNode) {
+        throw new NativeEditorBoundaryError_1.NativeEditorBoundaryError('SCHEMA_INVALID', 'schema has no document-role node');
+    }
+    return {
+        schema: resolvedSchema,
+        documentNodeName: documentNode.name,
+        emptyDocument: defaultEmptyDocument(resolvedSchema, resolvedLimits),
+    };
+}
+function normalizeDocumentJson(doc, schemaOrDescriptor = schemaPresets_1.defaultSchema, limits) {
+    const descriptor = 'documentNodeName' in schemaOrDescriptor
+        ? schemaOrDescriptor
+        : resolveDocumentDescriptor(schemaOrDescriptor, limits);
+    const root = doc;
+    if (root?.type !== descriptor.documentNodeName) {
+        return doc;
+    }
+    const content = root?.content;
+    if (Array.isArray(content) && content.length > 0) {
+        return doc;
+    }
+    return descriptor.emptyDocument;
+}

package/dist/schemaDocumentConstruction.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedEditorResourceLimits } from './ResourceLimits';
+import type { DocumentJSON } from './NativeEditorBridge';
+import type { SchemaDefinition } from './schemaDefinition';
+import { type AdmittedSchemaCollections } from './schemaNormalization';
+export declare function constructDefaultEmptyDocument(schema: SchemaDefinition, resolvedLimits: ResolvedEditorResourceLimits, admittedCollections: AdmittedSchemaCollections): DocumentJSON;