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

package/dist/ResourceLimits.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Bounds on the documents, schemas, and collaboration payloads the Rust core
+ * will admit. Set them on `NativeEditorCreateConfig.limits.resource` when
+ * creating a document handle, or on `RichTextViewer.resourceLimits`.
+ *
+ * Every field is optional; an omitted one uses
+ * {@link DEFAULT_EDITOR_RESOURCE_LIMITS}. Each value must be a positive
+ * integer no greater than the matching {@link HARD_EDITOR_RESOURCE_LIMITS}
+ * ceiling — anything else throws `NativeEditorBoundaryError`
+ * (`INVALID_RESOURCE_LIMIT`). Exceeding a limit at runtime raises
+ * `INPUT_LIMIT_EXCEEDED`, `DOCUMENT_LIMIT_EXCEEDED`, or `SCHEMA_INVALID`.
+ */
+export interface EditorResourceLimits {
+    /** Byte ceiling for a single config, document JSON, or HTML string crossing into the core. */
+    maxInputBytes?: number;
+    /** Maximum number of nodes in a document. */
+    maxDocumentNodes?: number;
+    /** Maximum node nesting depth in a document. */
+    maxDocumentDepth?: number;
+    /** Maximum number of node specs in a schema definition. */
+    maxSchemaNodes?: number;
+    /** Byte ceiling for the combined `content` expressions of a schema's nodes. */
+    maxSchemaExpressionBytes?: number;
+    /** Byte ceiling for one inbound collaboration message. */
+    maxCollaborationMessageBytes?: number;
+    /** Byte ceiling for an encoded Yjs state — imported room snapshots and exported ones. */
+    maxEncodedStateBytes?: number;
+}
+/**
+ * Bounds on editing work inside the engine, set on
+ * `NativeEditorCreateConfig.limits.editing`. Omitted fields use the Rust
+ * core's defaults; supplied values are validated against the same hard
+ * ceilings the core enforces.
+ */
+export interface EditorEditingLimits {
+    /** Maximum operations one compiled transaction may carry. Core default 256. */
+    maxOperationsPerTransaction?: number;
+    /** Maximum undoable groups retained in history. Core default 500. */
+    maxUndoGroups?: number;
+    /** Maximum document units the undo stack may retain across all groups. Core default 1,000,000. */
+    maxUndoRetainedUnits?: number;
+    /** Byte ceiling for derived output (HTML, JSON, render state) the engine produces. Core default 32 MiB. */
+    maxDerivedOutputBytes?: number;
+}
+/**
+ * Bounds on the native collaboration transport, set on
+ * `NativeEditorCreateConfig.limits.collaboration`. Omitted fields use the
+ * Rust core's defaults; supplied values are validated against the same hard
+ * ceilings the core enforces.
+ */
+export interface EditorCollaborationLimits {
+    /** Maximum protocol frames decoded from one transport message. Core default 64. */
+    maxFramesPerMessage?: number;
+    /** Byte ceiling for a single protocol frame. Core default 10 MiB. */
+    maxFrameBytes?: number;
+    /** Byte ceiling for all reply frames produced for one inbound message. Core default 10 MiB. */
+    maxAggregateResponseBytes?: number;
+    /** Maximum tracked awareness peers. Core default 1,024. */
+    maxAwarenessPeers?: number;
+    /** Byte ceiling for one peer's awareness state. Core default 64 KiB. */
+    maxAwarenessPeerBytes?: number;
+    /** Byte ceiling for all retained awareness state. Core default 10 MiB. */
+    maxAwarenessBytes?: number;
+    /** Maximum messages queued for send while disconnected. Core default 256. */
+    maxPendingOutboxMessages?: number;
+    /** Byte ceiling for the outbound queue. Core default 10 MiB. */
+    maxPendingOutboxBytes?: number;
+    /** Byte ceiling for remote updates buffered while awaiting their missing dependencies. Core default 10 MiB. */
+    maxPendingDependencyUpdateBytes?: number;
+    /** Work ceiling for those buffered dependency updates. Core default 1,000,000. */
+    maxPendingDependencyUpdateWork?: number;
+}
+/** {@link EditorResourceLimits} with every default filled in. */
+export interface ResolvedEditorResourceLimits {
+    maxInputBytes: number;
+    maxDocumentNodes: number;
+    maxDocumentDepth: number;
+    maxSchemaNodes: number;
+    maxSchemaExpressionBytes: number;
+    maxCollaborationMessageBytes: number;
+    maxEncodedStateBytes: number;
+}
+/** The value used for each {@link EditorResourceLimits} field left unset. */
+export declare const DEFAULT_EDITOR_RESOURCE_LIMITS: Readonly<ResolvedEditorResourceLimits>;
+/** The ceiling each {@link EditorResourceLimits} field may not exceed. */
+export declare const HARD_EDITOR_RESOURCE_LIMITS: Readonly<ResolvedEditorResourceLimits>;
+export declare function validateEditorCreateLimits(limits?: {
+    resource?: EditorResourceLimits;
+    editing?: EditorEditingLimits;
+    collaboration?: EditorCollaborationLimits;
+}): void;
+/**
+ * Fill in every unset {@link EditorResourceLimits} field from
+ * {@link DEFAULT_EDITOR_RESOURCE_LIMITS}, validating each value against
+ * {@link HARD_EDITOR_RESOURCE_LIMITS}.
+ *
+ * @throws NativeEditorBoundaryError `INVALID_RESOURCE_LIMIT` when a value is
+ * not a positive integer within its ceiling.
+ */
+export declare function resolveEditorResourceLimits(limits?: EditorResourceLimits): ResolvedEditorResourceLimits;

package/dist/ResourceLimits.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARD_EDITOR_RESOURCE_LIMITS = exports.DEFAULT_EDITOR_RESOURCE_LIMITS = void 0;
+exports.validateEditorCreateLimits = validateEditorCreateLimits;
+exports.resolveEditorResourceLimits = resolveEditorResourceLimits;
+const NativeEditorBoundaryError_1 = require("./NativeEditorBoundaryError");
+/** The value used for each {@link EditorResourceLimits} field left unset. */
+exports.DEFAULT_EDITOR_RESOURCE_LIMITS = {
+    maxInputBytes: 20 * 1024 * 1024,
+    maxDocumentNodes: 100000,
+    maxDocumentDepth: 256,
+    maxSchemaNodes: 1024,
+    maxSchemaExpressionBytes: 64 * 1024,
+    maxCollaborationMessageBytes: 10 * 1024 * 1024,
+    maxEncodedStateBytes: 50 * 1024 * 1024,
+};
+/** The ceiling each {@link EditorResourceLimits} field may not exceed. */
+exports.HARD_EDITOR_RESOURCE_LIMITS = {
+    maxInputBytes: 64 * 1024 * 1024,
+    maxDocumentNodes: 1000000,
+    maxDocumentDepth: 1024,
+    maxSchemaNodes: 10000,
+    maxSchemaExpressionBytes: 1024 * 1024,
+    maxCollaborationMessageBytes: 64 * 1024 * 1024,
+    maxEncodedStateBytes: 256 * 1024 * 1024,
+};
+const HARD_EDITOR_EDITING_LIMITS = {
+    maxOperationsPerTransaction: 4096,
+    maxUndoGroups: 2000,
+    maxUndoRetainedUnits: 8000000,
+    maxDerivedOutputBytes: 128 * 1024 * 1024,
+};
+const HARD_EDITOR_COLLABORATION_LIMITS = {
+    maxFramesPerMessage: 1024,
+    maxFrameBytes: 64 * 1024 * 1024,
+    maxAggregateResponseBytes: 64 * 1024 * 1024,
+    maxAwarenessPeers: 10000,
+    maxAwarenessPeerBytes: 1024 * 1024,
+    maxAwarenessBytes: 64 * 1024 * 1024,
+    maxPendingOutboxMessages: 4096,
+    maxPendingOutboxBytes: 64 * 1024 * 1024,
+    maxPendingDependencyUpdateBytes: 64 * 1024 * 1024,
+    maxPendingDependencyUpdateWork: 8000000,
+};
+function validateLimit(name, value, ceiling) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > ceiling) {
+        throw new NativeEditorBoundaryError_1.NativeEditorBoundaryError('INVALID_RESOURCE_LIMIT', `${name} must be a positive integer no greater than ${ceiling}`, ceiling, value);
+    }
+}
+function resolveLimit(name, value) {
+    const resolved = value ?? exports.DEFAULT_EDITOR_RESOURCE_LIMITS[name];
+    validateLimit(name, resolved, exports.HARD_EDITOR_RESOURCE_LIMITS[name]);
+    return resolved;
+}
+function validateOverrides(limits, ceilings) {
+    if (limits === undefined)
+        return;
+    for (const name of Object.keys(ceilings)) {
+        const value = limits[name];
+        if (value !== undefined) {
+            validateLimit(String(name), value, ceilings[name]);
+        }
+    }
+}
+function validateEditorCreateLimits(limits) {
+    validateOverrides(limits?.resource, exports.HARD_EDITOR_RESOURCE_LIMITS);
+    validateOverrides(limits?.editing, HARD_EDITOR_EDITING_LIMITS);
+    validateOverrides(limits?.collaboration, HARD_EDITOR_COLLABORATION_LIMITS);
+}
+/**
+ * Fill in every unset {@link EditorResourceLimits} field from
+ * {@link DEFAULT_EDITOR_RESOURCE_LIMITS}, validating each value against
+ * {@link HARD_EDITOR_RESOURCE_LIMITS}.
+ *
+ * @throws NativeEditorBoundaryError `INVALID_RESOURCE_LIMIT` when a value is
+ * not a positive integer within its ceiling.
+ */
+function resolveEditorResourceLimits(limits = {}) {
+    return Object.fromEntries(Object.keys(exports.DEFAULT_EDITOR_RESOURCE_LIMITS).map((name) => [name, resolveLimit(name, limits[name])]));
+}

package/dist/RichTextEditor.d.ts

@@ -0,0 +1,4 @@
+import { type RichTextEditorRef, type RichTextEditorProps } from './RichTextEditorTypes';
+export declare const RichTextEditor: import("react").ForwardRefExoticComponent<RichTextEditorProps & import("react").RefAttributes<RichTextEditorRef>>;
+/** @deprecated Use RichTextEditor instead. */
+export declare const NativeRichTextEditor: import("react").ForwardRefExoticComponent<RichTextEditorProps & import("react").RefAttributes<RichTextEditorRef>>;

package/dist/RichTextEditor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeRichTextEditor = exports.RichTextEditor = void 0;
+const react_1 = require("react");
+const useRichTextEditorState_1 = require("./useRichTextEditorState");
+const useRichTextEditorUpdates_1 = require("./useRichTextEditorUpdates");
+const useRichTextEditorCommands_1 = require("./useRichTextEditorCommands");
+const useRichTextEditorEvents_1 = require("./useRichTextEditorEvents");
+const useRichTextEditorMentions_1 = require("./useRichTextEditorMentions");
+const useRichTextEditorPresentation_1 = require("./useRichTextEditorPresentation");
+exports.RichTextEditor = (0, react_1.forwardRef)(function RichTextEditor(props, ref) {
+    const state = (0, useRichTextEditorState_1.useRichTextEditorState)(props, ref);
+    const updates = (0, useRichTextEditorUpdates_1.useRichTextEditorUpdates)(state);
+    const commands = (0, useRichTextEditorCommands_1.useRichTextEditorCommands)({ ...state, ...updates });
+    const events = (0, useRichTextEditorEvents_1.useRichTextEditorEvents)({ ...state, ...updates, ...commands });
+    const mentions = (0, useRichTextEditorMentions_1.useRichTextEditorMentions)({
+        ...state,
+        ...commands,
+        ...updates,
+        ...events,
+    });
+    return (0, useRichTextEditorPresentation_1.useRichTextEditorPresentation)({ ...state, ...mentions, ...commands, ...events });
+});
+/** @deprecated Use RichTextEditor instead. */
+exports.NativeRichTextEditor = exports.RichTextEditor;

package/dist/RichTextEditorNativeTypes.d.ts

@@ -0,0 +1,122 @@
+import { ExternalTextCompositionManager, type NativeExternalTextCompositionHandle } from './ExternalTextComposition';
+import { type ReactNode } from 'react';
+import { type NativeSyntheticEvent, type StyleProp, type ViewStyle } from 'react-native';
+import { type DocumentJSON, type NativeEditorDocumentHandle } from './NativeEditorBridge';
+import { type RichTextEditorAutoCapitalize, type RichTextEditorKeyboardType, type RichTextEditorToolbarPlacement, type RichTextEditorHeightBehavior } from './RichTextEditorTypes';
+export interface NativeExternalTextCompositionEvent {
+    editorId: string;
+    resultJson: string;
+}
+export interface NativeEditorViewHandle extends NativeExternalTextCompositionHandle {
+    focus?: () => void;
+    blur?: () => void;
+    getCaretRect?: () => Promise<string | null> | string | null;
+}
+export interface NativeEditorViewProps {
+    children?: ReactNode;
+    style?: StyleProp<ViewStyle>;
+    onLayout?: () => void;
+    accessibilityLabel?: string;
+    accessibilityHint?: string;
+    editorId: string;
+    placeholder?: string;
+    editable: boolean;
+    autoFocus: boolean;
+    autoCapitalize?: RichTextEditorAutoCapitalize;
+    autoCorrect?: boolean;
+    keyboardType?: RichTextEditorKeyboardType;
+    androidInputOptionsJson?: string;
+    showToolbar: boolean;
+    toolbarPlacement: RichTextEditorToolbarPlacement;
+    heightBehavior: RichTextEditorHeightBehavior;
+    allowImageResizing: boolean;
+    imageLoadingPolicyJson?: string;
+    themeJson?: string;
+    addonsJson?: string;
+    atomsJson?: string;
+    toolbarItemsJson?: string;
+    toolbarFrameJson?: string;
+    remoteSelectionsJson?: string;
+    editorUpdateJson?: string;
+    editorUpdateResetJson?: string;
+    editorUpdateEditorId?: string;
+    editorUpdateRevision?: number;
+    onEditorUpdate: (event: NativeSyntheticEvent<NativeUpdateEvent>) => void;
+    onEditorError: (event: NativeSyntheticEvent<NativeErrorEvent>) => void;
+    onExternalTextCompositionEnd: (event: NativeSyntheticEvent<NativeExternalTextCompositionEvent>) => void;
+    onSelectionChange: (event: NativeSyntheticEvent<NativeSelectionEvent>) => void;
+    onFocusChange: (event: NativeSyntheticEvent<NativeFocusEvent>) => void;
+    onContentHeightChange: (event: NativeSyntheticEvent<NativeContentHeightEvent>) => void;
+    onAtomLayout: (event: NativeSyntheticEvent<NativeAtomLayoutEvent>) => void;
+    onToolbarAction: (event: NativeSyntheticEvent<NativeToolbarActionEvent>) => void;
+    onAddonEvent: (event: NativeSyntheticEvent<NativeAddonEvent>) => void;
+}
+export interface NativeUpdateEvent {
+    updateJson: string;
+    editorId: string;
+    documentRevision: string;
+}
+export interface NativeErrorEvent {
+    editorId: string;
+    error: unknown;
+}
+export interface NativeSelectionEvent {
+    anchor: number;
+    head: number;
+    stateJson?: string;
+    editorId: string;
+    documentVersion?: string;
+}
+export interface NativeFocusEvent {
+    isFocused: boolean;
+    editorId: string;
+}
+export interface NativeContentHeightEvent {
+    contentHeight: number;
+    editorId: string;
+}
+export interface NativeAtomLayoutEvent {
+    width: number;
+    editorId: string;
+    positions?: readonly NativeAtomPosition[];
+    viewport?: {
+        y: number;
+        height: number;
+    };
+}
+export interface NativeAtomPosition {
+    /** Native editor coordinates used for Fabric responder measurements. */
+    hostX?: number;
+    hostY?: number;
+    height?: number;
+    width?: number;
+    key: string;
+    x: number;
+    y: number;
+}
+export interface NativeToolbarActionEvent {
+    key: string;
+    editorId: string;
+    updateJson?: string;
+    stateJson?: string;
+    documentRevision?: string;
+}
+export interface NativeAddonEvent {
+    eventJson: string;
+    editorId: string;
+}
+export interface NativeEditorErrorBinding {
+    readonly handle: NativeEditorDocumentHandle;
+    readonly editorId: string;
+    readonly generation: number;
+    readonly mounted: boolean;
+}
+export interface ControlledValueDelivery {
+    manager: ExternalTextCompositionManager;
+    key: string | null;
+    value: string | undefined;
+    valueJSON: DocumentJSON | undefined;
+}
+export interface ExternalCompositionDisposalToken {
+    cancelled: boolean;
+}

package/dist/RichTextEditorNativeTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/RichTextEditorNativeView.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type NativeEditorViewProps, type NativeEditorViewHandle } from './RichTextEditorNativeTypes';
+export declare const NativeEditorView: React.ComponentType<NativeEditorViewProps & React.RefAttributes<NativeEditorViewHandle>>;
+export declare const styles: {
+    container: {
+        position: "relative";
+    };
+    inlineToolbar: {
+        flexDirection: "row";
+        alignItems: "center";
+    };
+};

package/dist/RichTextEditorNativeView.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.styles = exports.NativeEditorView = void 0;
+const expo_modules_core_1 = require("expo-modules-core");
+const react_native_1 = require("react-native");
+exports.NativeEditorView = (0, expo_modules_core_1.requireNativeViewManager)('NativeEditor');
+exports.styles = react_native_1.StyleSheet.create({
+    container: {
+        position: 'relative',
+    },
+    inlineToolbar: {
+        flexDirection: 'row',
+        alignItems: 'center',
+    },
+});

package/dist/RichTextEditorSerialization.d.ts

@@ -0,0 +1,53 @@
+import { type EditorMentionTheme } from './EditorTheme';
+import { type ActiveState, type NativeEditorAtomicRenderSnapshot, type ReadonlyActiveState, type Selection } from './NativeEditorBridge';
+import { type AtomInstance } from './atomInstances';
+import { type EditorToolbarFrame, type EditorToolbarGroupChildItem, type EditorToolbarItem } from './EditorToolbar';
+import { type RichTextEditorProps, type RemoteSelectionDecoration, type RichTextEditorCaretRect } from './RichTextEditorTypes';
+export declare function externalCompositionErrorPayload(error: unknown): unknown;
+export declare const LINK_TOOLBAR_ACTION_KEY = "__native-editor-link__";
+export declare const IMAGE_TOOLBAR_ACTION_KEY = "__native-editor-image__";
+export declare let nextNativeEditorToolbarFrameOwnerId: number;
+export declare function mergeMentionSuggestionTheme(baseTheme: EditorMentionTheme | undefined, resolvedTheme: EditorMentionTheme | undefined): EditorMentionTheme | undefined;
+export declare function allocateToolbarFrameOwnerId(): number;
+export declare const EMPTY_ACTIVE_STATE: ActiveState;
+export type AtomRenderBlocks = NonNullable<NativeEditorAtomicRenderSnapshot['renderBlocks']>;
+export interface AtomRenderState {
+    blocks: AtomRenderBlocks;
+    instanceBlocks: ReadonlyArray<ReadonlyArray<AtomInstance>>;
+    instances: AtomInstance[];
+    documentVersion: string | null;
+    hasOnlyStableAtomKeys: boolean;
+}
+export declare function selectedAtomKeys(selection: Selection, instances: readonly AtomInstance[]): Set<string>;
+export declare function equalStringSets(left: ReadonlySet<string>, right: ReadonlySet<string>): boolean;
+export declare function equalAtomInstances(left: readonly AtomInstance[], right: readonly AtomInstance[]): boolean;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function parseSelectionFromUpdate(value: unknown): Selection | null;
+export declare function stringArray(value: unknown): string[];
+export declare function booleanMap(value: unknown): Record<string, boolean>;
+export declare function parseActiveStateFromUpdate(value: unknown): ActiveState | null;
+export declare function isRevisionMismatchError(error: unknown): boolean;
+export declare function isPositionInvalidError(error: unknown): boolean;
+export interface NativeCommitPayload {
+    editorId: string;
+    documentRevision: string;
+    updateJson: string;
+}
+export interface AcceptedNativeCommit {
+    documentRevision: string;
+    snapshot: NativeEditorAtomicRenderSnapshot;
+}
+/**
+ * Native commits are a transport boundary, not a best-effort view hint. The
+ * payload must be a complete atomic snapshot paired with the same canonical
+ * revision that native says it committed.
+ */
+export declare function acceptNativeCommitPayload(payload: NativeCommitPayload, boundEditorId: string, lastAcceptedRevision: string | null): AcceptedNativeCommit | null;
+export declare function mapToolbarChildForNative(item: EditorToolbarGroupChildItem, activeState: ReadonlyActiveState, editable: boolean, onRequestLink?: RichTextEditorProps['onRequestLink'], onRequestImage?: RichTextEditorProps['onRequestImage']): EditorToolbarGroupChildItem;
+export declare function mapToolbarItemsForNative(items: readonly EditorToolbarItem[], activeState: ReadonlyActiveState, editable: boolean, onRequestLink?: RichTextEditorProps['onRequestLink'], onRequestImage?: RichTextEditorProps['onRequestImage']): EditorToolbarItem[];
+export declare function serializeRemoteSelections(remoteSelections?: readonly RemoteSelectionDecoration[]): string | undefined;
+export declare function serializeToolbarFrames(frames: readonly EditorToolbarFrame[] | null | undefined): string | undefined;
+export declare function parseCaretRectJson(raw: string | null | undefined): RichTextEditorCaretRect | null;
+export declare const serializedJsonCache: WeakMap<object, string>;
+export declare function stringifyCachedJson(value: unknown): string;
+export declare function useSerializedValue<T>(value: T | null | undefined, serialize: (value: T) => string | undefined, revision?: unknown): string | undefined;