walkwright 0.0.1

package/build/pom-kcSMxwX2.d.ts

@@ -0,0 +1,349 @@
+import { Page, Fixtures, PlaywrightTestArgs, Locator, TestType, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions } from '@playwright/test';
+import { OverlayDescriptor, AppDescriptor, NestedSurfaceDescriptor, PageDescriptor } from './descriptor.js';
+import { LocatorDescriptor, LazyLocator, Mount } from './locator.js';
+import { AnyProvision, ProvisionMap } from './provisioner.js';
+
+interface ShotRecord {
+    file: string;
+    state: string;
+    page: string;
+    path?: string;
+    group?: string[];
+}
+interface Recorder {
+    record: {
+        <Target extends VisitablePage<never>>(target: PageOrFactory<Target>, state?: string, options?: ShotOptions): Promise<Target>;
+        <Params, Target extends VisitablePage<Params>>(target: PageOrFactory<Target>, params: Params, state?: string, options?: ShotOptions): Promise<Target>;
+        (dialog: OverlayDialog, options?: ShotOptions): Promise<void>;
+        (state: string, dialog: OverlayDialog, options?: ShotOptions): Promise<void>;
+        (state?: string, options?: ShotOptions): Promise<void>;
+    };
+    shots: () => ShotRecord[];
+}
+interface ShotOptions {
+    viewport?: {
+        width?: number;
+        height?: number;
+    };
+    page?: string;
+    group?: string[];
+    state?: string;
+}
+type PageFactory$1<Target> = (page: Page) => Target;
+type PageOrFactory<Target> = Target | PageFactory$1<Target>;
+interface VisitablePage<Params> {
+    path: string;
+    name: string;
+    url: (params: Params) => string;
+    goto: (params: Params) => Promise<void>;
+}
+interface OverlayDialog {
+    label?: string;
+    waitFor: (state?: "visible" | "hidden") => Promise<unknown>;
+    close: () => Promise<unknown>;
+    descriptor?: OverlayDescriptor;
+    self?: {
+        chain: LocatorDescriptor;
+    };
+}
+declare const runDirVariable = "WALKWRIGHT_RUN_DIR";
+declare const shotsAttachment = "walkwright-shots";
+interface RecordedShots {
+    pages: PageMeta[];
+    shots: ShotRecord[];
+}
+interface RecorderFixtures {
+    recording: boolean;
+    runDir: string;
+    record: Recorder["record"];
+}
+interface RecordedApp {
+    descriptor: AppDescriptor;
+}
+declare function createRecorderFixtures(app: RecordedApp): Fixtures<RecorderFixtures, object, PlaywrightTestArgs>;
+declare global {
+    interface Window {
+        __walkwrightRestore?: (() => void)[];
+    }
+}
+declare function describeError(error: unknown): string;
+
+type CaptureRule = {
+    element: string;
+    text: string;
+    match?: RegExp;
+} | {
+    match: RegExp;
+    text: string;
+};
+interface CaptureRules {
+    rules: CaptureRule[];
+}
+type ElementPath<E> = Extract<keyof E, string> | `${Extract<keyof E, string>}.${string}`;
+type TypedCaptureRule<E> = {
+    element: ElementPath<E>;
+    text: string;
+    match?: RegExp;
+} | {
+    match: RegExp;
+    text: string;
+};
+interface TypedCaptureRules<E> {
+    rules: TypedCaptureRule<E>[];
+}
+type Factory<T> = (page: Page) => T;
+interface Rooted {
+    self: LazyLocator;
+    root: Locator;
+}
+interface SurfaceInstance {
+    page: Page;
+    elements: object;
+}
+interface Surface<I extends SurfaceInstance = SurfaceInstance> {
+    (scope: LazyLocator): Surface<I & Rooted>;
+    (scope: Page): I;
+    readonly descriptor: NestedSurfaceDescriptor;
+}
+type AnySurface = Surface;
+interface OverlayEmbed {
+    overlay: OverlayFactory;
+    open?: () => Promise<void>;
+}
+type ElementMap = Record<string, LazyLocator | ((...params: never[]) => LazyLocator) | AnySurface | ((...params: never[]) => AnySurface) | OverlayEmbed | ((scope: Mount) => unknown) | ((...params: never[]) => (scope: Mount) => unknown)>;
+type ThisElements<Self> = Record<string, ElementMap[string] | (OverlayEmbed & ThisType<Self>)>;
+type Instantiated<M extends ElementMap> = {
+    [Key in keyof M]: M[Key] extends {
+        overlay: infer O extends AnySurface;
+    } ? SurfaceInstanceOf<O> : M[Key] extends LazyLocator ? Locator : M[Key] extends (...args: infer A) => LazyLocator ? (...args: A) => Locator : M[Key] extends {
+        (...params: infer Params): infer S;
+        parameterized: true;
+    } ? S extends AnySurface ? (...params: Params) => SurfaceInstanceOf<S> : never : M[Key] extends AnySurface ? SurfaceInstanceOf<M[Key]> : M[Key] extends (...args: infer A) => infer S ? S extends AnySurface ? (...args: A) => SurfaceInstanceOf<S> : S extends (scope: never) => infer R ? (...args: A) => R : S : never;
+};
+type ActionMap = Record<string, (...params: never[]) => unknown>;
+type Parameterized<Params extends unknown[], F> = ((...params: Params) => F) & {
+    parameterized: true;
+};
+type Component<E extends object, A extends object = Record<never, never>> = {
+    page: Page;
+    elements: E;
+    self?: LazyLocator;
+    root?: Locator;
+} & A;
+type RootedComponent<E extends object, A extends object = Record<never, never>> = Component<E, A> & Rooted;
+type SurfaceInstanceOf<S> = S extends (scope: Page) => infer I ? I : never;
+type ActionsOf<I> = Omit<I, keyof SurfaceInstance | keyof Rooted>;
+type IncludeShape<Inc extends readonly AnySurface[]> = Inc extends readonly [
+    infer First,
+    ...infer Rest
+] ? Rest extends readonly AnySurface[] ? SurfaceInstanceOf<First> extends infer I extends SurfaceInstance ? {
+    elements: I["elements"] & IncludeShape<Rest>["elements"];
+    actions: ActionsOf<I> & IncludeShape<Rest>["actions"];
+} : never : never : {
+    elements: unknown;
+    actions: unknown;
+};
+type IncludeElements<Inc extends readonly AnySurface[]> = IncludeShape<Inc>["elements"];
+type IncludeActions<Inc extends readonly AnySurface[]> = IncludeShape<Inc>["actions"];
+declare function rootOf(instance: {
+    root?: Locator;
+}): Locator;
+interface SurfaceDefinition {
+    elements?: ElementMap;
+    actions?: ActionMap;
+    include?: readonly AnySurface[];
+    capture?: CaptureRules;
+}
+interface ComponentDefinition<Inc extends readonly AnySurface[], M extends ElementMap, A extends ActionMap, Self> {
+    include?: readonly [...Inc];
+    elements?: M & ThisElements<Self> & ThisType<Self>;
+    actions?: A & ActionMap & ThisType<Self>;
+    capture?: TypedCaptureRules<IncludeElements<Inc> & Instantiated<M>>;
+}
+interface DefinitionShape {
+    root?: LazyLocator;
+}
+type ComponentInstanceOf<Def extends DefinitionShape, Inc extends readonly AnySurface[], M extends ElementMap, A extends ActionMap> = Def extends {
+    root: LazyLocator;
+} ? RootedComponent<IncludeElements<Inc> & Instantiated<M>, IncludeActions<Inc> & A> : Component<IncludeElements<Inc> & Instantiated<M>, IncludeActions<Inc> & A>;
+declare function defineComponent<Params extends unknown[], Def extends DefinitionShape, Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>>(build: (...params: Params) => Def & ComponentDefinition<Inc, M, A, ComponentInstanceOf<Def, Inc, M, A>>): Parameterized<Params, Surface<ComponentInstanceOf<Def, Inc, M, A>>>;
+declare function defineComponent<Def extends DefinitionShape, Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>>(definition: Def & ComponentDefinition<Inc, M, A, ComponentInstanceOf<Def, Inc, M, A>>): Surface<ComponentInstanceOf<Def, Inc, M, A>>;
+interface OverlayClose {
+    esc?: boolean;
+    button?: LazyLocator;
+}
+interface OverlayRecorder {
+    label: string;
+}
+interface OverlayHandle {
+    waitFor: (state?: "visible" | "hidden") => Promise<void>;
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+}
+type Overlay<E extends object> = {
+    page: Page;
+    elements: E;
+    label: string;
+} & Rooted & OverlayHandle;
+type Dialog<E extends object> = Overlay<E> & {
+    name: string | RegExp;
+};
+type AnyOverlayInstance = SurfaceInstance & Rooted & OverlayHandle & {
+    label: string;
+};
+interface OverlayFactory<I extends AnyOverlayInstance = AnyOverlayInstance> extends Surface<I> {
+    overlay: true;
+    descriptor: OverlayDescriptor;
+}
+type OverlayInstanceOf<Inc extends readonly AnySurface[], M extends ElementMap, A extends ActionMap> = Overlay<IncludeElements<Inc> & Instantiated<M>> & IncludeActions<Inc> & A;
+type DialogInstanceOf<Inc extends readonly AnySurface[], M extends ElementMap, A extends ActionMap> = Dialog<IncludeElements<Inc> & Instantiated<M>> & IncludeActions<Inc> & A;
+interface OverlayDefinition<Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>> extends ComponentDefinition<Inc, M, A, OverlayInstanceOf<Inc, M, A>> {
+    root: LazyLocator;
+    recorder: OverlayRecorder;
+    close?: OverlayClose;
+}
+interface DialogDefinition<Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>> extends ComponentDefinition<Inc, M, A, DialogInstanceOf<Inc, M, A>> {
+    name: string | RegExp;
+    role?: "dialog" | "alertdialog";
+    recorder?: OverlayRecorder;
+    close?: OverlayClose;
+}
+declare function defineOverlay<Params extends unknown[], Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>>(build: (...params: Params) => OverlayDefinition<Inc, M, A>): Parameterized<Params, OverlayFactory<OverlayInstanceOf<Inc, M, A>>>;
+declare function defineOverlay<Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>>(definition: OverlayDefinition<Inc, M, A>): OverlayFactory<OverlayInstanceOf<Inc, M, A>>;
+declare function defineDialog<Params extends unknown[], Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>>(build: (...params: Params) => DialogDefinition<Inc, M, A>): Parameterized<Params, OverlayFactory<DialogInstanceOf<Inc, M, A>>>;
+declare function defineDialog<Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, A extends ActionMap = Record<never, never>>(definition: DialogDefinition<Inc, M, A>): OverlayFactory<DialogInstanceOf<Inc, M, A>>;
+type PathParams<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? Record<Param, string> & PathParams<Rest> : Path extends `${string}:${infer Param}` ? Record<Param, string> : unknown;
+interface PageMeta {
+    name: string;
+    path: string;
+    group?: string[];
+}
+interface PageRecorder {
+    group?: string[];
+    label?: string;
+}
+interface Register {
+}
+type RegisteredPages = Register extends {
+    app: {
+        pages: infer P extends AnyPages;
+    };
+} ? BoundPages<P> : Record<string, never>;
+interface PageObject<Path extends string, E> {
+    page: Page;
+    path: Path;
+    name: string;
+    goto: (params: PathParams<Path>) => Promise<void>;
+    url: (params: PathParams<Path>) => string;
+    params: () => PathParams<Path>;
+    waitFor: () => Promise<void>;
+    elements: E;
+    pages: RegisteredPages;
+}
+interface PageFactory<Path extends string, E, A> {
+    (page: Page): PageObject<Path, E> & A;
+    descriptor: PageDescriptor;
+}
+type InstanceOf<T> = T extends (...args: never[]) => infer R ? R extends (...args: never[]) => infer R2 ? R2 : R : never;
+type HeaderElement<H extends string | undefined> = H extends string ? {
+    header: Locator;
+} : unknown;
+interface PageContext<E> {
+    page: Page;
+    elements: E;
+    pages: RegisteredPages;
+}
+type PageThis<Inc extends readonly AnySurface[], M extends ElementMap, H extends string | undefined, A extends ActionMap> = PageContext<IncludeElements<Inc> & Instantiated<M> & HeaderElement<H>> & IncludeActions<Inc> & A;
+interface PageDefinition<Path extends string, Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, H extends string | undefined = undefined, A extends ActionMap = Record<never, never>, Ambient extends readonly AnySurface[] = []> {
+    path: Path;
+    name: string;
+    recorder?: PageRecorder;
+    ready?: AppReady;
+    header?: H;
+    include?: readonly [...Inc];
+    elements?: M & ThisElements<PageThis<[...Ambient, ...Inc], M, H, A>> & ThisType<PageThis<[...Ambient, ...Inc], M, H, A>>;
+    anchor?: string | LazyLocator;
+    actions?: A & ActionMap & ThisType<PageThis<[...Ambient, ...Inc], M, H, A>>;
+    capture?: TypedCaptureRules<IncludeElements<Inc> & Instantiated<M> & HeaderElement<H>>;
+}
+interface PagePresetDefinition<Prefix extends string, Inc extends readonly AnySurface[] = []> {
+    path: Prefix;
+    include?: readonly [...Inc];
+    recorder?: {
+        group?: string[];
+    };
+    ready?: AppReady;
+    capture?: TypedCaptureRules<IncludeElements<Inc>>;
+}
+interface PagePreset<Prefix extends string, Inc extends readonly AnySurface[]> {
+    readonly path: Prefix;
+    readonly include: Inc;
+    <Params extends unknown[], Sub extends string, Own extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, H extends string | undefined = undefined, A extends ActionMap = Record<never, never>>(build: (...params: Params) => PageDefinition<Sub, Own, M, H, A, Inc>): Parameterized<Params, PageFactory<`${Prefix}${Sub}`, IncludeElements<[...Inc, ...Own]> & Instantiated<M> & HeaderElement<H>, IncludeActions<[...Inc, ...Own]> & A>>;
+    <Sub extends string, Own extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, H extends string | undefined = undefined, A extends ActionMap = Record<never, never>>(def: PageDefinition<Sub, Own, M, H, A, Inc>): PageFactory<`${Prefix}${Sub}`, IncludeElements<[...Inc, ...Own]> & Instantiated<M> & HeaderElement<H>, IncludeActions<[...Inc, ...Own]> & A>;
+    preset<SubPrefix extends string, SubInc extends readonly AnySurface[] = []>(base: PagePresetDefinition<SubPrefix, SubInc>): PagePreset<`${Prefix}${SubPrefix}`, [...Inc, ...SubInc]>;
+}
+type PresetPage<P extends PagePreset<string, readonly AnySurface[]>, Sub extends string, M extends ElementMap = Record<never, never>, H extends string | undefined = undefined, A extends ActionMap = Record<never, never>, Own extends readonly AnySurface[] = []> = PageFactory<`${P["path"]}${Sub}`, IncludeElements<[...P["include"], ...Own]> & Instantiated<M> & HeaderElement<H>, IncludeActions<[...P["include"], ...Own]> & A>;
+interface DefinePage {
+    <Params extends unknown[], Path extends string, Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, H extends string | undefined = undefined, A extends ActionMap = Record<never, never>>(build: (...params: Params) => PageDefinition<Path, Inc, M, H, A>): Parameterized<Params, PageFactory<Path, IncludeElements<Inc> & Instantiated<M> & HeaderElement<H>, IncludeActions<Inc> & A>>;
+    <Path extends string, Inc extends readonly AnySurface[] = [], M extends ElementMap = Record<never, never>, H extends string | undefined = undefined, A extends ActionMap = Record<never, never>>(def: PageDefinition<Path, Inc, M, H, A>): PageFactory<Path, IncludeElements<Inc> & Instantiated<M> & HeaderElement<H>, IncludeActions<Inc> & A>;
+    preset<Prefix extends string, Inc extends readonly AnySurface[] = []>(base: PagePresetDefinition<Prefix, Inc>): PagePreset<Prefix, Inc>;
+}
+type AppReady = {
+    selector: string;
+} | ((page: Page) => Promise<void>);
+interface AnyPageFactory {
+    (page: Page): unknown;
+    descriptor: PageDescriptor;
+}
+declare const definePage: DefinePage;
+type AnyPages = Record<string, AnyPageFactory>;
+interface AppDefinition<P extends AnyPages> {
+    pages: P;
+    ready?: AppReady;
+    capture?: {
+        rules: {
+            match: RegExp;
+            text: string;
+        }[];
+    };
+}
+type BoundPages<P extends AnyPages> = {
+    [K in keyof P]: P[K] extends (page: Page) => infer Instance ? Instance : never;
+};
+interface AppFixtures<P extends AnyPages> extends RecorderFixtures {
+    pages: BoundPages<P>;
+}
+type DefaultTestArgs<P extends AnyPages> = PlaywrightTestArgs & PlaywrightTestOptions & AppFixtures<P>;
+type DefaultWorkerArgs = PlaywrightWorkerArgs & PlaywrightWorkerOptions;
+interface AppFixtureOptions {
+    base?: TestType<PlaywrightTestArgs, NonNullable<unknown>>;
+}
+interface AppFixture<P extends AnyPages> {
+    <Defs extends readonly AnyProvision[], T extends PlaywrightTestArgs, W extends NonNullable<unknown>>(provisions: Defs, options: AppFixtureOptions & {
+        base: TestType<T, W>;
+    }): TestType<T & AppFixtures<P> & {
+        provision: ProvisionMap<Defs>;
+    }, W>;
+    <Defs extends readonly AnyProvision[]>(provisions: Defs, options?: AppFixtureOptions): TestType<DefaultTestArgs<P> & {
+        provision: ProvisionMap<Defs>;
+    }, DefaultWorkerArgs>;
+    <T extends PlaywrightTestArgs, W extends NonNullable<unknown>>(provisions: undefined, options: AppFixtureOptions & {
+        base: TestType<T, W>;
+    }): TestType<T & AppFixtures<P>, W>;
+    (provisions?: undefined, options?: AppFixtureOptions): TestType<DefaultTestArgs<P>, DefaultWorkerArgs>;
+}
+interface App<P extends AnyPages = AnyPages> {
+    pages: P;
+    fixture: AppFixture<P>;
+    descriptor: AppDescriptor;
+}
+declare function defineApp<P extends AnyPages>(def: AppDefinition<P>): App<P>;
+declare function loadPage(descriptor: PageDescriptor): PageFactory<string, Record<string, unknown>, Record<never, never>>;
+declare function loadApp(raw: unknown): App;
+declare function arriveAt<T extends {
+    waitFor: () => Promise<void>;
+}>(destination: Factory<T>, page: Page): Promise<T>;
+declare function waitForHydration(page: Page, timeoutMs?: number): Promise<void>;
+declare function pathParams<Path extends string>(path: Path, url: string): PathParams<Path>;
+
+export { type PageFactory as $, type ActionMap as A, type BoundPages as B, type Component as C, type CaptureRule as D, type CaptureRules as E, type ComponentDefinition as F, type DefinePage as G, type Dialog as H, type Instantiated as I, type DialogDefinition as J, type ElementMap as K, type Factory as L, type HeaderElement as M, type IncludeActions as N, type Overlay as O, type Parameterized as P, type IncludeElements as Q, type Rooted as R, type Surface as S, type InstanceOf as T, type OverlayClose as U, type VisitablePage as V, type OverlayDefinition as W, type OverlayEmbed as X, type OverlayRecorder as Y, type PageContext as Z, type PageDefinition as _, type SurfaceInstance as a, type PageMeta as a0, type PageObject as a1, type PagePreset as a2, type PagePresetDefinition as a3, type PageRecorder as a4, type PathParams as a5, type PresetPage as a6, type Register as a7, type RegisteredPages as a8, type SurfaceDefinition as a9, arriveAt as aa, defineApp as ab, defineComponent as ac, defineDialog as ad, defineOverlay as ae, definePage as af, loadApp as ag, loadPage as ah, pathParams as ai, rootOf as aj, waitForHydration as ak, type OverlayFactory as b, type RootedComponent as c, type OverlayHandle as d, type OverlayDialog as e, type PageFactory$1 as f, type PageOrFactory as g, type RecordedApp as h, type RecordedShots as i, type Recorder as j, type RecorderFixtures as k, type ShotOptions as l, type ShotRecord as m, createRecorderFixtures as n, describeError as o, type AnyPageFactory as p, type AnyPages as q, runDirVariable as r, shotsAttachment as s, type AnySurface as t, type App as u, type AppDefinition as v, type AppFixture as w, type AppFixtureOptions as x, type AppFixtures as y, type AppReady as z };

package/build/pom.d.ts

@@ -0,0 +1,6 @@
+import '@playwright/test';
+import './descriptor.js';
+export { Mount, Scope, pageOf } from './locator.js';
+import './provisioner.js';
+export { A as ActionMap, p as AnyPageFactory, q as AnyPages, t as AnySurface, u as App, v as AppDefinition, w as AppFixture, x as AppFixtureOptions, y as AppFixtures, z as AppReady, B as BoundPages, D as CaptureRule, E as CaptureRules, C as Component, F as ComponentDefinition, G as DefinePage, H as Dialog, J as DialogDefinition, K as ElementMap, L as Factory, M as HeaderElement, N as IncludeActions, Q as IncludeElements, T as InstanceOf, I as Instantiated, O as Overlay, U as OverlayClose, W as OverlayDefinition, X as OverlayEmbed, b as OverlayFactory, d as OverlayHandle, Y as OverlayRecorder, Z as PageContext, _ as PageDefinition, $ as PageFactory, a0 as PageMeta, a1 as PageObject, a2 as PagePreset, a3 as PagePresetDefinition, a4 as PageRecorder, P as Parameterized, a5 as PathParams, a6 as PresetPage, a7 as Register, a8 as RegisteredPages, R as Rooted, c as RootedComponent, S as Surface, a9 as SurfaceDefinition, a as SurfaceInstance, aa as arriveAt, ab as defineApp, ac as defineComponent, ad as defineDialog, ae as defineOverlay, af as definePage, ag as loadApp, ah as loadPage, ai as pathParams, aj as rootOf, ak as waitForHydration } from './pom-kcSMxwX2.js';
+import 'zod';

package/build/pom.js

@@ -0,0 +1,37 @@
+import {
+  arriveAt,
+  defineApp,
+  defineComponent,
+  defineDialog,
+  defineOverlay,
+  definePage,
+  loadApp,
+  loadPage,
+  pathParams,
+  rootOf,
+  waitForHydration
+} from "./chunk-6YRKPGUO.js";
+import "./chunk-KQN5IYN6.js";
+import "./chunk-5CHKYNP7.js";
+import "./chunk-KTXNERHT.js";
+import "./chunk-N4SSLHMP.js";
+import {
+  pageOf
+} from "./chunk-FJI2CMCE.js";
+import "./chunk-BODO6HIH.js";
+import "./chunk-UAWBPTDW.js";
+export {
+  arriveAt,
+  defineApp,
+  defineComponent,
+  defineDialog,
+  defineOverlay,
+  definePage,
+  loadApp,
+  loadPage,
+  pageOf,
+  pathParams,
+  rootOf,
+  waitForHydration
+};
+//# sourceMappingURL=pom.js.map

package/build/pom.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/project.d.ts

@@ -0,0 +1,13 @@
+declare const defaultReportsUrl = "https://app.walkwright.dev";
+interface WalkwrightConfig {
+    url: string;
+    project: string;
+    token: string;
+}
+declare function describeConfigPath(cwd?: string): string;
+declare function readWalkwrightConfig(cwd?: string): WalkwrightConfig | undefined;
+declare function writeWalkwrightConfig(config: WalkwrightConfig, cwd?: string): string;
+declare function currentBranch(cwd?: string): string;
+declare function repoName(cwd?: string): string;
+
+export { type WalkwrightConfig, currentBranch, defaultReportsUrl, describeConfigPath, readWalkwrightConfig, repoName, writeWalkwrightConfig };

package/build/project.js

@@ -0,0 +1,19 @@
+import {
+  currentBranch,
+  defaultReportsUrl,
+  describeConfigPath,
+  readWalkwrightConfig,
+  repoName,
+  writeWalkwrightConfig
+} from "./chunk-Z7CW5CAY.js";
+import "./chunk-BODO6HIH.js";
+import "./chunk-UAWBPTDW.js";
+export {
+  currentBranch,
+  defaultReportsUrl,
+  describeConfigPath,
+  readWalkwrightConfig,
+  repoName,
+  writeWalkwrightConfig
+};
+//# sourceMappingURL=project.js.map

package/build/project.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/provisioner.d.ts

@@ -0,0 +1,34 @@
+import { Page } from '@playwright/test';
+import { z } from 'zod';
+
+type Use = <D extends AnyProvision>(provision: D, ...input: ProvisionArgs<InputOf<D>>) => Promise<ResultOf<D>>;
+interface Provision<Name extends string, Input, Result> {
+    name: Name;
+    create: (page: Page, input: Input, use: Use) => Promise<Result>;
+    dispose?: (page: Page, result: Result) => Promise<void>;
+    schema?: z.ZodType<Result>;
+}
+interface AnyProvision {
+    name: string;
+    create: (page: Page, input: never, use: Use) => Promise<unknown>;
+    dispose?: (page: Page, result: never) => Promise<void>;
+    schema?: z.ZodType;
+}
+type InputOf<D extends AnyProvision> = D extends {
+    create: (page: Page, input: infer Input, use: Use) => Promise<unknown>;
+} ? Input : never;
+type ResultOf<D extends AnyProvision> = D extends {
+    create: (page: Page, input: never, use: Use) => Promise<infer Result>;
+} ? Result : never;
+declare function createProvision<Name extends string, Input, Result>(name: Name, create: (page: Page, input: Input, use: Use) => Promise<Result>, dispose?: (page: Page, result: Result) => Promise<void>): Provision<Name, Input, Result>;
+declare function createPersistentProvision<Name extends string, Input, Result>(name: Name, schema: z.ZodType<Result>, create: (page: Page, input: Input, use: Use) => Promise<Result>, dispose?: (page: Page, result: Result) => Promise<void>): Provision<Name, Input, Result>;
+type ProvisionMap<Defs extends readonly AnyProvision[]> = {
+    [D in Defs[number] as D["name"]]: (...input: ProvisionArgs<InputOf<D>>) => Promise<ResultOf<D>>;
+};
+interface Provisioner<Defs extends readonly AnyProvision[]> extends AsyncDisposable {
+    provision: ProvisionMap<Defs>;
+}
+declare function createProvisioner<Defs extends readonly AnyProvision[]>(page: Page, provisions: Defs): Provisioner<Defs>;
+type ProvisionArgs<Input> = undefined extends Input ? [input?: Input] : [input: Input];
+
+export { type AnyProvision, type InputOf, type Provision, type ProvisionMap, type Provisioner, type ResultOf, type Use, createPersistentProvision, createProvision, createProvisioner };

package/build/provisioner.js

@@ -0,0 +1,14 @@
+import {
+  createPersistentProvision,
+  createProvision,
+  createProvisioner
+} from "./chunk-KQN5IYN6.js";
+import "./chunk-KTXNERHT.js";
+import "./chunk-BODO6HIH.js";
+import "./chunk-UAWBPTDW.js";
+export {
+  createPersistentProvision,
+  createProvision,
+  createProvisioner
+};
+//# sourceMappingURL=provisioner.js.map

package/build/provisioner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/recorder.d.ts

@@ -0,0 +1,6 @@
+import '@playwright/test';
+import './descriptor.js';
+import './locator.js';
+export { e as OverlayDialog, f as PageFactory, g as PageOrFactory, h as RecordedApp, i as RecordedShots, j as Recorder, k as RecorderFixtures, l as ShotOptions, m as ShotRecord, V as VisitablePage, n as createRecorderFixtures, o as describeError, r as runDirVariable, s as shotsAttachment } from './pom-kcSMxwX2.js';
+import 'zod';
+import './provisioner.js';

package/build/recorder.js

@@ -0,0 +1,15 @@
+import {
+  createRecorderFixtures,
+  describeError,
+  runDirVariable,
+  shotsAttachment
+} from "./chunk-5CHKYNP7.js";
+import "./chunk-FJI2CMCE.js";
+import "./chunk-UAWBPTDW.js";
+export {
+  createRecorderFixtures,
+  describeError,
+  runDirVariable,
+  shotsAttachment
+};
+//# sourceMappingURL=recorder.js.map

package/build/recorder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/reporter.d.ts

@@ -0,0 +1,16 @@
+import { Reporter, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+
+interface ReporterOptions {
+    appUrl: string;
+    reportsDir?: string;
+}
+declare class WalkwrightReporter implements Reporter {
+    #private;
+    constructor(options: ReporterOptions);
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(result: FullResult): Promise<{
+        status: FullResult["status"];
+    } | undefined>;
+}
+
+export { type ReporterOptions, WalkwrightReporter as default };