slopkit 0.3.0 → 0.4.0-rc.0

package/dist/test/page.d.ts

@@ -0,0 +1,91 @@
+import type { WebConfig } from "../server/config.ts";
+import type { Logger } from "../server/log.ts";
+import type { Line, Meaning } from "../states.ts";
+import type { Model } from "../sync.ts";
+import type { World } from "./states.ts";
+/** What the app's server gives the driver: where it listens, how it stops, its due jobs run, its open jobs listed. */
+export type PageServer = {
+    url: string;
+    close: () => Promise<void>;
+    /** Runs the server's jobs due by now (the driver's clock). */
+    due?: () => unknown;
+    /** The server's jobs, for the honest check (`World.jobs`). */
+    jobs?: () => World["jobs"];
+};
+/** What the page shows and its sync model, read from the loaded page entry. */
+export type PageRead = {
+    shown: unknown;
+    model?: Model<any, any, any, any>;
+};
+export type PageOptions<E> = {
+    /** The app's server in this process, on the driver's web config, reading time from `now`. */
+    server: (context: {
+        home: string;
+        web: WebConfig;
+        now: () => number;
+        log: Logger;
+    }) => Promise<PageServer>;
+    /** Imports the app's page entry, which renders into `#app`; modules are fresh on each load. */
+    page: () => Promise<E>;
+    /** What the page shows and its sync model, from the loaded entry. */
+    read?: (entry: E) => PageRead;
+    /** When the clock starts: an instant or ms since the epoch. */
+    at: string | number;
+    /** Where the page first loads, on the server: a deep link (default `/`). */
+    path?: string;
+    /** The app's severity order, for the honest checks. */
+    order?: readonly Meaning[];
+    /** How far a settle waits for pending timeouts, in ms of the clock. */
+    idle?: number;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+};
+/** A line the page's view holds now. */
+export type ReadLine = {
+    subject: string;
+    kind: string;
+    meaning: Meaning;
+    text: string;
+    owed: Line<unknown>["owed"];
+};
+export type Page = {
+    /** Types into the text field with this accessible name (replacing its value), then settles. */
+    type: (name: string | RegExp, text: string) => Promise<void>;
+    /** Presses the button or link with this accessible name, then settles. */
+    press: (name: string | RegExp) => Promise<void>;
+    /** Picks an option (by value or label) in the select with this accessible name, then settles. */
+    select: (name: string | RegExp, option: string) => Promise<void>;
+    /** Moves the clock by `ms`, running what falls in it, then settles. */
+    advance: (ms: number) => Promise<void>;
+    /** Waits until quiet, then checks the view; throws on its problems unless `lenient`. */
+    settle: (options?: {
+        lenient?: boolean;
+    }) => Promise<{
+        lines: ReadLine[];
+        problems: string[];
+    }>;
+    /** The text of the element named by aria-label or aria-labelledby, or of the whole page. */
+    text: (name?: string | RegExp) => string;
+    /** The lines the view holds now. */
+    lines: () => ReadLine[];
+    /**
+     * A new page load at the address the page is on: fresh modules and DOM; this device's storage (IndexedDB,
+     * localStorage, sessionStorage), or a new device's, empty.
+     */
+    reload: (options?: {
+        device?: "same" | "new";
+    }) => Promise<void>;
+    /** The page's address, absolute. */
+    location: () => string;
+    /** History back within the page (an entry it pushed): the address moves and the page hears popstate; then settles. */
+    back: () => Promise<void>;
+    /** Drops the session: the server then answers this page as no one. */
+    signOut: () => Promise<void>;
+    /** Signs in again through the stand-in. */
+    signIn: () => Promise<void>;
+    readonly now: number;
+    close: () => Promise<void>;
+};
+export declare function openPage<E>(options: PageOptions<E>): Promise<Page>;