@openeditor/react-native-prose-editor 0.0.2

package/dist/addons.d.ts

@@ -0,0 +1,100 @@
+import type { EditorMentionTheme } from './EditorTheme';
+import type { DocumentJSON } from './NativeEditorBridge';
+import type { SchemaDefinition, NodeSpec } from './schemas';
+export interface MentionSuggestion {
+    key: string;
+    title: string;
+    subtitle?: string;
+    label?: string;
+    attrs?: Record<string, unknown>;
+}
+export interface MentionQueryChangeEvent {
+    query: string;
+    trigger: string;
+    range: {
+        anchor: number;
+        head: number;
+    };
+    isActive: boolean;
+    documentVersion?: number;
+}
+export interface MentionSelectEvent {
+    trigger: string;
+    suggestion: MentionSuggestion;
+    attrs: Record<string, unknown>;
+    documentVersion?: number;
+}
+export interface MentionSelectionAttrsEvent {
+    trigger: string;
+    suggestion: MentionSuggestion;
+    attrs: Record<string, unknown>;
+    range: {
+        anchor: number;
+        head: number;
+    };
+    documentVersion?: number;
+}
+export type MentionThemeResolveEvent = MentionSelectionAttrsEvent;
+export interface MentionsAddonConfig {
+    trigger?: string;
+    suggestions?: readonly MentionSuggestion[];
+    theme?: EditorMentionTheme;
+    resolveSelectionAttrs?: (event: MentionSelectionAttrsEvent) => Record<string, unknown> | null | undefined;
+    resolveTheme?: (event: MentionThemeResolveEvent) => EditorMentionTheme | null | undefined;
+    onQueryChange?: (event: MentionQueryChangeEvent) => void;
+    onSelect?: (event: MentionSelectEvent) => void;
+}
+export interface EditorAddons {
+    mentions?: MentionsAddonConfig;
+}
+export interface SerializedMentionSuggestion {
+    key: string;
+    title: string;
+    subtitle?: string;
+    label: string;
+    attrs: Record<string, unknown>;
+}
+export interface SerializedMentionsAddonConfig {
+    trigger: string;
+    theme?: EditorMentionTheme;
+    resolveSelectionAttrs?: boolean;
+    resolveTheme?: boolean;
+    suggestions: SerializedMentionSuggestion[];
+}
+export interface SerializedEditorAddons {
+    mentions?: SerializedMentionsAddonConfig;
+}
+export type EditorAddonEvent = {
+    type: 'mentionsQueryChange';
+    query: string;
+    trigger: string;
+    range: {
+        anchor: number;
+        head: number;
+    };
+    isActive: boolean;
+    documentVersion?: number;
+} | {
+    type: 'mentionsSelectRequest';
+    trigger: string;
+    suggestionKey: string;
+    attrs: Record<string, unknown>;
+    range: {
+        anchor: number;
+        head: number;
+    };
+    documentVersion?: number;
+    updateJson?: string;
+} | {
+    type: 'mentionsSelect';
+    trigger: string;
+    suggestionKey: string;
+    attrs: Record<string, unknown>;
+    documentVersion?: number;
+};
+export declare const MENTION_NODE_NAME = "mention";
+export declare function mentionNodeSpec(): NodeSpec;
+export declare function withMentionsSchema(schema: SchemaDefinition): SchemaDefinition;
+export declare function normalizeEditorAddons(addons?: EditorAddons): SerializedEditorAddons | undefined;
+export declare function serializeEditorAddons(addons?: EditorAddons): string | undefined;
+export declare function buildMentionFragmentJson(attrs: Record<string, unknown>): DocumentJSON;

package/dist/addons.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MENTION_NODE_NAME = void 0;
+exports.mentionNodeSpec = mentionNodeSpec;
+exports.withMentionsSchema = withMentionsSchema;
+exports.normalizeEditorAddons = normalizeEditorAddons;
+exports.serializeEditorAddons = serializeEditorAddons;
+exports.buildMentionFragmentJson = buildMentionFragmentJson;
+exports.MENTION_NODE_NAME = 'mention';
+const DEFAULT_MENTION_TRIGGER = '@';
+function mentionNodeSpec() {
+    return {
+        name: exports.MENTION_NODE_NAME,
+        content: '',
+        group: 'inline',
+        role: 'inline',
+        isVoid: true,
+        attrs: {
+            label: { default: null },
+        },
+    };
+}
+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 normalizeEditorAddons(addons) {
+    if (!addons?.mentions) {
+        return undefined;
+    }
+    const trigger = addons.mentions.trigger?.trim() || DEFAULT_MENTION_TRIGGER;
+    const suggestions = (addons.mentions.suggestions ?? []).map((suggestion) => {
+        const label = suggestion.label?.trim() || `${trigger}${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: addons.mentions.theme,
+            ...(typeof addons.mentions.resolveSelectionAttrs === 'function'
+                ? { resolveSelectionAttrs: true }
+                : {}),
+            ...(typeof addons.mentions.resolveTheme === 'function' ? { resolveTheme: true } : {}),
+            suggestions,
+        },
+    };
+}
+function serializeEditorAddons(addons) {
+    const normalized = normalizeEditorAddons(addons);
+    if (!normalized?.mentions) {
+        return undefined;
+    }
+    return JSON.stringify(normalized);
+}
+function buildMentionFragmentJson(attrs) {
+    return {
+        type: 'doc',
+        content: [
+            {
+                type: exports.MENTION_NODE_NAME,
+                attrs,
+            },
+        ],
+    };
+}

package/dist/heightCache.d.ts

@@ -0,0 +1,6 @@
+export declare const MAX_CACHE_SIZE = 500;
+export declare function computeRenderJsonHash(input: string): number;
+export declare function computeLayoutContextKey(themeJson: string | undefined, containerWidth: number): string;
+export declare function getHeightCache(contentId: string, layoutContextKey: string, renderJsonHash: number): number | null;
+export declare function setHeightCache(contentId: string, layoutContextKey: string, renderJsonHash: number, height: number): void;
+export declare function clearHeightCache(): void;

package/dist/heightCache.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CACHE_SIZE = void 0;
+exports.computeRenderJsonHash = computeRenderJsonHash;
+exports.computeLayoutContextKey = computeLayoutContextKey;
+exports.getHeightCache = getHeightCache;
+exports.setHeightCache = setHeightCache;
+exports.clearHeightCache = clearHeightCache;
+exports.MAX_CACHE_SIZE = 500;
+const cache = new Map();
+function computeRenderJsonHash(input) {
+    let hash = 5381;
+    for (let i = 0; i < input.length; i++) {
+        hash = ((hash << 5) + hash + input.charCodeAt(i)) | 0;
+    }
+    return hash >>> 0;
+}
+function computeLayoutContextKey(themeJson, containerWidth) {
+    return `${themeJson ?? ''}\x00${containerWidth}`;
+}
+function getHeightCache(contentId, layoutContextKey, renderJsonHash) {
+    const entry = cache.get(contentId);
+    if (!entry)
+        return null;
+    if (entry.layoutContextKey !== layoutContextKey ||
+        entry.renderJsonHash !== renderJsonHash) {
+        return null;
+    }
+    cache.delete(contentId);
+    cache.set(contentId, entry);
+    return entry.height;
+}
+function setHeightCache(contentId, layoutContextKey, renderJsonHash, height) {
+    cache.delete(contentId);
+    if (cache.size >= exports.MAX_CACHE_SIZE) {
+        const oldestKey = cache.keys().next().value;
+        if (oldestKey !== undefined) {
+            cache.delete(oldestKey);
+        }
+    }
+    cache.set(contentId, { height, renderJsonHash, layoutContextKey });
+}
+function clearHeightCache() {
+    cache.clear();
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { NativeRichTextEditor, type NativeRichTextEditorProps, type NativeRichTextEditorRef, type NativeRichTextEditorCaretRect, type NativeRichTextEditorHeightBehavior, type NativeRichTextEditorToolbarPlacement, type NativeRichTextEditorValueJSONUpdateMode, type NativeRichTextEditorAutoCapitalize, type NativeRichTextEditorKeyboardType, type RemoteSelectionDecoration, type LinkRequestContext, type ImageRequestContext, } from './NativeRichTextEditor';
+export { NativeProseViewer, type NativeProseViewerProps, type NativeProseViewerAddons, type NativeProseViewerMentionsAddonConfig, type NativeProseViewerMentionPrefix, type NativeProseViewerLinkPressEvent, type NativeProseViewerMentionRenderContext, type NativeProseViewerMentionPressEvent, } from './NativeProseViewer';
+export { EditorToolbar, DEFAULT_EDITOR_TOOLBAR_ITEMS, type EditorToolbarProps, type EditorToolbarItem, type EditorToolbarLeafItem, type EditorToolbarGroupChildItem, type EditorToolbarGroupItem, type EditorToolbarGroupPresentation, type EditorToolbarIcon, type EditorToolbarDefaultIconId, type EditorToolbarSFSymbolIcon, type EditorToolbarMaterialIcon, type EditorToolbarCommand, type EditorToolbarHeadingLevel, type EditorToolbarListType, } from './EditorToolbar';
+export type { EditorContentInsets, EditorTheme, EditorTextStyle, EditorLinkTheme, EditorHeadingTheme, EditorListTheme, EditorHorizontalRuleTheme, EditorMentionTheme, EditorToolbarTheme, EditorToolbarAppearance, EditorFontStyle, EditorFontWeight, } from './EditorTheme';
+export { MENTION_NODE_NAME, mentionNodeSpec, withMentionsSchema, buildMentionFragmentJson, type EditorAddons, type MentionsAddonConfig, type MentionSuggestion, type MentionQueryChangeEvent, type MentionSelectionAttrsEvent, type MentionThemeResolveEvent, type MentionSelectEvent, type EditorAddonEvent, } from './addons';
+export { tiptapSchema, prosemirrorSchema, IMAGE_NODE_NAME, imageNodeSpec, withImagesSchema, buildImageFragmentJson, type SchemaDefinition, type NodeSpec, type MarkSpec, type AttrSpec, type ImageNodeAttributes, } from './schemas';
+export { createYjsCollaborationController, useYjsCollaboration, type YjsCollaborationOptions, type YjsCollaborationState, type YjsTransportStatus, type LocalAwarenessState, type LocalAwarenessUser, type UseYjsCollaborationResult, type YjsCollaborationController, } from './YjsCollaboration';
+export type { Selection, ActiveState, HistoryState, EditorUpdate, DocumentJSON, CollaborationPeer, EncodedCollaborationStateInput, } from './NativeEditorBridge';
+export { encodeCollaborationStateBase64, decodeCollaborationStateBase64, } from './NativeEditorBridge';
+export { clearHeightCache } from './heightCache';

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearHeightCache = exports.decodeCollaborationStateBase64 = exports.encodeCollaborationStateBase64 = exports.useYjsCollaboration = exports.createYjsCollaborationController = exports.buildImageFragmentJson = exports.withImagesSchema = exports.imageNodeSpec = exports.IMAGE_NODE_NAME = exports.prosemirrorSchema = exports.tiptapSchema = exports.buildMentionFragmentJson = exports.withMentionsSchema = exports.mentionNodeSpec = exports.MENTION_NODE_NAME = exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = exports.EditorToolbar = exports.NativeProseViewer = exports.NativeRichTextEditor = void 0;
+var NativeRichTextEditor_1 = require("./NativeRichTextEditor");
+Object.defineProperty(exports, "NativeRichTextEditor", { enumerable: true, get: function () { return NativeRichTextEditor_1.NativeRichTextEditor; } });
+var NativeProseViewer_1 = require("./NativeProseViewer");
+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 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 schemas_1 = require("./schemas");
+Object.defineProperty(exports, "tiptapSchema", { enumerable: true, get: function () { return schemas_1.tiptapSchema; } });
+Object.defineProperty(exports, "prosemirrorSchema", { enumerable: true, get: function () { return schemas_1.prosemirrorSchema; } });
+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, "buildImageFragmentJson", { enumerable: true, get: function () { return schemas_1.buildImageFragmentJson; } });
+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 NativeEditorBridge_1 = require("./NativeEditorBridge");
+Object.defineProperty(exports, "encodeCollaborationStateBase64", { enumerable: true, get: function () { return NativeEditorBridge_1.encodeCollaborationStateBase64; } });
+Object.defineProperty(exports, "decodeCollaborationStateBase64", { enumerable: true, get: function () { return NativeEditorBridge_1.decodeCollaborationStateBase64; } });
+var heightCache_1 = require("./heightCache");
+Object.defineProperty(exports, "clearHeightCache", { enumerable: true, get: function () { return heightCache_1.clearHeightCache; } });

package/dist/schemas.d.ts

@@ -0,0 +1,37 @@
+import type { DocumentJSON } from './NativeEditorBridge';
+export interface AttrSpec {
+    default?: unknown;
+}
+export interface NodeSpec {
+    name: string;
+    content: string;
+    group?: string;
+    attrs?: Record<string, AttrSpec>;
+    role: string;
+    htmlTag?: string;
+    isVoid?: boolean;
+}
+export interface MarkSpec {
+    name: string;
+    attrs?: Record<string, AttrSpec>;
+    excludes?: string;
+}
+export interface SchemaDefinition {
+    nodes: NodeSpec[];
+    marks: MarkSpec[];
+}
+export interface ImageNodeAttributes {
+    src: string;
+    alt?: string | null;
+    title?: string | null;
+    width?: number | null;
+    height?: number | null;
+}
+export declare const IMAGE_NODE_NAME = "image";
+export declare function imageNodeSpec(name?: string): NodeSpec;
+export declare function withImagesSchema(schema: SchemaDefinition): SchemaDefinition;
+export declare function buildImageFragmentJson(attrs: ImageNodeAttributes): DocumentJSON;
+export declare const tiptapSchema: SchemaDefinition;
+export declare function defaultEmptyDocument(schema?: SchemaDefinition): DocumentJSON;
+export declare function normalizeDocumentJson(doc: DocumentJSON, schema?: SchemaDefinition): DocumentJSON;
+export declare const prosemirrorSchema: SchemaDefinition;

package/dist/schemas.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prosemirrorSchema = exports.tiptapSchema = exports.IMAGE_NODE_NAME = void 0;
+exports.imageNodeSpec = imageNodeSpec;
+exports.withImagesSchema = withImagesSchema;
+exports.buildImageFragmentJson = buildImageFragmentJson;
+exports.defaultEmptyDocument = defaultEmptyDocument;
+exports.normalizeDocumentJson = normalizeDocumentJson;
+exports.IMAGE_NODE_NAME = 'image';
+const HEADING_LEVELS = [1, 2, 3, 4, 5, 6];
+function imageNodeSpec(name = exports.IMAGE_NODE_NAME) {
+    return {
+        name,
+        content: '',
+        group: 'block',
+        attrs: {
+            src: {},
+            alt: { default: null },
+            title: { default: null },
+            width: { default: null },
+            height: { default: null },
+        },
+        role: 'block',
+        htmlTag: 'img',
+        isVoid: true,
+    };
+}
+function headingNodeSpec(level) {
+    return {
+        name: `h${level}`,
+        content: 'inline*',
+        group: 'block',
+        role: 'textBlock',
+        htmlTag: `h${level}`,
+    };
+}
+function withImagesSchema(schema) {
+    const hasImageNode = schema.nodes.some((node) => node.name === exports.IMAGE_NODE_NAME);
+    if (hasImageNode) {
+        return schema;
+    }
+    return {
+        ...schema,
+        nodes: [...schema.nodes, imageNodeSpec()],
+    };
+}
+function buildImageFragmentJson(attrs) {
+    return {
+        type: 'doc',
+        content: [
+            {
+                type: exports.IMAGE_NODE_NAME,
+                attrs,
+            },
+        ],
+    };
+}
+const MARKS = [
+    { name: 'bold' },
+    { name: 'italic' },
+    { name: 'underline' },
+    { name: 'strike' },
+    { name: 'link', attrs: { href: {} } },
+];
+exports.tiptapSchema = {
+    nodes: [
+        {
+            name: 'doc',
+            content: 'block+',
+            role: 'doc',
+        },
+        {
+            name: 'paragraph',
+            content: 'inline*',
+            group: 'block',
+            role: 'textBlock',
+            htmlTag: 'p',
+        },
+        ...HEADING_LEVELS.map((level) => headingNodeSpec(level)),
+        {
+            name: 'blockquote',
+            content: 'block+',
+            group: 'block',
+            role: 'block',
+            htmlTag: 'blockquote',
+        },
+        {
+            name: 'bulletList',
+            content: 'listItem+',
+            group: 'block',
+            role: 'list',
+            htmlTag: 'ul',
+        },
+        {
+            name: 'orderedList',
+            content: 'listItem+',
+            group: 'block',
+            attrs: { start: { default: 1 } },
+            role: 'list',
+            htmlTag: 'ol',
+        },
+        {
+            name: 'listItem',
+            content: 'paragraph block*',
+            role: 'listItem',
+            htmlTag: 'li',
+        },
+        {
+            name: 'hardBreak',
+            content: '',
+            group: 'inline',
+            role: 'hardBreak',
+            htmlTag: 'br',
+            isVoid: true,
+        },
+        {
+            name: 'horizontalRule',
+            content: '',
+            group: 'block',
+            role: 'block',
+            htmlTag: 'hr',
+            isVoid: true,
+        },
+        imageNodeSpec(),
+        {
+            name: 'text',
+            content: '',
+            group: 'inline',
+            role: 'text',
+        },
+    ],
+    marks: MARKS,
+};
+function acceptingGroupsForChildCount(content, existingChildCount) {
+    const tokens = content
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((token) => {
+        const quantifier = token[token.length - 1];
+        if (quantifier === '+' || quantifier === '*' || quantifier === '?') {
+            return {
+                group: token.slice(0, -1),
+                min: quantifier === '+' ? 1 : 0,
+                max: quantifier === '?' ? 1 : null,
+            };
+        }
+        return {
+            group: token,
+            min: 1,
+            max: 1,
+        };
+    });
+    let remaining = existingChildCount;
+    const acceptingGroups = [];
+    for (const token of tokens) {
+        if (remaining >= token.min) {
+            const consumed = token.max == null ? remaining : Math.min(remaining, token.max);
+            remaining = Math.max(0, remaining - consumed);
+            const atMax = token.max != null && consumed >= token.max;
+            if (!atMax) {
+                acceptingGroups.push(token.group);
+            }
+            continue;
+        }
+        acceptingGroups.push(token.group);
+        break;
+    }
+    return acceptingGroups;
+}
+function defaultEmptyDocument(schema = exports.tiptapSchema) {
+    const docNode = schema.nodes.find((node) => node.role === 'doc' || node.name === 'doc');
+    const acceptingGroups = docNode == null ? [] : acceptingGroupsForChildCount(docNode.content ?? '', 0);
+    const matchingTextBlocks = schema.nodes.filter((node) => node.role === 'textBlock' &&
+        acceptingGroups.some((group) => node.name === group || node.group === group));
+    const preferredTextBlock = matchingTextBlocks.find((node) => node.htmlTag === 'p' || node.name === 'paragraph') ??
+        matchingTextBlocks[0] ??
+        schema.nodes.find((node) => node.htmlTag === 'p' || node.name === 'paragraph') ??
+        schema.nodes.find((node) => node.role === 'textBlock');
+    return {
+        type: 'doc',
+        content: [{ type: preferredTextBlock?.name ?? 'paragraph' }],
+    };
+}
+function normalizeDocumentJson(doc, schema = exports.tiptapSchema) {
+    const root = doc;
+    if (root?.type !== 'doc') {
+        return doc;
+    }
+    if (Array.isArray(root.content) && root.content.length > 0) {
+        return doc;
+    }
+    return defaultEmptyDocument(schema);
+}
+exports.prosemirrorSchema = {
+    nodes: [
+        {
+            name: 'doc',
+            content: 'block+',
+            role: 'doc',
+        },
+        {
+            name: 'paragraph',
+            content: 'inline*',
+            group: 'block',
+            role: 'textBlock',
+            htmlTag: 'p',
+        },
+        ...HEADING_LEVELS.map((level) => headingNodeSpec(level)),
+        {
+            name: 'blockquote',
+            content: 'block+',
+            group: 'block',
+            role: 'block',
+            htmlTag: 'blockquote',
+        },
+        {
+            name: 'bullet_list',
+            content: 'list_item+',
+            group: 'block',
+            role: 'list',
+            htmlTag: 'ul',
+        },
+        {
+            name: 'ordered_list',
+            content: 'list_item+',
+            group: 'block',
+            attrs: { start: { default: 1 } },
+            role: 'list',
+            htmlTag: 'ol',
+        },
+        {
+            name: 'list_item',
+            content: 'paragraph block*',
+            role: 'listItem',
+            htmlTag: 'li',
+        },
+        {
+            name: 'hard_break',
+            content: '',
+            group: 'inline',
+            role: 'hardBreak',
+            htmlTag: 'br',
+            isVoid: true,
+        },
+        {
+            name: 'horizontal_rule',
+            content: '',
+            group: 'block',
+            role: 'block',
+            htmlTag: 'hr',
+            isVoid: true,
+        },
+        imageNodeSpec('image'),
+        {
+            name: 'text',
+            content: '',
+            group: 'inline',
+            role: 'text',
+        },
+    ],
+    marks: MARKS,
+};

package/dist/useNativeEditor.d.ts

@@ -0,0 +1,42 @@
+import { NativeEditorBridge, type ActiveState, type HistoryState, type RenderElement, type Selection } from './NativeEditorBridge';
+export interface UseNativeEditorOptions {
+    /** Maximum character length. Omit for no limit. */
+    maxLength?: number;
+    /** Initial HTML content to load after creation. */
+    initialHtml?: string;
+    /** Called when content changes after an editing operation. */
+    onChange?: (html: string) => void;
+    /** Called when selection changes. */
+    onSelectionChange?: (selection: Selection) => void;
+}
+export interface UseNativeEditorReturn {
+    /** The underlying bridge instance, or null before creation. */
+    bridge: NativeEditorBridge | null;
+    /** Whether the editor has been created and is ready. */
+    isReady: boolean;
+    /** Current selection state. */
+    selection: Selection;
+    /** Currently active marks/nodes at the selection. */
+    activeState: ActiveState;
+    /** Current undo/redo availability. */
+    historyState: HistoryState;
+    /** Current render elements. */
+    renderElements: RenderElement[];
+    /** Toggle a mark (e.g. 'bold', 'italic', 'underline'). */
+    toggleMark: (markType: string) => void;
+    /** Undo the last operation. */
+    undo: () => void;
+    /** Redo the last undone operation. */
+    redo: () => void;
+    /** Toggle blockquote wrapping around the current block selection. */
+    toggleBlockquote: () => void;
+    /** Toggle a heading level on the current block selection. */
+    toggleHeading: (level: 1 | 2 | 3 | 4 | 5 | 6) => void;
+    /** Insert text at a position. */
+    insertText: (pos: number, text: string) => void;
+    /** Delete a range [from, to). */
+    deleteRange: (from: number, to: number) => void;
+    /** Get the current HTML content. */
+    getHtml: () => string;
+}
+export declare function useNativeEditor(options?: UseNativeEditorOptions): UseNativeEditorReturn;