Commit b3b4b57794476c2e130d38f9243f3c5da1a0cbe7 | the-knife

apps/mobile/modules/t3-composer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt+7

 @@ -252,6 +252,9 @@ class T3ComposerEditorView(context: Context, appContext: AppContext) : ExpoView(
     val textLength = editor.text?.length ?: 0
     val safeStart = start.coerceIn(0, textLength)
     val safeEnd = end.coerceIn(0, textLength)
+    // Re-applying an unchanged selection resets the keyboard's suggestion
+    // state, so a no-op assignment must be skipped.
+    if (editor.selectionStart == safeStart && editor.selectionEnd == safeEnd) return
     editor.setSelection(safeStart, safeEnd)
   }
 @@ -281,6 +284,10 @@ class T3ComposerEditorView(context: Context, appContext: AppContext) : ExpoView(
     )
   private fun emitSelectionChange(start: Int, end: Int) {
+    // Caret moves advance the revision counter like text edits do: a
+    // controlled payload computed before this move is stale and must fail the
+    // revision guard instead of yanking the caret back mid-typing.
+    nativeEventCount += 1
     onComposerSelectionChange(
       mapOf(
         "value" to editor.text.toString(),

apps/mobile/modules/t3-composer-editor/ios/T3ComposerEditorView.swift+17-1

 @@ -489,6 +489,12 @@ public final class T3ComposerEditorView: ExpoView, UITextViewDelegate, UITextDro
       return
     }
     restoreBaseTypingAttributes()
+    // UIKit moves the selection before textViewDidChange runs. Emitting here
+    // would pair the post-edit text with a pre-edit revision counter, so let
+    // the change event that follows carry both; only pure caret moves emit.
+    guard self.textView.serializedText() == value else {
+      return
+    }
     emitSelection()
   }
 @@ -774,8 +780,12 @@ public final class T3ComposerEditorView: ExpoView, UITextViewDelegate, UITextDro
   }
   private func emitSelection() {
+    // Caret moves advance the revision counter like text edits do: a
+    // controlled payload computed before this move is stale and must fail the
+    // revision guard instead of yanking the caret back mid-typing.
     let currentValue = textView.serializedText()
     let selection = sourceSelection()
+    nativeEventCount += 1
     onComposerSelectionChange([
       "value": currentValue,
       "selection": ["start": selection.start, "end": selection.end],
 @@ -817,10 +827,16 @@ public final class T3ComposerEditorView: ExpoView, UITextViewDelegate, UITextDro
           NSMaxRange(nextRange) <= textView.attributedText.length else {
       return
     }
+    self.requestedSelection = nil
+    // Programmatically assigning selectedRange resets the keyboard's
+    // autocorrect and predictive-text context even when the range is
+    // unchanged, so a no-op assignment must be skipped.
+    guard !NSEqualRanges(nextRange, textView.selectedRange) else {
+      return
+    }
     isApplyingControlledValue = true
     textView.selectedRange = nextRange
     isApplyingControlledValue = false
-    self.requestedSelection = nil
   }
   private func updatePlaceholderVisibility() {

apps/mobile/src/native/T3ComposerEditor.ios.tsx+38-22

 @@ -19,6 +19,7 @@ import { useFontFamily } from "../lib/useFontFamily";
 import { useScaledTextRole } from "../features/settings/appearance/useScaledTextRole";
 import {
   acknowledgeComposerNativeEvent,
+  assumeComposerControlledState,
   isComposerNativeEcho,
   pruneAcknowledgedComposerNativeEvents,
   resolveComposerControlledEventCount,
 @@ -102,11 +103,11 @@ export function ComposerEditor({
   const nativeRef = useRef<NativeComposerEditorRef>(null);
   const mostRecentEventCountRef = useRef(0);
   const [mostRecentEventCount, setMostRecentEventCount] = useState(0);
-  const [nativeEventSequence, setNativeEventSequence] = useState(0);
+  const [, forceNativeEventRender] = useState(0);
-  const previousRenderedEventSequenceRef = useRef(0);
+  // The native editor mounts empty, so the snapshot history starts empty: the
-  const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([
+  // first controlled payload must be a non-echo so a restored draft (or a
-    { eventCount: 0, value: props.value, selection: selection ?? null },
+  // recycled native view) is applied rather than skipped.
-  ]);
+  const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([]);
   const confirmedTokensRef = useRef(collectComposerInlineTokens(props.value));
   const bodyText = useScaledTextRole("body");
   const textColor = useThemeColor("--color-foreground");
 @@ -154,15 +155,16 @@ export function ComposerEditor({
       })),
     );
   }, [props.value, skillLabels]);
-  const includesNativeEvent = nativeEventSequence !== previousRenderedEventSequenceRef.current;
+  // Every render resolves against the snapshot history, so a render whose
-  const controlledEventCount = includesNativeEvent
+  // (value, selection) lags the acknowledged native state is stamped behind
-    ? resolveComposerControlledEventCount(
+  // the native revision and rejected by the editor instead of re-applying a
-        props.value,
+  // stale caret or stale text mid-typing.
-        selection ?? null,
+  const controlledEventCount = resolveComposerControlledEventCount(
-        mostRecentEventCount,
+    props.value,
-        nativeEventSnapshotsRef.current,
+    selection ?? null,
-      )
+    mostRecentEventCount,
-    : mostRecentEventCount;
+    nativeEventSnapshotsRef.current,
+  );
   const acknowledgesLatestNativeEvent = isComposerNativeEcho(
     props.value,
     selection ?? null,
 @@ -170,9 +172,7 @@ export function ComposerEditor({
     nativeEventSnapshotsRef.current,
   );
   const isNativeEcho =
-    includesNativeEvent &&
+    controlledEventCount === mostRecentEventCount && acknowledgesLatestNativeEvent;
-    controlledEventCount === mostRecentEventCount &&
-    acknowledgesLatestNativeEvent;
   const controlledDocumentJson = JSON.stringify({
     value: props.value,
     selection: isNativeEcho ? null : (selection ?? null),
 @@ -180,9 +180,6 @@ export function ComposerEditor({
     mostRecentEventCount: controlledEventCount,
     isNativeEcho,
   });
-  useEffect(() => {
-    previousRenderedEventSequenceRef.current = nativeEventSequence;
-  }, [nativeEventSequence]);
   useEffect(() => {
     if (!acknowledgesLatestNativeEvent) return;
     nativeEventSnapshotsRef.current = pruneAcknowledgedComposerNativeEvents(
 @@ -190,6 +187,18 @@ export function ComposerEditor({
       mostRecentEventCount,
     );
   }, [acknowledgesLatestNativeEvent, mostRecentEventCount]);
+  const assumedValue = props.value;
+  useEffect(() => {
+    // A native event that arrived after this render was committed moves the
+    // acknowledged revision forward; the editor rejects this payload, so the
+    // snapshot history must not assume it applied.
+    if (isNativeEcho || controlledEventCount !== mostRecentEventCountRef.current) return;
+    nativeEventSnapshotsRef.current = assumeComposerControlledState(
+      nativeEventSnapshotsRef.current,
+      controlledEventCount,
+      assumedValue,
+    );
+  }, [assumedValue, controlledEventCount, isNativeEcho, controlledDocumentJson]);
   const acceptNativeEvent = useCallback(
     (eventCount: number, value: string, nextSelection: ComposerEditorSelection) => {
       const acknowledgedEventCount = acknowledgeComposerNativeEvent(
 @@ -257,7 +266,7 @@ export function ComposerEditor({
         onChangeText(event.nativeEvent.value);
         onSelectionChange?.(event.nativeEvent.selection);
         setMostRecentEventCount(acknowledgedEventCount);
-        setNativeEventSequence((sequence) => sequence + 1);
+        forceNativeEventRender((sequence) => sequence + 1);
       }}
       onComposerSelectionChange={(event) => {
         const acknowledgedEventCount = acceptNativeEvent(
 @@ -266,9 +275,16 @@ export function ComposerEditor({
           event.nativeEvent.selection,
         );
         if (acknowledgedEventCount === false) return;
+        // A selection change that raced a text mutation can carry post-edit
+        // text. It must reach the parent alongside the acknowledged revision,
+        // or the next render stamps the stale draft at that revision and can
+        // re-apply it over the newer native text.
+        if (event.nativeEvent.value !== props.value) {
+          onChangeText(event.nativeEvent.value);
+        }
         onSelectionChange?.(event.nativeEvent.selection);
         setMostRecentEventCount(acknowledgedEventCount);
-        setNativeEventSequence((sequence) => sequence + 1);
+        forceNativeEventRender((sequence) => sequence + 1);
       }}
       onComposerPasteImages={(event) => onPasteImages?.(event.nativeEvent.uris)}
       onComposerFocus={onFocus}

apps/mobile/src/native/T3ComposerEditor.native.tsx+39-22

 @@ -21,6 +21,7 @@ import { useFontFamily } from "../lib/useFontFamily";
 import { useThemeColor } from "../lib/useThemeColor";
 import {
   acknowledgeComposerNativeEvent,
+  assumeComposerControlledState,
   isComposerNativeEcho,
   pruneAcknowledgedComposerNativeEvents,
   resolveComposerControlledEventCount,
 @@ -103,11 +104,11 @@ export function ComposerEditor({
   const nativeRef = useRef<NativeComposerEditorRef>(null);
   const mostRecentEventCountRef = useRef(0);
   const [mostRecentEventCount, setMostRecentEventCount] = useState(0);
-  const [nativeEventSequence, setNativeEventSequence] = useState(0);
+  const [, forceNativeEventRender] = useState(0);
-  const previousRenderedEventSequenceRef = useRef(0);
+  // The native editor mounts empty, so the snapshot history starts empty: the
-  const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([
+  // first controlled payload must be a non-echo so a restored draft (or a
-    { eventCount: 0, value: props.value, selection: selection ?? null },
+  // recycled native view) is applied rather than skipped.
-  ]);
+  const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([]);
   const [initialConfirmedTokens] = useState(() => collectComposerInlineTokens(props.value));
   const confirmedTokensRef = useRef(initialConfirmedTokens);
   const textColor = useThemeColor("--color-foreground");
 @@ -155,15 +156,16 @@ export function ComposerEditor({
       })),
     );
   }, [props.value, skillLabels]);
-  const includesNativeEvent = nativeEventSequence !== previousRenderedEventSequenceRef.current;
+  // Every render resolves against the snapshot history, so a render whose
-  const controlledEventCount = includesNativeEvent
+  // (value, selection) lags the acknowledged native state is stamped behind
-    ? resolveComposerControlledEventCount(
+  // the native revision and rejected by the editor instead of re-applying a
-        props.value,
+  // stale caret or stale text mid-typing.
-        selection ?? null,
+  const controlledEventCount = resolveComposerControlledEventCount(
-        mostRecentEventCount,
+    props.value,
-        nativeEventSnapshotsRef.current,
+    selection ?? null,
-      )
+    mostRecentEventCount,
-    : mostRecentEventCount;
+    nativeEventSnapshotsRef.current,
+  );
   const acknowledgesLatestNativeEvent = isComposerNativeEcho(
     props.value,
     selection ?? null,
 @@ -171,9 +173,7 @@ export function ComposerEditor({
     nativeEventSnapshotsRef.current,
   );
   const isNativeEcho =
-    includesNativeEvent &&
+    controlledEventCount === mostRecentEventCount && acknowledgesLatestNativeEvent;
-    controlledEventCount === mostRecentEventCount &&
-    acknowledgesLatestNativeEvent;
   const controlledDocumentJson = JSON.stringify({
     value: props.value,
     selection: isNativeEcho ? null : (selection ?? null),
 @@ -181,9 +181,6 @@ export function ComposerEditor({
     mostRecentEventCount: controlledEventCount,
     isNativeEcho,
   });
-  useEffect(() => {
-    previousRenderedEventSequenceRef.current = nativeEventSequence;
-  }, [nativeEventSequence]);
   useEffect(() => {
     if (!acknowledgesLatestNativeEvent) return;
     nativeEventSnapshotsRef.current = pruneAcknowledgedComposerNativeEvents(
 @@ -191,6 +188,18 @@ export function ComposerEditor({
       mostRecentEventCount,
     );
   }, [acknowledgesLatestNativeEvent, mostRecentEventCount]);
+  const assumedValue = props.value;
+  useEffect(() => {
+    // A native event that arrived after this render was committed moves the
+    // acknowledged revision forward; the editor rejects this payload, so the
+    // snapshot history must not assume it applied.
+    if (isNativeEcho || controlledEventCount !== mostRecentEventCountRef.current) return;
+    nativeEventSnapshotsRef.current = assumeComposerControlledState(
+      nativeEventSnapshotsRef.current,
+      controlledEventCount,
+      assumedValue,
+    );
+  }, [assumedValue, controlledEventCount, isNativeEcho, controlledDocumentJson]);
   const acceptNativeEvent = useCallback(
     (eventCount: number, value: string, nextSelection: ComposerEditorSelection) => {
       const acknowledgedEventCount = acknowledgeComposerNativeEvent(
 @@ -263,7 +272,7 @@ export function ComposerEditor({
           onChangeText(event.nativeEvent.value);
           onSelectionChange?.(event.nativeEvent.selection);
           setMostRecentEventCount(acknowledgedEventCount);
-          setNativeEventSequence((sequence) => sequence + 1);
+          forceNativeEventRender((sequence) => sequence + 1);
         }}
         onComposerSelectionChange={(event) => {
           const acknowledgedEventCount = acceptNativeEvent(
 @@ -272,9 +281,17 @@ export function ComposerEditor({
             event.nativeEvent.selection,
           );
           if (acknowledgedEventCount === false) return;
+          // Android emits the selection change mid-mutation, before the change
+          // event, so the payload can carry post-edit text. It must reach the
+          // parent alongside the acknowledged revision, or the next render
+          // stamps the stale draft at that revision and can re-apply it over
+          // the newer native text.
+          if (event.nativeEvent.value !== props.value) {
+            onChangeText(event.nativeEvent.value);
+          }
           onSelectionChange?.(event.nativeEvent.selection);
           setMostRecentEventCount(acknowledgedEventCount);
-          setNativeEventSequence((sequence) => sequence + 1);
+          forceNativeEventRender((sequence) => sequence + 1);
         }}
         onComposerPasteImages={(event) => onPasteImages?.(event.nativeEvent.uris)}
         onComposerFocus={onFocus}

apps/mobile/src/native/composerEditorRevision.test.ts+87-2

...	@@ -2,6 +2,7 @@ import { describe, expect, it } from "@effect/vitest";	...	@@ -2,6 +2,7 @@ import { describe, expect, it } from "@effect/vitest";
2		2
3	import {	3	import {
4	acknowledgeComposerNativeEvent,	4	acknowledgeComposerNativeEvent,
		5	assumeComposerControlledState,
5	isComposerNativeEcho,	6	isComposerNativeEcho,
6	pruneAcknowledgedComposerNativeEvents,	7	pruneAcknowledgedComposerNativeEvents,
7	resolveComposerControlledEventCount,	8	resolveComposerControlledEventCount,
...	@@ -42,6 +43,19 @@ describe("isComposerNativeEcho", () => {	...	@@ -42,6 +43,19 @@ describe("isComposerNativeEcho", () => {
42	it("matches value and revision when selection is uncontrolled", () => {	43	it("matches value and revision when selection is uncontrolled", () => {
43	expect(isComposerNativeEcho("native", null, 3, snapshots)).toBe(true);	44	expect(isComposerNativeEcho("native", null, 3, snapshots)).toBe(true);
44	});	45	});
		46
		47	it("does not claim a controlled selection against an assumed state without one", () => {
		48	// An echo payload serializes `selection: null`; classifying a controlled
		49	// selection as an echo of an assumed state would drop a parent caret move.
		50	const assumed = [{ eventCount: 3, value: "native", selection: null }];
		51	expect(isComposerNativeEcho("native", { start: 0, end: 0 }, 3, assumed)).toBe(false);
		52	expect(isComposerNativeEcho("other", { start: 0, end: 0 }, 3, assumed)).toBe(false);
		53	});
		54
		55	it("matches an assumed state when selection is uncontrolled", () => {
		56	const assumed = [{ eventCount: 3, value: "native", selection: null }];
		57	expect(isComposerNativeEcho("native", null, 3, assumed)).toBe(true);
		58	});
45	});	59	});
46		60
47	describe("resolveComposerControlledEventCount", () => {	61	describe("resolveComposerControlledEventCount", () => {
...	@@ -95,7 +109,7 @@ describe("pruneAcknowledgedComposerNativeEvents", () => {	...	@@ -95,7 +109,7 @@ describe("pruneAcknowledgedComposerNativeEvents", () => {
95	selection: { start: eventCount, end: eventCount },	109	selection: { start: eventCount, end: eventCount },
96	}));	110	}));
97		111
98	expect(pruneAcknowledgedComposerNativeEvents(snapshots, 999)).toEqual([]);	112	expect(pruneAcknowledgedComposerNativeEvents(snapshots, 999)).toEqual([snapshots[999]]);
99	});	113	});
100		114
101	it("retains native events that arrive after the acknowledged render", () => {	115	it("retains native events that arrive after the acknowledged render", () => {
...	@@ -104,6 +118,77 @@ describe("pruneAcknowledgedComposerNativeEvents", () => {	...	@@ -104,6 +118,77 @@ describe("pruneAcknowledgedComposerNativeEvents", () => {
104	{ eventCount: 41, value: "ab", selection: { start: 2, end: 2 } },	118	{ eventCount: 41, value: "ab", selection: { start: 2, end: 2 } },
105	];	119	];
106		120
107	expect(pruneAcknowledgedComposerNativeEvents(snapshots, 40)).toEqual([snapshots[1]]);	121	expect(pruneAcknowledgedComposerNativeEvents(snapshots, 40)).toEqual(snapshots);
		122	});
		123
		124	it("retains the newest acknowledged snapshot so settled re-renders stay echoes", () => {
		125	const snapshots = [
		126	{ eventCount: 40, value: "a", selection: { start: 1, end: 1 } },
		127	{ eventCount: 41, value: "ab", selection: { start: 2, end: 2 } },
		128	{ eventCount: 42, value: "abc", selection: { start: 3, end: 3 } },
		129	];
		130
		131	const pruned = pruneAcknowledgedComposerNativeEvents(snapshots, 42);
		132	expect(pruned).toEqual([snapshots[2]]);
		133	expect(isComposerNativeEcho("abc", { start: 3, end: 3 }, 42, pruned)).toBe(true);
		134	});
		135
		136	it("keeps the newest of several snapshots sharing the acknowledged revision", () => {
		137	const snapshots = [
		138	{ eventCount: 41, value: "ab", selection: { start: 2, end: 2 } },
		139	{ eventCount: 41, value: "ab", selection: { start: 1, end: 1 } },
		140	];
		141
		142	expect(pruneAcknowledgedComposerNativeEvents(snapshots, 41)).toEqual([snapshots[1]]);
		143	});
		144	});
		145
		146	describe("assumeComposerControlledState", () => {
		147	it("replaces the acknowledged history with the applied controlled state", () => {
		148	const snapshots = [{ eventCount: 3, value: "typed", selection: { start: 5, end: 5 } }];
		149
		150	expect(assumeComposerControlledState(snapshots, 3, "")).toEqual([
		151	{ eventCount: 3, value: "", selection: null },
		152	]);
		153	});
		154
		155	it("keeps native events that raced past the controlled revision", () => {
		156	const snapshots = [
		157	{ eventCount: 3, value: "typed", selection: { start: 5, end: 5 } },
		158	{ eventCount: 4, value: "typed!", selection: { start: 6, end: 6 } },
		159	];
		160
		161	expect(assumeComposerControlledState(snapshots, 3, "")).toEqual([
		162	{ eventCount: 3, value: "", selection: null },
		163	snapshots[1],
		164	]);
		165	});
		166
		167	it("applies a parent caret move on the assumed value at the assumed revision", () => {
		168	// Same value, new caret: not an echo (so the selection is serialized) but
		169	// still stamped at the assumed revision so the editor accepts it.
		170	const snapshots = assumeComposerControlledState([], 3, "typed");
		171
		172	expect(isComposerNativeEcho("typed", { start: 2, end: 2 }, 3, snapshots)).toBe(false);
		173	expect(resolveComposerControlledEventCount("typed", { start: 2, end: 2 }, 3, snapshots)).toBe(
		174	3,
		175	);
		176	});
		177
		178	it("re-applies a parent value that round-trips back to an acknowledged state", () => {
		179	// Native acknowledged "typed", the parent then controlled the editor to ""
		180	// (a send clearing the draft) and back to "typed" (the send failed and the
		181	// draft was restored). The restore must be a fresh non-echo edit stamped at
		182	// the current revision, not an echo the editor would drop.
		183	const snapshots = assumeComposerControlledState(
		184	[{ eventCount: 3, value: "typed", selection: { start: 5, end: 5 } }],
		185	3,
		186	"",
		187	);
		188
		189	expect(isComposerNativeEcho("typed", { start: 5, end: 5 }, 3, snapshots)).toBe(false);
		190	expect(resolveComposerControlledEventCount("typed", { start: 5, end: 5 }, 3, snapshots)).toBe(
		191	3,
		192	);
108	});	193	});
109	});	194	});

apps/mobile/src/native/composerEditorRevision.ts+54-6

...	@@ -31,10 +31,7 @@ export function resolveComposerControlledEventCount(	...	@@ -31,10 +31,7 @@ export function resolveComposerControlledEventCount(
31	if (snapshot?.value !== value) continue;	31	if (snapshot?.value !== value) continue;
32		32
33	newestValueEventCount ??= snapshot.eventCount;	33	newestValueEventCount ??= snapshot.eventCount;
34	if (	34	if (selection === null \|\| snapshotSelectionMatches(snapshot, selection)) {
35	selection === null \|\|
36	(snapshot.selection?.start === selection.start && snapshot.selection.end === selection.end)
37	) {
38	return snapshot.eventCount;	35	return snapshot.eventCount;
39	}	36	}
40	}	37	}
...	@@ -49,6 +46,21 @@ export function resolveComposerControlledEventCount(	...	@@ -49,6 +46,21 @@ export function resolveComposerControlledEventCount(
49	return mostRecentEventCount;	46	return mostRecentEventCount;
50	}	47	}
51		48
		49	// A snapshot without a selection describes a state the editor applied itself
		50	// (an assumed controlled document, where the native side may have bounded the
		51	// caret). Revision stamping treats it as matching any controlled selection so
		52	// a parent caret move on the assumed value stays at the assumed revision and
		53	// passes the editor's staleness guard. Echo detection must not reuse this
		54	// wildcard: an echo payload serializes `selection: null`, which would drop
		55	// that caret move instead of applying it.
		56	function snapshotSelectionMatches(
		57	snapshot: ComposerNativeEventSnapshot,
		58	selection: ComposerEditorSelection,
		59	): boolean {
		60	if (snapshot.selection === null) return true;
		61	return snapshot.selection.start === selection.start && snapshot.selection.end === selection.end;
		62	}
		63
52	export function isComposerNativeEcho(	64	export function isComposerNativeEcho(
53	value: string,	65	value: string,
54	selection: ComposerEditorSelection \| null,	66	selection: ComposerEditorSelection \| null,
...	@@ -62,7 +74,9 @@ export function isComposerNativeEcho(	...	@@ -62,7 +74,9 @@ export function isComposerNativeEcho(
62	snapshot.eventCount === eventCount &&	74	snapshot.eventCount === eventCount &&
63	snapshot.value === value &&	75	snapshot.value === value &&
64	(selection === null \|\|	76	(selection === null \|\|
65	(snapshot.selection?.start === selection.start && snapshot.selection.end === selection.end))	77	(snapshot.selection !== null &&
		78	snapshot.selection.start === selection.start &&
		79	snapshot.selection.end === selection.end))
66	) {	80	) {
67	return true;	81	return true;
68	}	82	}
...	@@ -70,9 +84,43 @@ export function isComposerNativeEcho(	...	@@ -70,9 +84,43 @@ export function isComposerNativeEcho(
70	return false;	84	return false;
71	}	85	}
72		86
		87	/**
		88	* Records that a parent-driven controlled document was handed to the native
		89	* editor. From that point the acknowledged snapshot history describes a
		90	* superseded native state, so it is replaced with the assumed applied state;
		91	* a later parent update back to a previously acknowledged value must classify
		92	* as a fresh edit, not as a native echo the editor would drop. Native events
		93	* that raced past the controlled revision stay authoritative and are kept.
		94	*/
		95	export function assumeComposerControlledState(
		96	snapshots: ReadonlyArray<ComposerNativeEventSnapshot>,
		97	eventCount: number,
		98	value: string,
		99	): ComposerNativeEventSnapshot[] {
		100	return [
		101	{ eventCount, value, selection: null },
		102	...snapshots.filter((snapshot) => snapshot.eventCount > eventCount),
		103	];
		104	}
		105
73	export function pruneAcknowledgedComposerNativeEvents(	106	export function pruneAcknowledgedComposerNativeEvents(
74	snapshots: ReadonlyArray<ComposerNativeEventSnapshot>,	107	snapshots: ReadonlyArray<ComposerNativeEventSnapshot>,
75	acknowledgedEventCount: number,	108	acknowledgedEventCount: number,
76	): ComposerNativeEventSnapshot[] {	109	): ComposerNativeEventSnapshot[] {
77	return snapshots.filter((snapshot) => snapshot.eventCount > acknowledgedEventCount);	110	// The newest acknowledged snapshot must survive pruning: it is what lets a
		111	// later, unrelated re-render classify the settled composer state as a native
		112	// echo instead of a parent-driven edit that would re-control the caret (and
		113	// reset the keyboard's autocorrect context on iOS).
		114	let latestAcknowledgedIndex = -1;
		115	for (let index = snapshots.length - 1; index >= 0; index -= 1) {
		116	const snapshot = snapshots[index];
		117	if (snapshot !== undefined && snapshot.eventCount <= acknowledgedEventCount) {
		118	latestAcknowledgedIndex = index;
		119	break;
		120	}
		121	}
		122	return snapshots.filter(
		123	(snapshot, index) =>
		124	index === latestAcknowledgedIndex \|\| snapshot.eventCount > acknowledgedEventCount,
		125	);
78	}	126	}

author	Julius Marminge <julius0216@outlook.com> 2026-08-14 10:45:43+02:00
committer	GitHub <noreply@github.com> 2026-08-14 10:45:43+02:00
log	b3b4b57794476c2e130d38f9243f3c5da1a0cbe7
tree	cce08c0a6870c56657217b73eaf1cf68b84aa126
parent	6ae44b418a24dc021cf042cbb1e60ebeb47e160f
signature	Signed by PGP key B5690EEEBB952194

fix(mobile): preserve keyboard suggestions while typing (#6323)