@enekesabel/playwright-lite 0.3.0 → 0.5.0

package/THIRD_PARTY_NOTICES.txt

@@ -2,10 +2,14 @@ playwright-lite is MIT licensed. Included third-party code retains its own licen
 
 Playwright
 Copyright Microsoft Corporation and contributors.
-The browser injected and utility scripts, protocol serializers, copied upstream tests, keyboard layout, and other identified Playwright-derived code are distributed under Apache License 2.0.
+The browser injected and utility scripts, protocol serializers, copied upstream tests, keyboard layout, public expect wrapper, and other identified Playwright-derived code are distributed under Apache License 2.0.
 The pinned upstream revision is recorded in tests/upstream/corpus.ts. The injected script is generated with the upstream build tool, then bundled with a browser-side Page and Locator implementation. The keyboard layout retains its original data with local typing helpers. Copied upstream test specifications are unchanged.
 See LICENSES/PLAYWRIGHT-LICENSE.txt and the accompanying upstream notices in LICENSES.
 
+Jest expect components and their dependencies
+Copyright Meta Platforms, Inc. and affiliates, the Jest project contributors, and the respective dependency authors.
+The generic matcher library is based on Playwright's pinned Jest-derived expect sources. Its bundled browser dependencies retain their MIT licenses. See LICENSES/JEST-EXPECT-BUNDLE-LICENSES.txt.
+
 YAML
 Copyright 2018, 2019, 2020 Eemeli Aro and contributors.
 Bundled under the ISC license. See LICENSES/YAML-LICENSE.txt.

package/dist/index.d.mts

@@ -1,7 +1,248 @@
-import { Page, PlaywrightTestOptions } from "@playwright/test";
+import { ConsoleMessage, Locator, Page, PlaywrightTestOptions } from "@playwright/test";
+//#region src/expect.d.ts
+interface AsymmetricMatcher {
+  asymmetricMatch(other: unknown): boolean;
+}
+interface AsymmetricMatchers {
+  any(expectedObject: unknown): AsymmetricMatcher;
+  anything(): AsymmetricMatcher;
+  arrayContaining(sample: unknown[]): AsymmetricMatcher;
+  arrayOf(sample: unknown): AsymmetricMatcher;
+  closeTo(expected: number, precision?: number): AsymmetricMatcher;
+  objectContaining(sample: Record<string, unknown>): AsymmetricMatcher;
+  stringContaining(expected: string): AsymmetricMatcher;
+  stringMatching(expected: string | RegExp): AsymmetricMatcher;
+}
+interface GenericAssertions<R> {
+  toBe(expected: unknown): R;
+  toBeCloseTo(expected: number, precision?: number): R;
+  toBeDefined(): R;
+  toBeFalsy(): R;
+  toBeGreaterThan(expected: number | bigint): R;
+  toBeGreaterThanOrEqual(expected: number | bigint): R;
+  toBeInstanceOf(expected: Function): R;
+  toBeLessThan(expected: number | bigint): R;
+  toBeLessThanOrEqual(expected: number | bigint): R;
+  toBeNaN(): R;
+  toBeNull(): R;
+  toBeTruthy(): R;
+  toBeUndefined(): R;
+  toContain(expected: unknown): R;
+  toContainEqual(expected: unknown): R;
+  toEqual(expected: unknown): R;
+  toHaveLength(expected: number): R;
+  toHaveProperty(path: string | string[], value?: unknown): R;
+  toMatch(expected: string | RegExp): R;
+  toMatchObject(expected: Record<string, unknown> | unknown[]): R;
+  toStrictEqual(expected: unknown): R;
+  toThrow(expected?: unknown): R;
+  toThrowError(expected?: unknown): R;
+}
+type LocatorAssertionOptions = {
+  signal?: AbortSignal;
+  timeout?: number;
+};
+type TextAssertionOptions = LocatorAssertionOptions & {
+  ignoreCase?: boolean;
+};
+type AriaRole = Parameters<Locator["getByRole"]>[0];
+/** The browser-safe subset of Playwright's LocatorAssertions. */
+interface LocatorAssertions {
+  toBeAttached(options?: LocatorAssertionOptions & {
+    attached?: boolean;
+  }): Promise<void>;
+  toBeChecked(options?: LocatorAssertionOptions & {
+    checked?: boolean;
+    indeterminate?: boolean;
+  }): Promise<void>;
+  toBeDisabled(options?: LocatorAssertionOptions): Promise<void>;
+  toBeEditable(options?: LocatorAssertionOptions & {
+    editable?: boolean;
+  }): Promise<void>;
+  toBeEmpty(options?: LocatorAssertionOptions): Promise<void>;
+  toBeEnabled(options?: LocatorAssertionOptions & {
+    enabled?: boolean;
+  }): Promise<void>;
+  toBeFocused(options?: LocatorAssertionOptions): Promise<void>;
+  toBeHidden(options?: LocatorAssertionOptions): Promise<void>;
+  toBeInViewport(options?: LocatorAssertionOptions & {
+    ratio?: number;
+  }): Promise<void>;
+  toBeVisible(options?: LocatorAssertionOptions & {
+    visible?: boolean;
+  }): Promise<void>;
+  toContainText(expected: string | RegExp | ReadonlyArray<string | RegExp>, options?: TextAssertionOptions & {
+    useInnerText?: boolean;
+  }): Promise<void>;
+  toContainClass(expected: string | ReadonlyArray<string>, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveAccessibleDescription(expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
+  toHaveAccessibleName(expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
+  toHaveAccessibleErrorMessage(expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
+  toHaveAttribute(name: string, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveAttribute(name: string, expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
+  toHaveClass(expected: string | RegExp | ReadonlyArray<string | RegExp>, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveCount(expected: number, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveCSS(name: string, expected: string | RegExp, options?: LocatorAssertionOptions & {
+    pseudo?: string;
+  }): Promise<void>;
+  toHaveId(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveJSProperty(name: string, expected: unknown, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveRole(expected: AriaRole, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveText(expected: string | RegExp | ReadonlyArray<string | RegExp>, options?: TextAssertionOptions & {
+    useInnerText?: boolean;
+  }): Promise<void>;
+  toHaveValue(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
+  toHaveValues(expected: ReadonlyArray<string | RegExp>, options?: LocatorAssertionOptions): Promise<void>;
+  toMatchAriaSnapshot(expected: string, options?: LocatorAssertionOptions): Promise<void>;
+}
+type PageURLExpected = Parameters<Page["waitForURL"]>[0];
+type PageAssertionOptions = {
+  signal?: AbortSignal;
+  timeout?: number;
+};
+type PageURLAssertionOptions = PageAssertionOptions & {
+  ignoreCase?: boolean;
+};
+interface PageAssertions {
+  toHaveTitle(expected: string | RegExp, options?: PageAssertionOptions & {
+    ignoreCase?: boolean;
+  }): Promise<void>;
+  toHaveURL(expected: PageURLExpected, options?: PageURLAssertionOptions): Promise<void>;
+}
+interface ExpectMatcherUtils {
+  matcherHint(matcherName: string, received?: unknown, expected?: unknown, options?: Record<string, unknown>): string;
+  printDiffOrStringify(expected: unknown, received: unknown, expectedLabel: string, receivedLabel: string, expand: boolean): string;
+  printExpected(value: unknown): string;
+  printReceived(value: unknown): string;
+  printWithType<T>(name: string, value: T, print: (value: T) => string): string;
+  diff(a: unknown, b: unknown): string | null;
+  stringify(value: unknown, maxDepth?: number, maxWidth?: number): string;
+  EXPECTED_COLOR(value: string): string;
+}
+interface ExpectMatcherState {
+  isNot: boolean;
+  promise: "rejects" | "resolves" | "";
+  timeout: number;
+  utils: ExpectMatcherUtils;
+}
+interface MatcherResult {
+  message: () => string;
+  pass: boolean;
+  name?: string;
+  expected?: unknown;
+  actual?: unknown;
+  ariaSnapshot?: string;
+  log?: string[];
+  timeout?: number;
+}
+type ToUserMatcher<F, R> = F extends ((received: any, ...args: infer A) => infer M) ? (...args: A) => M extends PromiseLike<unknown> ? Promise<void> : R : never;
+type UserMatchers<E, R, T> = { [K in keyof E as E[K] extends ((received: T, ...args: any[]) => any) ? K : never]: ToUserMatcher<E[K], R>; };
+type FunctionAssertions = {
+  toPass(options?: {
+    timeout?: number;
+    intervals?: number[];
+  }): Promise<void>;
+};
+type Matchers<R, T, ExtendedMatchers> = {
+  not: Matchers<R, T, ExtendedMatchers>;
+  resolves: Matchers<Promise<void>, Awaited<T>, ExtendedMatchers>;
+  rejects: Matchers<Promise<void>, any, ExtendedMatchers>;
+} & GenericAssertions<R> & (T extends Locator ? LocatorAssertions : Record<never, never>) & (T extends Page ? PageAssertions : Record<never, never>) & (T extends ((...args: never[]) => unknown) ? FunctionAssertions : Record<never, never>) & UserMatchers<T extends Page ? Omit<ExtendedMatchers, keyof PageAssertions> : ExtendedMatchers, R, T>;
+type PollMatchers<T, ExtendedMatchers> = {
+  not: PollMatchers<T, ExtendedMatchers>;
+} & GenericAssertions<Promise<void>> & UserMatchers<ExtendedMatchers, Promise<void>, T>;
+type Expect<ExtendedMatchers = Record<never, never>> = {
+  <T = unknown>(actual: T, messageOrOptions?: string | {
+    message?: string;
+  }): Matchers<void, T, ExtendedMatchers>;
+  poll<T = unknown>(actual: () => T | Promise<T>, messageOrOptions?: string | {
+    message?: string;
+    timeout?: number;
+    intervals?: number[];
+  }): PollMatchers<T, ExtendedMatchers>;
+  extend<MoreMatchers extends Record<string, (this: ExpectMatcherState, received: any, ...args: any[]) => MatcherResult | Promise<MatcherResult>>>(matchers: MoreMatchers): Expect<ExtendedMatchers & MoreMatchers>;
+  configure(configuration: {
+    message?: string;
+    soft?: boolean;
+    timeout?: number;
+  }): Expect<ExtendedMatchers>;
+  getState(): object;
+  not: Omit<AsymmetricMatchers, "any" | "anything">;
+} & AsymmetricMatchers;
+declare const expect: Expect;
+//#endregion
+//#region src/network.d.ts
+interface Request {
+  /** The request URL, with the fragment stripped as the pinned server does. */
+  url(): string;
+  /** `"fetch"` or `"xhr"`: this observation sees only those two, by construction. */
+  resourceType(): string;
+  method(): string;
+  /**
+   * The request headers the caller set: `Request.headers` for a `fetch` call,
+   * `setRequestHeader` for an `XMLHttpRequest`.
+   */
+  headers(): Record<string, string>;
+  /** Reads `headers()`; a page never sees the headers that went on the wire. */
+  headerValue(name: string): Promise<string | null>;
+  postData(): string | null;
+  postDataBuffer(): Uint8Array | null;
+  postDataJSON(): unknown;
+  /** Always `false`: neither a `fetch` nor an XHR navigates the document. */
+  isNavigationRequest(): boolean;
+  failure(): {
+    errorText: string;
+  } | null;
+  /** Resolves with the response, or `null` once the request has failed. */
+  response(): Promise<Response | null>;
+}
+interface Response {
+  /** The final URL after redirects, which never carries a fragment. */
+  url(): string;
+  status(): number;
+  statusText(): string;
+  ok(): boolean;
+  /** The response headers the browser exposes to this document. */
+  headers(): Record<string, string>;
+  headerValue(name: string): Promise<string | null>;
+  body(): Promise<Uint8Array>;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+  /** Resolves once the response body has ended. */
+  finished(): Promise<null>;
+  request(): Request;
+}
+//#endregion
+//#region src/dialog.d.ts
+/** `beforeunload` is out of scope: it belongs to document replacement (ADR-0001). */
+type DialogType = "alert" | "confirm" | "prompt";
+type Settlement = {
+  accepted: boolean;
+  value?: string;
+};
+type SettlementBox = {
+  result?: Settlement;
+};
+/** One `alert`/`confirm`/`prompt` call, built per subscribed page around a settlement its siblings share. */
+declare class Dialog {
+  private readonly _type;
+  private readonly _message;
+  private readonly _defaultValue;
+  private readonly box;
+  private readonly _page;
+  constructor(_type: DialogType, _message: string, _defaultValue: string, box: SettlementBox, _page: () => Page);
+  type(): DialogType;
+  message(): string;
+  defaultValue(): string;
+  page(): Page;
+  accept(promptText?: string): Promise<void>;
+  dismiss(): Promise<void>;
+  private settle;
+}
+//#endregion
 //#region src/index.d.ts
 type CreatePageOptions = Partial<Pick<PlaywrightTestOptions, "testIdAttribute" | "actionTimeout" | "navigationTimeout">>;
 /** Creates a Page for the current browser window. Omitted settings keep the runtime defaults. */
 declare function createPage(options?: CreatePageOptions): Page;
 //#endregion
-export { CreatePageOptions, createPage };
+export { type ConsoleMessage, CreatePageOptions, type Dialog, type Expect, type Request, type Response, createPage, expect };