@apollohg/react-native-prose-editor 0.5.20 → 0.5.21

package/android/src/main/java/com/apollohg/editor/NativeEditorModule.kt

@@ -500,7 +500,17 @@ class NativeEditorModule : Module() {
             Prop("editorUpdateRevision") { view: NativeEditorExpoView, editorUpdateRevision: Int ->
                 view.setPendingEditorUpdateRevision(editorUpdateRevision)
             }
+            Prop("editorResetUpdateJson") { view: NativeEditorExpoView, editorResetUpdateJson: String? ->
+                view.setPendingEditorResetUpdateJson(editorResetUpdateJson)
+            }
+            Prop("editorResetUpdateEditorId") { view: NativeEditorExpoView, editorResetUpdateEditorId: Int? ->
+                view.setPendingEditorResetUpdateEditorId(editorResetUpdateEditorId?.let { nativeULong(it)?.toLong() })
+            }
+            Prop("editorResetUpdateRevision") { view: NativeEditorExpoView, editorResetUpdateRevision: Int ->
+                view.setPendingEditorResetUpdateRevision(editorResetUpdateRevision)
+            }
             OnViewDidUpdateProps { view: NativeEditorExpoView ->
+                view.applyPendingEditorResetUpdateIfNeeded()
                 view.applyPendingEditorUpdateIfNeeded()
             }
 
@@ -519,6 +529,10 @@ class NativeEditorModule : Module() {
                 view.applyEditorUpdate(updateJson)
             }
 
+            AsyncFunction("applyEditorResetUpdate") { view: NativeEditorExpoView, updateJson: String ->
+                view.applyEditorResetUpdate(updateJson)
+            }
+
         }
 
         View(NativeProseViewerExpoView::class) {

package/app.plugin.js

@@ -0,0 +1,62 @@
+const path = require('path');
+const { createRequire } = require('module');
+
+const pkg = require('./package.json');
+
+const PACKAGING_EXCLUDES_PROPERTY = 'android.packagingOptions.excludes';
+const LEGACY_JNA_ABI_EXCLUDES = [
+  '**/armeabi/libjnidispatch.so',
+  '**/mips/libjnidispatch.so',
+  '**/mips64/libjnidispatch.so',
+];
+
+function requireExpoConfigPlugins() {
+  try {
+    return require('expo/config-plugins');
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      throw error;
+    }
+
+    const appRequire = createRequire(path.join(process.cwd(), 'package.json'));
+    return appRequire('expo/config-plugins');
+  }
+}
+
+function mergeCommaList(value, additions) {
+  const values = (value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  return Array.from(new Set([...values, ...additions])).join(',');
+}
+
+function withReactNativeProseEditor(config) {
+  const { withGradleProperties } = requireExpoConfigPlugins();
+
+  return withGradleProperties(config, (config) => {
+    const existing = config.modResults.find(
+      (property) => property.type === 'property' && property.key === PACKAGING_EXCLUDES_PROPERTY
+    );
+    const value = mergeCommaList(existing && existing.value, LEGACY_JNA_ABI_EXCLUDES);
+
+    if (existing) {
+      existing.value = value;
+    } else {
+      config.modResults.push({
+        type: 'property',
+        key: PACKAGING_EXCLUDES_PROPERTY,
+        value,
+      });
+    }
+
+    return config;
+  });
+}
+
+module.exports = requireExpoConfigPlugins().createRunOncePlugin(
+  withReactNativeProseEditor,
+  pkg.name,
+  pkg.version
+);

package/dist/EditorToolbar.d.ts

@@ -107,9 +107,10 @@ interface EditorToolbarMentionState {
     onSelectSuggestion: (suggestion: MentionSuggestion) => void;
 }
 export declare function isEditorToolbarFocusPreservationActive(): boolean;
-export declare function useEditorToolbarFrames(): readonly EditorToolbarFrame[];
+export declare function setActiveEditorToolbarFrameOwnerForEditor(ownerId: number, isActive: boolean): void;
+export declare function useEditorToolbarFrames(ownerId: number): readonly EditorToolbarFrame[];
 export declare function setEditorToolbarMentionState(ownerId: number, state: Omit<EditorToolbarMentionState, 'ownerId'> | null): void;
-export declare function _setEditorToolbarFrameForTests(id: number, frame: EditorToolbarFrame | null): void;
+export declare function _setEditorToolbarFrameForTests(id: number, frame: EditorToolbarFrame | null, ownerId?: number | null): void;
 export declare function _resetEditorToolbarFrameRegistryForTests(): void;
 export declare function _beginEditorToolbarInteractionForTests(): void;
 export declare function _endEditorToolbarInteractionForTests(): void;

package/dist/EditorToolbar.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_EDITOR_TOOLBAR_ITEMS = void 0;
 exports.isEditorToolbarFocusPreservationActive = isEditorToolbarFocusPreservationActive;
+exports.setActiveEditorToolbarFrameOwnerForEditor = setActiveEditorToolbarFrameOwnerForEditor;
 exports.useEditorToolbarFrames = useEditorToolbarFrames;
 exports.setEditorToolbarMentionState = setEditorToolbarMentionState;
 exports._setEditorToolbarFrameForTests = _setEditorToolbarFrameForTests;
@@ -19,6 +20,7 @@ const editorToolbarMentionStateListeners = new Set();
 let nextEditorToolbarRegistrationId = 1;
 let activeEditorToolbarInteractions = 0;
 let editorToolbarFocusPreserveUntil = 0;
+let activeEditorToolbarFrameOwnerId = null;
 let editorToolbarMentionState = null;
 const EDITOR_TOOLBAR_FOCUS_PRESERVE_MS = 750;
 function areToolbarFramesEqual(left, right) {
@@ -27,14 +29,23 @@ function areToolbarFramesEqual(left, right) {
         left?.width === right?.width &&
         left?.height === right?.height);
 }
+function areToolbarFrameListsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((frame, index) => areToolbarFramesEqual(frame, right[index]));
+}
 function notifyEditorToolbarFrameListeners() {
     editorToolbarFrameListeners.forEach((listener) => listener());
 }
 function notifyEditorToolbarMentionStateListeners() {
     editorToolbarMentionStateListeners.forEach((listener) => listener());
 }
-function getEditorToolbarFramesSnapshot() {
-    return Array.from(editorToolbarFrames.values());
+function getEditorToolbarFramesSnapshot(ownerId) {
+    return Array.from(editorToolbarFrames.values())
+        .filter((registration) => registration.ownerId === ownerId ||
+        (registration.ownerId == null && activeEditorToolbarFrameOwnerId === ownerId))
+        .map((registration) => registration.frame);
 }
 function subscribeEditorToolbarMentionState(listener) {
     editorToolbarMentionStateListeners.add(listener);
@@ -48,18 +59,19 @@ function getEditorToolbarMentionStateSnapshot() {
 function useEditorToolbarMentionState() {
     return (0, react_1.useSyncExternalStore)(subscribeEditorToolbarMentionState, getEditorToolbarMentionStateSnapshot, getEditorToolbarMentionStateSnapshot);
 }
-function registerEditorToolbarFrame(id, frame) {
+function registerEditorToolbarFrame(id, frame, ownerId) {
     if (frame == null || frame.width <= 0 || frame.height <= 0) {
         if (editorToolbarFrames.delete(id)) {
             notifyEditorToolbarFrameListeners();
         }
         return;
     }
-    const currentFrame = editorToolbarFrames.get(id);
-    if (areToolbarFramesEqual(currentFrame, frame)) {
+    const currentRegistration = editorToolbarFrames.get(id);
+    if (currentRegistration?.ownerId === ownerId &&
+        areToolbarFramesEqual(currentRegistration.frame, frame)) {
         return;
     }
-    editorToolbarFrames.set(id, frame);
+    editorToolbarFrames.set(id, { ownerId, frame });
     notifyEditorToolbarFrameListeners();
 }
 function unregisterEditorToolbarFrame(id) {
@@ -81,16 +93,31 @@ function endEditorToolbarInteraction() {
 function isEditorToolbarFocusPreservationActive() {
     return activeEditorToolbarInteractions > 0 || Date.now() <= editorToolbarFocusPreserveUntil;
 }
-function useEditorToolbarFrames() {
-    const [frames, setFrames] = (0, react_1.useState)(getEditorToolbarFramesSnapshot);
+function setActiveEditorToolbarFrameOwnerForEditor(ownerId, isActive) {
+    const nextOwnerId = isActive
+        ? ownerId
+        : activeEditorToolbarFrameOwnerId === ownerId
+            ? null
+            : activeEditorToolbarFrameOwnerId;
+    if (activeEditorToolbarFrameOwnerId === nextOwnerId) {
+        return;
+    }
+    activeEditorToolbarFrameOwnerId = nextOwnerId;
+    notifyEditorToolbarFrameListeners();
+}
+function useEditorToolbarFrames(ownerId) {
+    const [frames, setFrames] = (0, react_1.useState)(() => getEditorToolbarFramesSnapshot(ownerId));
     (0, react_1.useEffect)(() => {
-        const listener = () => setFrames(getEditorToolbarFramesSnapshot());
+        const listener = () => {
+            const nextFrames = getEditorToolbarFramesSnapshot(ownerId);
+            setFrames((currentFrames) => areToolbarFrameListsEqual(currentFrames, nextFrames) ? currentFrames : nextFrames);
+        };
         editorToolbarFrameListeners.add(listener);
         listener();
         return () => {
             editorToolbarFrameListeners.delete(listener);
         };
-    }, []);
+    }, [ownerId]);
     return frames;
 }
 function setEditorToolbarMentionState(ownerId, state) {
@@ -108,14 +135,15 @@ function setEditorToolbarMentionState(ownerId, state) {
     };
     notifyEditorToolbarMentionStateListeners();
 }
-function _setEditorToolbarFrameForTests(id, frame) {
-    registerEditorToolbarFrame(id, frame);
+function _setEditorToolbarFrameForTests(id, frame, ownerId = null) {
+    registerEditorToolbarFrame(id, frame, ownerId);
 }
 function _resetEditorToolbarFrameRegistryForTests() {
     editorToolbarFrames.clear();
     editorToolbarMentionState = null;
     activeEditorToolbarInteractions = 0;
     editorToolbarFocusPreserveUntil = 0;
+    activeEditorToolbarFrameOwnerId = null;
     notifyEditorToolbarFrameListeners();
     notifyEditorToolbarMentionStateListeners();
 }
@@ -518,7 +546,7 @@ function EditorToolbar({ activeState, historyState, onToggleBold, onToggleItalic
             return;
         }
         toolbar.measureInWindow((x, y, width, height) => {
-            registerEditorToolbarFrame(registrationId, { x, y, width, height });
+            registerEditorToolbarFrame(registrationId, { x, y, width, height }, null);
         });
     }, [preserveEditorFocus]);
     const cancelScheduledFramePublishes = (0, react_1.useCallback)(() => {

package/dist/NativeRichTextEditor.d.ts

@@ -7,6 +7,7 @@ import { type EditorAddons } from './addons';
 import { type ImageNodeAttributes, type SchemaDefinition } from './schemas';
 export type NativeRichTextEditorHeightBehavior = 'fixed' | 'autoGrow';
 export type NativeRichTextEditorToolbarPlacement = 'keyboard' | 'inline';
+export type NativeRichTextEditorValueJSONUpdateMode = 'replace' | 'reset';
 export type NativeRichTextEditorAutoCapitalize = 'none' | 'sentences' | 'words' | 'characters';
 export type NativeRichTextEditorKeyboardType = 'default' | 'email-address' | 'numeric' | 'phone-pad' | 'ascii-capable' | 'numbers-and-punctuation' | 'url' | 'number-pad' | 'name-phone-pad' | 'decimal-pad' | 'twitter' | 'web-search' | 'visible-password' | 'ascii-capable-number-pad';
 export interface RemoteSelectionDecoration {
@@ -41,6 +42,12 @@ export interface NativeRichTextEditorProps {
     valueJSON?: DocumentJSON;
     /** Optional stable revision hint for `valueJSON` to avoid reserializing equal docs on rerender. */
     valueJSONRevision?: string | number;
+    /** Controls how external `valueJSON` changes are applied. Defaults to preserving undo history. */
+    valueJSONUpdateMode?: NativeRichTextEditorValueJSONUpdateMode;
+    /** When using reset-mode `valueJSON`, preserve the current local text selection after applying the reset. */
+    preserveSelectionOnValueJSONReset?: boolean;
+    /** Preferred selection to restore when applying reset-mode `valueJSON`; falls back to the live selection. */
+    selectionOnValueJSONReset?: Selection;
     /** Schema definition. Defaults to tiptapSchema if not provided. */
     schema?: SchemaDefinition;
     /** Placeholder text shown when editor is empty. */
@@ -137,6 +144,8 @@ export interface NativeRichTextEditorRef {
     setContent(html: string): void;
     /** Replace entire document with JSON (preserves undo history). */
     setContentJson(doc: DocumentJSON): void;
+    /** Clear the document to the active schema's empty text block. */
+    clearContent(): void;
     /** Get the current HTML content. */
     getContent(): string;
     /** Get the current content as ProseMirror JSON. */