ctrl-fx 0.0.1 → 0.1.0

package/dist/net/index.d.ts

@@ -0,0 +1,42 @@
+import { type Effect } from '../effects';
+import { type Result } from '../utils/result';
+export type Method = 'GET' | 'POST' | 'DELETE' | 'PUT' | 'HEAD' | 'OPTIONS';
+export type HttpRequest = {
+    readonly uri: string;
+    readonly method: Method;
+    readonly headers: Headers;
+    readonly body?: string;
+};
+export type Headers = {
+    [key: string]: string;
+};
+export type HttpResponse = {
+    readonly headers: Headers;
+    readonly body: ResponseBody;
+};
+export type HttpError = {
+    _type: 'HttpError';
+};
+export type RequestError = {
+    _type: 'RequestError';
+    cause: 'RequestAborted' | 'NetworkFailure' | 'UnexpectedError';
+    message: string;
+};
+export type DecodingError = {
+    _type: 'DecodingError';
+    message: string;
+};
+export declare class Json {
+    private wrapped;
+    constructor(wrapped: any);
+    decodeUnsafe<A>(): A;
+}
+export declare class ResponseBody {
+    private data;
+    constructor(data: ArrayBuffer);
+    asString(): string;
+    asBlob(): Blob;
+    asJson(): Result<Json, DecodingError>;
+}
+export declare function getJson<State, Event>(uri: string): Effect<State, Event, Result<Json, HttpError | RequestError | DecodingError>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/net/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/net/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,MAAM,EAAE,MAAM,YAAY,CAAA;AAEzD,OAAO,EAAoB,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAE/D,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,SAAS,CAAA;AAE3E,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,WAAW,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,cAAc,CAAA;IACrB,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,iBAAiB,CAAA;IAC9D,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,eAAe,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,qBAAa,IAAI;IAEf,OAAO,CAAC,OAAO,CAAK;gBAGR,OAAO,EAAE,GAAG;IAIxB,YAAY,CAAC,CAAC,KAAK,CAAC;CAGrB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,IAAI,CAAa;gBAEb,IAAI,EAAE,WAAW;IAI7B,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,IAAI;IAId,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC;CActC;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAClC,GAAG,EAAE,MAAM,GACV,MAAM,CACP,KAAK,EACL,KAAK,EACL,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,YAAY,GAAG,aAAa,CAAC,CACvD,CAUA"}

package/dist/net/index.js

@@ -0,0 +1,60 @@
+import { makeHttpRequest } from '../effects';
+import { failure, success } from '../utils/result';
+export class Json {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(wrapped) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "wrapped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.wrapped = wrapped;
+    }
+    decodeUnsafe() {
+        return this.wrapped;
+    }
+}
+export class ResponseBody {
+    constructor(data) {
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.data = data;
+    }
+    asString() {
+        return new TextDecoder().decode(this.data);
+    }
+    asBlob() {
+        return new Blob([this.data]);
+    }
+    asJson() {
+        try {
+            return success(new Json(JSON.parse(this.asString())));
+        }
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                return failure({ _type: 'DecodingError', message: err.message });
+            }
+            else {
+                return failure({
+                    _type: 'DecodingError',
+                    message: `Unexpected decoding error: ${err}`,
+                });
+            }
+        }
+    }
+}
+export function getJson(uri) {
+    return makeHttpRequest({
+        uri,
+        method: 'GET',
+        headers: {},
+    }).map(result => result.andThen(rsp => {
+        return rsp.body.asJson();
+    }));
+}

package/dist/net/location.d.ts

@@ -0,0 +1,21 @@
+import { type Fragment } from './fragment';
+import { type Path } from './path';
+import type { QueryParam } from './queryparam';
+export interface InternalLocation {
+    readonly path: Path;
+    readonly queryParams: readonly QueryParam[];
+    readonly fragment?: Fragment;
+}
+export declare function formatLocation(loc: InternalLocation): string;
+export declare function parseInternalLocation(s: string): InternalLocation;
+export interface Location {
+    readonly protocol?: string;
+    readonly hostname?: string;
+    readonly port?: number;
+    readonly path: Path;
+    readonly queryParams: readonly QueryParam[];
+    readonly fragment?: Fragment;
+}
+export declare function internalLocationFromLocation(location: Location): InternalLocation;
+export declare const emptyLocation: InternalLocation;
+//# sourceMappingURL=location.d.ts.map

package/dist/net/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../src/net/location.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AACzD,OAAO,EAAa,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAA;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAC7B;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,CAE5D;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,GAAG,gBAAgB,CA4BjE;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAA;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAC7B;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,QAAQ,GACjB,gBAAgB,CAMlB;AAED,eAAO,MAAM,aAAa,EAAE,gBAA4C,CAAA"}

package/dist/net/location.js

@@ -0,0 +1,41 @@
+import { parseFragment } from './fragment';
+import { parsePath } from './path';
+import { formatQueryString, parseAllQueryParams } from './queryparam';
+export function formatLocation(loc) {
+    return `${loc.path.format()}${formatQueryString(loc.queryParams)}${loc.fragment != null ? '#' + loc.fragment.format : ''}`;
+}
+export function parseInternalLocation(s) {
+    const fragStart = s.indexOf('#');
+    let pathAndParams, fragment;
+    if (fragStart < 0) {
+        pathAndParams = s;
+        fragment = undefined;
+    }
+    else {
+        pathAndParams = s.substring(0, fragStart);
+        fragment = parseFragment(s.substring(fragStart + 1));
+    }
+    let path, queryParams;
+    const paramsStart = pathAndParams.indexOf('?');
+    if (paramsStart < 0) {
+        path = parsePath(pathAndParams);
+        queryParams = [];
+    }
+    else {
+        path = parsePath(pathAndParams.substring(0, paramsStart));
+        queryParams = parseAllQueryParams(pathAndParams.substring(paramsStart + 1));
+    }
+    return {
+        path,
+        queryParams,
+        fragment,
+    };
+}
+export function internalLocationFromLocation(location) {
+    return {
+        path: location.path,
+        queryParams: location.queryParams,
+        fragment: location.fragment,
+    };
+}
+export const emptyLocation = parseInternalLocation('');

package/dist/net/path.d.ts

@@ -0,0 +1,12 @@
+export type Path = {
+    readonly elems: readonly string[];
+    format(): string;
+    matches(that: Path): boolean;
+};
+export declare const emptyPath: {
+    elems: never[];
+    format(): string;
+    matches(that: Path): boolean;
+};
+export declare function parsePath(s: string): Path;
+//# sourceMappingURL=path.d.ts.map

package/dist/net/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/net/path.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,GAAG;IACjB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,MAAM,IAAI,MAAM,CAAA;IAChB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAA;CAC7B,CAAA;AAED,eAAO,MAAM,SAAS;;;kBAKN,IAAI,GAAG,OAAO;CAG7B,CAAA;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAuBzC"}

package/dist/net/path.js

@@ -0,0 +1,29 @@
+export const emptyPath = {
+    elems: [],
+    format() {
+        return '';
+    },
+    matches(that) {
+        return that.elems.length === 0;
+    },
+};
+export function parsePath(s) {
+    return {
+        elems: s.split('/'),
+        format() {
+            return this.elems.join('/');
+        },
+        matches(that) {
+            if (this.elems.length !== that.elems.length) {
+                return false;
+            }
+            for (let i = 0; i < this.elems.length; i++) {
+                if (this.elems[i].toLocaleLowerCase() !==
+                    that.elems[i].toLocaleLowerCase()) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    };
+}

package/dist/net/queryparam.d.ts

@@ -0,0 +1,10 @@
+export interface QueryParam {
+    name: string;
+    value?: string;
+    format: string;
+}
+export declare function parseQueryParam(str: string): QueryParam;
+export declare function parseAllQueryParams(str: string): readonly QueryParam[];
+export declare function formatQueryString(queryParams: readonly QueryParam[]): string;
+export declare function findQueryParam(haystack: readonly QueryParam[], predicate: (queryParam: QueryParam) => boolean): QueryParam | undefined;
+//# sourceMappingURL=queryparam.d.ts.map

package/dist/net/queryparam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryparam.d.ts","sourceRoot":"","sources":["../../src/net/queryparam.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAiBvD;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CAItE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,CAM5E;AAED,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,OAAO,GAC7C,UAAU,GAAG,SAAS,CAExB"}

package/dist/net/queryparam.js

@@ -0,0 +1,34 @@
+export function parseQueryParam(str) {
+    const eqIndx = str.indexOf('=');
+    if (eqIndx < 0) {
+        return {
+            name: str,
+            format: str,
+        };
+    }
+    else {
+        const name = str.substring(0, eqIndx);
+        const value = str.substring(eqIndx + 1);
+        return {
+            name,
+            value,
+            format: str,
+        };
+    }
+}
+export function parseAllQueryParams(str) {
+    const normalizedInput = str.startsWith('?') ? str.substring(1) : str;
+    const qps = normalizedInput.split('&').filter(s => s.length > 0);
+    return qps.map(parseQueryParam);
+}
+export function formatQueryString(queryParams) {
+    if (queryParams.length === 0) {
+        return '';
+    }
+    else {
+        return '?' + queryParams.map(qp => qp.format).join('&');
+    }
+}
+export function findQueryParam(haystack, predicate) {
+    return haystack.find(qp => predicate(qp));
+}

package/dist/router.d.ts

@@ -0,0 +1,40 @@
+import type { EventActions } from './dom/events';
+import { type Effect } from './effects';
+import type { InternalLocation } from './net/location';
+export type { EventActions } from './dom/events';
+export type { InternalLocation } from './net/location';
+/** Named path-segment parameters extracted from a matched route. */
+export type Params = Record<string, string>;
+/** A map of URL patterns to handler functions. Pattern keys use `:param` syntax for named path segments. */
+export type RouteMap<Route> = {
+    [pattern: string]: (params: Params) => Route;
+};
+/**
+ * Creates a route-matching function from a pattern map. Pattern keys use `:param` syntax for
+ * named path segments. Returns `null` when no pattern matches.
+ *
+ * ```ts
+ * const match = router({ '/': () => 'home', '/users/:id': ({ id }) => `user-${id}` })
+ * ```
+ */
+export declare function router<Route>(routes: RouteMap<Route>): (location: InternalLocation) => Route | null;
+/**
+ * An effect describing a `history.pushState` to `path`, suitable for use as an `onClick` handler on an `<a>` element.
+ * Produces `{ preventDefault: true }` to suppress the default browser navigation.
+ */
+export declare function link<State, Event>(path: string): Effect<State, Event, EventActions>;
+/** An effect describing a `history.pushState` to `path`. Use in effect chains or button handlers. */
+export declare function navigate<State, Event>(path: string): Effect<State, Event, void>;
+/**
+ * Bundled router that strips `options.basePath` before matching and prepends it before navigating.
+ * Use when your app is mounted at a sub-path (e.g. a GitHub Pages subdirectory).
+ * Returns a `{ match, link, navigate }` object.
+ */
+export declare function createRouter<Route>(routes: RouteMap<Route>, options?: {
+    basePath?: string;
+}): {
+    match(location: InternalLocation): Route | null;
+    link<State, Event>(path: string): Effect<State, Event, EventActions>;
+    navigate<State, Event>(path: string): Effect<State, Event, void>;
+};
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAoB,KAAK,MAAM,EAAE,MAAM,WAAW,CAAA;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGtD,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEtD,oEAAoE;AACpE,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE3C,4GAA4G;AAC5G,MAAM,MAAM,QAAQ,CAAC,KAAK,IAAI;IAC5B,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,KAAK,CAAA;CAC7C,CAAA;AA0CD;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAC1B,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,GACtB,CAAC,QAAQ,EAAE,gBAAgB,KAAK,KAAK,GAAG,IAAI,CAG9C;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,EAC/B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,CAIpC;AAED,qGAAqG;AACrG,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EACnC,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAE5B;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAChC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,EACvB,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9B;IACD,KAAK,CAAC,QAAQ,EAAE,gBAAgB,GAAG,KAAK,GAAG,IAAI,CAAA;IAC/C,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,CAAA;IACpE,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAA;CACjE,CAeA"}

package/dist/router.js

@@ -0,0 +1,77 @@
+import { async, pushState } from './effects';
+import { parseInternalLocation } from './net/location';
+function compile(routes) {
+    return Object.entries(routes).map(([pattern, handler]) => ({
+        segments: pattern.split('/'),
+        handler,
+    }));
+}
+function matchRoute(compiled, location) {
+    const pathSegs = location.path.elems;
+    for (const { segments, handler } of compiled) {
+        if (segments.length !== pathSegs.length)
+            continue;
+        const params = {};
+        let matched = true;
+        for (let i = 0; i < segments.length; i++) {
+            const seg = segments[i];
+            if (seg.startsWith(':')) {
+                params[seg.slice(1)] = pathSegs[i];
+            }
+            else if (seg.toLowerCase() !== pathSegs[i].toLowerCase()) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched)
+            return handler(params);
+    }
+    return null;
+}
+/**
+ * Creates a route-matching function from a pattern map. Pattern keys use `:param` syntax for
+ * named path segments. Returns `null` when no pattern matches.
+ *
+ * ```ts
+ * const match = router({ '/': () => 'home', '/users/:id': ({ id }) => `user-${id}` })
+ * ```
+ */
+export function router(routes) {
+    const compiled = compile(routes);
+    return location => matchRoute(compiled, location);
+}
+/**
+ * An effect describing a `history.pushState` to `path`, suitable for use as an `onClick` handler on an `<a>` element.
+ * Produces `{ preventDefault: true }` to suppress the default browser navigation.
+ */
+export function link(path) {
+    return async(pushState(parseInternalLocation(path)), 0).as({
+        preventDefault: true,
+    });
+}
+/** An effect describing a `history.pushState` to `path`. Use in effect chains or button handlers. */
+export function navigate(path) {
+    return pushState(parseInternalLocation(path));
+}
+/**
+ * Bundled router that strips `options.basePath` before matching and prepends it before navigating.
+ * Use when your app is mounted at a sub-path (e.g. a GitHub Pages subdirectory).
+ * Returns a `{ match, link, navigate }` object.
+ */
+export function createRouter(routes, options) {
+    const compiled = compile(routes);
+    const base = options?.basePath ?? '';
+    return {
+        match(location) {
+            if (!base)
+                return matchRoute(compiled, location);
+            const fullPath = location.path.elems.join('/');
+            if (!fullPath.startsWith(base))
+                return null;
+            const relative = fullPath.slice(base.length) || '/';
+            return matchRoute(compiled, parseInternalLocation(relative));
+        },
+        link: (path) => link(base + path),
+        navigate: (path) => navigate(base + path),
+    };
+}

package/dist/scroll.d.ts

@@ -0,0 +1,7 @@
+export type ScrollElementError = {
+    _type: 'ScrollElementError';
+    cause: 'ElementNotFound';
+    selector: string;
+};
+export declare function scrollElementError(selector: string): ScrollElementError;
+//# sourceMappingURL=scroll.d.ts.map

package/dist/scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll.d.ts","sourceRoot":"","sources":["../src/scroll.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,oBAAoB,CAAA;IAC3B,KAAK,EAAE,iBAAiB,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAEvE"}

package/dist/scroll.js

@@ -0,0 +1,3 @@
+export function scrollElementError(selector) {
+    return { _type: 'ScrollElementError', cause: 'ElementNotFound', selector };
+}

package/dist/testing.d.ts

@@ -0,0 +1,248 @@
+import { type NonEmptyArray } from './utils';
+import { type Attr } from './dom/attrs';
+import type { Node } from './dom';
+import type { Component } from './dom/components';
+import { type NodeGroup } from './dom/views';
+import { type Effect, type ScrollOptions } from './effects';
+import { type HttpError, type HttpRequest, type HttpResponse, type RequestError } from './net';
+import { type Result } from './utils/result';
+import { TestDatabaseData } from './db/testdb';
+import type { DbStoreSnapshot } from './db/testdb';
+import type { InternalLocation } from './net/location';
+export { TestDatabaseData };
+export type { DbStoreSnapshot };
+export type { InternalLocation };
+export type { HttpRequest, HttpResponse, HttpError, RequestError };
+export type DownloadRecord = {
+    readonly filename: string;
+    readonly content: string;
+    readonly contentType: string;
+};
+export type BroadcastSentRecord = {
+    readonly channel: string;
+    readonly message: unknown;
+};
+export type SetAppBadge = {
+    _type: 'SetAppBadge';
+    count: number;
+};
+export type ClearAppBadge = {
+    _type: 'ClearAppBadge';
+};
+export type AppBadgeOperation = SetAppBadge | ClearAppBadge;
+export declare const clearAppBadge: ClearAppBadge;
+export declare function setAppBadge(count: number): SetAppBadge;
+export declare function appBadgeCount(operations: readonly AppBadgeOperation[]): number;
+export type HttpInteraction = {
+    readonly request: HttpRequest;
+    readonly response: Result<HttpResponse, RequestError | HttpError>;
+};
+export type HttpHandler = (request: HttpRequest, prior: readonly HttpInteraction[]) => Result<HttpResponse, RequestError | HttpError>;
+/** Configuration passed to `testApplication`/`testComponent` to control how side effects behave during tests. */
+export type TestConfig = {
+    readonly http: {
+        /** Called for each HTTP request. Throw or return a failure Result to simulate errors. */
+        readonly handler: HttpHandler;
+    };
+    readonly clock: {
+        /** Scripted return values for `getTime()`, consumed in order. When exhausted, returns `new Date(0)`. */
+        readonly values: readonly Date[];
+    };
+    readonly random: {
+        /** Scripted return values for `getRandom()`, consumed in order. When exhausted, uses a deterministic seeded PRNG. */
+        readonly values: readonly number[];
+    };
+};
+/** Creates a TestConfig that throws on any HTTP request. */
+export declare function defaultTestConfig(): TestConfig;
+export type ConfirmInteraction = {
+    message: string;
+    response: boolean;
+};
+export type PromptInteraction = {
+    message: string;
+    default: string | undefined;
+    response: string | null;
+};
+/** Snapshot of every observable side effect that occurred during a test run. */
+export type TestData<Custom = {}> = {
+    readonly window: {
+        readonly alerts: readonly any[];
+        readonly confirms: readonly ConfirmInteraction[];
+        readonly confirmResponses: readonly boolean[];
+        readonly prompts: readonly PromptInteraction[];
+        readonly promptResponses: readonly (string | null)[];
+    };
+    readonly navigator: {
+        readonly appBadgeOperations: readonly AppBadgeOperation[];
+    };
+    readonly clipboard: {
+        readonly content: string;
+        readonly writes: readonly string[];
+    };
+    readonly document: {
+        readonly title: string | null;
+    };
+    readonly http: {
+        readonly interactions: readonly HttpInteraction[];
+    };
+    readonly clock: {
+        /** Values returned by each `getTime()` call, in order. */
+        readonly calls: readonly Date[];
+    };
+    readonly random: {
+        /** Values returned by each `getRandom()` call, in order. */
+        readonly calls: readonly number[];
+    };
+    readonly console: {
+        readonly logs: readonly any[];
+    };
+    readonly db: TestDatabaseData;
+    readonly storage: {
+        readonly local: ReadonlyMap<string, string>;
+        readonly session: ReadonlyMap<string, string>;
+    };
+    readonly navigation: {
+        readonly locationHistory: readonly InternalLocation[];
+    };
+    readonly scroll: {
+        readonly windowScrolls: readonly ScrollOptions[];
+        readonly elementScrolls: readonly {
+            selector: string;
+            options: ScrollOptions;
+        }[];
+    };
+    readonly downloads: readonly DownloadRecord[];
+    readonly broadcasts: {
+        readonly sent: readonly BroadcastSentRecord[];
+    };
+    readonly custom: Custom;
+};
+/** Creates an empty TestData, optionally initialising the `custom` field. */
+export declare function newTestData<Custom = {}>(custom?: Custom): TestData<Custom>;
+export type TestInput<State, Params, Custom = {}> = {
+    state?: State;
+    params?: Params;
+    testData?: TestData<Custom>;
+};
+export type Click = {
+    type: 'Click';
+    selector: QuerySelector;
+};
+/** Simulates a click on the element(s) matching `selector`. */
+export declare function click(selector: QuerySelector): Click;
+export type AdvanceTime = {
+    _type: 'AdvanceTime';
+    milliseconds: number;
+};
+/** Advances the test scheduler clock by `milliseconds`, firing any scheduled tasks that come due. */
+export declare function advanceTime(milliseconds: number): AdvanceTime;
+export type ReceiveBroadcast = {
+    _type: 'ReceiveBroadcast';
+    channel: string;
+    message: unknown;
+};
+/** Delivers a BroadcastChannel message to any active subscriber on `channel`. */
+export declare function receiveBroadcast(channel: string, message: unknown): ReceiveBroadcast;
+export type FireCustomEvent = {
+    _type: 'FireCustomEvent';
+    selector: QuerySelector;
+    eventName: string;
+    detail: unknown;
+};
+/** Dispatches a custom DOM event on the element matching `selector`, invoking any `onEvent` handler. */
+export declare function fireCustomEvent(selector: QuerySelector, eventName: string, detail?: unknown): FireCustomEvent;
+export type Submit = {
+    _type: 'Submit';
+    selector: QuerySelector;
+};
+/** Simulates a form submit event on the element(s) matching `selector`. */
+export declare function submit(selector: QuerySelector): Submit;
+export type TextInput = {
+    _type: 'TextInput';
+    selector: QuerySelector;
+    value: string;
+};
+/** Simulates an `input` event on the element(s) matching `selector`. */
+export declare function textInput(selector: QuerySelector, value: string): TextInput;
+/** Creates an attribute object `{ name, value }` for use with `findOne(...).attrs.toContainEqual(attr(...))`. */
+export declare function attr(name: string, value: string): {
+    name: string;
+    value: string;
+};
+export type Interaction = Click | AdvanceTime | ReceiveBroadcast | FireCustomEvent | Submit | TextInput;
+export type { NonEmptyArray };
+export type DomElement = {
+    readonly tag: string;
+    readonly attrs: readonly Attr[];
+    readonly childNodes: readonly DomNode[];
+};
+export type DomNode = DomElement | string;
+export type TestableDom = {
+    head: DomElement;
+    body: DomElement;
+};
+/**
+ * The result of mounting a component for testing. Supports running interactions
+ * and querying the virtual DOM. Each call to `run` returns a new
+ * `TestableComponent` reflecting the state after those interactions, so tests
+ * can chain calls to build up complex scenarios step by step.
+ */
+export type TestableComponent<State, Params, Event, Custom = {}> = {
+    readonly config: TestConfig;
+    readonly state: State;
+    readonly data: TestData<Custom>;
+    /** Returns a copy with the given TestConfig. */
+    withConfig(config: TestConfig): TestableComponent<State, Params, Event, Custom>;
+    /** Returns a copy with the given TestData as the starting data. */
+    withData(data: TestData<Custom>): TestableComponent<State, Params, Event, Custom>;
+    readonly dom: TestableDom;
+    /**
+     * Applies one or more interactions in order and returns a new
+     * `TestableComponent` reflecting the resulting state and DOM. The original
+     * instance is unchanged, so you can branch from the same starting point to
+     * test different sequences.
+     */
+    run(...interactions: Interaction[]): TestableComponent<State, Params, Event, Custom>;
+    /** Returns all elements matching `selector`. */
+    find(selector: string): readonly DomElement[];
+    /** Returns the single element matching `selector`. Throws if not exactly one match. */
+    findOne(selector: string): DomElement;
+    /** Returns all elements matching `selector`. Throws if no match. */
+    findOneOrMore(selector: string): NonEmptyArray<DomElement>;
+    /** Returns the element matching `selector`, or undefined. */
+    findMaybeOne(selector: string): DomElement | undefined;
+};
+/**
+ * Creates a testable wrapper around a `Component`. Use this when testing a
+ * component that was created with `component()`. For testing a top-level view
+ * function directly, use `testApplication` instead.
+ */
+export declare function testComponent<State, Params, Event, Custom = {}>(component: Component<State, Params, Event>, config?: TestConfig, data?: TestData<Custom>): TestableComponent<State, Params, Event, Custom>;
+/**
+ * The main entry point for testing a ctrl-fx application. Wraps a view
+ * function and initial state into a `TestableComponent`. Call `.run(...)`
+ * with interactions to simulate user actions, then inspect `.state`, `.data`,
+ * and the `findOne`/`find` DOM query methods on the result.
+ */
+export declare function testApplication<State, Custom = {}>(app: (state: State) => NodeGroup<State, never> | Node<State, never>, initialState: State | Effect<State, never, State>, config?: TestConfig, data?: TestData<Custom>): TestableComponent<State, void, never, Custom>;
+export type ExactlyOne = {
+    _type: 'ExactlyOne';
+    selector: string;
+};
+export type ZeroOrMore = {
+    _type: 'ZeroOrMore';
+    selector: string;
+};
+export type ZeroOrOne = {
+    _type: 'ZeroOrOne';
+    selector: string;
+};
+export type OneOrMore = {
+    _type: 'OneOrMore';
+    selector: string;
+};
+/** Selects elements matching `selector`; throws during `run` if none are found. */
+export declare function one(selector: string): OneOrMore;
+export type QuerySelector = ExactlyOne | OneOrMore | ZeroOrMore | ZeroOrOne;
+//# sourceMappingURL=testing.d.ts.map