@symbiote-native/test-utils 0.4.6 → 0.5.0

package/build/index.d.ts

@@ -1,4 +1,8 @@
 export { createRecordingHost, installRecordingFabric, payloadOf, type IAuthoredNode, type IRecordingHost, } from './recording-host';
 export { censusLive, createLiveTree, type ILiveCensus, type ILiveNode, type ILiveTree, } from './live-tree';
+export { createListHarness, type IBox, type IListHarness, } from './list-harness';
 export { trackHostCrossings, type IHostCrossingTracker, } from './host-crossings';
 export * from './wait-for';
+export { nativeCallsTo } from './native-calls';
+export { emitRnDeviceEvent } from './rn-device-event';
+export { emitWindowDimensions, seedWindowDimensions, TEST_WINDOW, } from './window-dimensions';

package/build/index.js

@@ -10,6 +10,10 @@ export { createRecordingHost, installRecordingFabric, payloadOf, } from './recor
 // (`is this still mounted`, `did the pop remove it`) that `find` cannot answer, because `find`
 // searches the creation log. Anchors flatten, as the commit walk flattens them. See its header.
 export { censusLive, createLiveTree, } from './live-tree.js';
+export { createListHarness, } from './list-harness.js';
 // How many times JS crossed the host boundary — generic over whichever host is installed.
 export { trackHostCrossings, } from './host-crossings.js';
 export * from './wait-for.js';
+export { nativeCallsTo } from './native-calls.js';
+export { emitRnDeviceEvent } from './rn-device-event.js';
+export { emitWindowDimensions, seedWindowDimensions, TEST_WINDOW, } from './window-dimensions.js';

package/build/list-harness.d.ts

@@ -0,0 +1,19 @@
+import type { ILiveNode, ILiveTree } from './live-tree';
+import type { IAuthoredNode, IRecordingHost } from './recording-host';
+export type IBox = {
+    width: number;
+    height: number;
+};
+export type IListHarness = {
+    scrollView: () => IAuthoredNode;
+    contentView: () => ILiveNode;
+    cells: () => ILiveNode[];
+    shape: () => string;
+    simulateLayout: (args: {
+        viewport: IBox;
+        content: IBox;
+    }) => void;
+    simulateContentLayout: (box: IBox) => void;
+    simulateScroll: (y: number) => void;
+};
+export declare function createListHarness(fabric: IRecordingHost, live: ILiveTree): IListHarness;

package/build/list-harness.js

@@ -0,0 +1,65 @@
+// Drives a windowed list over the recording host: layout and scroll events aimed at its scroll
+// and content views, and a reading of the cells and spacers it currently renders
+function textOf(node) {
+    if (typeof node.payload.text === 'string')
+        return node.payload.text;
+    for (const child of node.children) {
+        const found = textOf(child);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function handleOf(node) {
+    const { instanceHandle } = node;
+    if (typeof instanceHandle !== 'object' || instanceHandle === null) {
+        throw new Error('the node has no instance handle to aim an event at');
+    }
+    return instanceHandle;
+}
+export function createListHarness(fabric, live) {
+    let viewport = { width: 0, height: 0 };
+    let content = { width: 0, height: 0 };
+    const scrollView = () => {
+        const node = fabric.find(one => one.viewName === 'RCTScrollView');
+        if (node === undefined)
+            throw new Error('no scroll view was created');
+        return node;
+    };
+    const contentView = () => {
+        const container = live.findLive(scrollView().handle, one => one.viewName === 'RCTScrollContentView');
+        if (container === undefined)
+            throw new Error('no scroll content view');
+        return container;
+    };
+    const cells = () => contentView().children.filter(child => textOf(child) !== undefined);
+    const simulateContentLayout = (box) => {
+        content = box;
+        fabric.fireEvent(handleOf(contentView()), 'topLayout', {
+            layout: { x: 0, y: 0, ...box },
+        });
+    };
+    return {
+        scrollView,
+        contentView,
+        cells,
+        shape: () => contentView()
+            .children.map(child => textOf(child) ?? `[${String(child.payload.height ?? 0)}]`)
+            .join(' '),
+        simulateLayout: args => {
+            viewport = args.viewport;
+            fabric.fireEvent(handleOf(scrollView()), 'topLayout', {
+                layout: { x: 0, y: 0, ...viewport },
+            });
+            simulateContentLayout(args.content);
+        },
+        simulateContentLayout,
+        simulateScroll: y => {
+            fabric.fireEvent(handleOf(scrollView()), 'topScroll', {
+                contentOffset: { x: 0, y },
+                contentSize: content,
+                layoutMeasurement: viewport,
+            });
+        },
+    };
+}

package/build/native-calls.d.ts

@@ -0,0 +1,7 @@
+type INativeCall = {
+    module: string;
+    method: string;
+    args: unknown[];
+};
+export declare function nativeCallsTo(moduleName: string): INativeCall[];
+export {};

package/build/native-calls.js

@@ -0,0 +1,17 @@
+// What a test sent to a native module through RN's `TurboModuleRegistry`, which vitest.config.ts
+// stubs and records into `globalThis.__symbioteNativeCalls`
+function isNativeCall(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'module' in value &&
+        'method' in value &&
+        'args' in value);
+}
+export function nativeCallsTo(moduleName) {
+    const recorded = Reflect.get(globalThis, '__symbioteNativeCalls');
+    if (!Array.isArray(recorded))
+        return [];
+    return recorded
+        .filter(isNativeCall)
+        .filter(call => call.module === moduleName);
+}

package/build/recording-host.d.ts

@@ -1,22 +1,10 @@
 /**
- * A tree host that RECORDS and derives nothing — for the 141 test files that never read a tree.
- *
- * Those files call `installFabric()` only because that is how a test gets a host at all: they
- * assert on state machines, prop resolution, listeners, styles. Attaching them to a second
- * implementation of Fabric's tree rules buys them nothing and costs the project a mirror.
- *
- * **Why this is not one.** It keeps the AUTHORED tree — who was appended to whom, what props were
- * set — because that is what the ops literally say and what an adapter's own seam asks back
- * (Solid's `getParentNode`, Vue's `nextSibling`, Svelte's `firstChild`). It does not decide what
- * COMMITS: no flattening, no stacking contexts, no virtual nodes, no clone protocol, no view-name
- * rewriting. There is no derived answer here to be wrong, which is the whole difference between
- * recording a statement and re-deriving a conclusion.
- *
- * A test that needs the committed tree belongs in `core/engine/cpp/tests/js`, where React Native
- * answers. Asking one of those questions here gets `undefined` rather than a plausible lie.
+ * A tree host that RECORDS and derives nothing, for test files that never read a tree
+ * It keeps the AUTHORED tree (who was appended to whom, which props were set), not what COMMITS
+ * A test that needs the committed tree belongs in `core/engine/cpp/tests/js`
  */
 import { type ISymbioteNode } from '@symbiote-native/engine';
-import type { ITreeHost } from '@symbiote-native/engine';
+import type { IDomRect, ITreeHost } from '@symbiote-native/engine';
 export type IRecorded = {
     handle: ISymbioteNode;
     instanceHandle: unknown;
@@ -30,18 +18,12 @@ export type IRecorded = {
     committedRootTag: number | undefined;
 };
 export type IRecordingHost = ITreeHost & {
-    /** How many commits the engine asked for. The op stream's own count, not a tree's. */
+    /** How many commits the engine asked for, the op stream's own count */
     commits: number;
-    /**
-     * The imperative calls the engine made, in order.
-     *
-     * These are the engine's own OUTPUT — it asked the platform to scroll, to focus, to take the
-     * responder — so recording them is reading what our code did, not deciding what the renderer
-     * would have done with it. The handle is the authored node, which is what a test holds.
-     */
+    /** The imperative calls the engine made, in order, on the authored node a test holds */
     commands: {
         handle: object;
-        /** As the ops named it — the authored view name, not a committed one. */
+        /** As the ops named it, not a committed name */
         viewName: string;
         commandName: string;
         args: readonly unknown[];
@@ -55,101 +37,51 @@ export type IRecordingHost = ITreeHost & {
         handle: object;
         eventType: string;
     }[];
-    /**
-     * Hand an event to the handler the engine registered, naming the target yourself.
-     *
-     * Not a tree read, and not the platform deciding anything: the engine installs this handler
-     * through `registerEventHandler` and this plays it back verbatim. What a REAL gesture needs —
-     * hit-testing coordinates to a target — is the renderer's answer and is not on offer here; a
-     * caller must already know which node it means, which is what an engine-side dispatch test does.
-     */
+    /** Hands an event to the registered handler, naming the target yourself, no hit-testing */
     fireEvent: (handle: object, topLevelType: string, nativeEvent?: Record<string, unknown>) => void;
-    /** The slot call, kept here so one object owns both halves of the round trip. */
+    /** The slot call, kept here so one object owns both halves of the round trip */
     registerEventHandler: (handler: IEventHandler) => void;
-    /**
-     * The first AUTHORED node matching `predicate` — the handle a test needs when the adapter, not
-     * the test, created the node.
-     *
-     * **The authored tree, and the word carries the whole caveat.** These are the nodes the ops named
-     * and the props they carried; nothing here says which of them Fabric kept, what it renamed, or
-     * what it flattened away. So this answers "find the node the app wrote" — to read its props, to
-     * hand it to `fabricProps`, to fire an event at it — and it does NOT answer any question about
-     * shape. That one belongs to `committedTree()` in `core/engine/cpp/tests/js`.
-     */
+    /** The first authored node matching `predicate`, for a node the adapter created */
     find: (predicate: (node: IAuthoredNode) => boolean) => IAuthoredNode | undefined;
-    /** Every authored node matching `predicate`, in CREATION order — not document order. */
+    /** Every authored node matching `predicate`, in creation order, not document order */
     findAll: (predicate: (node: IAuthoredNode) => boolean) => IAuthoredNode[];
     /**
-     * Clear the recordings. The authored tree survives, as it does under `installFabric`.
-     *
-     * What it also clears, and it is load-bearing: the list `find` searches. A file that mounts a
-     * fresh tree per case reuses its `testID`s, so a `find` spanning cases answers with the FIRST
-     * match — an earlier case's node, carrying an earlier case's props. Caught by a converted test
-     * whose second case read the first case's payload and reported a missing prop.
+     * Clears the recordings and the list `find` searches, the authored tree survives
+     * A file reusing its `testID`s per case would otherwise find an earlier case's node
      */
     reset: () => void;
     forget: () => void;
+    /**
+     * What `measureLayout` answers, by the two handles
+     * No Yoga runs headless, so a test that needs a rect names it here, no answer means it fails
+     */
+    answerMeasureLayout: (answer: ((handle: object, relativeTo: object) => IDomRect | undefined) | undefined) => void;
 };
 type IEventHandler = (handle: object, topLevelType: string, nativeEvent: Record<string, unknown>) => void;
-/**
- * A node as the OPS described it. Not a committed node and not pretending to be one — there is no
- * tag, because this host never spoke to Fabric and any number here would be an invention.
- */
+/** A node as the ops described it, with no tag because this host never spoke to Fabric */
 export type IAuthoredNode = {
-    /** The engine node itself, so it can be handed straight back to the engine's own API. */
+    /** The engine node itself, to hand back to the engine's own API */
     handle: ISymbioteNode;
-    /**
-     * The object the engine gave Fabric to hand back with an event — undefined for a raw text or an
-     * anchor, which are created with none.
-     *
-     * It is what `fireEvent` has to be aimed at: the engine's event handler resolves a target by
-     * this object, not by the node, so passing the node would silently deliver to nothing.
-     */
+    /** The object `fireEvent` must be aimed at, undefined for a raw text or an anchor */
     instanceHandle: unknown;
-    /** As the ops named it. Fabric may commit it under a different name; that is not known here. */
+    /** As the ops named it, Fabric may commit it under a different name */
     viewName: string;
-    /**
-     * The intrinsic tag, for a node a host behavior attached to; empty for every other node.
-     *
-     * Recorded so a test can ASK what a node is — the real host resolves a tag's platform props off
-     * it and a plain `RCTView` cannot be told from a `<pressable>` any other way. It changes nothing
-     * about the payload this host builds; see the `OP_SET_TAG` case.
-     */
+    /** The intrinsic tag of a node a host behavior attached to, empty for every other node */
     tagName: string;
-    /**
-     * Which event names a BEHAVIOR owns currently have an app callback wired, by name.
-     *
-     * The presence only — the callback never crosses and is not here. It is what lets a platform rule
-     * resolve a key that depends on whether the app wired anything (`focusable` on a touchable is
-     * `focusable !== false && onPress !== undefined && !disabled`). Recorded for the same reason
-     * `tagName` is: so a test can ask what the host was TOLD, separately from what a rule made of it.
-     */
+    /** Which event names a behavior owns have an app callback wired, presence only */
     ownedListeners: Record<string, boolean>;
-    /** Whether a behavior's feedback is showing — see `OP_SET_UNDERLAY_SHOWN`. */
+    /** Whether a behavior's feedback is showing, see `OP_SET_UNDERLAY_SHOWN` */
     underlayShown: boolean;
     props: Readonly<Record<string, unknown>>;
 };
 /**
- * Install the recording host, with the minimum slot the engine insists on.
- *
- * `createSurface` calls `installEventHandler`, which reaches `globalThis.nativeFabricUIManager` and
- * throws if it is absent — so a host alone is not enough to get a surface open. The slot below
- * exists to be PRESENT: every method answers nothing except `registerEventHandler`, which hands the
- * engine's handler to the host so `fireEvent` can play it back.
- *
- * What that does NOT buy is a real gesture. Deciding which node a touch lands on is hit-testing,
- * and that is the renderer's answer; a test that needs it belongs in `core/engine/cpp/tests/js`.
+ * Installs the recording host with the minimum slot the engine insists on
+ * `createSurface` throws without `nativeFabricUIManager`, so the slot only has to be present
  */
 export declare function installRecordingFabric(): IRecordingHost;
 /**
- * The Fabric payload for a node — what the engine WOULD hand the renderer for it, built by the
- * engine's own builder rather than read off anything.
- *
- * This exists because the two are easy to confuse and the difference bites: a node's PROPS are the
- * author's bag (`style` is still an object), while the PAYLOAD is what `fabricProps` makes of it —
- * style flattened into top-level keys, the aria fold run, the ten RN processors applied. A test
- * asking about `padding` or `accessibilityRole` or a parsed `backgroundSize` means the payload, and
- * reading the bag instead comes back `undefined` with nothing to explain why.
+ * The Fabric payload for a node, built by the engine's own builder
+ * Props are the author's bag (`style` is an object), the payload is what `fabricProps` makes of it
  */
 export declare function payloadOf(node: ISymbioteNode): Record<string, unknown>;
 export declare function createRecordingHost(): IRecordingHost;

package/build/recording-host.js

@@ -1,32 +1,13 @@
 /**
- * A tree host that RECORDS and derives nothing — for the 141 test files that never read a tree.
- *
- * Those files call `installFabric()` only because that is how a test gets a host at all: they
- * assert on state machines, prop resolution, listeners, styles. Attaching them to a second
- * implementation of Fabric's tree rules buys them nothing and costs the project a mirror.
- *
- * **Why this is not one.** It keeps the AUTHORED tree — who was appended to whom, what props were
- * set — because that is what the ops literally say and what an adapter's own seam asks back
- * (Solid's `getParentNode`, Vue's `nextSibling`, Svelte's `firstChild`). It does not decide what
- * COMMITS: no flattening, no stacking contexts, no virtual nodes, no clone protocol, no view-name
- * rewriting. There is no derived answer here to be wrong, which is the whole difference between
- * recording a statement and re-deriving a conclusion.
- *
- * A test that needs the committed tree belongs in `core/engine/cpp/tests/js`, where React Native
- * answers. Asking one of those questions here gets `undefined` rather than a plausible lie.
+ * A tree host that RECORDS and derives nothing, for test files that never read a tree
+ * It keeps the AUTHORED tree (who was appended to whom, which props were set), not what COMMITS
+ * A test that needs the committed tree belongs in `core/engine/cpp/tests/js`
  */
 import { fabricProps, propsOf, setTreeHost, } from '@symbiote-native/engine';
 import { createRecordedTree } from './recorded-tree.js';
 /**
- * Install the recording host, with the minimum slot the engine insists on.
- *
- * `createSurface` calls `installEventHandler`, which reaches `globalThis.nativeFabricUIManager` and
- * throws if it is absent — so a host alone is not enough to get a surface open. The slot below
- * exists to be PRESENT: every method answers nothing except `registerEventHandler`, which hands the
- * engine's handler to the host so `fireEvent` can play it back.
- *
- * What that does NOT buy is a real gesture. Deciding which node a touch lands on is hit-testing,
- * and that is the renderer's answer; a test that needs it belongs in `core/engine/cpp/tests/js`.
+ * Installs the recording host with the minimum slot the engine insists on
+ * `createSurface` throws without `nativeFabricUIManager`, so the slot only has to be present
  */
 export function installRecordingFabric() {
     const host = createRecordingHost();
@@ -38,6 +19,7 @@ export function installRecordingFabric() {
             dispatchCommand() { },
             setIsJSResponder() { },
             sendAccessibilityEvent() { },
+            configureNextLayoutAnimation() { },
             measure() { },
             measureInWindow() { },
             measureLayout() { },
@@ -47,27 +29,18 @@ export function installRecordingFabric() {
     return host;
 }
 /**
- * The Fabric payload for a node — what the engine WOULD hand the renderer for it, built by the
- * engine's own builder rather than read off anything.
- *
- * This exists because the two are easy to confuse and the difference bites: a node's PROPS are the
- * author's bag (`style` is still an object), while the PAYLOAD is what `fabricProps` makes of it —
- * style flattened into top-level keys, the aria fold run, the ten RN processors applied. A test
- * asking about `padding` or `accessibilityRole` or a parsed `backgroundSize` means the payload, and
- * reading the bag instead comes back `undefined` with nothing to explain why.
+ * The Fabric payload for a node, built by the engine's own builder
+ * Props are the author's bag (`style` is an object), the payload is what `fabricProps` makes of it
  */
 export function payloadOf(node) {
     return fabricProps(node, propsOf(node));
 }
-/**
- * Where a tag would be. Not a Fabric tag and not pretending to be one — this host never speaks to
- * Fabric, so any number here would be an invention.
- */
+// Where a tag would be, this host never speaks to Fabric so any number would be an invention
 const NO_TAG = -1;
 export function createRecordingHost() {
     const tree = createRecordedTree();
     const { nodeOf } = tree;
-    let eventHandler;
+    let measureLayoutAnswer;
     const commands = [];
     const responderHandovers = [];
     const accessibilityEvents = [];
@@ -76,8 +49,19 @@ export function createRecordingHost() {
         commands.length = 0;
         responderHandovers.length = 0;
         accessibilityEvents.length = 0;
+        measureLayoutAnswer = undefined;
     };
+    let eventHandler;
     return {
+        registerEventHandler(handler) {
+            eventHandler = handler;
+        },
+        fireEvent(handle, topLevelType, nativeEvent = {}) {
+            if (eventHandler === undefined) {
+                throw new Error('no event handler registered by the renderer');
+            }
+            eventHandler(handle, topLevelType, nativeEvent);
+        },
         get commits() {
             return tree.commits;
         },
@@ -91,11 +75,9 @@ export function createRecordingHost() {
         propsOf(handle) {
             return nodeOf(handle, 'propsOf').props;
         },
-        // Nothing is memoized here, so there is nothing to invalidate.
+        // Nothing is memoized here, so there is nothing to invalidate
         markPropsDirty() { },
-        // That the ops COMMITTED this node, and nothing more. Read off `committedRootTag` and not a
-        // live walk, т.к. `removeChild` cuts the parent link before the teardown sweep runs in the
-        // SAME commit
+        // Read off `committedRootTag`, т.к. `removeChild` cuts the parent link before the sweep
         committedRecordOf(handle) {
             const node = tree.recordedOf(handle);
             if (node === undefined || node.committedRootTag === undefined) {
@@ -107,9 +89,7 @@ export function createRecordingHost() {
                 rootTag: node.committedRootTag,
             };
         },
-        // REFUSED loudly, т.к. the payload is `SymbioteFabricProps.cpp`'s and that code does not run
-        // in vitest. A test asking this belongs in `core/engine/cpp/tests/js`, where the real builder
-        // does run
+        // Refused loudly, т.к. the payload builder is C++ and does not run here
         committedPayloadOf() {
             throw new Error('recording host: committedPayloadOf needs the real payload builder — move this to an itest');
         },
@@ -143,9 +123,7 @@ export function createRecordingHost() {
                 walk(nodeOf(root, 'subtreesOf'));
             return out;
         },
-        // The twin of the engine's narrowed walk, and it MUST narrow here too: the vitest suite is
-        // where the sweep is asserted, so handing back everything would pass those cases whatever the
-        // engine does
+        // Narrows like the engine's walk, else the sweep cases would pass whatever the engine does
         teardownSubtreesOf(roots) {
             const out = [];
             const walk = (node, isRoot) => {
@@ -180,8 +158,7 @@ export function createRecordingHost() {
             };
             for (const root of roots)
                 walk(nodeOf(root, 'census'));
-            // The skip counts belong to the commit rules, which this host does not have. Zero is the
-            // honest answer: nothing here was skipped, because nothing here was decided.
+            // The skip counts belong to commit rules this host lacks, so zero is the honest answer
             return {
                 nodes,
                 anchors: 0,
@@ -190,9 +167,8 @@ export function createRecordingHost() {
                 flattenWidths: [],
             };
         },
-        // The imperative six ask the PLATFORM — a frame, a gesture, an announcement. Three of them
-        // carry a request the engine MADE, so they are recorded; the measuring three want an answer
-        // only a platform has, and there is none here.
+        // Three imperative calls carry a request the engine made and are recorded
+        // The measuring three want an answer only a platform has, and there is none here
         dispatchCommand(handle, commandName, args) {
             commands.push({
                 handle,
@@ -210,27 +186,25 @@ export function createRecordingHost() {
         getBoundingClientRect() {
             return { x: 0, y: 0, width: 0, height: 0 };
         },
-        measureLayout(_handle, _relativeTo, onFail, _onSuccess) {
-            onFail();
+        measureLayout(handle, relativeTo, onFail, onSuccess) {
+            const rect = measureLayoutAnswer?.(handle, relativeTo);
+            if (rect === undefined)
+                onFail();
+            else
+                onSuccess(rect.x, rect.y, rect.width, rect.height);
+        },
+        answerMeasureLayout(answer) {
+            measureLayoutAnswer = answer;
         },
         setIsJSResponder(handle, isResponder, blockNativeResponder) {
             responderHandovers.push({ handle, isResponder, blockNativeResponder });
         },
-        registerEventHandler(handler) {
-            eventHandler = handler;
-        },
         find(predicate) {
             return tree.authored.find(predicate);
         },
         findAll(predicate) {
             return tree.authored.filter(predicate);
         },
-        fireEvent(handle, topLevelType, nativeEvent = {}) {
-            if (eventHandler === undefined) {
-                throw new Error('no event handler registered by the renderer');
-            }
-            eventHandler(handle, topLevelType, nativeEvent);
-        },
         reset: clearRecords,
         forget() {
             tree.forget();

package/build/rn-device-event.d.ts

@@ -0,0 +1 @@
+export declare function emitRnDeviceEvent(eventType: string, payload: unknown): void;

package/build/rn-device-event.js

@@ -0,0 +1,10 @@
+// Native pushes a device event through RN's `RCTDeviceEventEmitter`, which is where RN's own
+// `Dimensions`, `Appearance` and `AppState` listen once the engine forwards to them
+import RCTDeviceEventEmitter from 'react-native/Libraries/EventEmitter/RCTDeviceEventEmitter';
+export function emitRnDeviceEvent(eventType, payload) {
+    const emit = Reflect.get(RCTDeviceEventEmitter, 'emit');
+    if (typeof emit !== 'function') {
+        throw new Error('RN device event emitter has no emit');
+    }
+    Reflect.apply(emit, RCTDeviceEventEmitter, [eventType, payload]);
+}

package/build/window-dimensions.d.ts

@@ -0,0 +1,13 @@
+export declare const TEST_WINDOW: {
+    width: number;
+    height: number;
+    scale: number;
+    fontScale: number;
+};
+export declare function seedWindowDimensions(): void;
+export declare function emitWindowDimensions(window: typeof TEST_WINDOW, screen?: {
+    width: number;
+    height: number;
+    scale: number;
+    fontScale: number;
+}): void;

package/build/window-dimensions.js

@@ -0,0 +1,12 @@
+// A headless run has no `DeviceInfo` to answer `Dimensions.get`, so anything that reads the window
+// at mount (InputAccessoryView's content width) throws until a test seeds one
+import { Dimensions } from '@symbiote-native/engine';
+import { emitRnDeviceEvent } from './rn-device-event.js';
+export const TEST_WINDOW = { width: 390, height: 844, scale: 3, fontScale: 1 };
+export function seedWindowDimensions() {
+    Dimensions.set({ window: TEST_WINDOW, screen: TEST_WINDOW });
+}
+// Native pushes new metrics as a `didUpdateDimensions` device event, which RN's `Dimensions` hears
+export function emitWindowDimensions(window, screen = window) {
+    emitRnDeviceEvent('didUpdateDimensions', { window, screen });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/test-utils",
-  "version": "0.4.6",
+  "version": "0.5.0",
   "description": "Shared, framework-agnostic fake-Fabric test harness for SymbioteNative — the fake nativeFabricUIManager recorder used by the co-located test suites across the engine, every adapter, and the example apps.",
   "license": "MIT",
   "repository": {
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@symbiote-native/engine": "1.5.0"
+    "@symbiote-native/engine": "1.7.0"
   },
   "scripts": {
     "typecheck": "tsc --build",