@continuum-js/test 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { type Child } from "@continuum-js/dom";
+/** A mounted view under test. */
+export interface RenderResult {
+    /** The container element, attached to `document.body`. */
+    container: HTMLElement;
+    /** Unmount the view (cascading FRP/ownership cleanup) and drop the container. */
+    dispose: () => void;
+}
+/**
+ * Mount `view` into a fresh container appended to `document.body` (so focus
+ * and event bubbling behave like in a real page). Dispose manually, or let
+ * `cleanup()` collect everything at the end of the test.
+ */
+export declare function render(view: () => Child): RenderResult;
+/** Dispose every view still mounted by `render`. Call from `afterEach`. */
+export declare function cleanup(): void;
+/** Dispatch `event` on `el`. Returns the `dispatchEvent` result. */
+export declare function fire(el: EventTarget, event: Event): boolean;
+/** Click an element (a bubbling, cancelable MouseEvent). */
+export declare function click(el: EventTarget): boolean;
+/**
+ * Type `text` into an input character by character, dispatching a bubbling
+ * `input` event after each one — the shape `bindInput` listens to.
+ */
+export declare function type(input: HTMLInputElement, text: string): void;
+/**
+ * Drain the microtask queue so settled promises (e.g. `perform` results)
+ * re-enter the network. Transactions themselves are synchronous — this only
+ * waits for the JS runtime, not for Continuum.
+ */
+export declare function flush(rounds?: number): Promise<void>;
+/**
+ * Advance vitest fake timers by `ms` and flush microtasks, so time-based
+ * combinators (`debounce`, `throttle`, `interval`, `delay`) fire and their
+ * downstream settles. Requires `vi.useFakeTimers()` in the test.
+ */
+export declare function advanceTimers(ms: number): Promise<void>;

package/dist/index.js

@@ -0,0 +1,64 @@
+// Continuum test utilities — render/cleanup, event helpers, async helpers.
+// Framework-agnostic except `advanceTimers`, which integrates with vitest's
+// fake timers (vitest is an optional peer, imported lazily).
+import { mount } from "@continuum-js/dom";
+const live = new Set();
+/**
+ * Mount `view` into a fresh container appended to `document.body` (so focus
+ * and event bubbling behave like in a real page). Dispose manually, or let
+ * `cleanup()` collect everything at the end of the test.
+ */
+export function render(view) {
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const unmount = mount(container, () => view());
+    const dispose = () => {
+        live.delete(dispose);
+        unmount();
+        container.remove();
+    };
+    live.add(dispose);
+    return { container, dispose };
+}
+/** Dispose every view still mounted by `render`. Call from `afterEach`. */
+export function cleanup() {
+    for (const dispose of [...live])
+        dispose();
+}
+/** Dispatch `event` on `el`. Returns the `dispatchEvent` result. */
+export function fire(el, event) {
+    return el.dispatchEvent(event);
+}
+/** Click an element (a bubbling, cancelable MouseEvent). */
+export function click(el) {
+    return fire(el, new MouseEvent("click", { bubbles: true, cancelable: true }));
+}
+/**
+ * Type `text` into an input character by character, dispatching a bubbling
+ * `input` event after each one — the shape `bindInput` listens to.
+ */
+export function type(input, text) {
+    for (const ch of text) {
+        input.value += ch;
+        fire(input, new Event("input", { bubbles: true }));
+    }
+}
+/**
+ * Drain the microtask queue so settled promises (e.g. `perform` results)
+ * re-enter the network. Transactions themselves are synchronous — this only
+ * waits for the JS runtime, not for Continuum.
+ */
+export async function flush(rounds = 3) {
+    for (let i = 0; i < rounds; i++)
+        await Promise.resolve();
+}
+/**
+ * Advance vitest fake timers by `ms` and flush microtasks, so time-based
+ * combinators (`debounce`, `throttle`, `interval`, `delay`) fire and their
+ * downstream settles. Requires `vi.useFakeTimers()` in the test.
+ */
+export async function advanceTimers(ms) {
+    const { vi } = await import("vitest");
+    await vi.advanceTimersByTimeAsync(ms);
+    await flush();
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@continuum-js/test",
+  "version": "0.1.0",
+  "description": "Continuum test utilities — render, event helpers, flush, fake-timer integration",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/denislibs/continuum.git",
+    "directory": "packages/test"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@continuum-js/dom": "^0.3.0",
+    "@continuum-js/frp": "^0.3.0"
+  },
+  "peerDependencies": {
+    "vitest": ">=2"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  }
+}