@solidrt/test 0.0.72 → 0.0.74

package/AGENTS.md

@@ -59,6 +59,20 @@ 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, data })` 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.
+- `await app.microphone({ sampleRate, samples })` makes a mono float clip
+  what the microphone hears: every microphone the app opens at that rate
+  holds it from the open, with no device and no prompt (`settle()` after
+  the mount, the open resolves through the engine), and an open one hears it now
+  (a runtime module reading the session included). Call it before the
+  app opens its microphone; call it again to say more. An open at another
+  rate fails naming both rates.
 - 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.72",
+  "version": "0.0.74",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -14,9 +14,9 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.72"
+    "@solidrt/flux-types": "0.0.74"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.72"
+    "@solidrt/core": "0.0.74"
   }
 }

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, microphone as installMicrophone, painted as paintFrame, setFrameRate, settle, time, windowReady } from "sol:test"
 import { createElement, insert, render } from "@solidrt/core"
 
 export { expect }
@@ -158,6 +158,20 @@ export interface PointerOptions {
   meta?: boolean
 }
 
+/** An RGBA8 image, tightly packed rows top to bottom: the shape `decodeImage` returns (and the web's `ImageData`). */
+export interface CameraImage {
+  width: number
+  height: number
+  data: Uint8Array
+}
+
+/** A mono clip: float samples at a sample rate, the shape `read()` of a microphone session delivers. */
+export interface MicrophoneClip {
+  /** Hz; the rate the app opens its microphone at. */
+  sampleRate: number
+  samples: Float32Array
+}
+
 /** The app under test, as a test's function receives it. */
 export interface TestApp {
   /**
@@ -191,6 +205,40 @@ 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 an image 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>
+  /**
+   * Makes `clip` what the microphone hears: every microphone the app opens
+   * at the clip's rate from now on holds it from the open (a
+   * `createMicrophone` or `open` resolves at once, no device, no prompt), and a
+   * microphone already open hears it now, so a module reading the session
+   * on its own thread gets it too. Call it before `mount` or `load` so the
+   * app's own open finds a microphone; call it again to say something else
+   * to an open one. An open at another rate than the clip's fails naming
+   * both rates. Results a module or recognizer produces land through the
+   * engine: `settle()` after the install.
+   *
+   * @example
+   * await app.microphone({ sampleRate: 16000, samples: tone })
+   * let mic = createMicrophone()
+   * expect(mic.read()).toEqual(tone)
+   */
+  microphone(clip: MicrophoneClip): Promise<void>
   /**
    * Calls a debug command the app registered (`registerDebug` of
    * `sol:dev`), runs a frame, and returns what the command returned. The
@@ -497,6 +545,22 @@ 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.data instanceof Uint8Array
+    if (!ok) throw new TypeError("camera: pass { width, height, data }, with data a Uint8Array of RGBA8 (what decodeImage returns)")
+    let { width, height, data } = 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 (data.length !== width * height * RGBA) throw new TypeError(`camera: ${width} x ${height} RGBA8 is ${width * height * RGBA} bytes, got ${data.length}`)
+    installCamera(width, height, data)
+    await app.frame()
+  },
+  async microphone(clip) {
+    let ok = clip !== null && typeof clip === "object" && clip.samples instanceof Float32Array
+    if (!ok) throw new TypeError("microphone: pass { sampleRate, samples }, with samples a Float32Array of mono samples")
+    let { sampleRate, samples } = clip
+    if (!Number.isInteger(sampleRate) || sampleRate <= 0) throw new TypeError(`microphone: the sample rate must be a positive integer, got ${sampleRate}`)
+    installMicrophone(sampleRate, samples)
+  },
   async debug(name, args) {
     let result = debug(name, args === undefined ? null : JSON.stringify(args))
     await app.frame()