@wardic/test 0.0.0-stage → 1.0.0-rc.2

package/dist/input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","sourceRoot":"","sources":["../src/input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,0BAA0B,CAAA;AACvD,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,WAAW,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;;;;;;;GAUG;AACH,yCAAyC;AACzC,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,aAAa,GAAgD,EAAE,EAC/D,WAAW,GAA8C,EAAE,EAC3D,SAAS,GAAiD,EAAE,EACtB,EAAE,CACxC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE;IACrC,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC;IAC1C,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC;IACvC,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC;IACtC,YAAY,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE;CAClC,CAAC,CAAA;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wFAAwF;AACxF,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,OAA+E,EAKrG,EAAE,CACH,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;IACf,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAgC,CAAA;IACzD,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,EAA8B,CAAA;IACrD,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAiC,CAAA;IACvD,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE;YAC5C,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI;YAC3B,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI;YACzB,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI;YACvB,WAAW,EAAE,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;YAC3D,YAAY,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE;gBAC7B,IAAI,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC1B,MAAM,IAAI,GAAiC,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA;oBAClF,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;oBAClC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBAC1B,CAAC;gBACD,OAAO,MAAM,CAAC,IAAI,EAAE,CAAA;YACtB,CAAC;SACF,CAAC;QACF,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,SAAS,EAAE,KAAK,CAAC,IAAI;QACrB,OAAO,EAAE,IAAI,CAAC,IAAI;KACnB,CAAA;AACH,CAAC,CAAC,CAAA;AAEJ,0GAA0G;AAC1G,MAAM,gBAAgB,GAAG,CAAC,GAAY,EAAuC,EAAE,CAC7E,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,WAAW,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,IAAK,GAAoC,CAAC,OAAO,CAAA"}

package/dist/layer.d.ts

@@ -0,0 +1,27 @@
+import * as Announcer from "@wardic/core/Announcer";
+import type * as Clock from "@wardic/core/Clock";
+import * as DefaultTransition from "@wardic/core/DefaultTransition";
+import * as FrameLoop from "@wardic/core/FrameLoop";
+import type * as InputSource from "@wardic/core/InputSource";
+import * as InterpolatorRegistry from "@wardic/core/InterpolatorRegistry";
+import type * as Probe from "@wardic/core/Probe";
+import * as ReducedMotion from "@wardic/core/ReducedMotion";
+import * as RefreshFrameSource from "@wardic/core/RefreshFrameSource";
+import type * as Renderer from "@wardic/core/Renderer";
+import * as Layer from "effect/Layer";
+import { AtomRegistry } from "effect/reactivity";
+/**
+ * The full headless environment: deterministic Clock (driven by `frames`), a Refresh frame
+ * source that never calls back, recording Renderer, static Probe, silent InputSource, core's real
+ * interpolator registry, a fresh AtomRegistry for reading Probe atoms
+ * (`viewport`, `prefersReducedMotion`), and a fresh Drag activity, so one test's
+ * drag never blocks another's hover or press, and core's Frame loop over that
+ * Clock. Provide this in place of `DomLive` to test animation code without a
+ * page. It draws nothing on one: an element rendered under it keeps its Starting style, so an
+ * app's components are tested with `DomLive` under the test runner's fake timers instead
+ * (https://wardic.dev/guides/testing).
+ */
+export declare const testLayer: (frames?: ReadonlyArray<number>) => Layer.Layer<Clock.Clock | RefreshFrameSource.RefreshFrameSource | FrameLoop.FrameLoop | Renderer.Renderer | Probe.Probe | InputSource.InputSource | InterpolatorRegistry.InterpolatorRegistry | ReducedMotion.PositionalKeys | DefaultTransition.DefaultTransition | Announcer.Announcer | AtomRegistry.AtomRegistry>;
+/** `testLayer()` with an empty clock — for tests that drive their own frames. It never ticks on its own. */
+export declare const TestLive: Layer.Layer<Announcer.Announcer | AtomRegistry.AtomRegistry | Clock.Clock | DefaultTransition.DefaultTransition | FrameLoop.FrameLoop | InputSource.InputSource | InterpolatorRegistry.InterpolatorRegistry | ReducedMotion.PositionalKeys | Probe.Probe | RefreshFrameSource.RefreshFrameSource | Renderer.Renderer, never, never>;
+//# sourceMappingURL=layer.d.ts.map

package/dist/layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../src/layer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,KAAK,KAAK,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,iBAAiB,MAAM,gCAAgC,CAAA;AAEnE,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,KAAK,WAAW,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,oBAAoB,MAAM,mCAAmC,CAAA;AAEzE,OAAO,KAAK,KAAK,KAAK,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,aAAa,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,kBAAkB,MAAM,iCAAiC,CAAA;AACrE,OAAO,KAAK,KAAK,QAAQ,MAAM,uBAAuB,CAAA;AAEtD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAahD;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,SAAS,YACZ,aAAa,CAAC,MAAM,CAAC,KAC5B,KAAK,CAAC,KAAK,CACV,KAAK,CAAC,KAAK,GACX,kBAAkB,CAAC,kBAAkB,GACrC,SAAS,CAAC,SAAS,GACnB,QAAQ,CAAC,QAAQ,GACjB,KAAK,CAAC,KAAK,GACX,WAAW,CAAC,WAAW,GACvB,oBAAoB,CAAC,oBAAoB,GACzC,aAAa,CAAC,cAAc,GAC5B,iBAAiB,CAAC,iBAAiB,GACnC,SAAS,CAAC,SAAS,GACnB,YAAY,CAAC,YAAY,CAsB1B,CAAA;AAEH,4GAA4G;AAC5G,eAAO,MAAM,QAAQ,qUAAc,CAAA"}

package/dist/layer.js

@@ -0,0 +1,43 @@
+import * as Announcer from "@wardic/core/Announcer";
+import * as DefaultTransition from "@wardic/core/DefaultTransition";
+import * as DragActivity from "@wardic/core/DragActivity";
+import * as FrameLoop from "@wardic/core/FrameLoop";
+import * as InterpolatorRegistry from "@wardic/core/InterpolatorRegistry";
+import * as PressClaims from "@wardic/core/PressClaims";
+import * as ReducedMotion from "@wardic/core/ReducedMotion";
+import * as RefreshFrameSource from "@wardic/core/RefreshFrameSource";
+import { constUndefined, constVoid } from "effect/Function";
+import * as Layer from "effect/Layer";
+import { AtomRegistry } from "effect/reactivity";
+import * as TestClock from "./clock.js";
+import * as TestInput from "./input.js";
+import * as TestProbe from "./probe.js";
+import * as TestRenderer from "./renderer.js";
+/**
+ * The headless Environment's Refresh frame source: it never calls back, as its Clock never ticks
+ * on its own, so a flush gate built on it never flushes by itself. A test that fires frames
+ * provides `TestClock.pushable()`'s layer over it (ADR-0031, decision 6).
+ */
+const stillFrames = { requestFrame: constUndefined, cancelFrame: constVoid };
+/**
+ * The full headless environment: deterministic Clock (driven by `frames`), a Refresh frame
+ * source that never calls back, recording Renderer, static Probe, silent InputSource, core's real
+ * interpolator registry, a fresh AtomRegistry for reading Probe atoms
+ * (`viewport`, `prefersReducedMotion`), and a fresh Drag activity, so one test's
+ * drag never blocks another's hover or press, and core's Frame loop over that
+ * Clock. Provide this in place of `DomLive` to test animation code without a
+ * page. It draws nothing on one: an element rendered under it keeps its Starting style, so an
+ * app's components are tested with `DomLive` under the test runner's fake timers instead
+ * (https://wardic.dev/guides/testing).
+ */
+// The Drag activity: ADR-0019. The Frame loop: ADR-0027. The testing guide: #558.
+export const testLayer = (frames = []) => FrameLoop.layer.pipe(Layer.provideMerge(Layer.mergeAll(TestClock.layer(frames), RefreshFrameSource.layer(stillFrames), TestRenderer.layer, TestProbe.layer(), TestInput.layer(), InterpolatorRegistry.layer, 
+// The transforms only: the Test Environment names no box keys (ADR-0036).
+ReducedMotion.transformsOnly, 
+// No opinion on a key's Default transition: every key on one spring (ADR-0051).
+DefaultTransition.layerOneSpring, 
+// No assistive technology to reach headless (ADR-0037).
+Announcer.layerSilent, AtomRegistry.layer, Layer.sync(DragActivity.DragActivity, DragActivity.make), Layer.sync(PressClaims.PressClaims, PressClaims.make))));
+/** `testLayer()` with an empty clock — for tests that drive their own frames. It never ticks on its own. */
+export const TestLive = testLayer();
+//# sourceMappingURL=layer.js.map

package/dist/layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer.js","sourceRoot":"","sources":["../src/layer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAA;AAEnD,OAAO,KAAK,iBAAiB,MAAM,gCAAgC,CAAA;AACnE,OAAO,KAAK,YAAY,MAAM,2BAA2B,CAAA;AACzD,OAAO,KAAK,SAAS,MAAM,wBAAwB,CAAA;AAEnD,OAAO,KAAK,oBAAoB,MAAM,mCAAmC,CAAA;AACzE,OAAO,KAAK,WAAW,MAAM,0BAA0B,CAAA;AAEvD,OAAO,KAAK,aAAa,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,kBAAkB,MAAM,iCAAiC,CAAA;AAErE,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,YAAY,MAAM,eAAe,CAAA;AAE7C;;;;GAIG;AACH,MAAM,WAAW,GAA6B,EAAE,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,CAAA;AAEtG;;;;;;;;;;GAUG;AACH,kFAAkF;AAClF,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,MAAM,GAA0B,EAAE,EAalC,EAAE,CACF,SAAS,CAAC,KAAK,CAAC,IAAI,CAClB,KAAK,CAAC,YAAY,CAChB,KAAK,CAAC,QAAQ,CACZ,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EACvB,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,EACrC,YAAY,CAAC,KAAK,EAClB,SAAS,CAAC,KAAK,EAAE,EACjB,SAAS,CAAC,KAAK,EAAE,EACjB,oBAAoB,CAAC,KAAK;AAC1B,0EAA0E;AAC1E,aAAa,CAAC,cAAc;AAC5B,gFAAgF;AAChF,iBAAiB,CAAC,cAAc;AAChC,wDAAwD;AACxD,SAAS,CAAC,WAAW,EACrB,YAAY,CAAC,KAAK,EAClB,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,YAAY,CAAC,IAAI,CAAC,EACxD,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,WAAW,CAAC,IAAI,CAAC,CACtD,CACF,CACF,CAAA;AAEH,4GAA4G;AAC5G,MAAM,CAAC,MAAM,QAAQ,GAAG,SAAS,EAAE,CAAA"}

package/dist/probe.d.ts

@@ -0,0 +1,46 @@
+import * as Probe from "@wardic/core/Probe";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { AtomRegistry } from "effect/reactivity";
+/** Options for the static test Probe. */
+export interface Options {
+    readonly bounds?: Probe.Bounds;
+    readonly viewport?: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly prefersReducedMotion?: boolean;
+    /** Whether the page is shown: `true` when left out. */
+    readonly pageVisible?: boolean;
+    /** Every container's scroll, as `scroll` gives it: a page that doesn't scroll when left out. */
+    readonly scroll?: Probe.Scroll;
+    /**
+     * Script of intersection (in-view) booleans replayed by `observeIntersection`, an **Input feed**
+     * that ends after it. Mirrors the InputSource test harness: omitted (or empty) means it
+     * emits nothing and ends.
+     */
+    readonly intersection?: ReadonlyArray<boolean>;
+}
+/**
+ * A static Probe: fixed bounds/viewport. `observeIntersection` replays the
+ * optional `intersection` script to each subscriber (empty by default, so it
+ * emits nothing); `observeResize` stays empty.
+ */
+export declare const layer: (options?: Options) => Layer.Layer<Probe.Probe>;
+/**
+ * A push-based Probe for tests that need to interleave intersection
+ * (in-view/out-of-view) transitions with other effects on their own schedule —
+ * mirroring {@link TestInput.pushable}. `observeIntersection(target)` subscribes
+ * to a hub, so every subscriber sees the same transitions and only
+ * events pushed *after* a subscription is live reach it. `pushIntersection`
+ * doesn't yield: a subscriber handles the transition inside the push,
+ * as `TestInput.pushable`'s do. `pushScroll` sets the scroll every container reads,
+ * through the Environment's registry, as a scroll event would.
+ * measure/viewport/prefersReducedMotion/observeResize behave as in {@link layer}.
+ */
+export declare const pushable: (options?: Options) => Effect.Effect<{
+    readonly layer: Layer.Layer<Probe.Probe>;
+    readonly pushIntersection: (inView: boolean) => Effect.Effect<void>;
+    readonly pushScroll: (scroll: Probe.Scroll) => Effect.Effect<void, never, AtomRegistry.AtomRegistry>;
+}>;
+//# sourceMappingURL=probe.d.ts.map

package/dist/probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../src/probe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,oBAAoB,CAAA;AAE3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,EAAQ,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAWtD,yCAAyC;AAEzC,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAA;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IACvE,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAA;IACvC,uDAAuD;IACvD,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B,gGAAgG;IAChG,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAA;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CAC/C;AAED;;;;GAIG;AACH,eAAO,MAAM,KAAK,aAAa,OAAO,KAAQ,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAMpE,CAAA;AAeD;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,QAAQ,aAAa,OAAO,KAAQ,MAAM,CAAC,MAAM,CAAC;IAC7D,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IACxC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACnE,QAAQ,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,YAAY,CAAC,YAAY,CAAC,CAAA;CACrG,CAUG,CAAA"}

package/dist/probe.js

@@ -0,0 +1,60 @@
+import * as Probe from "@wardic/core/Probe";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import { Atom, AtomRegistry } from "effect/reactivity";
+import * as Feeds from "./feeds.js";
+const ZERO_BOUNDS = { x: 0, y: 0, width: 0, height: 0, top: 0, right: 0, bottom: 0, left: 0 };
+const VIEWPORT = { width: 1024, height: 768 };
+/** A page that doesn't scroll: no range, and progress 1, as Motion reads a container with none. */
+const STILL_SCROLL = { x: { current: 0, length: 0, progress: 1 }, y: { current: 0, length: 0, progress: 1 } };
+/** A scripted in-view boolean as the Probe reports it, with no platform record. */
+const toIntersection = (intersecting) => ({ intersecting });
+/**
+ * A static Probe: fixed bounds/viewport. `observeIntersection` replays the
+ * optional `intersection` script to each subscriber (empty by default, so it
+ * emits nothing); `observeResize` stays empty.
+ */
+export const layer = (options = {}) => {
+    const { intersection = [], scroll = STILL_SCROLL } = options;
+    return Layer.succeed(Probe.Probe, {
+        ...fixed(options, Atom.make(scroll)),
+        observeIntersection: () => Feeds.script(Arr.map(intersection, toIntersection)),
+    });
+};
+/**
+ * Both Probes' fixed part: the bounds, the viewport, the preference and the page's visibility, each defaulted, no resizes,
+ * and one scroll Atom for every container, target and offset (#234).
+ */
+const fixed = ({ bounds = ZERO_BOUNDS, viewport = VIEWPORT, prefersReducedMotion = false, pageVisible = true }, scroll) => ({
+    measure: () => Effect.sync(() => bounds),
+    viewport: Atom.make(viewport),
+    prefersReducedMotion: Atom.make(prefersReducedMotion),
+    pageVisible: Atom.make(pageVisible),
+    scroll: () => Effect.succeed(scroll),
+    observeResize: () => Stream.empty,
+});
+/**
+ * A push-based Probe for tests that need to interleave intersection
+ * (in-view/out-of-view) transitions with other effects on their own schedule —
+ * mirroring {@link TestInput.pushable}. `observeIntersection(target)` subscribes
+ * to a hub, so every subscriber sees the same transitions and only
+ * events pushed *after* a subscription is live reach it. `pushIntersection`
+ * doesn't yield: a subscriber handles the transition inside the push,
+ * as `TestInput.pushable`'s do. `pushScroll` sets the scroll every container reads,
+ * through the Environment's registry, as a scroll event would.
+ * measure/viewport/prefersReducedMotion/observeResize behave as in {@link layer}.
+ */
+// The hub: #318. No yield: ADR-0032. Scroll: #234.
+export const pushable = (options = {}) => Effect.sync(() => {
+    const intersections = Feeds.hub();
+    const { scroll = STILL_SCROLL } = options;
+    const scrollAtom = Atom.make(scroll);
+    return {
+        layer: Layer.succeed(Probe.Probe, { ...fixed(options, scrollAtom), observeIntersection: () => intersections.feed }),
+        pushIntersection: (inView) => intersections.push(toIntersection(inView)),
+        pushScroll: (next) => AtomRegistry.AtomRegistry.use((registry) => Effect.sync(() => registry.set(scrollAtom, next))),
+    };
+});
+//# sourceMappingURL=probe.js.map

package/dist/probe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.js","sourceRoot":"","sources":["../src/probe.ts"],"names":[],"mappings":"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"}

package/dist/renderer.d.ts

@@ -0,0 +1,32 @@
+import * as Renderer from "@wardic/core/Renderer";
+import * as Layer from "effect/Layer";
+/** A single recorded `project` call. */
+export interface ProjectCall {
+    readonly values: Record<string, unknown>;
+}
+/** A single recorded `commit` call. */
+export interface CommitCall {
+    readonly target: unknown;
+    readonly patch: Renderer.Patch;
+}
+/**
+ * A Renderer that records every `project` and `commit` invocation into
+ * separate arrays instead of touching an environment — lets a test assert
+ * both the pure projection step and the imperative writes that would have
+ * been issued.
+ *
+ * Defaults:
+ *  - `project` is identity (`(values) => values as Patch`).
+ *  - `commit` pushes onto `commitCalls`.
+ */
+export declare const make: () => {
+    readonly service: {
+        readonly project: (values: Record<string, unknown>) => Renderer.Patch;
+        readonly commit: (target: unknown, patch: Renderer.Patch) => void;
+    };
+    readonly projectCalls: ReadonlyArray<ProjectCall>;
+    readonly commitCalls: ReadonlyArray<CommitCall>;
+};
+/** The {@link DISCARDING} Renderer's Layer. */
+export declare const layer: Layer.Layer<Renderer.Renderer>;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,uBAAuB,CAAA;AAEjD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,wCAAwC;AACxC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACzC;AAED,uCAAuC;AACvC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAA;CAC/B;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,QAAO;IACtB,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,QAAQ,CAAC,KAAK,CAAA;QACrE,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,KAAK,IAAI,CAAA;KAClE,CAAA;IACD,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IACjD,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CAiBhD,CAAA;AAaD,+CAA+C;AAC/C,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAgD,CAAA"}

package/dist/renderer.js

@@ -0,0 +1,43 @@
+import * as Renderer from "@wardic/core/Renderer";
+import { constVoid } from "effect/Function";
+import * as Layer from "effect/Layer";
+/**
+ * A Renderer that records every `project` and `commit` invocation into
+ * separate arrays instead of touching an environment — lets a test assert
+ * both the pure projection step and the imperative writes that would have
+ * been issued.
+ *
+ * Defaults:
+ *  - `project` is identity (`(values) => values as Patch`).
+ *  - `commit` pushes onto `commitCalls`.
+ */
+export const make = () => {
+    const projectCalls = [];
+    const commitCalls = [];
+    return {
+        service: {
+            project: (values) => {
+                projectCalls.push({ values });
+                return values;
+            },
+            commit: (target, patch) => {
+                commitCalls.push({ target, patch });
+            },
+        },
+        projectCalls,
+        commitCalls,
+    };
+};
+/**
+ * A Renderer that draws nothing and keeps nothing: `project` hands its values back as the patch, and
+ * `commit` drops it. A test that reads the calls makes its own with {@link make}.
+ */
+// #618 (decision 7): this was one recording renderer made at module load, whose calls every test in a
+// file added to and nothing read.
+const DISCARDING = {
+    project: (values) => values,
+    commit: constVoid,
+};
+/** The {@link DISCARDING} Renderer's Layer. */
+export const layer = Layer.succeed(Renderer.Renderer, DISCARDING);
+//# sourceMappingURL=renderer.js.map

package/dist/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAarC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,GAOlB,EAAE;IACF,MAAM,YAAY,GAAuB,EAAE,CAAA;IAC3C,MAAM,WAAW,GAAsB,EAAE,CAAA;IACzC,OAAO;QACL,OAAO,EAAE;YACP,OAAO,EAAE,CAAC,MAA+B,EAAkB,EAAE;gBAC3D,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,CAAA;gBAC7B,OAAO,MAAwB,CAAA;YACjC,CAAC;YACD,MAAM,EAAE,CAAC,MAAe,EAAE,KAAqB,EAAQ,EAAE;gBACvD,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;YACrC,CAAC;SACF;QACD,YAAY;QACZ,WAAW;KACZ,CAAA;AACH,CAAC,CAAA;AAED;;;GAGG;AACH,sGAAsG;AACtG,kCAAkC;AAClC,MAAM,UAAU,GAAiC;IAC/C,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAwB;IAC7C,MAAM,EAAE,SAAS;CAClB,CAAA;AAED,+CAA+C;AAC/C,MAAM,CAAC,MAAM,KAAK,GAAmC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@wardic/test",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-rc.2",
+  "description": "Headless testing Layers for Wardic: a clock that replays the frames you give it, a renderer that records what it's asked to draw, and input you push, so animation code runs without a browser.",
+  "keywords": [
+    "animation",
+    "testing",
+    "effect"
+  ],
+  "homepage": "https://wardic.dev",
+  "bugs": "https://github.com/wardiclabs/wardic/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wardiclabs/wardic.git",
+    "directory": "packages/test"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "The Wardic contributors",
+    "email": "hello@wardic.dev",
+    "url": "https://wardic.dev"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.map",
+    "src",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@wardic/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "../../node_modules/typescript-7/bin/tsc --build",
+    "typecheck": "../../node_modules/typescript-7/bin/tsc --build",
+    "typecheck:tests": "../../node_modules/typescript-7/bin/tsc -p tsconfig.test.json"
+  },
+  "dependencies": {
+    "@wardic/core": "1.0.0-rc.2"
+  },
+  "peerDependencies": {
+    "effect": "^4.1.1"
+  }
+}

package/src/clock.ts

@@ -0,0 +1,136 @@
+import * as Clock from "@wardic/core/Clock"
+import * as RefreshFrameSource from "@wardic/core/RefreshFrameSource"
+import * as Arr from "effect/Array"
+import * as Effect from "effect/Effect"
+import { constVoid } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as MutableRef from "effect/MutableRef"
+import * as Predicate from "effect/Predicate"
+import * as PubSub from "effect/PubSub"
+import * as Stream from "effect/Stream"
+import * as UndefinedOr from "effect/UndefinedOr"
+
+/**
+ * A deterministic Clock for frame-level tests. `ticks` replays the supplied `dt`
+ * sequence (in seconds) exactly once, so a primitive's per-frame output can be
+ * collected with `Stream.runCollect` and asserted. Its `now` is the time those
+ * ticks have reached, in ms, from 0: the furthest any subscriber has
+ * reached, so two subscribers replaying the same frames don't run it twice as
+ * fast. A live Clock (rAF-driven) is `@wardic/dom`'s.
+ */
+// `now`: #460.
+export const make = (frames: ReadonlyArray<number> = []): Clock.Clock["Service"] => {
+  const time = MutableRef.make(0)
+  // Each frame with the time it reaches, in ms from 0 (#618, decision 7: each subscriber added its
+  // frames to one sum).
+  const reached = Arr.zip(frames, Arr.drop(Arr.scan(frames, 0, (at, dt) => at + dt * 1000), 1))
+  return {
+    ticks: Stream.map(Stream.fromIterable(reached), ([dt, at]) => {
+      MutableRef.update(time, (t) => Math.max(t, at))
+      return dt
+    }),
+    tick: (_t: number) => Effect.sync(() => {}),
+    now: () => MutableRef.get(time),
+  }
+}
+
+/** Clock Layer that emits `frames` (dt values, seconds) then completes. */
+export const layer = (frames: ReadonlyArray<number> = []): Layer.Layer<Clock.Clock> =>
+  // A Clock per build: one Layer built twice shares no time (#618).
+  Layer.sync(Clock.Clock, () => make(frames))
+
+/**
+ * Convenience: `n` frames of a fixed `dt` (default 1/60s) — e.g. `frames(30)`
+ * for half a second at 60fps.
+ */
+export const frames = (count: number, dt = 1 / 60): ReadonlyArray<number> =>
+  Array.from({ length: count }, () => dt)
+
+/**
+ * The Refresh frames `pushable`'s `advance` fires: a `RefreshFrameSource` that keeps the
+ * contract's order rules, as `requestAnimationFrame` does (ADR-0031, decision 4). `fire` runs the
+ * callbacks requested before it, in request order. One requested while they run waits for the
+ * next `fire`, and one cancelled before its turn never runs.
+ */
+const makeFrames = () => {
+  const pending = new Map<number, (timestampMs: number) => void>()
+  const nextHandle = MutableRef.make(1)
+  const source: RefreshFrameSource.Shape = {
+    requestFrame: (callback) => {
+      const handle = MutableRef.getAndIncrement(nextHandle)
+      pending.set(handle, callback)
+      return handle
+    },
+    cancelFrame: (handle) => {
+      if (Predicate.isNumber(handle)) pending.delete(handle)
+    },
+  }
+  /** Run the callbacks requested so far at timestamp `t` (ms). */
+  const fire = (t: number): void =>
+    Arr.forEach(Arr.fromIterable(pending.keys()), (handle) =>
+      UndefinedOr.match(pending.get(handle), {
+        onUndefined: constVoid,
+        onDefined: (callback) => {
+          pending.delete(handle)
+          callback(t)
+        },
+      }))
+  return { source, fire }
+}
+
+/**
+ * A push-based Clock for tests that need to advance frames *on demand* —
+ * interleaved with pointer input — rather than replaying a fixed sequence. The
+ * static {@link layer} drains its whole `ticks` stream as fast as the consumer
+ * pulls, which makes it impossible to assert "advance a few frames, do
+ * something, advance more". This form lets the test `advance` one dt at a time.
+ *
+ * Backed by a `PubSub` (broadcast, no replay) so a consumer only sees ticks
+ * pushed *after* it subscribes — matching a live rAF clock where motion starts
+ * from the moment you subscribe. It has no Cold start: its ticks are the advances.
+ *
+ * Its `layer` also provides the Environment's `RefreshFrameSource`, and one `advance`
+ * is one Refresh frame in the web's order: it runs the frames requested so far (a flush gate's
+ * flush of a write made outside a tick), in request order, then publishes `dt` (the Clock's
+ * tick, at whose end a Frame loop over this Clock calls its `afterTick` hooks: the gate's
+ * flush). A frame requested during that `advance` waits for the next one. The frames'
+ * timestamps start at 0 and advance by `dt`, and the Clock's `now` is the last one's: a test's
+ * advances drive velocities too.
+ *
+ * It doesn't yield: a subscriber waiting on the ticks handles the tick inside the
+ * publish, as every subscriber does inside a real Refresh frame's callback, so a consumer that
+ * hops through Effect's scheduler on its way to its sink hasn't got there when `advance`
+ * returns, and its test sees it.
+ *
+ * @example
+ * const clock = yield* TestClock.pushable()
+ * // … fork a stream that consumes Clock.ticks, providing clock.layer …
+ * yield* clock.advance()        // one 1/60s frame
+ * yield* clock.advance(1 / 30)  // a custom dt
+ */
+// The RefreshFrameSource: ADR-0031. The gate's flush at the tick's end: ADR-0033. `now`: #460. No
+// yield: ADR-0032.
+export const pushable: () => Effect.Effect<{
+  readonly layer: Layer.Layer<Clock.Clock | RefreshFrameSource.RefreshFrameSource>
+  readonly advance: (dt?: number) => Effect.Effect<void>
+}> = Effect.fnUntraced(
+  function* () {
+    const pubsub = yield* PubSub.unbounded<number>()
+    const frames = makeFrames()
+    const time = MutableRef.make(0)
+    return {
+      layer: Layer.merge(
+        Layer.succeed(Clock.Clock, {
+          ticks: Stream.fromPubSub(pubsub),
+          tick: (_t: number) => Effect.sync(() => {}),
+          now: () => MutableRef.get(time),
+        }),
+        RefreshFrameSource.layer(frames.source),
+      ),
+      advance: (dt = 1 / 60) =>
+        Effect.sync(() => frames.fire(MutableRef.updateAndGet(time, (t) => t + dt * 1000))).pipe(
+          Effect.andThen(PubSub.publish(pubsub, dt)),
+          Effect.asVoid,
+        ),
+    }
+  })

package/src/feeds.ts

@@ -0,0 +1,46 @@
+/**
+ * The Test Environment's **Input feeds** (#318): a script replayed to each subscriber, and a hub a
+ * test pushes into.
+ */
+import type * as InputFeed from "@wardic/core/InputFeed"
+import * as Arr from "effect/Array"
+import * as Effect from "effect/Effect"
+import { constVoid } from "effect/Function"
+
+/**
+ * A fixed script as a feed: each subscriber hears every event as it subscribes, then the end. A
+ * Stream over it (`InputFeed.toStream`) emits the script and ends, as `Stream.fromIterable` did; an
+ * empty one ends at once. Not shared: each subscriber gets the whole script (tests address one
+ * surface, and a consumer may read it twice).
+ */
+export const script =
+  <A>(events: ReadonlyArray<A>): InputFeed.InputFeed<A> =>
+  (emit, end) => {
+    Arr.forEach(events, emit)
+    end()
+    return constVoid
+  }
+
+/** A live feed a test pushes into, and the push. */
+export interface Hub<A> {
+  readonly feed: InputFeed.InputFeed<A>
+  readonly push: (event: A) => Effect.Effect<void>
+}
+
+/**
+ * A live feed: every subscriber hears each event pushed after it subscribed, in the order they
+ * subscribed. `push` doesn't yield (ADR-0032): a subscriber handles the event inside the push, as an
+ * Environment's consumers handle a real event inside its dispatch.
+ */
+export const hub = <A>(): Hub<A> => {
+  let subscribers: ReadonlyArray<(event: A) => void> = []
+  return {
+    feed: (emit) => {
+      subscribers = Arr.append(subscribers, emit)
+      return () => {
+        subscribers = Arr.filter(subscribers, (s) => s !== emit)
+      }
+    },
+    push: (event) => Effect.sync(() => Arr.forEach(subscribers, (emit) => emit(event))),
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @wardic/test — headless testing Layers.
+ *
+ * Provide `TestLive` (or `testLayer(frames)`) in place of `@wardic/dom`'s
+ * `DomLive` to run animation code without a page. The Clock is deterministic
+ * (replays a `dt` sequence), so primitive output is collectable frame-by-frame.
+ * Nothing is drawn on a page: an app's components are tested with `DomLive`
+ * under the test runner's fake timers, as https://wardic.dev/guides/testing shows.
+ */
+// The testing guide: #558.
+export const VERSION = "1.0.0-rc.2"
+
+export * as TestClock from "./clock.ts"
+export * as TestRenderer from "./renderer.ts"
+export * as TestProbe from "./probe.ts"
+export * as TestInput from "./input.ts"
+export { testLayer, TestLive } from "./layer.ts"