@sigx/lynx-testing 0.2.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,236 @@
+# @sigx/lynx-testing
+
+Vitest-native testing utilities for sigx-lynx components — render, fire events, query the rendered tree, and wait for reactive updates.
+
+Renders into an in-memory `TestNode` tree (no Lynx runtime, no PAPI mocks for the BG side). Pair with vitest in your project — no Jest, no preset.
+
+```bash
+pnpm add -D @sigx/lynx-testing vitest
+```
+
+## Quick start
+
+```tsx
+import { describe, it, expect } from 'vitest';
+import { render, fireEvent, act } from '@sigx/lynx-testing';
+import { component, signal, jsx } from '@sigx/lynx';
+
+it('updates on tap', async () => {
+  const count = signal({ value: 0 });
+  const Counter = component(() => {
+    return () => jsx('view', {
+      bindtap: () => { count.value++; },
+      children: [jsx('text', { children: String(count.value) })],
+    });
+  });
+
+  const { container, getByType, getByText } = render(jsx(Counter, {}));
+  expect(getByText('0')).toBeTruthy();
+
+  await act(() => fireEvent.tap(getByType('view')));
+  expect(getByText('1')).toBeTruthy();
+});
+```
+
+## API
+
+### `render(element, { appContext? }) → RenderResult`
+
+Mounts a JSX element into a fresh `TestNode` tree. Returns:
+
+- `container: TestNode` — the root node
+- `unmount(): void` — tears down the render
+- `getByType(type) / getAllByType(type) / queryByType(type)` — find by element name (`'view'`, `'text'`, `'scroll-view'`, …)
+- `getByText(text) / queryByText(text)` — substring match on text content
+- `getByProp(key, value)` — find by an arbitrary prop value (`getByProp('id', 'submit')`)
+- `debug(): string` — pretty-print the rendered tree
+
+`get*` throws if no node matches; `query*` returns `null`.
+
+### `fireEvent`
+
+```ts
+fireEvent.tap(node, { x?, y? })
+fireEvent.touchStart(node, { touches?, changedTouches? })
+fireEvent.touchMove(node, { touches?, changedTouches? })
+fireEvent.touchEnd(node, { touches?, changedTouches? })
+fireEvent.touchCancel(node, { touches?, changedTouches? })
+fireEvent.scroll(node, { detail: { scrollTop?, scrollLeft?, deltaX?, deltaY?, ... } })
+fireEvent.input(node, { detail: { value? } })
+fireEvent.longPress(node)
+```
+
+Each method dispatches both the `bind*` form (`bindtap`, `bindscroll`, …) and the camelCase form (`onTap`, `onScroll`, …) so component-vs-element handler shapes both fire.
+
+### `touch(pageX, pageY, identifier = 1)`
+
+Helper for building synthetic touch objects:
+
+```ts
+fireEvent.touchMove(view, { touches: [touch(150, 200)] });
+```
+
+### `act(fn)` / `waitForUpdate()`
+
+Reactive flush helpers. Wrap signal mutations in `act` so the renderer commits before you assert:
+
+```ts
+await act(() => {
+  state.count = 5;
+  state.name = 'Alice';
+});
+expect(getByText('5')).toBeTruthy();
+```
+
+`waitForUpdate()` is the bare flush — useful when the mutation already happened (e.g. inside an event handler).
+
+## Vitest config
+
+A minimal `vitest.config.ts` for an app using sigx-lynx:
+
+```ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  oxc: {
+    jsx: { runtime: 'automatic', importSource: 'sigx' },
+  },
+  test: {
+    environment: 'happy-dom',
+    include: ['src/**/__tests__/**/*.test.{ts,tsx}'],
+    globals: true,
+  },
+});
+```
+
+## Testing MT-thread components
+
+`render()` mounts the **BG side** of your component. Worklet props (`main-thread-bindtap`, `main-thread:ref`, `'main thread'`-marked function bodies) are rendered as inert handlers — the SWC worklet transform does not run, and the MT runtime is not booted. So `render()`-driven tests cover JSX shape + signal-driven re-renders, not worklet behavior.
+
+For end-to-end MT coverage, use the `@sigx/lynx-testing/mt` subpath. It boots the upstream `@lynx-js/react/worklet-runtime`, runs the SWC `'main thread'` transform on real source, eval's the extracted `registerWorkletInternal(...)` calls, and hands back the registered worklets so you can drive them with fabricated events.
+
+### Setup
+
+Add a separate vitest config that picks up `*.mt.test.ts` files. The MT harness is heavier than the BG `render()` path — keeping it in its own config avoids paying the bootstrap cost on every BG test.
+
+```ts
+// vitest.mt.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'happy-dom',
+    globals: true,
+    include: ['__tests__/**\/*.mt.test.ts'],
+    setupFiles: ['@sigx/lynx-testing/mt/setup'],
+  },
+});
+```
+
+```jsonc
+// package.json
+{
+  "scripts": {
+    "test:mt": "vitest run --config vitest.mt.config.ts"
+  },
+  "devDependencies": {
+    "@lynx-js/react": "^0.119.0",
+    "@sigx/lynx-runtime-main": "workspace:^",
+    "@sigx/lynx-testing": "workspace:^",
+    "vitest": "^4"
+  }
+}
+```
+
+`@lynx-js/react` and `@sigx/lynx-runtime-main` are peer dependencies of `@sigx/lynx-testing/mt` and must be installed by the consumer (they ship the worklet runtime + the MT bootstrap that the setup file imports).
+
+### Worked example
+
+```ts
+// __tests__/my-button.mt.test.ts
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  compileMTWorklets,
+  fabricateTapEvent,
+  makeRef,
+} from '@sigx/lynx-testing/mt';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+const SRC = resolve(__dirname, '../src/components/MyButton.tsx');
+
+describe('MyButton — MT worklets', () => {
+  let onBegin: Function;
+  let onStart: Function;
+
+  beforeEach(() => {
+    // Compiles the source through the SWC LEPUS transform, eval's the
+    // emitted `registerWorkletInternal(...)` calls, and returns the
+    // worklets in source order.
+    const worklets = compileMTWorklets({
+      filename: SRC,
+      source: readFileSync(SRC, 'utf8'),
+    });
+    expect(worklets).toHaveLength(2); // your component's worklet count
+    [onBegin, onStart] = worklets;
+  });
+
+  it('onBegin sets pressed-state styles', () => {
+    const setStyleProperties = vi.fn();
+    const ctx = {
+      _c: {
+        elRef: makeRef({ setStyleProperties }, 1),
+        opacity: 0.6,
+      },
+    };
+    onBegin.call(ctx, fabricateTapEvent());
+    expect(setStyleProperties).toHaveBeenCalledWith({ opacity: 0.6 });
+  });
+});
+```
+
+### API
+
+#### `compileMTWorklets({ filename, source, runtimePkg? }) → Function[]`
+
+Compile a `.tsx` source through the SWC LEPUS transform and register every `'main thread'`-marked function as a worklet on the live runtime that `setup.ts` bootstrapped. Returns the worklets in source order (top-to-bottom). Indexing into the returned array maps to your component's worklet declarations:
+
+| Component shape | Index | Worklet |
+|---|---|---|
+| `Gesture.Pan().onBegin().onStart().onUpdate().onEnd()` | `[0]` | onBegin |
+|  | `[1]` | onStart |
+|  | `[2]` | onUpdate |
+|  | `[3]` | onEnd |
+
+Pass `runtimePkg` if your project uses something other than `@sigx/lynx-runtime-main` (rare).
+
+#### `fabricatePanEvent({ pageX, pageY? }) / fabricateTapEvent({ pageX?, pageY? })`
+
+Synthetic gesture-event payloads matching what Lynx's iOS arena delivers to MT worklets. **Important:** `pageX/pageY` are nested under `e.params` (NOT top-level on `e`). This mirrors `LynxBaseGestureHandler.m::eventParamsFromTouchEvent`. Worklets that read `e.pageX` will get `undefined` against this fabricated event — they should read `e.params.pageX`.
+
+#### `makeRef<T>(current, id?) → { current, _wvid }`
+
+Synthetic `MainThreadRef` shape. Worklets read `ref.current.value` and may mutate it.
+
+#### `getWorkletMap() → Record<string, Function>`
+
+Direct access to `lynxWorkletImpl._workletMap`. Useful when you need to look up a specific `_wkltId` rather than rely on source order. Throws if `setup.ts` didn't run.
+
+#### `getJsContext() / resetJsContextSpy()`
+
+Read or reset the JS-context spy that the lynx mock installs. Use to assert `dispatchEvent` calls (e.g. `Lynx.Sigx.AvPublish` from a worklet's `runOnBackground`).
+
+#### `extractRegistrations(lepusCode) → string`
+
+Extract `registerWorkletInternal(...)` calls from a LEPUS-target transform output. `compileMTWorklets()` calls this internally; export it for callers that want to roll their own compile flow.
+
+### Lynx native quirks worth knowing about
+
+These are real arena behaviors observed on iOS Lynx 3.5 / Android Lynx 3.6 — your worklets must accommodate them. Not bugs in this harness; the harness exposes them:
+
+1. **`Gesture.Pan` requires an empty `.onBegin()` on iOS.** The native handler only sets `_isInvokedBegin` inside an onBegin handler, and `onStart`/`onEnd` short-circuit if that flag is false. Register a no-op onBegin on Pan or onStart never fires.
+2. **Pan event payload is nested under `e.params`.** Top-level `e` has only dispatch metadata (`type`, `timestamp`, `target`, `currentTarget`); pageX/pageY/scrollX/etc. live in `e.params` (and a duplicate `e.detail`). The fabricators above match this shape.
+3. **iOS arena fires `Tap.onEnd` ~6ms after touchstart for sibling-composed gestures.** `Gesture.Simultaneous(Tap, LongPress)` looks like it should let both gestures resolve independently, but iOS dispatches a fail/reset path that fires Tap.onEnd before recognition completes. `Tap.onStart` then never fires. Workaround in `<Pressable>`: register only `Tap.onBegin` + `Tap.onStart` (no Tap.onEnd) and emit press from `LongPress.onEnd`'s no-`longPressFired`-and-no-movement fallback. See `packages/gestures/src/components/Pressable.tsx` for the full pattern.
+4. **`<scroll-view>` doesn't participate in the new gesture arena.** Its UIKit `panGestureRecognizer` runs independently of `LynxGestureArenaManager`, so a Pan registered on a descendant fires concurrently with the parent scroll. `<ScrollView>` exposes a `useScrollContext`-published `dragging` signal that descendants flip during their drag lifecycle as the workaround.
+
+This pattern catches regressions like the Phase 2 "cannot read property bind of undefined" bug — silent through every source-shape regex test, would have failed at the e2e harness's `expect(workletFns.length).toBe(N)` assertion.

package/dist/fire-event.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Fire synthetic events on TestNode elements.
+ */
+import { TestNode } from './test-node.js';
+interface SyntheticTouch {
+    identifier?: number;
+    x?: number;
+    y?: number;
+    pageX?: number;
+    pageY?: number;
+    clientX?: number;
+    clientY?: number;
+}
+interface SyntheticTouchEvent {
+    touches?: SyntheticTouch[];
+    changedTouches?: SyntheticTouch[];
+}
+interface SyntheticScrollEvent {
+    detail?: {
+        scrollTop?: number;
+        scrollLeft?: number;
+        scrollHeight?: number;
+        scrollWidth?: number;
+        deltaX?: number;
+        deltaY?: number;
+    };
+}
+interface SyntheticInputEvent {
+    detail?: {
+        value?: string;
+    };
+}
+/** Create a normalized touch object with defaults. */
+export declare function touch(pageX: number, pageY: number, identifier?: number): SyntheticTouch;
+export declare const fireEvent: {
+    /** Fire bindtap / onTap event. */
+    tap(node: TestNode, data?: {
+        x?: number;
+        y?: number;
+    }): void;
+    /** Fire bindtouchstart event. */
+    touchStart(node: TestNode, data?: SyntheticTouchEvent): void;
+    /** Fire bindtouchmove event. */
+    touchMove(node: TestNode, data?: SyntheticTouchEvent): void;
+    /** Fire bindtouchend event. */
+    touchEnd(node: TestNode, data?: SyntheticTouchEvent): void;
+    /** Fire bindtouchcancel event. */
+    touchCancel(node: TestNode, data?: SyntheticTouchEvent): void;
+    /** Fire bindscroll event. */
+    scroll(node: TestNode, data?: SyntheticScrollEvent): void;
+    /** Fire bindinput event. */
+    input(node: TestNode, data?: SyntheticInputEvent): void;
+    /** Fire bindlongpress event. */
+    longPress(node: TestNode): void;
+};
+export {};
+//# sourceMappingURL=fire-event.d.ts.map

package/dist/fire-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fire-event.d.ts","sourceRoot":"","sources":["../src/fire-event.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,UAAU,cAAc;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,mBAAmB;IAC3B,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;IAC3B,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;CACnC;AAED,UAAU,oBAAoB;IAC5B,MAAM,CAAC,EAAE;QACP,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,UAAU,mBAAmB;IAC3B,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAED,sDAAsD;AACtD,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,UAAU,SAAI,GACb,cAAc,CAEhB;AAmBD,eAAO,MAAM,SAAS;IACpB,kCAAkC;IAClC,GAAG,OAAO,QAAQ,SAAS;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAgB5D,iCAAiC;IACjC,UAAU,OAAO,QAAQ,SAAS,mBAAmB,GAAG,IAAI;IAI5D,gCAAgC;IAChC,SAAS,OAAO,QAAQ,SAAS,mBAAmB,GAAG,IAAI;IAI3D,+BAA+B;IAC/B,QAAQ,OAAO,QAAQ,SAAS,mBAAmB,GAAG,IAAI;IAI1D,kCAAkC;IAClC,WAAW,OAAO,QAAQ,SAAS,mBAAmB,GAAG,IAAI;IAI7D,6BAA6B;IAC7B,MAAM,OAAO,QAAQ,SAAS,oBAAoB,GAAG,IAAI;IAoBzD,4BAA4B;IAC5B,KAAK,OAAO,QAAQ,SAAS,mBAAmB,GAAG,IAAI;IAYvD,gCAAgC;IAChC,SAAS,OAAO,QAAQ,GAAG,IAAI;CAWhC,CAAC"}

package/dist/flush.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utilities for waiting on reactive updates in tests.
+ */
+/**
+ * Wait for all pending reactive effects and microtasks to complete.
+ * Use after mutating signal state to ensure the rendered tree is updated.
+ *
+ * @example
+ * ```ts
+ * state.count = 5;
+ * await waitForUpdate();
+ * expect(getByText(container, '5')).toBeTruthy();
+ * ```
+ */
+export declare function waitForUpdate(): Promise<void>;
+/**
+ * Run a callback and wait for reactive effects to flush.
+ *
+ * @example
+ * ```ts
+ * await act(() => {
+ *   state.count++;
+ *   state.name = 'Alice';
+ * });
+ * // Tree is now updated
+ * ```
+ */
+export declare function act(fn: () => void | Promise<void>): Promise<void>;
+//# sourceMappingURL=flush.d.ts.map

package/dist/flush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flush.d.ts","sourceRoot":"","sources":["../src/flush.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ7C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,GAAG,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAGvE"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { render } from './render.js';
+export type { RenderResult } from './render.js';
+export { TestNode } from './test-node.js';
+export { fireEvent, touch } from './fire-event.js';
+export { waitForUpdate, act } from './flush.js';
+export { getByType, getAllByType, getByText, queryByType, queryByText, getByProp, } from './queries.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EACL,SAAS,EACT,YAAY,EACZ,SAAS,EACT,WAAW,EACX,WAAW,EACX,SAAS,GACV,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,305 @@
+import { createRenderer as e } from "@sigx/runtime-core/internals";
+//#region src/test-node.ts
+var t = class {
+	type;
+	props = {};
+	children = [];
+	parent = null;
+	text;
+	_handlers = /* @__PURE__ */ new Map();
+	_style = {};
+	_class = "";
+	constructor(e) {
+		this.type = e;
+	}
+	findByType(e) {
+		for (let t of this.children) {
+			if (t.type === e) return t;
+			let n = t.findByType(e);
+			if (n) return n;
+		}
+		return null;
+	}
+	findAllByType(e) {
+		let t = [];
+		for (let n of this.children) n.type === e && t.push(n), t.push(...n.findAllByType(e));
+		return t;
+	}
+	findByText(e) {
+		if (this.text !== void 0 && String(this.text).includes(e)) return this;
+		for (let t of this.children) {
+			let n = t.findByText(e);
+			if (n) return n;
+		}
+		return null;
+	}
+	textContent() {
+		return this.text === void 0 ? this.children.map((e) => e.textContent()).join("") : String(this.text);
+	}
+	toDebugString(e = 0) {
+		let t = "  ".repeat(e);
+		if (this.type === "#text") return `${t}${JSON.stringify(this.text)}`;
+		if (this.type === "#comment") return `${t}<!-- -->`;
+		let n = Object.keys(this.props).length > 0 ? " " + Object.entries(this.props).map(([e, t]) => `${e}=${JSON.stringify(t)}`).join(" ") : "";
+		if (this.children.length === 0) return `${t}<${this.type}${n} />`;
+		let r = this.children.map((t) => t.toDebugString(e + 1)).join("\n");
+		return `${t}<${this.type}${n}>\n${r}\n${t}</${this.type}>`;
+	}
+}, n = e({
+	createElement(e) {
+		return new t(e);
+	},
+	createText(e) {
+		let n = new t("#text");
+		return n.text = e, n;
+	},
+	createComment(e) {
+		return new t("#comment");
+	},
+	setText(e, t) {
+		e.text = t;
+	},
+	setElementText(e, n) {
+		e.children = [];
+		let r = new t("#text");
+		r.text = n, r.parent = e, e.children.push(r);
+	},
+	insert(e, t, n) {
+		if (e.parent) {
+			let t = e.parent.children.indexOf(e);
+			t !== -1 && e.parent.children.splice(t, 1);
+		}
+		if (e.parent = t, n) {
+			let r = t.children.indexOf(n);
+			if (r !== -1) {
+				t.children.splice(r, 0, e);
+				return;
+			}
+		}
+		t.children.push(e);
+	},
+	remove(e) {
+		if (e.parent) {
+			let t = e.parent.children.indexOf(e);
+			t !== -1 && e.parent.children.splice(t, 1), e.parent = null;
+		}
+	},
+	patchProp(e, t, n, r) {
+		t === "style" ? (e._style = r ?? {}, e.props[t] = r) : t === "class" ? (e._class = r ?? "", e.props[t] = r) : t.startsWith("bind") || t.startsWith("catch") || t.startsWith("on") || t.startsWith("main-thread-bind") || t.startsWith("main-thread-catch") || t.startsWith("global-") ? (typeof r == "function" ? e._handlers.set(t, r) : e._handlers.delete(t), e.props[t] = r) : r == null ? delete e.props[t] : e.props[t] = r;
+	},
+	parentNode(e) {
+		return e.parent;
+	},
+	nextSibling(e) {
+		if (!e.parent) return null;
+		let t = e.parent.children.indexOf(e);
+		return e.parent.children[t + 1] ?? null;
+	},
+	cloneNode(e) {
+		return new t(e.type);
+	}
+});
+//#endregion
+//#region src/queries.ts
+function r(e, t) {
+	let n = e.findByType(t);
+	if (!n) throw Error(`No element found with type "${t}"`);
+	return n;
+}
+function i(e, t) {
+	return e.findAllByType(t);
+}
+function a(e, t) {
+	let n = e.findByText(t);
+	if (!n) throw Error(`No element found with text "${t}"`);
+	return n;
+}
+function o(e, t) {
+	return e.findByType(t);
+}
+function s(e, t) {
+	return e.findByText(t);
+}
+function c(e, t, n) {
+	function r(e) {
+		if (e.props[t] === n) return e;
+		for (let t of e.children) {
+			let e = r(t);
+			if (e) return e;
+		}
+		return null;
+	}
+	let i = r(e);
+	if (!i) throw Error(`No element found with ${t}="${n}"`);
+	return i;
+}
+//#endregion
+//#region src/render.ts
+function l(e, l) {
+	let u = new t("root");
+	return n.render(e, u, l?.appContext ?? void 0), {
+		container: u,
+		unmount: () => {
+			n.render(null, u);
+		},
+		getByType: (e) => r(u, e),
+		getAllByType: (e) => i(u, e),
+		getByText: (e) => a(u, e),
+		queryByType: (e) => o(u, e),
+		queryByText: (e) => s(u, e),
+		getByProp: (e, t) => c(u, e, t),
+		debug: () => u.toDebugString()
+	};
+}
+//#endregion
+//#region src/fire-event.ts
+function u(e, t, n = 1) {
+	return {
+		identifier: n,
+		x: e,
+		y: t,
+		pageX: e,
+		pageY: t,
+		clientX: e,
+		clientY: t
+	};
+}
+function d(e, t, n) {
+	let r = e._handlers.get(t);
+	r && r(n);
+}
+function f(e) {
+	return {
+		type: "touch",
+		timestamp: Date.now(),
+		touches: e?.touches ?? [],
+		changedTouches: e?.changedTouches ?? e?.touches ?? [],
+		target: {
+			id: "",
+			dataset: {},
+			uid: 0
+		},
+		currentTarget: {
+			id: "",
+			dataset: {},
+			uid: 0
+		},
+		detail: {}
+	};
+}
+var p = {
+	tap(e, t) {
+		let n = t?.x ?? 0, r = t?.y ?? 0, i = {
+			type: "tap",
+			timestamp: Date.now(),
+			target: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			currentTarget: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			detail: {
+				x: n,
+				y: r
+			},
+			touches: [u(n, r)],
+			changedTouches: [u(n, r)]
+		};
+		d(e, "bindtap", i), d(e, "onTap", i);
+	},
+	touchStart(e, t) {
+		d(e, "bindtouchstart", f(t));
+	},
+	touchMove(e, t) {
+		d(e, "bindtouchmove", f(t));
+	},
+	touchEnd(e, t) {
+		d(e, "bindtouchend", f(t));
+	},
+	touchCancel(e, t) {
+		d(e, "bindtouchcancel", f(t));
+	},
+	scroll(e, t) {
+		let n = {
+			type: "scroll",
+			timestamp: Date.now(),
+			target: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			currentTarget: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			detail: {
+				scrollTop: 0,
+				scrollLeft: 0,
+				scrollHeight: 0,
+				scrollWidth: 0,
+				deltaX: 0,
+				deltaY: 0,
+				...t?.detail
+			}
+		};
+		d(e, "bindscroll", n), d(e, "onScroll", n);
+	},
+	input(e, t) {
+		let n = {
+			type: "input",
+			timestamp: Date.now(),
+			target: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			currentTarget: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			detail: {
+				value: "",
+				...t?.detail
+			}
+		};
+		d(e, "bindinput", n), d(e, "onInput", n);
+	},
+	longPress(e) {
+		let t = {
+			type: "longpress",
+			timestamp: Date.now(),
+			target: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			currentTarget: {
+				id: "",
+				dataset: {},
+				uid: 0
+			},
+			detail: {}
+		};
+		d(e, "bindlongpress", t), d(e, "onLongpress", t);
+	}
+};
+//#endregion
+//#region src/flush.ts
+function m() {
+	return new Promise((e) => {
+		Promise.resolve().then(() => new Promise((e) => setTimeout(e, 0))).then(e);
+	});
+}
+async function h(e) {
+	await e(), await m();
+}
+//#endregion
+export { t as TestNode, h as act, p as fireEvent, i as getAllByType, c as getByProp, a as getByText, r as getByType, s as queryByText, o as queryByType, l as render, u as touch, m as waitForUpdate };
+
+//# sourceMappingURL=index.js.map