@apollohg/react-native-rich-text-editor 2.0.2 → 2.0.4

package/dist/useRichTextEditorPresentation.d.ts

@@ -2,4 +2,4 @@ import { type useRichTextEditorState } from './useRichTextEditorState';
 import { type useRichTextEditorMentions } from './useRichTextEditorMentions';
 import { type useRichTextEditorCommands } from './useRichTextEditorCommands';
 import { type useRichTextEditorEvents } from './useRichTextEditorEvents';
-export declare function useRichTextEditorPresentation(context: Pick<ReturnType<typeof useRichTextEditorState>, 'theme' | 'addons' | 'imageLoadingPolicy' | 'androidInputOptions' | 'remoteSelections' | 'atoms' | 'atomState' | 'atomComponents' | 'warnedUnknownAtomTypesRef' | 'atomContentWidth' | 'atomPositions' | 'atomViewport' | 'virtualizeAtoms' | 'nativeAtomViewport' | 'selectedKeys' | 'editable' | 'atomsInteractive' | 'documentHandle' | 'activeState' | 'onRequestLink' | 'onRequestImage' | 'toolbarItemsSerializationCacheRef' | 'toolbarItems' | 'document' | 'toolbarPlacement' | 'showToolbar' | 'containerStyle' | 'style' | 'heightBehavior' | 'autoGrowHeight' | 'pushedUpdate' | 'editorId' | 'registeredToolbarFrames' | 'suppliedFocusPreservingFrames' | 'isFocused' | 'nativeViewRef' | 'refreshFocusPreservingFrames' | 'accessibilityLabel' | 'accessibilityHint' | 'placeholder' | 'autoFocus' | 'autoCapitalize' | 'autoCorrect' | 'keyboardType' | 'allowImageResizing' | 'toolbarFrameOwnerId' | 'onToolbarAction'> & Pick<ReturnType<typeof useRichTextEditorMentions>, 'mentionSuggestionTheme' | 'handleAddonEvent'> & Pick<ReturnType<typeof useRichTextEditorCommands>, 'runAtomAction' | 'updateAtomAttrs' | 'atomOwnerRef' | 'commandToggleMark' | 'commandToggleList' | 'commandToggleHeading' | 'commandToggleBlockquote' | 'commandInsertNode' | 'commandIndentListItem' | 'commandOutdentListItem' | 'openLinkRequest' | 'openImageRequest'> & Pick<ReturnType<typeof useRichTextEditorEvents>, 'handleEditorUpdate' | 'handleEditorError' | 'handleExternalTextCompositionEnd' | 'handleSelectionChange' | 'handleFocusChange' | 'handleContentHeightChange' | 'handleAtomLayout' | 'handleToolbarAction'>): import("react/jsx-runtime").JSX.Element | null;
+export declare function useRichTextEditorPresentation(context: Pick<ReturnType<typeof useRichTextEditorState>, 'theme' | 'addons' | 'imageLoadingPolicy' | 'androidInputOptions' | 'remoteSelections' | 'atoms' | 'atomState' | 'atomComponents' | 'warnedUnknownAtomTypesRef' | 'atomContentWidth' | 'atomPositions' | 'atomViewport' | 'virtualizeAtoms' | 'nativeAtomViewport' | 'selectedKeys' | 'editable' | 'atomsInteractive' | 'documentHandle' | 'activeState' | 'onRequestLink' | 'onRequestImage' | 'toolbarItemsSerializationCacheRef' | 'toolbarItems' | 'document' | 'toolbarPlacement' | 'showToolbar' | 'containerStyle' | 'style' | 'heightBehavior' | 'autoGrowHeight' | 'pushedUpdate' | 'editorId' | 'registeredToolbarFrames' | 'suppliedFocusPreservingFrames' | 'isFocused' | 'nativeViewRef' | 'refreshFocusPreservingFrames' | 'accessibilityLabel' | 'accessibilityHint' | 'placeholder' | 'autoFocus' | 'pasteMode' | 'autoCapitalize' | 'autoCorrect' | 'keyboardType' | 'allowImageResizing' | 'toolbarFrameOwnerId' | 'onToolbarAction'> & Pick<ReturnType<typeof useRichTextEditorMentions>, 'mentionSuggestionTheme' | 'handleAddonEvent'> & Pick<ReturnType<typeof useRichTextEditorCommands>, 'runAtomAction' | 'updateAtomAttrs' | 'atomOwnerRef' | 'commandToggleMark' | 'commandToggleList' | 'commandToggleHeading' | 'commandToggleBlockquote' | 'commandInsertNode' | 'commandIndentListItem' | 'commandOutdentListItem' | 'openLinkRequest' | 'openImageRequest'> & Pick<ReturnType<typeof useRichTextEditorEvents>, 'handleEditorUpdate' | 'handleEditorError' | 'handleExternalTextCompositionEnd' | 'handleSelectionChange' | 'handleFocusChange' | 'handleContentHeightChange' | 'handleAtomLayout' | 'handleToolbarAction'>): import("react/jsx-runtime").JSX.Element | null;

package/dist/useRichTextEditorPresentation.js

@@ -17,7 +17,7 @@ const EditorToolbar_1 = require("./EditorToolbar");
 const RichTextEditorSerialization_1 = require("./RichTextEditorSerialization");
 const RichTextEditorNativeView_1 = require("./RichTextEditorNativeView");
 function useRichTextEditorPresentation(context) {
-    const { theme, mentionSuggestionTheme, addons, imageLoadingPolicy, androidInputOptions, remoteSelections, atoms, atomState, atomComponents, warnedUnknownAtomTypesRef, runAtomAction, updateAtomAttrs, atomOwnerRef, atomContentWidth, atomPositions, atomViewport, virtualizeAtoms, nativeAtomViewport, selectedKeys, editable, atomsInteractive, documentHandle, activeState, onRequestLink, onRequestImage, toolbarItemsSerializationCacheRef, toolbarItems, document, toolbarPlacement, showToolbar, containerStyle, style, heightBehavior, autoGrowHeight, pushedUpdate, editorId, registeredToolbarFrames, suppliedFocusPreservingFrames, isFocused, nativeViewRef, refreshFocusPreservingFrames, accessibilityLabel, accessibilityHint, placeholder, autoFocus, autoCapitalize, autoCorrect, keyboardType, allowImageResizing, handleEditorUpdate, handleEditorError, handleExternalTextCompositionEnd, handleSelectionChange, handleFocusChange, handleContentHeightChange, handleAtomLayout, handleToolbarAction, handleAddonEvent, toolbarFrameOwnerId, commandToggleMark, commandToggleList, commandToggleHeading, commandToggleBlockquote, commandInsertNode, commandIndentListItem, commandOutdentListItem, openLinkRequest, openImageRequest, onToolbarAction, } = context;
+    const { theme, mentionSuggestionTheme, addons, imageLoadingPolicy, androidInputOptions, remoteSelections, atoms, atomState, atomComponents, warnedUnknownAtomTypesRef, runAtomAction, updateAtomAttrs, atomOwnerRef, atomContentWidth, atomPositions, atomViewport, virtualizeAtoms, nativeAtomViewport, selectedKeys, editable, atomsInteractive, documentHandle, activeState, onRequestLink, onRequestImage, toolbarItemsSerializationCacheRef, toolbarItems, document, toolbarPlacement, showToolbar, containerStyle, style, heightBehavior, autoGrowHeight, pushedUpdate, editorId, registeredToolbarFrames, suppliedFocusPreservingFrames, isFocused, nativeViewRef, refreshFocusPreservingFrames, accessibilityLabel, accessibilityHint, placeholder, autoFocus, pasteMode, autoCapitalize, autoCorrect, keyboardType, allowImageResizing, handleEditorUpdate, handleEditorError, handleExternalTextCompositionEnd, handleSelectionChange, handleFocusChange, handleContentHeightChange, handleAtomLayout, handleToolbarAction, handleAddonEvent, toolbarFrameOwnerId, commandToggleMark, commandToggleList, commandToggleHeading, commandToggleBlockquote, commandInsertNode, commandIndentListItem, commandOutdentListItem, openLinkRequest, openImageRequest, onToolbarAction, } = context;
     const themeJson = (0, react_1.useMemo)(() => (0, EditorTheme_1.serializeEditorTheme)(theme, mentionSuggestionTheme), [mentionSuggestionTheme, theme]);
     const addonsJson = (0, RichTextEditorSerialization_1.useSerializedValue)(addons, value => (0, addons_1.serializeNormalizedEditorAddons)(value));
     const imageLoadingPolicyJson = (0, RichTextEditorSerialization_1.useSerializedValue)(imageLoadingPolicy, value => (0, ImageLoadingPolicy_1.serializeEditorImageLoadingPolicy)(value));
@@ -161,7 +161,7 @@ function useRichTextEditorPresentation(context) {
     const currentPushedUpdate = pushedUpdate?.editorId === editorId ? pushedUpdate : null;
     const focusPreservingFrames = [...registeredToolbarFrames, ...suppliedFocusPreservingFrames];
     const toolbarFrameJson = (0, RichTextEditorSerialization_1.serializeToolbarFrames)(editable && isFocused ? focusPreservingFrames : undefined);
-    return ((0, jsx_runtime_1.jsxs)(react_native_1.View, { style: [RichTextEditorNativeView_1.styles.container, containerStyle], children: [(0, jsx_runtime_1.jsx)(RichTextEditorNativeView_1.NativeEditorView, { ref: nativeViewRef, style: nativeViewStyle, onLayout: refreshFocusPreservingFrames, accessibilityLabel: accessibilityLabel, accessibilityHint: accessibilityHint, editorId: editorId, placeholder: placeholder, editable: editable, autoFocus: autoFocus, autoCapitalize: autoCapitalize, autoCorrect: autoCorrect, keyboardType: keyboardType, ...(react_native_1.Platform.OS === 'android' ? { androidInputOptionsJson } : {}), showToolbar: showToolbar, toolbarPlacement: toolbarPlacement, heightBehavior: heightBehavior, allowImageResizing: allowImageResizing, imageLoadingPolicyJson: imageLoadingPolicyJson, themeJson: themeJson, addonsJson: addonsJson, atomsJson: atomsJson, toolbarItemsJson: toolbarItemsJson, toolbarFrameJson: toolbarFrameJson, remoteSelectionsJson: remoteSelectionsJson, editorUpdateJson: currentPushedUpdate?.json, editorUpdateResetJson: currentPushedUpdate?.resetJson, editorUpdateEditorId: currentPushedUpdate?.editorId, editorUpdateRevision: currentPushedUpdate?.revision ?? 0, onEditorUpdate: handleEditorUpdate, onEditorError: handleEditorError, onExternalTextCompositionEnd: handleExternalTextCompositionEnd, onSelectionChange: handleSelectionChange, onFocusChange: handleFocusChange, onContentHeightChange: handleContentHeightChange, onAtomLayout: handleAtomLayout, onToolbarAction: handleToolbarAction, onAddonEvent: handleAddonEvent, children: atomChildren }), shouldRenderJsToolbar ? ((0, jsx_runtime_1.jsx)(react_native_1.View, { testID: 'native-editor-js-toolbar', style: [RichTextEditorNativeView_1.styles.inlineToolbar, { marginTop: inlineToolbarMarginTop }], children: (0, jsx_runtime_1.jsx)(EditorToolbar_1.EditorToolbarFrameOwnerProvider, { ownerId: toolbarFrameOwnerId, children: (0, jsx_runtime_1.jsx)(EditorToolbar_1.EditorToolbar, { activeState: activeState, historyState: document.historyState, toolbarItems: toolbarItems, theme: theme?.toolbar, showTopBorder: theme?.toolbar?.showTopBorder ?? false, preserveEditorFocus: false, onToggleMark: commandToggleMark, onToggleListType: (listType) => commandToggleList(listType), onToggleHeading: commandToggleHeading, onToggleBlockquote: commandToggleBlockquote, onInsertNodeType: commandInsertNode, onRunCommand: (command) => {
+    return ((0, jsx_runtime_1.jsxs)(react_native_1.View, { style: [RichTextEditorNativeView_1.styles.container, containerStyle], children: [(0, jsx_runtime_1.jsx)(RichTextEditorNativeView_1.NativeEditorView, { ref: nativeViewRef, style: nativeViewStyle, onLayout: refreshFocusPreservingFrames, accessibilityLabel: accessibilityLabel, accessibilityHint: accessibilityHint, editorId: editorId, placeholder: placeholder, editable: editable, autoFocus: autoFocus, pasteMode: pasteMode, autoCapitalize: autoCapitalize, autoCorrect: autoCorrect, keyboardType: keyboardType, ...(react_native_1.Platform.OS === 'android' ? { androidInputOptionsJson } : {}), showToolbar: showToolbar, toolbarPlacement: toolbarPlacement, heightBehavior: heightBehavior, allowImageResizing: allowImageResizing, imageLoadingPolicyJson: imageLoadingPolicyJson, themeJson: themeJson, addonsJson: addonsJson, atomsJson: atomsJson, toolbarItemsJson: toolbarItemsJson, toolbarFrameJson: toolbarFrameJson, remoteSelectionsJson: remoteSelectionsJson, editorUpdateJson: currentPushedUpdate?.json, editorUpdateResetJson: currentPushedUpdate?.resetJson, editorUpdateEditorId: currentPushedUpdate?.editorId, editorUpdateRevision: currentPushedUpdate?.revision ?? 0, onEditorUpdate: handleEditorUpdate, onEditorError: handleEditorError, onExternalTextCompositionEnd: handleExternalTextCompositionEnd, onSelectionChange: handleSelectionChange, onFocusChange: handleFocusChange, onContentHeightChange: handleContentHeightChange, onAtomLayout: handleAtomLayout, onToolbarAction: handleToolbarAction, onAddonEvent: handleAddonEvent, children: atomChildren }), shouldRenderJsToolbar ? ((0, jsx_runtime_1.jsx)(react_native_1.View, { testID: 'native-editor-js-toolbar', style: [RichTextEditorNativeView_1.styles.inlineToolbar, { marginTop: inlineToolbarMarginTop }], children: (0, jsx_runtime_1.jsx)(EditorToolbar_1.EditorToolbarFrameOwnerProvider, { ownerId: toolbarFrameOwnerId, children: (0, jsx_runtime_1.jsx)(EditorToolbar_1.EditorToolbar, { activeState: activeState, historyState: document.historyState, toolbarItems: toolbarItems, theme: theme?.toolbar, showTopBorder: theme?.toolbar?.showTopBorder ?? false, preserveEditorFocus: false, onToggleMark: commandToggleMark, onToggleListType: (listType) => commandToggleList(listType), onToggleHeading: commandToggleHeading, onToggleBlockquote: commandToggleBlockquote, onInsertNodeType: commandInsertNode, onRunCommand: (command) => {
                             switch (command) {
                                 case 'indentList':
                                     commandIndentListItem();

package/dist/useRichTextEditorState.d.ts

@@ -1,3 +1,4 @@
+import type { StyleProp, ViewStyle } from 'react-native';
 import { type EditorToolbarItem } from './EditorToolbar';
 import type React from 'react';
 import { type ReadonlyActiveState, type Selection } from './NativeEditorBridge';
@@ -8,7 +9,7 @@ import { type AtomViewport } from './AtomHost';
 import { type RichTextEditorProps, type RichTextEditorRef } from './RichTextEditorTypes';
 import { type AtomRenderState } from './RichTextEditorSerialization';
 import { type NativeEditorViewHandle, type NativeEditorErrorBinding, type NativeAtomPosition } from './RichTextEditorNativeTypes';
-export declare function useRichTextEditorState({ documentHandle, documentRevision, value, valueJSON, valueJSONRevision, valueJSONUpdateMode, placeholder, editable, autoFocus, autoCapitalize, autoCorrect, keyboardType, androidInputOptions, heightBehavior, showToolbar, toolbarPlacement, toolbarItems, onToolbarAction, onRequestLink, onRequestImage, imageLoadingPolicy, accessibilityLabel, accessibilityHint, style, containerStyle, theme, addons: addonDescriptors, atoms, atomsInteractive, virtualizeAtoms, atomViewport, remoteSelections, allowImageResizing, onContentChange, onContentChangeJSON, onSelectionChange, onActiveStateChange, onHistoryStateChange, onFocus, onBlur, focusPreservingRefs, onLocalCommit, }: RichTextEditorProps, ref: React.ForwardedRef<RichTextEditorRef>): {
+export declare function useRichTextEditorState({ documentHandle, documentRevision, value, valueJSON, valueJSONRevision, valueJSONUpdateMode, placeholder, editable, pasteMode, autoFocus, autoCapitalize, autoCorrect, keyboardType, androidInputOptions, heightBehavior, showToolbar, toolbarPlacement, toolbarItems, onToolbarAction, onRequestLink, onRequestImage, imageLoadingPolicy, accessibilityLabel, accessibilityHint, style, containerStyle, theme, addons: addonDescriptors, atoms, atomsInteractive, virtualizeAtoms, atomViewport, remoteSelections, allowImageResizing, onContentChange, onContentChangeJSON, onSelectionChange, onActiveStateChange, onHistoryStateChange, onFocus, onBlur, focusPreservingRefs, onLocalCommit, }: RichTextEditorProps, ref: React.ForwardedRef<RichTextEditorRef>): {
     atomStateRef: React.RefObject<AtomRenderState>;
     setSelectedKeys: React.Dispatch<React.SetStateAction<ReadonlySet<string>>>;
     bridge: import("./NativeEditorDocumentBridge").NativeEditorDocumentBridge;
@@ -156,8 +157,8 @@ export declare function useRichTextEditorState({ documentHandle, documentRevisio
     toolbarItems: readonly EditorToolbarItem[];
     toolbarPlacement: import("./RichTextEditorTypes").RichTextEditorToolbarPlacement;
     showToolbar: boolean;
-    containerStyle: import("react-native").StyleProp<import("react-native").ViewStyle>;
-    style: import("react-native").StyleProp<import("react-native").ViewStyle>;
+    containerStyle: StyleProp<ViewStyle>;
+    style: StyleProp<ViewStyle>;
     autoGrowHeight: number | null;
     pushedUpdate: {
         json: string;
@@ -172,6 +173,7 @@ export declare function useRichTextEditorState({ documentHandle, documentRevisio
     accessibilityHint: string | undefined;
     placeholder: string | undefined;
     autoFocus: boolean;
+    pasteMode: import("./RichTextEditorTypes").RichTextEditorPasteMode;
     autoCapitalize: import("./RichTextEditorTypes").RichTextEditorAutoCapitalize | undefined;
     autoCorrect: boolean | undefined;
     keyboardType: import("./RichTextEditorTypes").RichTextEditorKeyboardType | undefined;

package/dist/useRichTextEditorState.js

@@ -10,7 +10,7 @@ const useNativeEditor_1 = require("./useNativeEditor");
 const addons_1 = require("./addons");
 const useFocusPreservingFrames_1 = require("./useFocusPreservingFrames");
 const RichTextEditorSerialization_1 = require("./RichTextEditorSerialization");
-function useRichTextEditorState({ documentHandle, documentRevision, value, valueJSON, valueJSONRevision, valueJSONUpdateMode = 'replace', placeholder, editable = true, autoFocus = false, autoCapitalize, autoCorrect, keyboardType, androidInputOptions, heightBehavior = 'autoGrow', showToolbar = true, toolbarPlacement = 'keyboard', toolbarItems = EditorToolbar_1.DEFAULT_EDITOR_TOOLBAR_ITEMS, onToolbarAction, onRequestLink, onRequestImage, imageLoadingPolicy, accessibilityLabel, accessibilityHint, style, containerStyle, theme, addons: addonDescriptors, atoms, atomsInteractive = true, virtualizeAtoms = false, atomViewport, remoteSelections, allowImageResizing = true, onContentChange, onContentChangeJSON, onSelectionChange, onActiveStateChange, onHistoryStateChange, onFocus, onBlur, focusPreservingRefs, onLocalCommit, }, ref) {
+function useRichTextEditorState({ documentHandle, documentRevision, value, valueJSON, valueJSONRevision, valueJSONUpdateMode = 'replace', placeholder, editable = true, pasteMode = 'rich', autoFocus = false, autoCapitalize, autoCorrect, keyboardType, androidInputOptions, heightBehavior = 'autoGrow', showToolbar = true, toolbarPlacement = 'keyboard', toolbarItems = EditorToolbar_1.DEFAULT_EDITOR_TOOLBAR_ITEMS, onToolbarAction, onRequestLink, onRequestImage, imageLoadingPolicy, accessibilityLabel, accessibilityHint, style, containerStyle, theme, addons: addonDescriptors, atoms, atomsInteractive = true, virtualizeAtoms = false, atomViewport, remoteSelections, allowImageResizing = true, onContentChange, onContentChangeJSON, onSelectionChange, onActiveStateChange, onHistoryStateChange, onFocus, onBlur, focusPreservingRefs, onLocalCommit, }, ref) {
     const addons = (0, react_1.useMemo)(() => (0, addons_1.normalizeEditorAddons)(addonDescriptors), [addonDescriptors]);
     (0, NativeEditorBridge_1._assertNativeEditorDocumentHandle)(documentHandle);
     const documentDescriptor = (0, NativeEditorBridge_1._getNativeEditorDocumentHandleDescriptor)(documentHandle);
@@ -390,8 +390,8 @@ function useRichTextEditorState({ documentHandle, documentRevision, value, value
         toolbarItems,
         toolbarPlacement,
         showToolbar,
-        containerStyle,
-        style,
+        containerStyle: containerStyle,
+        style: style,
         autoGrowHeight,
         pushedUpdate,
         registeredToolbarFrames,
@@ -401,6 +401,7 @@ function useRichTextEditorState({ documentHandle, documentRevision, value, value
         accessibilityHint,
         placeholder,
         autoFocus,
+        pasteMode,
         autoCapitalize,
         autoCorrect,
         keyboardType,

package/ios/EditorTextView+KeyboardInput.swift

@@ -1,7 +1,306 @@
 import os
 import UIKit
 
+enum EditorPasteMode: String {
+    case rich
+    case plainText
+    case disabled
+}
+
+struct EditorClipboardPayload {
+    static let fragmentType = "com.apollohg.native-editor.fragment"
+
+    let fragment: String
+    let html: String
+    let text: String
+
+    init(fragment: String, html: String, text: String) {
+        self.fragment = fragment
+        self.html = html
+        self.text = text
+    }
+
+    init?(json: String) {
+        guard let data = json.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              object["empty"] as? Bool != true,
+              let fragment = object["fragment"] as? String,
+              let html = object["html"] as? String,
+              let text = object["text"] as? String
+        else { return nil }
+        self.init(fragment: fragment, html: html, text: text)
+    }
+
+    @discardableResult
+    func write(to pasteboard: UIPasteboard) -> Bool {
+        pasteboard.items = [[
+            Self.fragmentType: Data(fragment.utf8),
+            "public.html": Data(html.utf8),
+            "public.utf8-plain-text": text
+        ]]
+        return pasteboard.data(forPasteboardType: Self.fragmentType) != nil
+            && pasteboard.data(forPasteboardType: "public.html") != nil
+            && pasteboard.string != nil
+    }
+}
+
+enum EditorClipboardPaste {
+    static let maximumRTFBytes = 64 * 1_024 * 1_024
+
+    static let supportedTypes = [
+        EditorClipboardPayload.fragmentType,
+        "public.html",
+        "public.rtf",
+        "public.utf8-plain-text",
+        "public.plain-text",
+        "public.text"
+    ]
+
+    static func hasSupportedContent(in pasteboard: UIPasteboard) -> Bool {
+        pasteboard.contains(pasteboardTypes: supportedTypes)
+    }
+
+    static func command(
+        from pasteboard: UIPasteboard,
+        mode: EditorPasteMode,
+        maximumRTFBytes: Int = EditorClipboardPaste.maximumRTFBytes
+    ) -> [String: Any]? {
+        guard mode != .disabled else { return nil }
+        var command: [String: Any] = ["type": "paste"]
+        if let fragment = utf8String(pasteboard.data(forPasteboardType: EditorClipboardPayload.fragmentType)) {
+            command["fragment"] = fragment
+        }
+        var html = utf8String(pasteboard.data(forPasteboardType: "public.html"))
+        var text = pasteboard.string
+        if html == nil,
+           let rtf = pasteboard.data(forPasteboardType: "public.rtf"),
+           rtf.count <= maximumRTFBytes,
+           let attributed = try? NSAttributedString(
+               data: rtf,
+               options: [.documentType: NSAttributedString.DocumentType.rtf],
+               documentAttributes: nil
+           ) {
+            let convertedHTML = semanticHTML(from: attributed)
+            if !convertedHTML.isEmpty {
+                html = convertedHTML
+            }
+            if text == nil {
+                text = attributed.string
+            }
+        }
+        let hasStructuredContent = command["fragment"] != nil || html != nil
+        guard hasStructuredContent || !(text?.isEmpty ?? true) else { return nil }
+        if let html {
+            command["html"] = html
+        }
+        if let text {
+            command["text"] = text
+        }
+        if mode == .plainText {
+            command["plainText"] = true
+        }
+        return command.count > 1 ? command : nil
+    }
+
+    private static func utf8String(_ data: Data?) -> String? {
+        guard let data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    private static func semanticHTML(from attributed: NSAttributedString) -> String {
+        let range = NSRange(location: 0, length: attributed.length)
+        var hasList = false
+        attributed.enumerateAttribute(.paragraphStyle, in: range) { value, _, stop in
+            if let style = value as? NSParagraphStyle, !style.textLists.isEmpty {
+                hasList = true
+                stop.pointee = true
+            }
+        }
+        guard attributed.string.contains("\n") || attributed.string.contains("\r") || hasList else {
+            return semanticInlineHTML(from: attributed, range: range)
+        }
+
+        let string = attributed.string as NSString
+        var paragraphs: [(html: String, listTags: [String])] = []
+        var location = 0
+        while location < string.length {
+            let paragraphRange = string.paragraphRange(
+                for: NSRange(location: location, length: 0)
+            )
+            var contentLength = paragraphRange.length
+            while contentLength > 0 {
+                let scalar = string.character(at: paragraphRange.location + contentLength - 1)
+                guard scalar == 0x000A || scalar == 0x000D else { break }
+                contentLength -= 1
+            }
+            let contentRange = NSRange(location: paragraphRange.location, length: contentLength)
+            let styleLocation = min(paragraphRange.location, max(attributed.length - 1, 0))
+            let style = attributed.length > 0
+                ? attributed.attribute(.paragraphStyle, at: styleLocation, effectiveRange: nil)
+                    as? NSParagraphStyle
+                : nil
+            paragraphs.append((
+                html: semanticInlineHTML(from: attributed, range: contentRange),
+                listTags: style?.textLists.map(listTag) ?? []
+            ))
+            location = NSMaxRange(paragraphRange)
+        }
+        if let finalScalar = attributed.string.utf16.last,
+           finalScalar == 0x000A || finalScalar == 0x000D {
+            let style = attributed.attribute(
+                .paragraphStyle,
+                at: attributed.length - 1,
+                effectiveRange: nil
+            ) as? NSParagraphStyle
+            paragraphs.append((html: "", listTags: style?.textLists.map(listTag) ?? []))
+        }
+
+        var html = ""
+        var openListTags: [String] = []
+        for paragraph in paragraphs {
+            guard !paragraph.listTags.isEmpty else {
+                closeLists(&openListTags, into: &html)
+                html += "<p>\(paragraph.html)</p>"
+                continue
+            }
+
+            let sharedDepth = zip(openListTags, paragraph.listTags)
+                .prefix { $0.0 == $0.1 }
+                .count
+            while openListTags.count > sharedDepth {
+                let tag = openListTags.removeLast()
+                html += "</li></\(tag)>"
+            }
+            if !openListTags.isEmpty, openListTags.count == paragraph.listTags.count {
+                html += "</li><li>"
+            }
+            for tag in paragraph.listTags.dropFirst(sharedDepth) {
+                html += "<\(tag)><li>"
+                openListTags.append(tag)
+            }
+            html += paragraph.html
+        }
+        closeLists(&openListTags, into: &html)
+        return html
+    }
+
+    private static func semanticInlineHTML(
+        from attributed: NSAttributedString,
+        range: NSRange
+    ) -> String {
+        var html = ""
+        attributed.enumerateAttributes(in: range) { attributes, range, _ in
+            var run = escapeHTMLText(attributed.attributedSubstring(from: range).string)
+            if let font = attributes[.font] as? UIFont {
+                let traits = font.fontDescriptor.symbolicTraits
+                if traits.contains(.traitBold) {
+                    run = "<strong>\(run)</strong>"
+                }
+                if traits.contains(.traitItalic) {
+                    run = "<em>\(run)</em>"
+                }
+            }
+            if styleIsSet(attributes[.underlineStyle]) {
+                run = "<u>\(run)</u>"
+            }
+            if styleIsSet(attributes[.strikethroughStyle]) {
+                run = "<s>\(run)</s>"
+            }
+            if let href = linkString(attributes[.link]) {
+                run = "<a href=\"\(escapeHTMLAttribute(href))\">\(run)</a>"
+            }
+            html += run
+        }
+        guard !html.isEmpty else { return "" }
+        return "<span style=\"white-space:pre-wrap\">\(html)</span>"
+    }
+
+    private static func listTag(_ list: NSTextList) -> String {
+        let marker = String(describing: list.markerFormat).lowercased()
+        let orderedMarkers = ["decimal", "roman", "alpha", "latin"]
+        return orderedMarkers.contains { marker.contains($0) } ? "ol" : "ul"
+    }
+
+    private static func closeLists(_ tags: inout [String], into html: inout String) {
+        while let tag = tags.popLast() {
+            html += "</li></\(tag)>"
+        }
+    }
+
+    private static func escapeHTMLText(_ value: String) -> String {
+        value
+            .replacingOccurrences(of: "&", with: "&amp;")
+            .replacingOccurrences(of: "<", with: "&lt;")
+            .replacingOccurrences(of: ">", with: "&gt;")
+            .replacingOccurrences(of: "\r\n", with: "\n")
+            .replacingOccurrences(of: "\r", with: "\n")
+            .replacingOccurrences(of: "\n", with: "<br>")
+    }
+
+    private static func escapeHTMLAttribute(_ value: String) -> String {
+        value
+            .replacingOccurrences(of: "&", with: "&amp;")
+            .replacingOccurrences(of: "<", with: "&lt;")
+            .replacingOccurrences(of: ">", with: "&gt;")
+            .replacingOccurrences(of: "\"", with: "&quot;")
+            .replacingOccurrences(of: "'", with: "&#39;")
+    }
+
+    private static func styleIsSet(_ value: Any?) -> Bool {
+        guard let number = value as? NSNumber else { return false }
+        return number.intValue != 0
+    }
+
+    private static func linkString(_ value: Any?) -> String? {
+        if let url = value as? URL {
+            return url.absoluteString
+        }
+        return value as? String
+    }
+}
+
 extension EditorTextView {
+    @discardableResult
+    func exportSelectionToPasteboard(_ pasteboard: UIPasteboard = .general) -> Bool {
+        ensureInternalTextViewDelegate()
+        guard editorId != 0 else { return false }
+        guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return false }
+        guard prepareForExternalEditorUpdate() else { return false }
+        guard syncClipboardSelectionToRust(requiresRange: true) != nil else { return false }
+        guard let payload = EditorV2Shadow.clipboardPayload(id: editorId) else { return false }
+        return payload.write(to: pasteboard)
+    }
+
+    func syncClipboardSelectionToRust(
+        requiresRange: Bool = false
+    ) -> (anchor: UInt32, head: UInt32)? {
+        guard let selection = currentScalarSelection() else { return nil }
+        guard !requiresRange
+            || selection.anchor != selection.head
+            || selectedImageSelectionState() != nil
+        else { return nil }
+        let sync: EditorV2SelectionSync?
+        if let image = selectedImageSelectionState() {
+            sync = EditorV2Shadow.setNodeSelection(id: editorId, docPos: image.docPos)
+        } else {
+            sync = EditorV2Shadow.setSelectionScalar(
+                id: editorId,
+                scalarAnchor: selection.anchor,
+                scalarHead: selection.head
+            )
+        }
+        guard let sync else { return nil }
+        if let refreshed = sync.refreshedUpdateJSON {
+            applyUpdateJSON(refreshed, notifyDelegate: false)
+        }
+        return selection
+    }
+
+    func applyClipboardCommand(_ command: [String: Any]) {
+        let updateJSON = EditorV2Shadow.applyClipboardCommand(id: editorId, command: command)
+        applyUpdateJSON(updateJSON)
+    }
+
     @objc func handleIndentKeyCommand() {
         handleListDepthKeyCommand(outdent: false)
     }

package/ios/EditorTextView+Selection.swift

@@ -49,7 +49,8 @@ extension EditorTextView {
               prepareForExternalEditorUpdate(),
               let position = closestPosition(to: point)
         else { return false }
-        let offset = self.offset(from: beginningOfDocument, to: position)
+        let caretPosition = autocapitalizationFriendlyEmptyBlockPosition(for: position) ?? position
+        let offset = self.offset(from: beginningOfDocument, to: caretPosition)
         guard !isAtomBoundaryCaretOffset(offset) else { return false }
         _ = becomeFirstResponder()
         logicalSelectionScalarRange = nil
@@ -154,7 +155,9 @@ extension EditorTextView {
            selectedRange.length == 0,
            let point = caretPlacementTapRecognizer.pendingCaretPoint,
            let position = closestPosition(to: point) {
-            let offset = self.offset(from: beginningOfDocument, to: position)
+            // Match empty-block normalization so synchronous callbacks cannot alternate offsets.
+            let caretPosition = autocapitalizationFriendlyEmptyBlockPosition(for: position) ?? position
+            let offset = self.offset(from: beginningOfDocument, to: caretPosition)
             if selectedRange.location != offset, !isAtomBoundaryCaretOffset(offset) {
                 // Correct UIKit's word snap before publishing or drawing the selection.
                 selectedRange = NSRange(location: offset, length: 0)

package/ios/EditorTextView.swift

@@ -35,6 +35,7 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
     var hidesNativeSelectionChrome = false
     var isPreviewingImageResize = false
     var allowImageResizing = true
+    var pasteMode: EditorPasteMode = .rich
 
     override var isEditable: Bool {
         didSet {
@@ -622,6 +623,11 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
                 input: "\t",
                 modifierFlags: [.shift],
                 action: #selector(handleOutdentKeyCommand)
+            ),
+            UIKeyCommand(
+                input: "v",
+                modifierFlags: [.command, .shift],
+                action: #selector(pasteAndMatchStyle(_:))
             )
         ]
     }
@@ -875,61 +881,75 @@ final class EditorTextView: UITextView, UIGestureRecognizerDelegate, UITextDragD
         }
     }
 
-    // MARK: - Paste Handling
+    // MARK: - Clipboard
+
+    override func canPerformAction(_ action: Selector, withSender sender: Any?) -> Bool {
+        guard editorId != 0 else {
+            return super.canPerformAction(action, withSender: sender)
+        }
+        switch action {
+        case #selector(copy(_:)):
+            return selectedTextRange?.isEmpty == false
+        case #selector(cut(_:)):
+            return isEditable && selectedTextRange?.isEmpty == false
+        case #selector(paste(_:)), #selector(pasteAndMatchStyle(_:)):
+            return isEditable
+                && pasteMode != .disabled
+                && EditorClipboardPaste.hasSupportedContent(in: .general)
+        default:
+            return super.canPerformAction(action, withSender: sender)
+        }
+    }
+
+    override func copy(_ sender: Any?) {
+        guard editorId != 0 else {
+            super.copy(sender)
+            return
+        }
+        _ = exportSelectionToPasteboard()
+    }
+
+    override func cut(_ sender: Any?) {
+        guard editorId != 0 else {
+            super.cut(sender)
+            return
+        }
+        guard isEditable, exportSelectionToPasteboard() else { return }
+        performInterceptedInput {
+            applyClipboardCommand(["type": "paste", "text": "", "plainText": true])
+        }
+    }
 
-    /// Intercept paste operations to route content through Rust.
-    ///
-    /// Attempts to extract HTML from the pasteboard first (for rich text paste),
-    /// falling back to plain text.
     override func paste(_ sender: Any?) {
+        pasteFromPasteboard(forcePlainText: false, sender: sender)
+    }
+
+    override func pasteAndMatchStyle(_ sender: Any?) {
+        pasteFromPasteboard(forcePlainText: true, sender: sender)
+    }
+
+    private func pasteFromPasteboard(forcePlainText: Bool, sender: Any?) {
         ensureInternalTextViewDelegate()
         guard editorId != 0 else {
-            super.paste(sender)
+            if forcePlainText {
+                super.pasteAndMatchStyle(sender)
+            } else {
+                super.paste(sender)
+            }
             return
         }
+        guard isEditable, pasteMode != .disabled else { return }
         guard finishExternalTextCompositionBeforeInteractionIfNeeded() else { return }
         guard prepareForExternalEditorUpdate() else { return }
+        guard syncClipboardSelectionToRust() != nil else { return }
+        let mode: EditorPasteMode = forcePlainText ? .plainText : pasteMode
+        guard let command = EditorClipboardPaste.command(from: .general, mode: mode) else { return }
 
         Self.inputLog.debug(
             "[paste] selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
         )
-
-        let pasteboard = UIPasteboard.general
-
-        if let htmlData = pasteboard.data(forPasteboardType: "public.html"),
-           let html = String(data: htmlData, encoding: .utf8) {
-            performInterceptedInput {
-                pasteHTML(html)
-            }
-            return
-        }
-
-        if let rtfData = pasteboard.data(forPasteboardType: "public.rtf") {
-            if let attrStr = try? NSAttributedString(
-                data: rtfData,
-                options: [.documentType: NSAttributedString.DocumentType.rtf],
-                documentAttributes: nil
-            ) {
-                if let htmlData = try? attrStr.data(
-                    from: NSRange(location: 0, length: attrStr.length),
-                    documentAttributes: [.documentType: NSAttributedString.DocumentType.html]
-                ), let html = String(data: htmlData, encoding: .utf8) {
-                    performInterceptedInput {
-                        if !pasteHTML(html, detectContentChange: true),
-                           !attrStr.string.isEmpty {
-                            pastePlainText(attrStr.string)
-                        }
-                    }
-                    return
-                }
-            }
-        }
-
-        if let text = pasteboard.string {
-            performInterceptedInput {
-                pastePlainText(text)
-            }
-            return
+        performInterceptedInput {
+            applyClipboardCommand(command)
         }
     }
 

package/ios/EditorV2Adapter+Commands.swift

@@ -1,6 +1,28 @@
 import Foundation
 
 extension EditorV2Adapter {
+    func clipboardPayloadJSON() -> String? {
+        guard beginRuntimeOperation() else { return nil }
+        defer { endRuntimeOperation() }
+        switch Self.normalizeJsonResult(editorV2GetClipboard(editorId: editorId)) {
+        case .failure(let error):
+            emit(error)
+            return nil
+        case .success(let json):
+            return json
+        }
+    }
+
+    func applyClipboardCommand(_ command: [String: Any]) -> String? {
+        guard beginRuntimeOperation() else { return nil }
+        defer { endRuntimeOperation() }
+        return performMutation(adoptEngineSelection: true) {
+            self.callWithEnvelope(["command": command]) { requestJson in
+                editorV2ApplyCommand(editorId: self.editorId, requestJson: requestJson)
+            }
+        }
+    }
+
     func toggleMark(_ markType: String, anchor: UInt32, head: UInt32) -> String? {
         guard beginRuntimeOperation() else { return nil }
         defer { endRuntimeOperation() }

package/ios/EditorV2Shadow.swift

@@ -71,6 +71,11 @@ enum EditorV2Shadow {
         adapter(for: id)?.contentSnapshotJSON() ?? "{\"html\":\"\",\"json\":{}}"
     }
 
+    static func clipboardPayload(id: UInt64) -> EditorClipboardPayload? {
+        guard let json = adapter(for: id)?.clipboardPayloadJSON() else { return nil }
+        return EditorClipboardPayload(json: json)
+    }
+
     // MARK: - State / selection reads
 
     static func getCurrentState(id: UInt64) -> String {
@@ -295,6 +300,13 @@ enum EditorV2Shadow {
         adapter(for: id)?.insertContentHtmlAtEngineSelection(html) ?? "{}"
     }
 
+    static func applyClipboardCommand(
+        id: UInt64,
+        command: [String: Any]
+    ) -> String {
+        adapter(for: id)?.applyClipboardCommand(command) ?? "{}"
+    }
+
     static func insertContentJson(id: UInt64, json: String) -> String {
         adapter(for: id)?.insertContentJsonAtEngineSelection(json) ?? "{}"
     }

package/ios/Generated_editor_core.swift

@@ -2077,6 +2077,13 @@ public func editorV2DocToScalar(editorId: String, docPos: UInt32) -> FfiJsonResu
     )
 })
 }
+public func editorV2GetClipboard(editorId: String) -> FfiJsonResult  {
+    return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
+    uniffi_editor_core_fn_func_editor_v2_get_clipboard(
+        FfiConverterString.lower(editorId),$0
+    )
+})
+}
 public func editorV2GetContentSnapshot(editorId: String) -> FfiJsonResult  {
     return try!  FfiConverterTypeFfiJsonResult_lift(try! rustCall() {
     uniffi_editor_core_fn_func_editor_v2_get_content_snapshot(
@@ -2289,6 +2296,9 @@ private let initializationResult: InitializationResult = {
     if (uniffi_editor_core_checksum_func_editor_v2_doc_to_scalar() != 62503) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_editor_core_checksum_func_editor_v2_get_clipboard() != 3214) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_editor_core_checksum_func_editor_v2_get_content_snapshot() != 21323) {
         return InitializationResult.apiChecksumMismatch
     }