react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/src/EnrichedMarkdownTextInput.tsx

@@ -2,6 +2,7 @@ import {
   useCallback,
   useEffect,
   useImperativeHandle,
+  useLayoutEffect,
   useMemo,
   useRef,
 } from 'react';
@@ -13,6 +14,7 @@ import EnrichedMarkdownTextInputNativeComponent, {
   type OnChangeMarkdownEvent,
   type OnChangeSelectionEvent,
   type OnChangeStateEvent,
+  type OnKeyPressEvent,
   type OnRequestMarkdownResultEvent,
   type OnRequestCaretRectResultEvent,
   type OnCaretRectChangeEvent,
@@ -24,6 +26,7 @@ import EnrichedMarkdownTextInputNativeComponent, {
   type OnEndMentionEvent,
 } from './EnrichedMarkdownTextInputNativeComponent';
 export type {
+  OnKeyPressEvent,
   OnLinkDetected,
   OnStartMentionEvent,
   OnChangeMentionEvent,
@@ -37,9 +40,11 @@ import type {
   TextStyle,
   ColorValue,
 } from 'react-native';
+import type { OnPasteEvent } from './types/events';
 import { normalizeMarkdownTextInputStyle } from './normalizeMarkdownTextInputStyle';
 import { normalizeMenuItem } from './normalizeMenuItem';
 import { toNativeRegexConfig } from './utils/regexParser';
+import { TextInputState } from './utils/textInputState';
 import type { RefObject } from 'react';
 
 type NativeRef = HostInstance;
@@ -50,7 +55,12 @@ export interface LinkStyle {
   backgroundColor?: string;
 }
 
-export interface MathStyle {
+/**
+ * Chip style for inline math (`$...$`) in the editor. Mirrors the read-only
+ * renderer's `markdownStyle.inlineMath`, which shares `color`; the remaining
+ * fields are the chip's own box and have no counterpart there.
+ */
+export interface InputInlineMathStyle {
   color?: string;
   fontSize?: number;
   backgroundColor?: string;
@@ -64,10 +74,36 @@ export interface MathStyle {
   fontWeight?: 'bold' | 'normal';
 }
 
-export interface MathBlockStyle extends MathStyle {
+/**
+ * Chip style for block math (`$$...$$`) in the editor. Field names mirror the
+ * read-only renderer's `markdownStyle.math` (`padding`, `marginTop`,
+ * `marginBottom`, `textAlign`) so the same key means the same thing on both
+ * surfaces; the chip additionally splits `padding` per axis.
+ */
+export interface InputMathStyle extends InputInlineMathStyle {
+  /**
+   * Shorthand for both padding axes, matching the renderer's
+   * `markdownStyle.math.padding`. `paddingHorizontal` / `paddingVertical`
+   * override it per axis when both are given.
+   */
+  padding?: number;
   marginTop?: number;
   marginBottom?: number;
-  alignment?: 'left' | 'center' | 'right';
+  textAlign?: 'left' | 'center' | 'right';
+}
+
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+
+const VALID_HEADING_LEVELS = new Set<number>([1, 2, 3, 4, 5, 6]);
+
+function toHeadingLevel(n: number): HeadingLevel {
+  return (VALID_HEADING_LEVELS.has(n) ? n : 1) as HeadingLevel;
+}
+
+export interface HeadingStyle {
+  fontSize?: number;
+  fontWeight?: string;
+  color?: string;
 }
 
 export interface MarkdownTextInputStyle {
@@ -83,8 +119,28 @@ export interface MarkdownTextInputStyle {
     color?: string;
     backgroundColor?: string;
   };
-  math?: MathStyle;
-  mathBlock?: MathBlockStyle;
+  inlineMath?: InputInlineMathStyle;
+  math?: InputMathStyle;
+  /**
+   * Per-level heading styling for the editor, mirroring the readonly
+   * renderer's `markdownStyle` h1..h6. Omitted levels fall back to defaults
+   * (font sizes 30/24/20/18/16/14).
+   */
+  h1?: HeadingStyle;
+  h2?: HeadingStyle;
+  h3?: HeadingStyle;
+  h4?: HeadingStyle;
+  h5?: HeadingStyle;
+  h6?: HeadingStyle;
+  /** List styling shared by bullet and numbered lists. */
+  list?: {
+    /**
+     * Vertical spacing (points) added above each list item so items read as
+     * separate rows. iOS uses `paragraphSpacingBefore`; Android a `LineHeightSpan`.
+     * @default 0
+     */
+    itemSpacing?: number;
+  };
 }
 
 export interface StyleState {
@@ -94,6 +150,9 @@ export interface StyleState {
   strikethrough: { isActive: boolean };
   spoiler: { isActive: boolean };
   link: { isActive: boolean };
+  heading: { isActive: boolean; level: HeadingLevel };
+  unorderedList: { isActive: boolean; depth: number };
+  orderedList: { isActive: boolean; depth: number };
 }
 
 export interface ContextMenuItem {
@@ -139,8 +198,14 @@ export interface EnrichedMarkdownTextInputInstance {
   toggleUnderline: () => void;
   toggleStrikethrough: () => void;
   toggleSpoiler: () => void;
+  toggleHeading: (level: HeadingLevel) => void;
+  toggleUnorderedList: () => void;
+  toggleOrderedList: () => void;
+  indentList: () => void;
+  outdentList: () => void;
   setLink: (url: string) => void;
   insertLink: (text: string, url: string) => void;
+  insertText: (text: string) => void;
   insertMention: (displayText: string, url: string) => void;
   startMention: (indicator: string) => void;
   removeLink: () => void;
@@ -152,6 +217,13 @@ export interface EnrichedMarkdownTextInputInstance {
   ) => void;
   removeMath: (start: number) => void;
   copyToClipboard: () => void;
+  /**
+   * Completes a paste reported through `onPaste`. Call it exactly once per
+   * event: `resolvePaste('', '')` drops the clipboard content (replacing any
+   * selection), a non-empty `markdown` re-applies the copied formatting, and
+   * plain `text` inserts verbatim.
+   */
+  resolvePaste: (text: string, markdown?: string) => void;
   getMarkdown: () => Promise<string>;
   getCaretRect: () => Promise<CaretRect>;
 }
@@ -204,7 +276,17 @@ export interface EnrichedMarkdownTextInputProps extends Omit<
   editable?: boolean;
   autoFocus?: boolean;
   scrollEnabled?: boolean;
+  blockSyntax?: boolean;
   autoCapitalize?: string;
+  /**
+   * Report pastes through `onPaste` instead of inserting them. Only takes
+   * effect when `onPaste` is also set — otherwise native would swallow every
+   * paste with nobody left to resolve it.
+   *
+   * macOS ignores this prop and always pastes inline.
+   * @default false
+   */
+  interceptPaste?: boolean;
   multiline?: boolean;
   cursorColor?: ColorValue;
   selectionColor?: ColorValue;
@@ -214,9 +296,16 @@ export interface EnrichedMarkdownTextInputProps extends Omit<
   onChangeMarkdown?: (markdown: string) => void;
   onChangeSelection?: (selection: { start: number; end: number }) => void;
   onChangeState?: (state: StyleState) => void;
+  onKeyPress?: (e: NativeSyntheticEvent<OnKeyPressEvent>) => void;
   onCaretRectChange?: (rect: CaretRect) => void;
   onLinkDetected?: (event: OnLinkDetected) => void;
   onMathPress?: (event: OnMathPressEvent) => void;
+  /**
+   * Fires instead of the insert when `interceptPaste` is on. The handler owns
+   * the paste from here: it must call `resolvePaste` exactly once, on every
+   * path including failures, or the paste is silently dropped.
+   */
+  onPaste?: (event: OnPasteEvent) => void;
   mentionIndicators?: string[];
   onStartMention?: (event: OnStartMentionEvent) => void;
   onChangeMention?: (event: OnChangeMentionEvent) => void;
@@ -284,7 +373,9 @@ export const EnrichedMarkdownTextInput = ({
   editable = true,
   autoFocus = false,
   scrollEnabled = true,
+  blockSyntax = true,
   autoCapitalize = 'sentences',
+  interceptPaste = false,
   multiline = true,
   cursorColor,
   selectionColor,
@@ -292,9 +383,11 @@ export const EnrichedMarkdownTextInput = ({
   onChangeMarkdown,
   onChangeSelection,
   onChangeState,
+  onKeyPress,
   onCaretRectChange,
   onLinkDetected,
   onMathPress,
+  onPaste,
   mentionIndicators,
   onStartMention,
   onChangeMention,
@@ -352,6 +445,27 @@ export const EnrichedMarkdownTextInput = ({
     };
   }, []);
 
+  /**
+   * Mirrors the built-in TextInput's TextInputState integration so scroll
+   * containers' keyboardShouldPersistTaps logic and Keyboard.dismiss treat
+   * this input like a native TextInput. See utils/textInputState.ts for the
+   * full rationale. The unmount cleanup blurs through blurTextInput so both
+   * the registry entry and the native focus are released, matching the
+   * TextInput unmount path.
+   */
+  useLayoutEffect(() => {
+    const instance = nativeRef.current;
+    if (instance == null) return;
+
+    TextInputState.registerInput(instance);
+    return () => {
+      if (TextInputState.currentlyFocusedInput() === instance) {
+        TextInputState.blurTextInput(instance);
+      }
+      TextInputState.unregisterInput(instance);
+    };
+  }, []);
+
   const normalizedStyle = normalizeMarkdownTextInputStyle(markdownStyle);
 
   const normalizedSelectionMenuConfig = useMemo(() => {
@@ -436,6 +550,14 @@ export const EnrichedMarkdownTextInput = ({
     [onMathPress]
   );
 
+  const handlePaste = useCallback(
+    (e: NativeSyntheticEvent<OnPasteEvent>) => {
+      const { text, markdown } = e.nativeEvent;
+      onPaste?.({ text, markdown });
+    },
+    [onPaste]
+  );
+
   const handleChangeText = useCallback(
     (e: NativeSyntheticEvent<OnChangeTextEvent>) => {
       onChangeText?.(e.nativeEvent.value);
@@ -460,8 +582,17 @@ export const EnrichedMarkdownTextInput = ({
 
   const handleChangeState = useCallback(
     (e: NativeSyntheticEvent<OnChangeStateEvent>) => {
-      const { bold, italic, underline, strikethrough, spoiler, link } =
-        e.nativeEvent;
+      const {
+        bold,
+        italic,
+        underline,
+        strikethrough,
+        spoiler,
+        link,
+        heading,
+        unorderedList,
+        orderedList,
+      } = e.nativeEvent;
       onChangeState?.({
         bold,
         italic,
@@ -469,6 +600,9 @@ export const EnrichedMarkdownTextInput = ({
         strikethrough,
         spoiler,
         link,
+        heading: { ...heading, level: toHeadingLevel(heading.level) },
+        unorderedList,
+        orderedList,
       });
     },
     [onChangeState]
@@ -504,10 +638,12 @@ export const EnrichedMarkdownTextInput = ({
   );
 
   const handleFocus = useCallback(() => {
+    TextInputState.focusInput(nativeRef.current);
     onFocus?.();
   }, [onFocus]);
 
   const handleBlur = useCallback(() => {
+    TextInputState.blurInput(nativeRef.current);
     onBlur?.();
   }, [onBlur]);
 
@@ -548,7 +684,13 @@ export const EnrichedMarkdownTextInput = ({
       callback?.({
         text: selectedText,
         selection: { start: selectionStart, end: selectionEnd },
-        styleState,
+        styleState: {
+          ...styleState,
+          heading: {
+            ...styleState.heading,
+            level: toHeadingLevel(styleState.heading.level),
+          },
+        },
       });
     },
     []
@@ -574,8 +716,14 @@ export const EnrichedMarkdownTextInput = ({
       toggleUnderline: () => Commands.toggleUnderline(commandRef),
       toggleStrikethrough: () => Commands.toggleStrikethrough(commandRef),
       toggleSpoiler: () => Commands.toggleSpoiler(commandRef),
+      toggleHeading: (level) => Commands.toggleHeading(commandRef, level),
+      toggleUnorderedList: () => Commands.toggleUnorderedList(commandRef),
+      toggleOrderedList: () => Commands.toggleOrderedList(commandRef),
+      indentList: () => Commands.indentList(commandRef),
+      outdentList: () => Commands.outdentList(commandRef),
       setLink: (url) => Commands.setLink(commandRef, url),
       insertLink: (text, url) => Commands.insertLink(commandRef, text, url),
+      insertText: (text) => Commands.insertText(commandRef, text),
       insertMention: (displayText, url) =>
         Commands.insertMention(commandRef, displayText, url),
       startMention: (indicator) => Commands.startMention(commandRef, indicator),
@@ -591,6 +739,8 @@ export const EnrichedMarkdownTextInput = ({
         ),
       removeMath: (start) => Commands.removeMath(commandRef, start),
       copyToClipboard: () => Commands.copyToClipboard(commandRef),
+      resolvePaste: (text, markdown = '') =>
+        Commands.resolvePaste(commandRef, text, markdown),
       getMarkdown: () =>
         new Promise<string>((resolve, reject) => {
           const requestId = nextRequestId.current++;
@@ -620,7 +770,9 @@ export const EnrichedMarkdownTextInput = ({
       editable={editable}
       autoFocus={autoFocus}
       scrollEnabled={scrollEnabled}
+      blockSyntax={blockSyntax}
       autoCapitalize={autoCapitalize}
+      interceptPaste={interceptPaste === true && onPaste != null}
       multiline={multiline}
       cursorColor={cursorColor}
       selectionColor={selectionColor}
@@ -631,8 +783,10 @@ export const EnrichedMarkdownTextInput = ({
         handleChangeSelection as NativeProps['onChangeSelection']
       }
       onChangeState={handleChangeState as NativeProps['onChangeState']}
+      onInputKeyPress={onKeyPress as NativeProps['onInputKeyPress']}
       onLinkDetected={handleLinkDetected as NativeProps['onLinkDetected']}
       onMathPress={handleMathPress as NativeProps['onMathPress']}
+      onPaste={handlePaste as NativeProps['onPaste']}
       onInputFocus={handleFocus as NativeProps['onInputFocus']}
       onInputBlur={handleBlur as NativeProps['onInputBlur']}
       onRequestMarkdownResult={

package/src/EnrichedMarkdownTextInputNativeComponent.ts

@@ -8,7 +8,13 @@ import {
 } from 'react-native';
 import type React from 'react';
 
-interface MathStyleInternal {
+interface HeadingStyleInternal {
+  fontSize: CodegenTypes.Float;
+  fontWeight: string;
+  color: ColorValue;
+}
+
+interface InputInlineMathStyleInternal {
   color: ColorValue;
   fontSize: CodegenTypes.Float;
   backgroundColor: ColorValue;
@@ -22,10 +28,10 @@ interface MathStyleInternal {
   fontWeight: string;
 }
 
-interface MathBlockStyleInternal extends MathStyleInternal {
+interface InputMathStyleInternal extends InputInlineMathStyleInternal {
   marginTop: CodegenTypes.Float;
   marginBottom: CodegenTypes.Float;
-  alignment: string;
+  textAlign: string;
 }
 
 interface MarkdownTextInputStyleInternal {
@@ -52,8 +58,27 @@ interface MarkdownTextInputStyleInternal {
     color: ColorValue;
     backgroundColor: ColorValue;
   };
-  math: MathStyleInternal;
-  mathBlock: MathBlockStyleInternal;
+  // Per-level heading styles, mirroring the readonly renderer's markdownStyle
+  // h1..h6 so heading sizing is configured consistently across read and edit
+  // views. Always provided with complete defaults via normalizeMarkdownTextInputStyle.
+  h1: HeadingStyleInternal;
+  h2: HeadingStyleInternal;
+  h3: HeadingStyleInternal;
+  h4: HeadingStyleInternal;
+  h5: HeadingStyleInternal;
+  h6: HeadingStyleInternal;
+  list: {
+    // Vertical spacing (points) added above each list item. iOS applies it via
+    // paragraphSpacingBefore; Android via a LineHeightSpan. Float for parity with
+    // every other spacing value in the library.
+    itemSpacing: CodegenTypes.Float;
+  };
+  // Inline math (`$...$`) chip; block math (`$$...$$`) chip. Key names and the
+  // shared field names match the read-only renderer's markdownStyle. The
+  // author-facing `math.padding` shorthand is expanded into the two axes by
+  // normalizeMarkdownTextInputStyle, so nothing below carries it.
+  inlineMath: InputInlineMathStyleInternal;
+  math: InputMathStyleInternal;
 }
 
 interface TargetedEvent {
@@ -68,6 +93,10 @@ export interface OnChangeMarkdownEvent {
   value: string;
 }
 
+export interface OnKeyPressEvent {
+  key: string;
+}
+
 export interface OnChangeSelectionEvent {
   start: CodegenTypes.Int32;
   end: CodegenTypes.Int32;
@@ -80,6 +109,9 @@ export interface OnChangeStateEvent {
   strikethrough: { isActive: boolean };
   spoiler: { isActive: boolean };
   link: { isActive: boolean };
+  heading: { isActive: boolean; level: CodegenTypes.Int32 };
+  unorderedList: { isActive: boolean; depth: CodegenTypes.Int32 };
+  orderedList: { isActive: boolean; depth: CodegenTypes.Int32 };
 }
 
 export interface OnRequestMarkdownResultEvent {
@@ -141,6 +173,11 @@ export interface OnEndMentionEvent {
   indicator: string;
 }
 
+export interface OnPasteEvent {
+  text: string;
+  markdown: string;
+}
+
 export interface ContextMenuItemConfig {
   text: string;
   icon?: string;
@@ -180,6 +217,9 @@ export interface OnContextMenuItemPressEvent {
     strikethrough: { isActive: boolean };
     spoiler: { isActive: boolean };
     link: { isActive: boolean };
+    heading: { isActive: boolean; level: CodegenTypes.Int32 };
+    unorderedList: { isActive: boolean; depth: CodegenTypes.Int32 };
+    orderedList: { isActive: boolean; depth: CodegenTypes.Int32 };
   };
 }
 
@@ -211,10 +251,31 @@ export interface NativeProps extends ViewProps {
    * @default true
    */
   scrollEnabled?: boolean;
+  /**
+   * Whether block-level markdown syntax is interpreted.
+   *
+   * When `false`, list markers, headings, blockquotes, tables, code blocks and
+   * thematic breaks stay in the text verbatim instead of being consumed as
+   * structure, so the markdown round-trips byte-for-byte. Inline syntax
+   * (`**bold**`, links, `$math$`) still applies. `\r\n` is normalized to `\n`
+   * and `U+000B` is stripped from the input.
+   * @default true
+   */
+  blockSyntax?: boolean;
   /**
    * Auto-capitalization behavior.
    */
   autoCapitalize?: string;
+  /**
+   * When `true`, a paste is reported through `onPaste` instead of being
+   * inserted. Native reads the clipboard and leaves the buffer untouched — the
+   * JS handler decides what happens and must call the `resolvePaste` command
+   * exactly once, or the paste is dropped.
+   *
+   * macOS ignores this prop and always pastes inline.
+   * @default false
+   */
+  interceptPaste?: boolean;
   /**
    * Whether the input supports multiple lines.
    * @default true
@@ -292,6 +353,7 @@ export interface NativeProps extends ViewProps {
   onChangeText?: CodegenTypes.DirectEventHandler<OnChangeTextEvent>;
   onChangeMarkdown?: CodegenTypes.DirectEventHandler<OnChangeMarkdownEvent>;
   onChangeSelection?: CodegenTypes.DirectEventHandler<OnChangeSelectionEvent>;
+  onInputKeyPress?: CodegenTypes.DirectEventHandler<OnKeyPressEvent>;
   onChangeState?: CodegenTypes.DirectEventHandler<OnChangeStateEvent>;
   onInputFocus?: CodegenTypes.DirectEventHandler<TargetedEvent>;
   onInputBlur?: CodegenTypes.DirectEventHandler<TargetedEvent>;
@@ -301,6 +363,7 @@ export interface NativeProps extends ViewProps {
   onContextMenuItemPress?: CodegenTypes.DirectEventHandler<OnContextMenuItemPressEvent>;
   onLinkDetected?: CodegenTypes.DirectEventHandler<OnLinkDetected>;
   onMathPress?: CodegenTypes.DirectEventHandler<OnMathPressNativeEvent>;
+  onPaste?: CodegenTypes.DirectEventHandler<OnPasteEvent>;
   onStartMention?: CodegenTypes.DirectEventHandler<OnStartMentionEvent>;
   onChangeMention?: CodegenTypes.DirectEventHandler<OnChangeMentionEvent>;
   onEndMention?: CodegenTypes.DirectEventHandler<OnEndMentionEvent>;
@@ -325,12 +388,21 @@ interface NativeCommands {
   toggleUnderline: (viewRef: React.ElementRef<ComponentType>) => void;
   toggleStrikethrough: (viewRef: React.ElementRef<ComponentType>) => void;
   toggleSpoiler: (viewRef: React.ElementRef<ComponentType>) => void;
+  toggleHeading: (
+    viewRef: React.ElementRef<ComponentType>,
+    level: CodegenTypes.Int32
+  ) => void;
+  toggleUnorderedList: (viewRef: React.ElementRef<ComponentType>) => void;
+  toggleOrderedList: (viewRef: React.ElementRef<ComponentType>) => void;
+  indentList: (viewRef: React.ElementRef<ComponentType>) => void;
+  outdentList: (viewRef: React.ElementRef<ComponentType>) => void;
   setLink: (viewRef: React.ElementRef<ComponentType>, url: string) => void;
   insertLink: (
     viewRef: React.ElementRef<ComponentType>,
     text: string,
     url: string
   ) => void;
+  insertText: (viewRef: React.ElementRef<ComponentType>, text: string) => void;
   insertMention: (
     viewRef: React.ElementRef<ComponentType>,
     displayText: string,
@@ -357,6 +429,11 @@ interface NativeCommands {
     start: CodegenTypes.Int32
   ) => void;
   copyToClipboard: (viewRef: React.ElementRef<ComponentType>) => void;
+  resolvePaste: (
+    viewRef: React.ElementRef<ComponentType>,
+    text: string,
+    markdown: string
+  ) => void;
   requestMarkdown: (
     viewRef: React.ElementRef<ComponentType>,
     requestId: CodegenTypes.Int32
@@ -378,8 +455,14 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
     'toggleUnderline',
     'toggleStrikethrough',
     'toggleSpoiler',
+    'toggleHeading',
+    'toggleUnorderedList',
+    'toggleOrderedList',
+    'indentList',
+    'outdentList',
     'setLink',
     'insertLink',
+    'insertText',
     'insertMention',
     'startMention',
     'removeLink',
@@ -387,6 +470,7 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
     'updateMath',
     'removeMath',
     'copyToClipboard',
+    'resolvePaste',
     'requestMarkdown',
     'requestCaretRect',
   ],

package/src/EnrichedMarkdownTextNativeComponent.ts

@@ -29,6 +29,8 @@ interface BlockquoteStyleInternal extends BaseBlockStyleInternal {
   borderWidth: CodegenTypes.Float;
   gapWidth: CodegenTypes.Float;
   backgroundColor: ColorValue;
+  borderRadius: CodegenTypes.Float;
+  padding: CodegenTypes.Float;
 }
 
 interface ListStyleInternal extends BaseBlockStyleInternal {
@@ -39,6 +41,24 @@ interface ListStyleInternal extends BaseBlockStyleInternal {
   markerFontWeight: string;
   gapWidth: CodegenTypes.Float;
   marginLeft: CodegenTypes.Float;
+  itemSpacing: CodegenTypes.Float;
+}
+
+interface CodeBlockSyntaxColorsInternal {
+  keyword: ColorValue;
+  operatorColor: ColorValue;
+  punctuation: ColorValue;
+  string: ColorValue;
+  number: ColorValue;
+  constant: ColorValue;
+  comment: ColorValue;
+  function: ColorValue;
+  type: ColorValue;
+  variable: ColorValue;
+  property: ColorValue;
+  tag: ColorValue;
+  attribute: ColorValue;
+  embedded: ColorValue;
 }
 
 interface CodeBlockStyleInternal extends BaseBlockStyleInternal {
@@ -47,6 +67,7 @@ interface CodeBlockStyleInternal extends BaseBlockStyleInternal {
   borderRadius: CodegenTypes.Float;
   borderWidth: CodegenTypes.Float;
   padding: CodegenTypes.Float;
+  syntaxColors: CodeBlockSyntaxColorsInternal;
 }
 
 interface LinkStyleInternal {
@@ -94,6 +115,10 @@ interface CodeStyleInternal {
 
 interface ImageStyleInternal {
   height: CodegenTypes.Float;
+  maxHeight: CodegenTypes.Float;
+  aspectRatio: CodegenTypes.Float;
+  // Nested struct fields cannot use WithDefault; default is applied in JS normalization.
+  resizeMode: string;
   borderRadius: CodegenTypes.Float;
   marginTop: CodegenTypes.Float;
   marginBottom: CodegenTypes.Float;
@@ -121,6 +146,8 @@ interface TableStyleInternal extends BaseBlockStyleInternal {
   borderRadius: CodegenTypes.Float;
   cellPaddingHorizontal: CodegenTypes.Float;
   cellPaddingVertical: CodegenTypes.Float;
+  horizontalOverflow: CodegenTypes.Float;
+  align: string;
 }
 
 interface TaskListStyleInternal {
@@ -225,11 +252,21 @@ export interface TaskListItemPressEvent {
   text: string;
 }
 
+export interface CopyPressEvent {
+  code: string;
+  language: string;
+}
+
 export interface ContextMenuItemConfig {
   text: string;
   icon?: string;
 }
 
+export interface ImageRequestHeaderInternal {
+  name: string;
+  value: string;
+}
+
 export interface SelectionMenuConfig {
   copyAsMarkdown: boolean;
   copyImageUrl: boolean;
@@ -311,10 +348,16 @@ export interface Md4cFlagsInternal {
    * @default false
    */
   highlight: boolean;
+  /**
+   * Treat soft breaks (single newlines) as hard breaks (visible line breaks).
+   * @default false
+   */
+  hardSoftBreaks: boolean;
 }
 
 interface StreamingConfigInternal {
   tableMode: string;
+  codeBlockMode: string;
 }
 
 export interface NativeProps extends ViewProps {
@@ -345,6 +388,21 @@ export interface NativeProps extends ViewProps {
    * Receives the 0-based task index, current checked state, and the item's plain text.
    */
   onTaskListItemPress?: CodegenTypes.BubblingEventHandler<TaskListItemPressEvent>;
+  /**
+   * Controls whether tapping a task list checkbox toggles its checked state.
+   *
+   * When `false`, the tap is fully inert: no visual toggle and no
+   * `onTaskListItemPress` emission. Text selection and links are unaffected.
+   *
+   * @default true
+   */
+  enableTaskListItemToggle?: CodegenTypes.WithDefault<boolean, true>;
+  /**
+   * Callback fired when code is copied from a fenced code block's header copy
+   * button, its long-press context-menu "Copy" action, or the VoiceOver copy
+   * action. Receives the copied code and its language.
+   */
+  onCopyPress?: CodegenTypes.BubblingEventHandler<CopyPressEvent>;
   /**
    * Controls whether the system link preview is shown on long press (iOS only).
    *
@@ -424,10 +482,18 @@ export interface NativeProps extends ViewProps {
    * @default 'particles'
    */
   spoilerOverlay?: CodegenTypes.WithDefault<string, 'particles'>;
+  /**
+   * Hides the text selection context menu while keeping text selectable.
+   */
+  contextMenuHidden?: CodegenTypes.WithDefault<boolean, false>;
   /**
    * Custom items to show in the text selection context menu.
    */
   contextMenuItems?: ReadonlyArray<Readonly<ContextMenuItemConfig>>;
+  /**
+   * HTTP headers attached to remote image requests, as name/value pairs.
+   */
+  imageRequestHeaders?: ReadonlyArray<Readonly<ImageRequestHeaderInternal>>;
   /**
    * Built-in items to show in the text selection context menu.
    */