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

package/src/contentExpression.ts

@@ -0,0 +1,338 @@
+export const CONTENT_EXPRESSION_MAX_DEPTH = 128;
+export const DEFAULT_CONTENT_MAX_NODES = 10_000;
+const MAX_AUTOMATON_STATES = 10_000;
+const MAX_REPETITION_BOUND = 10_000;
+
+type Expression =
+    | { kind: 'empty' }
+    | { kind: 'symbol'; symbol: string }
+    | { kind: 'sequence'; expressions: Expression[] }
+    | { kind: 'alternation'; expressions: Expression[] }
+    | { kind: 'repeat'; expression: Expression; min: number; max: number | null };
+
+interface State {
+    epsilon: number[];
+    transitions: Array<{ symbol: string; target: number }>;
+}
+
+function collectExpressionSymbols(expression: Expression, symbols: Set<string>): void {
+    if (expression.kind === 'symbol') {
+        symbols.add(expression.symbol);
+    } else if (expression.kind !== 'empty') {
+        if (expression.kind === 'repeat') collectExpressionSymbols(expression.expression, symbols);
+        else for (const nested of expression.expressions) collectExpressionSymbols(nested, symbols);
+    }
+}
+
+/** Return every referenced node/group symbol, or null for an invalid expression. */
+export function contentExpressionSymbols(content: string): string[] | null {
+    try {
+        const expression = new ContentExpressionParser(content).parse();
+        const compiler = new ContentExpressionCompiler();
+        compiler.compile(expression);
+        const symbols = new Set<string>();
+        collectExpressionSymbols(expression, symbols);
+        return [...symbols];
+    } catch {
+        return null;
+    }
+}
+
+class ContentExpressionParser {
+    private position = 0;
+    private depth = 0;
+
+    constructor(private readonly source: string) {}
+
+    parse(): Expression {
+        if (this.source.trim() === '') return { kind: 'empty' };
+        const expression = this.parseAlternation();
+        this.skipWhitespace();
+        if (!this.atEnd()) throw new Error(`unexpected '${this.peek()}'`);
+        return expression;
+    }
+
+    private parseAlternation(): Expression {
+        const expressions = [this.parseSequence()];
+        while (true) {
+            this.skipWhitespace();
+            if (!this.consume('|')) break;
+            this.skipWhitespace();
+            if (this.atEnd() || this.peek() === ')' || this.peek() === '|') {
+                throw new Error("missing expression after '|'");
+            }
+            expressions.push(this.parseSequence());
+        }
+        return expressions.length === 1 ? expressions[0] : { kind: 'alternation', expressions };
+    }
+
+    private parseSequence(): Expression {
+        const expressions: Expression[] = [];
+        while (true) {
+            this.skipWhitespace();
+            if (this.atEnd() || this.peek() === ')' || this.peek() === '|') break;
+            expressions.push(this.parseRepeated());
+        }
+        if (expressions.length === 0) throw new Error('expected expression');
+        return expressions.length === 1 ? expressions[0] : { kind: 'sequence', expressions };
+    }
+
+    private parseRepeated(): Expression {
+        const atom = this.parseAtom();
+        this.skipWhitespace();
+        let expression = atom;
+        if (this.consume('?')) expression = { kind: 'repeat', expression: atom, min: 0, max: 1 };
+        else if (this.consume('*'))
+            expression = { kind: 'repeat', expression: atom, min: 0, max: null };
+        else if (this.consume('+'))
+            expression = { kind: 'repeat', expression: atom, min: 1, max: null };
+        else if (this.consume('{')) expression = this.parseRange(atom);
+        this.skipWhitespace();
+        if (['?', '*', '+', '{'].includes(this.peek() ?? '')) {
+            throw new Error('multiple quantifiers');
+        }
+        return expression;
+    }
+
+    private parseAtom(): Expression {
+        this.skipWhitespace();
+        if (this.consume('(')) {
+            if (this.depth >= CONTENT_EXPRESSION_MAX_DEPTH)
+                throw new Error('expression nesting too deep');
+            this.depth += 1;
+            try {
+                this.skipWhitespace();
+                if (this.peek() === ')') throw new Error('empty group');
+                const expression = this.parseAlternation();
+                this.skipWhitespace();
+                if (!this.consume(')')) throw new Error("missing ')'");
+                return expression;
+            } finally {
+                this.depth -= 1;
+            }
+        }
+
+        const start = this.position;
+        while (this.peek() != null && /[A-Za-z0-9_-]/.test(this.peek()!)) this.position += 1;
+        if (start === this.position) throw new Error('expected node or group name');
+        return { kind: 'symbol', symbol: this.source.slice(start, this.position) };
+    }
+
+    private parseRange(expression: Expression): Expression {
+        const min = this.parseNumber();
+        let max: number | null;
+        if (this.consume('}')) max = min;
+        else {
+            if (!this.consume(',')) throw new Error("expected ',' or '}'");
+            if (this.consume('}')) max = null;
+            else {
+                max = this.parseNumber();
+                if (!this.consume('}')) throw new Error("expected '}'");
+            }
+        }
+        if (max != null && max < min) throw new Error('range maximum is smaller than minimum');
+        if ((max ?? min) > MAX_REPETITION_BOUND) throw new Error('repetition bound too large');
+        return { kind: 'repeat', expression, min, max };
+    }
+
+    private parseNumber(): number {
+        const start = this.position;
+        while (this.peek() != null && /[0-9]/.test(this.peek()!)) this.position += 1;
+        if (start === this.position) throw new Error('expected number');
+        const value = Number(this.source.slice(start, this.position));
+        if (!Number.isSafeInteger(value) || value > 0xffff_ffff) throw new Error('invalid count');
+        return value;
+    }
+
+    private skipWhitespace(): void {
+        while (this.peek() != null && /\s/.test(this.peek()!)) this.position += 1;
+    }
+
+    private peek(): string | undefined {
+        return this.source[this.position];
+    }
+
+    private consume(character: string): boolean {
+        if (this.peek() !== character) return false;
+        this.position += 1;
+        return true;
+    }
+
+    private atEnd(): boolean {
+        return this.position === this.source.length;
+    }
+}
+
+class ContentExpressionCompiler {
+    readonly states: State[] = [];
+
+    compile(expression: Expression, depth = 0): [number, number] {
+        if (depth > CONTENT_EXPRESSION_MAX_DEPTH) throw new Error('expression nesting too deep');
+        if (expression.kind === 'empty') {
+            const start = this.state();
+            const end = this.state();
+            this.states[start].epsilon.push(end);
+            return [start, end];
+        }
+        if (expression.kind === 'symbol') {
+            const start = this.state();
+            const end = this.state();
+            this.states[start].transitions.push({ symbol: expression.symbol, target: end });
+            return [start, end];
+        }
+        if (expression.kind === 'sequence') {
+            const start = this.state();
+            let tail = start;
+            for (const nested of expression.expressions) {
+                const [nestedStart, nestedEnd] = this.compile(nested, depth + 1);
+                this.states[tail].epsilon.push(nestedStart);
+                tail = nestedEnd;
+            }
+            return [start, tail];
+        }
+        if (expression.kind === 'alternation') {
+            const start = this.state();
+            const end = this.state();
+            for (const nested of expression.expressions) {
+                const [nestedStart, nestedEnd] = this.compile(nested, depth + 1);
+                this.states[start].epsilon.push(nestedStart);
+                this.states[nestedEnd].epsilon.push(end);
+            }
+            return [start, end];
+        }
+        return this.compileRepeat(expression.expression, expression.min, expression.max, depth + 1);
+    }
+
+    private compileRepeat(
+        expression: Expression,
+        min: number,
+        max: number | null,
+        depth: number
+    ): [number, number] {
+        const start = this.state();
+        const end = this.state();
+        let tail = start;
+        for (let count = 0; count < min; count += 1) {
+            const [itemStart, itemEnd] = this.compile(expression, depth);
+            this.states[tail].epsilon.push(itemStart);
+            tail = itemEnd;
+        }
+        if (max == null) {
+            this.states[tail].epsilon.push(end);
+            const [itemStart, itemEnd] = this.compile(expression, depth);
+            this.states[tail].epsilon.push(itemStart);
+            this.states[itemEnd].epsilon.push(tail);
+        } else {
+            for (let count = min; count < max; count += 1) {
+                this.states[tail].epsilon.push(end);
+                const [itemStart, itemEnd] = this.compile(expression, depth);
+                this.states[tail].epsilon.push(itemStart);
+                tail = itemEnd;
+            }
+            this.states[tail].epsilon.push(end);
+        }
+        return [start, end];
+    }
+
+    private state(): number {
+        if (this.states.length >= MAX_AUTOMATON_STATES)
+            throw new Error('too many automaton states');
+        this.states.push({ epsilon: [], transitions: [] });
+        return this.states.length - 1;
+    }
+}
+
+function epsilonClosure(states: State[], initial: Iterable<number>): Set<number> {
+    const result = new Set<number>();
+    const pending = [...initial];
+    while (pending.length > 0) {
+        const state = pending.pop()!;
+        if (result.has(state)) continue;
+        result.add(state);
+        pending.push(...states[state].epsilon);
+    }
+    return result;
+}
+
+export function acceptingContentSymbols(
+    content: string,
+    existingChildTypes: readonly string[] = [],
+    symbolMatches: (childType: string, symbol: string) => boolean = (child, symbol) =>
+        child === symbol
+): string[] {
+    try {
+        const expression = new ContentExpressionParser(content).parse();
+        const compiler = new ContentExpressionCompiler();
+        const [start] = compiler.compile(expression);
+        let current = epsilonClosure(compiler.states, [start]);
+        for (const childType of existingChildTypes) {
+            const next = new Set<number>();
+            for (const state of current) {
+                for (const transition of compiler.states[state].transitions) {
+                    if (symbolMatches(childType, transition.symbol)) next.add(transition.target);
+                }
+            }
+            current = epsilonClosure(compiler.states, next);
+        }
+        const symbols = new Set<string>();
+        for (const state of current) {
+            for (const transition of compiler.states[state].transitions) {
+                symbols.add(transition.symbol);
+            }
+        }
+        return [...symbols].sort();
+    } catch {
+        return [];
+    }
+}
+
+export function minimalContentMatch<T>(
+    content: string,
+    choose: (symbol: string) => T | undefined,
+    consumeWork: () => boolean = () => true
+): T[] | undefined {
+    try {
+        const expression = new ContentExpressionParser(content).parse();
+        const compiler = new ContentExpressionCompiler();
+        const [start, accept] = compiler.compile(expression);
+        interface Path {
+            value: T;
+            previous?: Path;
+        }
+        let current = new Map<number, Path | undefined>([[start, undefined]]);
+        const visited = new Set<number>();
+        while (current.size > 0) {
+            const closure = new Map<number, Path | undefined>();
+            const pending = [...current.entries()];
+            while (pending.length > 0) {
+                if (!consumeWork()) return undefined;
+                const [state, path] = pending.pop()!;
+                if (closure.has(state)) continue;
+                closure.set(state, path);
+                for (const target of compiler.states[state].epsilon) pending.push([target, path]);
+            }
+            const accepted = closure.get(accept);
+            if (closure.has(accept)) {
+                const result: T[] = [];
+                for (let path = accepted; path; path = path.previous) result.push(path.value);
+                return result.reverse();
+            }
+            const next = new Map<number, Path | undefined>();
+            for (const [state, path] of closure) {
+                if (visited.has(state)) continue;
+                visited.add(state);
+                for (const transition of compiler.states[state].transitions) {
+                    if (!consumeWork()) return undefined;
+                    const value = choose(transition.symbol);
+                    if (value !== undefined && !next.has(transition.target)) {
+                        next.set(transition.target, { value, previous: path });
+                    }
+                }
+            }
+            current = next;
+        }
+        return undefined;
+    } catch {
+        return undefined;
+    }
+}

package/src/index.ts

@@ -0,0 +1,295 @@
+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/src/listMarkers.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 const TASK_LIST_MARKER_CHECKED = '☑ ';
+export const TASK_LIST_MARKER_UNCHECKED = '☐ ';
+export const UNORDERED_LIST_MARKER = '• ';
+
+export function orderedListMarker(index: number): string {
+    return `${index}. `;
+}