@solidrt/test 0.0.71 → 0.0.73

package/AGENTS.md

@@ -37,7 +37,8 @@ agents/testing.md.
   `.record` (the `/tree` record).
 - Input is the real pipeline: `app.tap(locator)`, `app.drag(from, to, {
   durationMs })`, `app.key("Enter")`, `app.type("text")` (to the focused
-  node), `app.input([...])` for raw events in the `send_input` shape. A tap
+  node), `app.back()` (the user's back, into the `onBack` stack),
+  `app.input([...])` for raw events in the `send_input` shape. A tap
   on a node that something covers at its center throws and names the
   cover; a point (`{ x, y }`) lands on whatever is there. Each verb returns
   after the frame its last event landed in, so the tree is current.
@@ -58,6 +59,13 @@ agents/testing.md.
   app registered with `registerDebug` and returns its value: the way to
   put a loaded app into a state its UI reaches slowly. A `gamepad` event
   in `app.input` seats and drives a synthetic pad, as `send_input` does.
+- `await app.camera({ width, height, pixels })` makes an RGBA8 image (a
+  `decodeImage` result, or pixels the test builds) what the camera sees:
+  every camera the app opens shows it, with no device and no prompt, and
+  an open one shows it from the next frame. Call it before the app opens
+  its camera; call it again to show another image. A QR code in it is
+  decoded as from a real camera, so `settle()` after the open and read
+  the app's barcode state.
 - Past a node's record: `locator.outline()` is the subtree as an outline
   (kind, label, text, box per line, no ids) to pin a layout or print it;
   `locator.pixel(x, y)` is `[r, g, b, a]` at a point of the node and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/test",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -14,9 +14,9 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.71"
+    "@solidrt/flux-types": "0.0.73"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.71"
+    "@solidrt/core": "0.0.73"
   }
 }

package/src/index.ts

@@ -16,7 +16,7 @@
 
 import { test as register, expect } from "flux:test"
 import * as gui from "flux:test/gui"
-import { capture, debug, frame as stepFrame, frameRate, inputPlan, inputStep, link, painted as paintFrame, setFrameRate, settle, time, windowReady } from "sol:test"
+import { camera as installCamera, capture, debug, frame as stepFrame, frameRate, inputPlan, inputStep, link, painted as paintFrame, setFrameRate, settle, time, windowReady } from "sol:test"
 import { createElement, insert, render } from "@solidrt/core"
 
 export { expect }
@@ -145,7 +145,7 @@ export interface Pixels {
 export type RefLocator = Locator & ((node: { id: number }) => void)
 
 /** One event in the control API's `/input` shape. */
-export type InputEvent = Record<string, unknown> & { type: "pointer" | "key" | "wheel" | "text" | "gamepad" }
+export type InputEvent = Record<string, unknown> & { type: "pointer" | "key" | "wheel" | "text" | "gamepad" | "back" }
 
 export interface PointerOptions {
   /** "mouse" (the default) or "touch". */
@@ -158,13 +158,24 @@ export interface PointerOptions {
   meta?: boolean
 }
 
+/** An RGBA8 image, tightly packed rows top to bottom: what `decodeImage` returns. */
+export interface CameraImage {
+  width: number
+  height: number
+  pixels: Uint8Array
+}
+
 /** The app under test, as a test's function receives it. */
 export interface TestApp {
   /**
    * Mounts `ui` and returns a locator for the window it is in. `ui` is what
    * an app hands `render`: its `<window>`, or any content, which is then
    * put in a window of its own. Once per test (a test is one app). The
-   * first frame is built when this returns; no app time has passed.
+   * first frame is built when this returns; no app time has passed, and
+   * no animation clock is stamped yet: a transition written before the
+   * first `frame` or `advance` starts at the first frame that runs (the
+   * startup anchor), not at `time` 0, so a test timing a track against
+   * `time` runs one frame first and writes after it.
    * `ui` runs as a component body, the owner of what it creates: a
    * pointer feed, an input map, a GPU buffer or a scene is created inside
    * it, never at the top of the test.
@@ -187,6 +198,23 @@ export interface TestApp {
    * `settle()` after it.
    */
   link(link: string): Promise<void>
+  /**
+   * Makes `image` what the camera sees: every camera the app opens from
+   * now on shows it (a `createCamera` or `open` resolves at once, no device
+   * and no permission prompt), and a camera already open shows it from the
+   * next frame. Call it before `mount` or `load` so the app's own open finds
+   * it; call it again to show the app another image. A QR code in the
+   * image is decoded like one in front of a real camera: `settle()` after
+   * the open and the app's barcode handler has run. Pass a `decodeImage`
+   * result, or pixels the test builds.
+   *
+   * @example
+   * await app.camera(decodeImage(png))
+   * let cam = createCamera({ scan: ["qr"] })
+   * await app.settle()
+   * expect(cam.barcode()?.data).toBe("solidrt")
+   */
+  camera(image: CameraImage): Promise<void>
   /**
    * Calls a debug command the app registered (`registerDebug` of
    * `sol:dev`), runs a frame, and returns what the command returned. The
@@ -276,6 +304,12 @@ export interface TestApp {
   key(key: string, options?: { holdMs?: number; shift?: boolean; ctrl?: boolean; alt?: boolean; meta?: boolean }): Promise<void>
   /** Text as an input method commits it, to the focused node. */
   type(text: string): Promise<void>
+  /**
+   * The user's back intent, the event the Android button, a pad's back
+   * button and the desktop dev chord become: into the `onBack` stack,
+   * never a key.
+   */
+  back(): Promise<void>
   /**
    * Events in the control API's `/input` shape, as `send_input` takes them.
    * `delayMs` and `holdMs` are app time: frames run to cover them. One
@@ -487,6 +521,15 @@ let app: TestApp = {
     if (!link(target)) throw new Error(`link: the app does not listen for links (no onLink handler), so ${JSON.stringify(target)} went nowhere`)
     await app.frame()
   },
+  async camera(image) {
+    let ok = image !== null && typeof image === "object" && image.pixels instanceof Uint8Array
+    if (!ok) throw new TypeError("camera: pass { width, height, pixels }, with the pixels a Uint8Array of RGBA8")
+    let { width, height, pixels } = image
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) throw new TypeError(`camera: the size must be positive integers, got ${width} x ${height}`)
+    if (pixels.length !== width * height * RGBA) throw new TypeError(`camera: ${width} x ${height} RGBA8 is ${width * height * RGBA} bytes, got ${pixels.length}`)
+    installCamera(width, height, pixels)
+    await app.frame()
+  },
   async debug(name, args) {
     let result = debug(name, args === undefined ? null : JSON.stringify(args))
     await app.frame()
@@ -543,6 +586,9 @@ let app: TestApp = {
   type(text) {
     return app.input([{ type: "text", text }])
   },
+  back() {
+    return app.input([{ type: "back" }])
+  },
   async input(events) {
     let waits = inputPlan(JSON.stringify(events))
     for (let i = 0; i < waits.length; i++) {