stream-chat-react-native-core 9.7.0 → 9.7.1-beta.2

package/src/__tests__/offline-support/offline-feature.tsx

@@ -257,8 +257,8 @@ export const Generic = () => {
     } as ChannelFilters;
     const sort: ChannelSort = { last_updated: 1 };
 
-    const renderComponent = () =>
-      render(
+    const renderComponent = async () => {
+      const result = render(
         <Chat client={chatClient} enableOfflineSupport>
           <WithComponents overrides={{ ChannelPreview: ChannelPreviewComponent }}>
             <ChannelList filters={filters} sort={sort} swipeActionsEnabled={false} />
@@ -266,6 +266,15 @@ export const Generic = () => {
         </Chat>,
       );
 
+      await waitFor(async () => {
+        const tablesInDb = (await BetterSqlite.getTables()) as Array<{ name: string }>;
+        const tableNamesInDB = tablesInDb.map((table) => table.name);
+        expect(Object.keys(tables).every((name) => tableNamesInDB.includes(name))).toBe(true);
+      });
+
+      return result;
+    };
+
     const expectCIDsOnUIToBeInDB = async (
       queryAllByLabelText: typeof screen.queryAllByLabelText,
     ) => {
@@ -365,7 +374,7 @@ export const Generic = () => {
 
     it('should store filter-sort query and cids on ChannelList in channelQueries table', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
 
       await act(() => dispatchConnectionChangedEvent(chatClient, false));
       // await waiter();
@@ -381,7 +390,7 @@ export const Generic = () => {
     it('should store channels and its state in tables', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
 
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
@@ -400,7 +409,7 @@ export const Generic = () => {
       useMockedApis(chatClient, [queryChannelsApi([emptyChannel])]);
       jest.spyOn(chatClient, 'hydrateActiveChannels');
 
-      renderComponent();
+      await renderComponent();
 
       await waitFor(async () => {
         act(() => dispatchConnectionChangedEvent(chatClient));
@@ -415,7 +424,7 @@ export const Generic = () => {
     it('should add a new message to database', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -444,7 +453,7 @@ export const Generic = () => {
     it('should correctly handle multiple new messages and add them to the database', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -506,7 +515,7 @@ export const Generic = () => {
     it('should correctly handle multiple new messages from our own user', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -568,7 +577,7 @@ export const Generic = () => {
     it('should add a new channel and a new message to database from notification event', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => {
@@ -609,7 +618,7 @@ export const Generic = () => {
     it('should update a message in database', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -637,7 +646,7 @@ export const Generic = () => {
     it('should remove the channel from DB when user is removed as member', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -671,7 +680,7 @@ export const Generic = () => {
     it('should remove the channel from DB if the channel is deleted', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -705,7 +714,7 @@ export const Generic = () => {
     it('should correctly mark the channel as hidden in the db', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -739,7 +748,7 @@ export const Generic = () => {
     it('should correctly mark the channel as visible if it was hidden before in the db', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -800,7 +809,7 @@ export const Generic = () => {
     it('should add the channel to DB when user is added as member', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -838,7 +847,7 @@ export const Generic = () => {
     it('should remove the channel messages from DB when channel is truncated', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -874,7 +883,7 @@ export const Generic = () => {
     it('should truncate the correct messages if channel.truncated arrives with truncated_at', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -926,7 +935,7 @@ export const Generic = () => {
     it('should gracefully handle a truncated_at date before each message', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -962,7 +971,7 @@ export const Generic = () => {
     it('should gracefully handle a truncated_at date after each message', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1004,7 +1013,7 @@ export const Generic = () => {
 
     it('should add a reaction to DB when a new reaction is added', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1049,7 +1058,7 @@ export const Generic = () => {
 
     it('should correctly add multiple reactions to the DB', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1136,7 +1145,7 @@ export const Generic = () => {
 
     it('should gracefully handle multiple reaction.new events of the same type for the same user', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1205,7 +1214,7 @@ export const Generic = () => {
     it('should remove a reaction from DB when reaction is deleted', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1259,7 +1268,7 @@ export const Generic = () => {
     it('should update a reaction in DB when reaction is updated', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1296,7 +1305,7 @@ export const Generic = () => {
 
     it('should correctly upsert reactions when enforce_unique is true', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1396,7 +1405,7 @@ export const Generic = () => {
 
     it('should also update the corresponding message.reaction_groups with reaction.new', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1455,7 +1464,7 @@ export const Generic = () => {
 
     it('should also update the corresponding message.reaction_groups with reaction.updated', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1512,7 +1521,7 @@ export const Generic = () => {
 
     it('should also update the corresponding message.reaction_groups with reaction.deleted', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1569,7 +1578,7 @@ export const Generic = () => {
 
     it('should add a member to DB when a new member is added to channel', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
-      renderComponent();
+      await renderComponent();
 
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
@@ -1592,7 +1601,7 @@ export const Generic = () => {
     it('should remove a member from DB when a member is removed from channel', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1614,7 +1623,7 @@ export const Generic = () => {
     it('should update the member in DB when a member of a channel is updated', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1641,7 +1650,7 @@ export const Generic = () => {
     it('should update the channel data in DB when a channel is updated', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1667,7 +1676,7 @@ export const Generic = () => {
     it('should update reads in DB when channel is read', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());
@@ -1715,7 +1724,7 @@ export const Generic = () => {
     it('should update reads in DB when a channel is marked as unread', async () => {
       useMockedApis(chatClient, [queryChannelsApi(channels)]);
 
-      renderComponent();
+      await renderComponent();
       act(() => dispatchConnectionChangedEvent(chatClient));
       await act(async () => await getSyncManager(chatClient).invokeSyncStatusListeners(true));
       await waitFor(() => expect(screen.getByTestId('channel-list-view')).toBeTruthy());

package/src/components/Message/utils/__tests__/measureInWindow.test.ts

@@ -0,0 +1,217 @@
+import { Dimensions, Platform, View } from 'react-native';
+
+import type { EdgeInsets } from 'react-native-safe-area-context';
+
+import { isMeasuredRectBogus, measureInWindow } from '../measureInWindow';
+
+// `measureInWindow` is globally mocked in jest-setup so other suites don't hit native
+// measurement; this suite exercises the real implementation.
+jest.unmock('../measureInWindow');
+
+// measureInWindow reads `isRN86OrGreater` as a live binding at call time, so mocking the constants
+// module with a mutable flag lets us exercise both the "RN handles the inset" and "we compensate"
+// branches without reimporting. (Flag is `mock`-prefixed as jest requires for values referenced
+// inside a mock factory.)
+let mockIsRN86OrGreater = false;
+jest.mock('../../../../utils/react-native-constants', () => ({
+  __esModule: true,
+  get isRN86OrGreater() {
+    return mockIsRN86OrGreater;
+  },
+}));
+
+// screen 400x800 => bogus threshold is |x| > 800 and |y| > 1600 (2x each)
+const SCREEN = { fontScale: 1, height: 800, scale: 2, width: 400 };
+const INSETS: EdgeInsets = { bottom: 10, left: 0, right: 0, top: 24 };
+
+const setPlatform = (os: typeof Platform.OS) => {
+  Object.defineProperty(Platform, 'OS', { configurable: true, get: () => os });
+};
+
+type MeasureInWindowTuple = [number, number, number, number];
+type MeasureTuple = [number, number, number, number, number, number];
+
+/**
+ * Builds a fake native handle whose `measureInWindow`/`measure` callbacks fire synchronously
+ * (as Fabric does). Omitting `measure` produces a handle without the method, exercising the
+ * "no fallback available" branch.
+ */
+const makeNode = ({
+  measure,
+  measureInWindow: miw,
+}: {
+  measure?: MeasureTuple;
+  measureInWindow: MeasureInWindowTuple;
+}): { current: View | null } => {
+  const handle: Record<string, unknown> = {
+    measureInWindow: (cb: (...args: MeasureInWindowTuple) => void) => cb(...miw),
+  };
+  if (measure) {
+    handle.measure = (cb: (...args: MeasureTuple) => void) => cb(...measure);
+  }
+  return { current: handle as unknown as View };
+};
+
+describe('isMeasuredRectBogus', () => {
+  beforeEach(() => {
+    jest.spyOn(Dimensions, 'get').mockReturnValue(SCREEN);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('accepts a normal on-screen rect', () => {
+    expect(isMeasuredRectBogus(50, 300, 200, 40)).toBe(false);
+  });
+
+  it('accepts a rect within the 2x margin (e.g. partially off-screen)', () => {
+    expect(isMeasuredRectBogus(50, 1500, 200, 40)).toBe(false);
+  });
+
+  it.each([
+    ['NaN x', [NaN, 10, 20, 20]],
+    ['NaN y', [10, NaN, 20, 20]],
+    ['Infinity x', [Infinity, 10, 20, 20]],
+    ['-Infinity y', [10, -Infinity, 20, 20]],
+    ['NaN width', [10, 10, NaN, 20]],
+    ['Infinity height', [10, 10, 20, Infinity]],
+  ] as [string, MeasureInWindowTuple][])('flags non-finite values: %s', (_label, [x, y, w, h]) => {
+    expect(isMeasuredRectBogus(x, y, w, h)).toBe(true);
+  });
+
+  it.each([
+    ['zero width', [10, 10, 0, 40]],
+    ['zero height', [10, 10, 40, 0]],
+    ['negative width', [10, 10, -5, 40]],
+    ['negative height', [10, 10, 40, -5]],
+  ] as [string, MeasureInWindowTuple][])(
+    'flags non-positive dimensions: %s',
+    (_label, [x, y, w, h]) => {
+      expect(isMeasuredRectBogus(x, y, w, h)).toBe(true);
+    },
+  );
+
+  it.each([
+    ['huge y (the FLAG_LAYOUT_NO_LIMITS failure)', [50, 29000, 40, 36]],
+    ['huge x', [29000, 300, 40, 36]],
+    ['huge negative x', [-2000, 300, 40, 36]],
+    ['huge negative y', [50, -2000, 40, 36]],
+  ] as [string, MeasureInWindowTuple][])(
+    'flags coordinates beyond 2x the screen: %s',
+    (_label, [x, y, w, h]) => {
+      expect(isMeasuredRectBogus(x, y, w, h)).toBe(true);
+    },
+  );
+
+  it('treats the exact 2x boundary as valid and just past it as bogus', () => {
+    // bounds are 800 (x) and 1600 (y); the check uses strict `>`
+    expect(isMeasuredRectBogus(800, 1600, 40, 36)).toBe(false);
+    expect(isMeasuredRectBogus(801, 300, 40, 36)).toBe(true);
+    expect(isMeasuredRectBogus(50, 1601, 40, 36)).toBe(true);
+  });
+
+  it('trusts the measurement when screen dimensions are unavailable', () => {
+    jest.spyOn(Dimensions, 'get').mockReturnValue({ ...SCREEN, height: 0, width: 0 });
+    expect(isMeasuredRectBogus(99999, 99999, 40, 36)).toBe(false);
+  });
+});
+
+describe('measureInWindow', () => {
+  const originalOS = Platform.OS;
+
+  beforeEach(() => {
+    jest.spyOn(Dimensions, 'get').mockReturnValue(SCREEN);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    setPlatform(originalOS);
+    mockIsRN86OrGreater = false;
+  });
+
+  it('rejects when the node is not mounted', async () => {
+    await expect(measureInWindow({ current: null }, INSETS)).rejects.toThrow(/native handle/);
+  });
+
+  describe('healthy measurement (primary path)', () => {
+    it('resolves with the window rect unchanged on iOS', async () => {
+      setPlatform('ios');
+      const node = makeNode({ measureInWindow: [10, 300, 200, 40] });
+      await expect(measureInWindow(node, INSETS)).resolves.toEqual({
+        h: 40,
+        w: 200,
+        x: 10,
+        y: 300,
+      });
+    });
+
+    it('compensates by insets.top on Android below RN 0.86', async () => {
+      setPlatform('android');
+      mockIsRN86OrGreater = false;
+      const node = makeNode({ measureInWindow: [10, 300, 200, 40] });
+      await expect(measureInWindow(node, INSETS)).resolves.toEqual({
+        h: 40,
+        w: 200,
+        x: 10,
+        y: 324,
+      });
+    });
+
+    it('does not compensate on Android from RN 0.86 onward (RN corrects the inset natively)', async () => {
+      setPlatform('android');
+      mockIsRN86OrGreater = true;
+      const node = makeNode({ measureInWindow: [10, 300, 200, 40] });
+      await expect(measureInWindow(node, INSETS)).resolves.toEqual({
+        h: 40,
+        w: 200,
+        x: 10,
+        y: 300,
+      });
+    });
+  });
+
+  describe('bogus measurement (measure() fallback)', () => {
+    it('falls back to root-relative pageX/pageY', async () => {
+      setPlatform('ios');
+      const node = makeNode({
+        measure: [0, 0, 64, 36, 12, 717],
+        measureInWindow: [28903, 29088, 64, 36],
+      });
+      await expect(measureInWindow(node, INSETS)).resolves.toEqual({ h: 36, w: 64, x: 12, y: 717 });
+    });
+
+    it('does not add insets.top to the fallback, since pageY already accounts for it', async () => {
+      setPlatform('android');
+      const node = makeNode({
+        measure: [0, 0, 64, 36, 12, 717],
+        measureInWindow: [28903, 29088, 64, 36],
+      });
+      await expect(measureInWindow(node, INSETS)).resolves.toEqual({ h: 36, w: 64, x: 12, y: 717 });
+    });
+
+    it('returns the compensated window rect when no measure() fallback is available (RN < 0.86)', async () => {
+      setPlatform('android');
+      mockIsRN86OrGreater = false;
+      const node = makeNode({ measureInWindow: [28903, 29088, 64, 36] });
+      await expect(measureInWindow(node, INSETS)).resolves.toEqual({
+        h: 36,
+        w: 64,
+        x: 28903,
+        y: 29112,
+      });
+    });
+
+    it('returns the uncompensated window rect when no measure() fallback is available (RN >= 0.86)', async () => {
+      setPlatform('android');
+      mockIsRN86OrGreater = true;
+      const node = makeNode({ measureInWindow: [28903, 29088, 64, 36] });
+      await expect(measureInWindow(node, INSETS)).resolves.toEqual({
+        h: 36,
+        w: 64,
+        x: 28903,
+        y: 29088,
+      });
+    });
+  });
+});

package/src/components/Message/utils/measureInWindow.ts

@@ -1,20 +1,83 @@
 import React from 'react';
-import { Platform, View } from 'react-native';
+import { Dimensions, Platform, View } from 'react-native';
 import { EdgeInsets } from 'react-native-safe-area-context';
 
+import { isRN86OrGreater } from '../../../utils/react-native-constants';
+
+type MeasuredRect = { x: number; y: number; w: number; h: number };
+
+/**
+ * On Android, `measureInWindow` historically did not account for the top inset, so we added it
+ * ourselves. React Native 0.86 fixed this upstream as part of its edge-to-edge rework and now
+ * returns topInset corrected window coordinates. On >= 0.86 adding it again double counts the
+ * inset and offsets every measured view down by `insets.top`, so we only compensate on Android
+ * running React Native below 0.86.
+ */
+const androidTopInsetCompensation = (insets: EdgeInsets): number =>
+  Platform.OS === 'android' && !isRN86OrGreater ? insets.top : 0;
+
+/**
+ * How many screen lengths away from the origin a measured coordinate may fall before we treat it as
+ * bogus. Real targets (a view currently on screen) always measure well within one screen and the failure
+ * mode we guard against is off by tens of screens, so a generous multiplier cleanly separates the two
+ * with no risk of false positives on legitimate values.
+ */
+const SCREEN_BOUND_MULTIPLIER = 2;
+
+/**
+ * `measureInWindow` can return wildly out of bounds coordinates on Android when the native window has
+ * been forced edge-to-edge behind React Native's back (i.e a library setting `FLAG_LAYOUT_NO_LIMITS`,
+ * as `react-native-system-navigation-bar` does for a transparent nav bar) while RN's own edge-to-edge
+ * (`edgeToEdgeEnabled`) is off. In that state the window relative measurement is corrupted and would
+ * return a position of the View far offscreen.
+ */
+export const isMeasuredRectBogus = (x: number, y: number, w: number, h: number): boolean => {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(w) || !Number.isFinite(h)) {
+    return true;
+  }
+  if (w <= 0 || h <= 0) {
+    return true;
+  }
+  const { width, height } = Dimensions.get('screen');
+  if (width <= 0 || height <= 0) {
+    // can't reason about bounds, trust the measurement
+    return false;
+  }
+  return (
+    Math.abs(x) > width * SCREEN_BOUND_MULTIPLIER || Math.abs(y) > height * SCREEN_BOUND_MULTIPLIER
+  );
+};
+
 export const measureInWindow = (
   node: React.RefObject<View | null>,
   insets: EdgeInsets,
-): Promise<{ x: number; y: number; w: number; h: number }> => {
+): Promise<MeasuredRect> => {
   return new Promise((resolve, reject) => {
     const handle = node.current;
-    if (!handle)
+    if (!handle) {
       return reject(
         new Error('The native handle could not be found while invoking measureInWindow.'),
       );
+    }
+
+    handle.measureInWindow((x, y, w, h) => {
+      if (!isMeasuredRectBogus(x, y, w, h)) {
+        resolve({ h, w, x, y: y + androidTopInsetCompensation(insets) });
+        return;
+      }
+
+      // If `measureInWindow` returned an out of bounds rect, fallback to `measure()`, whose
+      // `pageX`/`pageY` are relative to the app root and are the same coordinate space as the window.
+      // They will stays correct when the window frame has been mutated out from under
+      // React Native.
+      if (typeof handle.measure !== 'function') {
+        resolve({ h, w, x, y: y + androidTopInsetCompensation(insets) });
+        return;
+      }
 
-    handle.measureInWindow((x, y, w, h) =>
-      resolve({ h, w, x, y: y + (Platform.OS === 'android' ? insets.top : 0) }),
-    );
+      handle.measure((_x, _y, width, height, pageX, pageY) => {
+        resolve({ h: height, w: width, x: pageX, y: pageY });
+      });
+    });
   });
 };