walkwright 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hasan Ayan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,276 @@
+# walkwright
+
+The app-agnostic half of the walk: the recorder, the reporter that describes and
+uploads a run, the provisioner mechanism, the account cache and the `walkwright`
+command. Nothing in here knows about any particular app — the app supplies its
+own config, tests and resources through the seams below.
+
+## The walk
+
+A walk is Playwright: spec files under a `walk` project, and this package's
+reporter. `walkwright walk` is a thin wrapper around `playwright test` — there is no
+separate runner.
+
+```sh
+walkwright walk
+walkwright walk --workers 4 --headed
+walkwright walk --upload-on-fail
+walkwright walk --no-upload
+walkwright walk --branch main
+playwright test --project=walk    # the same lanes as a smoke run: no shots
+```
+
+| Flag                | Meaning                                               |
+| ------------------- | ----------------------------------------------------- |
+| `--upload-on-fail`  | upload the passing lanes' shots even though it failed |
+| `--no-upload`       | skip the upload entirely                              |
+| `--branch <name>`   | report under this branch instead of git's             |
+| `--project <name>`  | the Playwright project to run (default `walk`)        |
+| `--version`         | the banner                                            |
+| `--help`, `-h`, `?` | keys and flags                                        |
+| everything else     | forwarded to `playwright test` verbatim               |
+
+```ts
+// playwright.config.ts
+import { walk } from "walkwright/config";
+
+reporter: [["list"], ...walk.reporter({ appUrl })],
+
+projects: [{ name: "walk", use: { ...use, ...walk.use } }],
+```
+
+The helper reads `WALK_RECORDING` — set by `walkwright walk`, unset for a plain
+`playwright test` — and does the wiring above either way: on, it returns the
+reporter and `recording: true`; off, an empty reporter list and
+`recording: false`, so the same lanes double as smoke tests in an ordinary
+`playwright test` run with no shots taken. `walk.recording` is the boolean on
+its own, for anything else that needs to branch on it.
+
+The reporter names the run's directory — `.walkwright/reports/run-<timestamp>` —
+before the first worker is spawned, and hands it to them in `WALKWRIGHT_RUN_DIR`.
+Every recording test shoots into that one directory.
+
+A run always writes its directory and `manifest.json` locally, failed or not.
+A failed run uploads nothing unless `--upload-on-fail` — with the override,
+only the passing lanes' shots go up; the failing ones never made it into the
+manifest. `--no-upload` skips the upload outright, pass or fail.
+
+| Option       | Meaning                                                       |
+| ------------ | ------------------------------------------------------------- |
+| `appUrl`     | the app the run walked, as the report viewer names it         |
+| `reportsDir` | where run directories are made (default `.walkwright/reports`) |
+
+See `docs/run-manifest.md` for the manifest's shape.
+
+What the CLI sets for the child process:
+
+| Variable                   | Set by             | Meaning                                   |
+| -------------------------- | ------------------ | ----------------------------------------- |
+| `WALK_RECORDING`           | `walkwright walk`   | on for every run through the bin          |
+| `WALKWRIGHT_UPLOAD_ON_FAIL` | `--upload-on-fail` | upload a failed run's passing shots       |
+| `WALKWRIGHT_NO_UPLOAD`      | `--no-upload`      | skip the upload                           |
+| `WALKWRIGHT_BRANCH`         | `--branch <name>`  | report under this branch instead of git's |
+| `WALKWRIGHT_RUN_DIR`        | the reporter       | internal — hands each worker its run dir  |
+| `WALKWRIGHT_THEME`          | you                | `light` or `dark`; otherwise `COLORFGBG`  |
+
+Invoking Playwright directly instead of through `walkwright walk`, set the first four
+yourself; `WALKWRIGHT_RUN_DIR` is the reporter's business.
+
+## Recording
+
+`walkwright/recorder` is a pair of Playwright fixtures the app extends its own
+`test` with:
+
+```ts
+import type { RecorderFixtures } from "walkwright/recorder";
+import { createRecorderFixtures } from "walkwright/recorder";
+
+const walkTest = test.extend<RecorderFixtures>(createRecorderFixtures(app));
+
+walkTest("items", async ({ page, record, runDir }) => {
+  await record(itemsPage, {}, "empty");
+});
+```
+
+`record` shoots into `runDir` and hands the reporter what it shot when the test
+passes — when `recording` is on; off, `runDir` is empty and nothing is shot. A shot recorded with a page object is named after it; anything else is
+attributed by the URL, matched against the pages `definePage` registered, and
+`ShotOptions` (`category`, `page`, `state`) overrides any part of that.
+
+`runDir` is also where a test writes artifacts that belong beside its shots.
+
+## Logging in
+
+`walkwright login [--force] [--url <server>]` sets a project's upload token up on its
+own — the same device-authorization login and implicit project creation the
+reporter's first upload needs. It writes `.walkwright/config.json`; without one,
+a green run writes its manifest and skips the upload. `--url` picks the reports
+server (default `https://app.walkwright.dev`) and is written into the config
+next to the project id and token, so the reporter uploads to the same server
+the login happened on. `--force --url` repoints a project.
+
+`WALKWRIGHT_BRANCH` names the branch a run is reported under when git cannot
+(a detached CI checkout).
+
+## Files
+
+Everything walkwright writes into a project lives under one folder:
+
+```
+.walkwright/
+  config.json          walkwright login — project id, token, server; commit it
+  reports/run-<ts>/    the reporter — shots and manifest.json
+  store/worker-<n>/    walkwright/store — worker-scoped caches
+  store/shared/        walkwright/store — project-scoped caches
+  .gitignore           written by walkwright — ignores all but config.json
+```
+
+The project is the package the walk runs from: the nearest ancestor of the
+cwd with a `package.json` (or an existing `.walkwright/`), never the git
+toplevel — in a monorepo the e2e package is its own project. The folder's
+`.gitignore` keeps everything but the config out of git, and is itself ignored,
+so nothing under `.walkwright/` but the config ever shows up in a status.
+walkwright only writes that file when it is missing: a project that must not
+commit its token (a public repo) keeps a local `*`-only one.
+
+## Stores
+
+`walkwright/store` keeps a JSON value across runs so the app never touches the
+file system itself:
+
+```ts
+import { createStore } from "walkwright/store";
+
+const accounts = createStore("account", { schema: accountSchema });
+
+const account = accounts.read() ?? (await signUp());
+accounts.persist(account);
+```
+
+| Option   | Meaning                                                                                     |
+| -------- | ------------------------------------------------------------------------------------------- |
+| `scope`  | `worker` (default) — one file per parallel worker; `project` — one file for all             |
+| `schema` | a zod schema: `read` decodes through it and ignores a file that does not, `persist` encodes |
+
+A worker-scoped store lives under `store/worker-<n>/`, keyed by Playwright's
+`TEST_PARALLEL_INDEX`; a project-scoped one under `store/shared/`. Writes go
+through a temporary file and a rename, so a killed worker never leaves half a
+file, and a project-scoped store that several workers save at once ends up with
+whichever finished last, intact. A file that is missing, not JSON or fails its
+schema reads as `undefined` and is reported, never thrown: the caller makes a
+fresh value instead. `clear` removes the file; `path` is where it lives.
+
+`walkwright/storage-state` is the same for a browser session:
+
+```ts
+import {
+  createStorageStateStore,
+  storageStateOf,
+} from "walkwright/storage-state";
+
+const session = createStorageStateStore("session");
+const services = createStorageStateStore("services", { scope: "project" });
+const github = createStorageStateStore("github", {
+  scope: "project",
+  cookies: (cookie) => cookie.domain.endsWith("github.com"),
+});
+
+test.extend({ storageState: storageStateOf(session, services) });
+
+await session.save(page.context());
+await github.restore(page.context());
+```
+
+`save` writes the context's storage state; with a `cookies` filter it keeps the
+matching cookies only and no origins. `restore` adds the saved cookies to a
+context that already exists, for a session picked up part-way through a test.
+`storageStateOf` is for Playwright's `storageState` option: the path of the
+first store that has a file, or `emptyStorageState` when none does.
+
+## Modules
+
+| Import                    | Role                                                       |
+| ------------------------- | ---------------------------------------------------------- |
+| `walkwright/reporter`      | the run directory, `manifest.json`, the upload             |
+| `walkwright/recorder`      | the recorder, and the fixtures that bind it to a test      |
+| `walkwright/pom`           | `definePage`: page objects, dialogs, fragments             |
+| `walkwright/browser`       | `hideStyle`: an init script hiding chrome that would move  |
+| `walkwright/provisioner`   | resources created through the app, disposed in reverse     |
+| `walkwright/store`         | a JSON value cached across runs, per worker or per project |
+| `walkwright/storage-state` | a browser session cached across runs, for `storageState`   |
+
+## Page objects
+
+`walkwright/pom` has one grammar for every definer:
+
+```ts
+defineX(definition).withActions(map); // a literal
+defineX((...params) => definition).withActions(map); // a builder, params-first
+```
+
+| Definer           | Definition                                            | Instance                                       |
+| ----------------- | ----------------------------------------------------- | ---------------------------------------------- |
+| `defineComponent` | `{ root?, elements? }` — `root` present: rooted       | `{ root?, ...elements, ...actions }`           |
+| `defineDialog`    | `{ name, role?, trigger?, dismiss?, elements? }`      | `{ root, open, close, waitFor, ... }`          |
+| `definePage`      | `{ path, name, header?, fragments?, elements?, ... }` | `{ goto, url, waitFor, elements, ...actions }` |
+| `defineLayout`    | `{ path, group?, chrome?, parent? }` — literal only   | shared by its pages                            |
+
+Element entries take the context first, own params after; the annotation is
+inferred:
+
+| Entry                                           | Instantiates to                    |
+| ----------------------------------------------- | ---------------------------------- |
+| `back: link("Back")`                            | a value — a leaf, called           |
+| `deployment: link`                              | a method — a leaf, mounted bare    |
+| `email: ({ scope }) => scope.getByLabel(...)`   | a value — ≤ 1 parameter            |
+| `member: ({ scope }, email: string) => ...`     | a method — ≥ 2 parameters          |
+| `first(): Locator { return this.rows.first() }` | a value — `this` is the siblings   |
+| `row: defineComponent((name) => ...)`           | a method — a builder, mounted bare |
+
+The builder form comes back branded (`parameterized: true`): mounted under a
+key it is a method, `elements.row("a")`, and its params reach the actions
+context as `params`. `parameterized()` brands hand-written leaves the same
+way; nothing else needs it.
+
+`defineComponent`, `defineOverlay`, `defineDialog`, `definePage`, page
+presets and `defineApp` all take a `capture: { rules }` option — declarative
+rules that rewrite dynamic text (counters, relative times, ids, user names)
+in the live DOM right before a screenshot and restore it right after, so
+walks stay stable. See `docs/descriptor-schema.md#capture-rules`.
+
+Actions (`withActions`) receive the context — `scope`, `page`, `elements`,
+plus `root` for rooted components and dialogs, `params` for builders — then
+their own params, and see sibling actions as `this`. Actions never mint
+locators: locating is for `elements` and `root`. A page's actions orchestrate
+its elements, including those its fragments spread in; a fragment's actions
+are for callers.
+
+Every `withActions` member and every top-level factory names its return type
+(`explicit-function-return-type`); nothing else needs an annotation — a
+`ReturnType<typeof page>` alias, or an explicit interface for a page that
+navigates in a cycle with another, is the exception.
+
+## Seams
+
+| Seam                                       | The app supplies                                                  |
+| ------------------------------------------ | ----------------------------------------------------------------- |
+| the `walk` project                         | the walks themselves, and the session they run as                 |
+| `["walkwright/reporter", { appUrl }]`       | the app the report is of                                          |
+| `test.extend(createRecorderFixtures(app))` | the test the recorder shoots through, and the page inventory      |
+| `definePage({ afterGoto })`                | the readiness a page object's `goto` waits out                    |
+| `createProvisioner(page, kinds)`           | the resource kinds, how each is made, and how it is disposed      |
+| `createStore(name, { scope, schema })`     | the value cached across runs, its shape, and how far it is shared |
+
+## Building
+
+Consumed as a built package — the reporter and the `walkwright` bin both run under
+plain `node`, which resolves `walkwright` through `node_modules` to `build/`.
+The bin is `bin/walkwright.js`, a checked-in launcher for `build/cli.js`, so it links
+whether or not the package has been built yet. After changing anything here:
+
+```sh
+pnpm build
+```
+
+Consumers install it from the filesystem (`"walkwright": "link:…/packages/sdk"`)
+and build it before they run, so a fresh build is automatic.

package/bin/walkwright.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+// the bin is checked in so it can be linked before the package is built
+import "../build/cli.js";

package/build/aria.d.ts

@@ -0,0 +1,92 @@
+import { O as Overlay, C as Component, S as Surface, a as SurfaceInstance, R as Rooted, b as OverlayFactory, c as RootedComponent, P as Parameterized, I as Instantiated, d as OverlayHandle } from './pom-kcSMxwX2.js';
+import { Locator, Page } from '@playwright/test';
+import { LazyLocator, Mount } from './locator.js';
+import './descriptor.js';
+import 'zod';
+import './provisioner.js';
+
+interface Menu<Action extends string> extends Overlay<{
+    item: (action: Action) => Locator;
+}> {
+    choose: (action: Action) => Promise<void>;
+}
+interface MenuFactory {
+    <Action extends string>(name: string | RegExp, options?: {
+        label?: string;
+    }): OverlayFactory<Menu<Action>>;
+    parameterized: true;
+}
+declare const menu: MenuFactory;
+interface TabsElements<N extends string> {
+    names: () => readonly N[];
+    tab: (n: N) => LazyLocator;
+    tabPanel: (n: N) => LazyLocator;
+    select: (n: N) => (scope: Mount) => Promise<void>;
+}
+declare const tabs: <const N extends string>(names: readonly N[]) => TabsElements<N>;
+type RadioGroup<Option extends string> = RootedComponent<{
+    radio: (option: Option) => Locator;
+}, {
+    select: (option: Option) => Promise<void>;
+}>;
+interface RadioGroupFactory {
+    <Option extends string>(name: string): Surface<RadioGroup<Option>>;
+    parameterized: true;
+}
+declare const radioGroup: RadioGroupFactory;
+type ComboboxOptions<Value extends string> = Overlay<{
+    option: (value: Value) => Locator;
+}>;
+type SelectCombobox<Value extends string> = RootedComponent<{
+    options: ComboboxOptions<Value>;
+}, {
+    ensureSelected: (value: Value) => Promise<void>;
+}>;
+type SelectComboboxFactory = <Value extends string>(scope: LazyLocator) => Surface<SelectCombobox<Value>>;
+declare const selectCombobox: SelectComboboxFactory;
+type MultiCombobox<Value extends string> = RootedComponent<{
+    options: ComboboxOptions<Value>;
+    selectedTag: (value: Value) => Locator;
+}, {
+    ensureSelected: (values: readonly Value[], allValues?: readonly Value[]) => Promise<void>;
+}>;
+interface MultiComboboxFactory {
+    <Value extends string>(selectedTag: (value: Value) => LazyLocator): (scope: LazyLocator) => Surface<MultiCombobox<Value>>;
+    parameterized: true;
+}
+declare const multiCombobox: MultiComboboxFactory;
+declare const freeCombobox: Surface<Component<Instantiated<Record<never, never>>, {
+    ensureSelected(values: readonly string[]): Promise<void>;
+}>>;
+type Disclosure<Panel = Locator> = Component<{
+    trigger: Locator;
+    panel: Panel;
+}, {
+    expand: () => Promise<void>;
+    collapse: () => Promise<void>;
+}>;
+interface DisclosureFactory {
+    (trigger: LazyLocator, panel: LazyLocator): Surface<Disclosure>;
+    <I extends SurfaceInstance>(trigger: LazyLocator, panel: LazyLocator, contents: Surface<I>): Surface<Disclosure<I & Rooted>>;
+}
+declare const disclosure: DisclosureFactory;
+declare const confirmDelete: Parameterized<[def: {
+    name: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    confirmed?: (page: Page) => Promise<void>;
+}], OverlayFactory<{
+    page: Page;
+    elements: Instantiated<{
+        confirmTextbox: LazyLocator;
+        deleteButton: LazyLocator;
+        cancelButton: LazyLocator;
+    }>;
+    label: string;
+} & Rooted & OverlayHandle & {
+    name: string | RegExp;
+} & {
+    confirm(name: string): Promise<void>;
+}>>;
+
+export { type ComboboxOptions, type Disclosure, type DisclosureFactory, type Menu, type MenuFactory, type MultiCombobox, type MultiComboboxFactory, type RadioGroup, type RadioGroupFactory, type SelectCombobox, type SelectComboboxFactory, type TabsElements, confirmDelete, disclosure, freeCombobox, menu, multiCombobox, radioGroup, selectCombobox, tabs };

package/build/aria.js

@@ -0,0 +1,215 @@
+import {
+  defineComponent,
+  defineDialog,
+  defineOverlay,
+  rootOf
+} from "./chunk-6YRKPGUO.js";
+import "./chunk-KQN5IYN6.js";
+import "./chunk-5CHKYNP7.js";
+import "./chunk-KTXNERHT.js";
+import "./chunk-N4SSLHMP.js";
+import {
+  button,
+  listbox,
+  menu,
+  menuitem,
+  option,
+  radio,
+  radiogroup,
+  resolveLocator,
+  tab,
+  tabpanel,
+  textbox
+} from "./chunk-FJI2CMCE.js";
+import "./chunk-BODO6HIH.js";
+import "./chunk-UAWBPTDW.js";
+
+// src/aria.ts
+function labelOf(name, label) {
+  if (label !== void 0) {
+    return label;
+  }
+  if (typeof name === "string") {
+    return name;
+  }
+  throw new Error(
+    `the ${name.source} menu needs a label: its name is a pattern`
+  );
+}
+var menu2 = defineOverlay(
+  (name, options) => ({
+    root: menu(name),
+    recorder: { label: labelOf(name, options?.label) },
+    elements: {
+      item: (action) => menuitem(action)
+    },
+    actions: {
+      async choose(action) {
+        await this.open();
+        await this.elements.item(action).click();
+        await this.waitFor("hidden");
+      }
+    }
+  })
+);
+async function selectTab(tab2) {
+  if (await tab2.getAttribute("aria-selected") !== "true") {
+    await tab2.click();
+  }
+}
+var tabs = (names) => ({
+  names: () => names,
+  tab: (n) => tab(n),
+  tabPanel: (n) => tabpanel(n),
+  select: (n) => async (scope) => {
+    await selectTab(resolveLocator(scope, tab(n).chain));
+    await resolveLocator(scope, tabpanel(n).chain).waitFor();
+  }
+});
+var radioGroup = defineComponent((name) => ({
+  root: radiogroup(name),
+  elements: {
+    radio: (option2) => radio(option2)
+  },
+  actions: {
+    async select(option2) {
+      await this.elements.radio(option2).check();
+    }
+  }
+}));
+var comboboxOptions = defineOverlay({
+  root: listbox(),
+  recorder: { label: "Options" },
+  elements: {
+    option: (name) => option(name)
+  }
+});
+var selectCombobox = defineComponent({
+  elements: {
+    options: comboboxOptions
+  },
+  actions: {
+    async ensureSelected(value) {
+      await rootOf(this).click();
+      await this.elements.options.elements.option(value).click();
+    }
+  }
+});
+var multiCombobox = defineComponent(
+  (selectedTag) => ({
+    elements: {
+      options: comboboxOptions,
+      selectedTag
+    },
+    actions: {
+      async ensureSelected(values, allValues = []) {
+        const root = rootOf(this);
+        const { options, selectedTag: selectedTag2 } = this.elements;
+        await root.click();
+        for (const value of values) {
+          const option2 = options.elements.option(value);
+          if (await option2.getAttribute("aria-selected") !== "true") {
+            await option2.click();
+          }
+        }
+        await root.press("Escape");
+        for (const value of values) {
+          await selectedTag2(value).waitFor();
+        }
+        for (const value of allValues.filter((it) => !values.includes(it))) {
+          const tag = selectedTag2(value);
+          if (!await tag.isVisible()) {
+            continue;
+          }
+          await root.click();
+          await options.elements.option(value).click();
+          await root.press("Escape");
+          await tag.waitFor({ state: "hidden" });
+        }
+      }
+    }
+  })
+);
+var freeCombobox = defineComponent({
+  actions: {
+    async ensureSelected(values) {
+      const root = rootOf(this);
+      for (const value of values) {
+        await root.fill(value);
+        await root.press("Enter");
+      }
+      await root.press("Escape");
+    }
+  }
+});
+var disclosure = ((trigger, panel, contents) => {
+  const within = panel.within(trigger);
+  return defineComponent({
+    elements: {
+      trigger,
+      panel: contents === void 0 ? within : contents(within)
+    },
+    actions: {
+      async expand() {
+        const { trigger: trigger2 } = this.elements;
+        const expanded = trigger2.and(
+          this.page.locator('[aria-expanded="true"]')
+        );
+        const collapsed = trigger2.and(
+          this.page.locator('[aria-expanded="false"]')
+        );
+        await expanded.or(collapsed).waitFor();
+        if (await expanded.count() > 0) {
+          return;
+        }
+        await trigger2.click();
+        await expanded.waitFor();
+      },
+      async collapse() {
+        const { trigger: trigger2 } = this.elements;
+        const expanded = trigger2.and(
+          this.page.locator('[aria-expanded="true"]')
+        );
+        const collapsed = trigger2.and(
+          this.page.locator('[aria-expanded="false"]')
+        );
+        await expanded.or(collapsed).waitFor();
+        if (await collapsed.count() > 0) {
+          return;
+        }
+        await trigger2.click();
+        await collapsed.waitFor();
+      }
+    }
+  });
+});
+var confirmDelete = defineDialog(
+  (def) => ({
+    name: def.name,
+    close: { button: button(def.cancelLabel) },
+    elements: {
+      confirmTextbox: textbox(def.confirmLabel),
+      deleteButton: button(def.name),
+      cancelButton: button(def.cancelLabel)
+    },
+    actions: {
+      async confirm(name) {
+        await this.elements.confirmTextbox.fill(name);
+        await this.elements.deleteButton.click();
+        await this.root.waitFor({ state: "hidden", timeout: 15e3 });
+        await def.confirmed?.(this.page);
+      }
+    }
+  })
+);
+export {
+  confirmDelete,
+  disclosure,
+  freeCombobox,
+  menu2 as menu,
+  multiCombobox,
+  radioGroup,
+  selectCombobox,
+  tabs
+};
+//# sourceMappingURL=aria.js.map

package/build/aria.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/aria.ts"],"sourcesContent":["import type { Locator, Page } from \"@playwright/test\";\n\nimport type { LazyLocator, Mount } from \"./locator.js\";\nimport {\n  button,\n  listbox,\n  menu as menuRole,\n  menuitem,\n  option as optionLeaf,\n  radio as radioLeaf,\n  radiogroup,\n  resolveLocator,\n  tab as tabLeaf,\n  tabpanel as tabpanelLeaf,\n  textbox,\n} from \"./locator.js\";\nimport type {\n  AnySurface,\n  Component,\n  Overlay,\n  OverlayFactory,\n  Rooted,\n  RootedComponent,\n  Surface,\n  SurfaceInstance,\n} from \"./pom.js\";\nimport { defineComponent, defineDialog, defineOverlay, rootOf } from \"./pom.js\";\n\nexport interface Menu<Action extends string> extends Overlay<{\n  item: (action: Action) => Locator;\n}> {\n  choose: (action: Action) => Promise<void>;\n}\n\nexport interface MenuFactory {\n  <Action extends string>(\n    name: string | RegExp,\n    options?: { label?: string },\n  ): OverlayFactory<Menu<Action>>;\n  parameterized: true;\n}\n\nfunction labelOf(name: string | RegExp, label: string | undefined): string {\n  if (label !== undefined) {\n    return label;\n  }\n\n  if (typeof name === \"string\") {\n    return name;\n  }\n\n  throw new Error(\n    `the ${name.source} menu needs a label: its name is a pattern`,\n  );\n}\n\nexport const menu = defineOverlay(\n  (name: string | RegExp, options?: { label?: string }) => ({\n    root: menuRole(name),\n    recorder: { label: labelOf(name, options?.label) },\n    elements: {\n      item: (action: string): LazyLocator => menuitem(action),\n    },\n    actions: {\n      async choose(action: string): Promise<void> {\n        await this.open();\n        await this.elements.item(action).click();\n        await this.waitFor(\"hidden\");\n      },\n    },\n  }),\n) as unknown as MenuFactory;\n\nasync function selectTab(tab: Locator): Promise<void> {\n  if ((await tab.getAttribute(\"aria-selected\")) !== \"true\") {\n    await tab.click();\n  }\n}\n\nexport interface TabsElements<N extends string> {\n  names: () => readonly N[];\n  tab: (n: N) => LazyLocator;\n  tabPanel: (n: N) => LazyLocator;\n  select: (n: N) => (scope: Mount) => Promise<void>;\n}\n\nexport const tabs = <const N extends string>(\n  names: readonly N[],\n): TabsElements<N> => ({\n  names: (): readonly N[] => names,\n  tab: (n: N): LazyLocator => tabLeaf(n),\n  tabPanel: (n: N): LazyLocator => tabpanelLeaf(n),\n  select:\n    (n: N) =>\n    async (scope: Mount): Promise<void> => {\n      await selectTab(resolveLocator(scope, tabLeaf(n).chain));\n      await resolveLocator(scope, tabpanelLeaf(n).chain).waitFor();\n    },\n});\n\nexport type RadioGroup<Option extends string> = RootedComponent<\n  { radio: (option: Option) => Locator },\n  { select: (option: Option) => Promise<void> }\n>;\n\nexport interface RadioGroupFactory {\n  <Option extends string>(name: string): Surface<RadioGroup<Option>>;\n  parameterized: true;\n}\n\nexport const radioGroup = defineComponent((name: string) => ({\n  root: radiogroup(name),\n  elements: {\n    radio: (option: string): LazyLocator => radioLeaf(option),\n  },\n  actions: {\n    async select(option: string): Promise<void> {\n      await this.elements.radio(option).check();\n    },\n  },\n})) as unknown as RadioGroupFactory;\n\nconst comboboxOptions = defineOverlay({\n  root: listbox(),\n  recorder: { label: \"Options\" },\n  elements: {\n    option: (name: string): LazyLocator => optionLeaf(name),\n  },\n});\n\nexport type ComboboxOptions<Value extends string> = Overlay<{\n  option: (value: Value) => Locator;\n}>;\n\nexport type SelectCombobox<Value extends string> = RootedComponent<\n  { options: ComboboxOptions<Value> },\n  { ensureSelected: (value: Value) => Promise<void> }\n>;\n\nexport type SelectComboboxFactory = <Value extends string>(\n  scope: LazyLocator,\n) => Surface<SelectCombobox<Value>>;\n\nexport const selectCombobox = defineComponent({\n  elements: {\n    options: comboboxOptions,\n  },\n  actions: {\n    async ensureSelected(value: string): Promise<void> {\n      await rootOf(this).click();\n      await this.elements.options.elements.option(value).click();\n    },\n  },\n}) as unknown as SelectComboboxFactory;\n\nexport type MultiCombobox<Value extends string> = RootedComponent<\n  {\n    options: ComboboxOptions<Value>;\n    selectedTag: (value: Value) => Locator;\n  },\n  {\n    ensureSelected: (\n      values: readonly Value[],\n      allValues?: readonly Value[],\n    ) => Promise<void>;\n  }\n>;\n\nexport interface MultiComboboxFactory {\n  <Value extends string>(\n    selectedTag: (value: Value) => LazyLocator,\n  ): (scope: LazyLocator) => Surface<MultiCombobox<Value>>;\n  parameterized: true;\n}\n\nexport const multiCombobox = defineComponent(\n  (selectedTag: (value: string) => LazyLocator) => ({\n    elements: {\n      options: comboboxOptions,\n      selectedTag,\n    },\n    actions: {\n      async ensureSelected(\n        values: readonly string[],\n        allValues: readonly string[] = [],\n      ): Promise<void> {\n        const root = rootOf(this);\n        const { options, selectedTag } = this.elements;\n\n        await root.click();\n\n        for (const value of values) {\n          const option = options.elements.option(value);\n          if ((await option.getAttribute(\"aria-selected\")) !== \"true\") {\n            await option.click();\n          }\n        }\n\n        await root.press(\"Escape\");\n\n        for (const value of values) {\n          await selectedTag(value).waitFor();\n        }\n\n        for (const value of allValues.filter((it) => !values.includes(it))) {\n          const tag = selectedTag(value);\n          if (!(await tag.isVisible())) {\n            continue;\n          }\n\n          await root.click();\n          await options.elements.option(value).click();\n          await root.press(\"Escape\");\n          await tag.waitFor({ state: \"hidden\" });\n        }\n      },\n    },\n  }),\n) as unknown as MultiComboboxFactory;\n\nexport const freeCombobox = defineComponent({\n  actions: {\n    async ensureSelected(values: readonly string[]): Promise<void> {\n      const root = rootOf(this);\n\n      for (const value of values) {\n        await root.fill(value);\n        await root.press(\"Enter\");\n      }\n\n      await root.press(\"Escape\");\n    },\n  },\n});\n\nexport type Disclosure<Panel = Locator> = Component<\n  { trigger: Locator; panel: Panel },\n  { expand: () => Promise<void>; collapse: () => Promise<void> }\n>;\n\nexport interface DisclosureFactory {\n  (trigger: LazyLocator, panel: LazyLocator): Surface<Disclosure>;\n  <I extends SurfaceInstance>(\n    trigger: LazyLocator,\n    panel: LazyLocator,\n    contents: Surface<I>,\n  ): Surface<Disclosure<I & Rooted>>;\n}\n\nexport const disclosure = ((\n  trigger: LazyLocator,\n  panel: LazyLocator,\n  contents?: AnySurface,\n): AnySurface => {\n  const within = panel.within(trigger);\n\n  return defineComponent({\n    elements: {\n      trigger,\n      panel: contents === undefined ? within : contents(within),\n    },\n    actions: {\n      async expand(): Promise<void> {\n        const { trigger } = this.elements;\n        const expanded = trigger.and(\n          this.page.locator('[aria-expanded=\"true\"]'),\n        );\n        const collapsed = trigger.and(\n          this.page.locator('[aria-expanded=\"false\"]'),\n        );\n\n        await expanded.or(collapsed).waitFor();\n\n        if ((await expanded.count()) > 0) {\n          return;\n        }\n\n        await trigger.click();\n        await expanded.waitFor();\n      },\n      async collapse(): Promise<void> {\n        const { trigger } = this.elements;\n        const expanded = trigger.and(\n          this.page.locator('[aria-expanded=\"true\"]'),\n        );\n        const collapsed = trigger.and(\n          this.page.locator('[aria-expanded=\"false\"]'),\n        );\n\n        await expanded.or(collapsed).waitFor();\n\n        if ((await collapsed.count()) > 0) {\n          return;\n        }\n\n        await trigger.click();\n        await collapsed.waitFor();\n      },\n    },\n  });\n}) as unknown as DisclosureFactory;\n\nexport const confirmDelete = defineDialog(\n  (def: {\n    name: string;\n    confirmLabel: string;\n    cancelLabel: string;\n    confirmed?: (page: Page) => Promise<void>;\n  }) => ({\n    name: def.name,\n    close: { button: button(def.cancelLabel) },\n    elements: {\n      confirmTextbox: textbox(def.confirmLabel),\n      deleteButton: button(def.name),\n      cancelButton: button(def.cancelLabel),\n    },\n    actions: {\n      async confirm(name: string): Promise<void> {\n        await this.elements.confirmTextbox.fill(name);\n        await this.elements.deleteButton.click();\n        await this.root.waitFor({ state: \"hidden\", timeout: 15_000 });\n        await def.confirmed?.(this.page);\n      },\n    },\n  }),\n);\n"],"mappings":"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","names":["menu","tab","option","selectedTag","trigger"]}

package/build/browser.d.ts

@@ -0,0 +1,3 @@
+declare function hideStyle(selectors: string[]): string | undefined;
+
+export { hideStyle };

package/build/browser.js

@@ -0,0 +1,18 @@
+import "./chunk-UAWBPTDW.js";
+
+// src/browser.ts
+function hideStyle(selectors) {
+  if (selectors.length === 0) {
+    return void 0;
+  }
+  const css = selectors.map((selector) => `${selector}{display:none;}`).join("");
+  return `document.addEventListener("DOMContentLoaded", () => {
+  const style = document.createElement("style");
+  style.textContent = ${JSON.stringify(css)};
+  document.head.append(style);
+});`;
+}
+export {
+  hideStyle
+};
+//# sourceMappingURL=browser.js.map

package/build/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/browser.ts"],"sourcesContent":["export function hideStyle(selectors: string[]): string | undefined {\n  if (selectors.length === 0) {\n    return undefined;\n  }\n\n  const css = selectors\n    .map((selector) => `${selector}{display:none;}`)\n    .join(\"\");\n\n  return `document.addEventListener(\"DOMContentLoaded\", () => {\n  const style = document.createElement(\"style\");\n  style.textContent = ${JSON.stringify(css)};\n  document.head.append(style);\n});`;\n}\n"],"mappings":";;;AAAO,SAAS,UAAU,WAAyC;AACjE,MAAI,UAAU,WAAW,GAAG;AAC1B,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,UACT,IAAI,CAAC,aAAa,GAAG,QAAQ,iBAAiB,EAC9C,KAAK,EAAE;AAEV,SAAO;AAAA;AAAA,wBAEe,KAAK,UAAU,GAAG,CAAC;AAAA;AAAA;AAG3C;","names":[]}