@stablyai/internal-playwright 0.1.0

package/lib/matchers/matchers.js

@@ -0,0 +1,366 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var matchers_exports = {};
+__export(matchers_exports, {
+  toBeAttached: () => toBeAttached,
+  toBeChecked: () => toBeChecked,
+  toBeDisabled: () => toBeDisabled,
+  toBeEditable: () => toBeEditable,
+  toBeEmpty: () => toBeEmpty,
+  toBeEnabled: () => toBeEnabled,
+  toBeFocused: () => toBeFocused,
+  toBeHidden: () => toBeHidden,
+  toBeInViewport: () => toBeInViewport,
+  toBeOK: () => toBeOK,
+  toBeVisible: () => toBeVisible,
+  toContainClass: () => toContainClass,
+  toContainText: () => toContainText,
+  toHaveAccessibleDescription: () => toHaveAccessibleDescription,
+  toHaveAccessibleErrorMessage: () => toHaveAccessibleErrorMessage,
+  toHaveAccessibleName: () => toHaveAccessibleName,
+  toHaveAttribute: () => toHaveAttribute,
+  toHaveCSS: () => toHaveCSS,
+  toHaveClass: () => toHaveClass,
+  toHaveCount: () => toHaveCount,
+  toHaveId: () => toHaveId,
+  toHaveJSProperty: () => toHaveJSProperty,
+  toHaveRole: () => toHaveRole,
+  toHaveText: () => toHaveText,
+  toHaveTitle: () => toHaveTitle,
+  toHaveURL: () => toHaveURL,
+  toHaveValue: () => toHaveValue,
+  toHaveValues: () => toHaveValues,
+  toPass: () => toPass
+});
+module.exports = __toCommonJS(matchers_exports);
+var import_utils = require("playwright-core/lib/utils");
+var import_utils2 = require("playwright-core/lib/utils");
+var import_util = require("../util");
+var import_toBeTruthy = require("./toBeTruthy");
+var import_toEqual = require("./toEqual");
+var import_toHaveURL = require("./toHaveURL");
+var import_toMatchText = require("./toMatchText");
+var import_config = require("../common/config");
+var import_globals = require("../common/globals");
+var import_testInfo = require("../worker/testInfo");
+var import_matcherHint = require("./matcherHint");
+function toBeAttached(locator, options) {
+  const attached = !options || options.attached === void 0 || options.attached;
+  const expected = attached ? "attached" : "detached";
+  const arg = attached ? "" : "{ attached: false }";
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeAttached", locator, "Locator", expected, arg, async (isNot, timeout) => {
+    return await locator._expect(attached ? "to.be.attached" : "to.be.detached", { isNot, timeout });
+  }, options);
+}
+function toBeChecked(locator, options) {
+  const checked = options?.checked;
+  const indeterminate = options?.indeterminate;
+  const expectedValue = {
+    checked,
+    indeterminate
+  };
+  let expected;
+  let arg;
+  if (options?.indeterminate) {
+    expected = "indeterminate";
+    arg = `{ indeterminate: true }`;
+  } else {
+    expected = options?.checked === false ? "unchecked" : "checked";
+    arg = options?.checked === false ? `{ checked: false }` : "";
+  }
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeChecked", locator, "Locator", expected, arg, async (isNot, timeout) => {
+    return await locator._expect("to.be.checked", { isNot, timeout, expectedValue });
+  }, options);
+}
+function toBeDisabled(locator, options) {
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeDisabled", locator, "Locator", "disabled", "", async (isNot, timeout) => {
+    return await locator._expect("to.be.disabled", { isNot, timeout });
+  }, options);
+}
+function toBeEditable(locator, options) {
+  const editable = !options || options.editable === void 0 || options.editable;
+  const expected = editable ? "editable" : "readOnly";
+  const arg = editable ? "" : "{ editable: false }";
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeEditable", locator, "Locator", expected, arg, async (isNot, timeout) => {
+    return await locator._expect(editable ? "to.be.editable" : "to.be.readonly", { isNot, timeout });
+  }, options);
+}
+function toBeEmpty(locator, options) {
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeEmpty", locator, "Locator", "empty", "", async (isNot, timeout) => {
+    return await locator._expect("to.be.empty", { isNot, timeout });
+  }, options);
+}
+function toBeEnabled(locator, options) {
+  const enabled = !options || options.enabled === void 0 || options.enabled;
+  const expected = enabled ? "enabled" : "disabled";
+  const arg = enabled ? "" : "{ enabled: false }";
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeEnabled", locator, "Locator", expected, arg, async (isNot, timeout) => {
+    return await locator._expect(enabled ? "to.be.enabled" : "to.be.disabled", { isNot, timeout });
+  }, options);
+}
+function toBeFocused(locator, options) {
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeFocused", locator, "Locator", "focused", "", async (isNot, timeout) => {
+    return await locator._expect("to.be.focused", { isNot, timeout });
+  }, options);
+}
+function toBeHidden(locator, options) {
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeHidden", locator, "Locator", "hidden", "", async (isNot, timeout) => {
+    return await locator._expect("to.be.hidden", { isNot, timeout });
+  }, options);
+}
+function toBeVisible(locator, options) {
+  const visible = !options || options.visible === void 0 || options.visible;
+  const expected = visible ? "visible" : "hidden";
+  const arg = visible ? "" : "{ visible: false }";
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeVisible", locator, "Locator", expected, arg, async (isNot, timeout) => {
+    return await locator._expect(visible ? "to.be.visible" : "to.be.hidden", { isNot, timeout });
+  }, options);
+}
+function toBeInViewport(locator, options) {
+  return import_toBeTruthy.toBeTruthy.call(this, "toBeInViewport", locator, "Locator", "in viewport", "", async (isNot, timeout) => {
+    return await locator._expect("to.be.in.viewport", { isNot, expectedNumber: options?.ratio, timeout });
+  }, options);
+}
+function toContainText(locator, expected, options = {}) {
+  if (Array.isArray(expected)) {
+    return import_toEqual.toEqual.call(this, "toContainText", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)(expected, { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
+      return await locator._expect("to.contain.text.array", { expectedText, isNot, useInnerText: options.useInnerText, timeout });
+    }, expected, { ...options, contains: true });
+  } else {
+    return import_toMatchText.toMatchText.call(this, "toContainText", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
+      return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options.useInnerText, timeout });
+    }, expected, { ...options, matchSubstring: true });
+  }
+}
+function toHaveAccessibleDescription(locator, expected, options) {
+  return import_toMatchText.toMatchText.call(this, "toHaveAccessibleDescription", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
+    return await locator._expect("to.have.accessible.description", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveAccessibleName(locator, expected, options) {
+  return import_toMatchText.toMatchText.call(this, "toHaveAccessibleName", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
+    return await locator._expect("to.have.accessible.name", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveAccessibleErrorMessage(locator, expected, options) {
+  return import_toMatchText.toMatchText.call(this, "toHaveAccessibleErrorMessage", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });
+    return await locator._expect("to.have.accessible.error.message", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveAttribute(locator, name, expected, options) {
+  if (!options) {
+    if (typeof expected === "object" && !(0, import_utils.isRegExp)(expected)) {
+      options = expected;
+      expected = void 0;
+    }
+  }
+  if (expected === void 0) {
+    return import_toBeTruthy.toBeTruthy.call(this, "toHaveAttribute", locator, "Locator", "have attribute", "", async (isNot, timeout) => {
+      return await locator._expect("to.have.attribute", { expressionArg: name, isNot, timeout });
+    }, options);
+  }
+  return import_toMatchText.toMatchText.call(this, "toHaveAttribute", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase });
+    return await locator._expect("to.have.attribute.value", { expressionArg: name, expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveClass(locator, expected, options) {
+  if (Array.isArray(expected)) {
+    return import_toEqual.toEqual.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
+      return await locator._expect("to.have.class.array", { expectedText, isNot, timeout });
+    }, expected, options);
+  } else {
+    return import_toMatchText.toMatchText.call(this, "toHaveClass", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
+      return await locator._expect("to.have.class", { expectedText, isNot, timeout });
+    }, expected, options);
+  }
+}
+function toContainClass(locator, expected, options) {
+  if (Array.isArray(expected)) {
+    if (expected.some((e) => (0, import_utils.isRegExp)(e)))
+      throw new Error(`"expected" argument in toContainClass cannot contain RegExp values`);
+    return import_toEqual.toEqual.call(this, "toContainClass", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
+      return await locator._expect("to.contain.class.array", { expectedText, isNot, timeout });
+    }, expected, options);
+  } else {
+    if ((0, import_utils.isRegExp)(expected))
+      throw new Error(`"expected" argument in toContainClass cannot be a RegExp value`);
+    return import_toMatchText.toMatchText.call(this, "toContainClass", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
+      return await locator._expect("to.contain.class", { expectedText, isNot, timeout });
+    }, expected, options);
+  }
+}
+function toHaveCount(locator, expected, options) {
+  return import_toEqual.toEqual.call(this, "toHaveCount", locator, "Locator", async (isNot, timeout) => {
+    return await locator._expect("to.have.count", { expectedNumber: expected, isNot, timeout });
+  }, expected, options);
+}
+function toHaveCSS(locator, name, expected, options) {
+  return import_toMatchText.toMatchText.call(this, "toHaveCSS", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
+    return await locator._expect("to.have.css", { expressionArg: name, expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveId(locator, expected, options) {
+  return import_toMatchText.toMatchText.call(this, "toHaveId", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
+    return await locator._expect("to.have.id", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveJSProperty(locator, name, expected, options) {
+  return import_toEqual.toEqual.call(this, "toHaveJSProperty", locator, "Locator", async (isNot, timeout) => {
+    return await locator._expect("to.have.property", { expressionArg: name, expectedValue: expected, isNot, timeout });
+  }, expected, options);
+}
+function toHaveRole(locator, expected, options) {
+  if (!(0, import_utils.isString)(expected))
+    throw new Error(`"role" argument in toHaveRole must be a string`);
+  return import_toMatchText.toMatchText.call(this, "toHaveRole", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
+    return await locator._expect("to.have.role", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveText(locator, expected, options = {}) {
+  if (Array.isArray(expected)) {
+    return import_toEqual.toEqual.call(this, "toHaveText", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)(expected, { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
+      return await locator._expect("to.have.text.array", { expectedText, isNot, useInnerText: options?.useInnerText, timeout });
+    }, expected, options);
+  } else {
+    return import_toMatchText.toMatchText.call(this, "toHaveText", locator, "Locator", async (isNot, timeout) => {
+      const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });
+      return await locator._expect("to.have.text", { expectedText, isNot, useInnerText: options?.useInnerText, timeout });
+    }, expected, options);
+  }
+}
+function toHaveValue(locator, expected, options) {
+  return import_toMatchText.toMatchText.call(this, "toHaveValue", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected]);
+    return await locator._expect("to.have.value", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveValues(locator, expected, options) {
+  return import_toEqual.toEqual.call(this, "toHaveValues", locator, "Locator", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)(expected);
+    return await locator._expect("to.have.values", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveTitle(page, expected, options = {}) {
+  return import_toMatchText.toMatchText.call(this, "toHaveTitle", page, "Page", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { normalizeWhiteSpace: true });
+    return await page.mainFrame()._expect("to.have.title", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+function toHaveURL(page, expected, options) {
+  if (typeof expected === "function")
+    return import_toHaveURL.toHaveURLWithPredicate.call(this, page, expected, options);
+  const baseURL = page.context()._options.baseURL;
+  expected = typeof expected === "string" ? (0, import_utils.constructURLBasedOnBaseURL)(baseURL, expected) : expected;
+  return import_toMatchText.toMatchText.call(this, "toHaveURL", page, "Page", async (isNot, timeout) => {
+    const expectedText = (0, import_utils.serializeExpectedTextValues)([expected], { ignoreCase: options?.ignoreCase });
+    return await page.mainFrame()._expect("to.have.url", { expectedText, isNot, timeout });
+  }, expected, options);
+}
+async function toBeOK(response) {
+  const matcherName = "toBeOK";
+  (0, import_util.expectTypes)(response, ["APIResponse"], matcherName);
+  const contentType = response.headers()["content-type"];
+  const isTextEncoding = contentType && (0, import_utils.isTextualMimeType)(contentType);
+  const [log, text] = this.isNot === response.ok() ? await Promise.all([
+    response._fetchLog(),
+    isTextEncoding ? response.text() : null
+  ]) : [];
+  const message = () => (0, import_matcherHint.formatMatcherMessage)(this, {
+    matcherName,
+    receiver: "response",
+    expectation: "",
+    log
+  }) + (text === null ? "" : `
+Response text:
+${import_utils2.colors.dim(text?.substring(0, 1e3) || "")}`);
+  const pass = response.ok();
+  return { message, pass };
+}
+async function toPass(callback, options = {}) {
+  const testInfo = (0, import_globals.currentTestInfo)();
+  const timeout = (0, import_config.takeFirst)(options.timeout, testInfo?._projectInternal.expect?.toPass?.timeout, 0);
+  const intervals = (0, import_config.takeFirst)(options.intervals, testInfo?._projectInternal.expect?.toPass?.intervals, [100, 250, 500, 1e3]);
+  const { deadline, timeoutMessage } = testInfo ? testInfo._deadlineForMatcher(timeout) : import_testInfo.TestInfoImpl._defaultDeadlineForMatcher(timeout);
+  const result = await (0, import_utils.pollAgainstDeadline)(async () => {
+    if (testInfo && (0, import_globals.currentTestInfo)() !== testInfo)
+      return { continuePolling: false, result: void 0 };
+    try {
+      await callback();
+      return { continuePolling: !!this.isNot, result: void 0 };
+    } catch (e) {
+      return { continuePolling: !this.isNot, result: e };
+    }
+  }, deadline, intervals);
+  if (result.timedOut) {
+    const message = result.result ? [
+      result.result.message,
+      "",
+      `Call Log:`,
+      `- ${timeoutMessage}`
+    ].join("\n") : timeoutMessage;
+    return { message: () => message, pass: !!this.isNot };
+  }
+  return { pass: !this.isNot, message: () => "" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toBeAttached,
+  toBeChecked,
+  toBeDisabled,
+  toBeEditable,
+  toBeEmpty,
+  toBeEnabled,
+  toBeFocused,
+  toBeHidden,
+  toBeInViewport,
+  toBeOK,
+  toBeVisible,
+  toContainClass,
+  toContainText,
+  toHaveAccessibleDescription,
+  toHaveAccessibleErrorMessage,
+  toHaveAccessibleName,
+  toHaveAttribute,
+  toHaveCSS,
+  toHaveClass,
+  toHaveCount,
+  toHaveId,
+  toHaveJSProperty,
+  toHaveRole,
+  toHaveText,
+  toHaveTitle,
+  toHaveURL,
+  toHaveValue,
+  toHaveValues,
+  toPass
+});

package/lib/matchers/matchers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/matchers/matchers.ts"],
+  "sourcesContent": ["/**\n * Copyright Microsoft Corporation. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { constructURLBasedOnBaseURL, isRegExp, isString, isTextualMimeType, pollAgainstDeadline, serializeExpectedTextValues } from 'playwright-core/lib/utils';\nimport { colors } from 'playwright-core/lib/utils';\n\nimport { callLogText, expectTypes } from '../util';\nimport { toBeTruthy } from './toBeTruthy';\nimport { toEqual } from './toEqual';\nimport { toHaveURLWithPredicate } from './toHaveURL';\nimport { toMatchText } from './toMatchText';\nimport { takeFirst } from '../common/config';\nimport { currentTestInfo } from '../common/globals';\nimport { TestInfoImpl } from '../worker/testInfo';\n\nimport type { ExpectMatcherState } from '../../types/test';\nimport type { TestStepInfoImpl } from '../worker/testInfo';\nimport type { APIResponse, Locator, Frame, Page } from 'playwright-core';\nimport type { FrameExpectParams } from 'playwright-core/lib/client/types';\n\nexport type ExpectMatcherStateInternal = ExpectMatcherState & { _stepInfo?: TestStepInfoImpl };\n\nexport interface LocatorEx extends Locator {\n  _expect(expression: string, options: FrameExpectParams): Promise<{ matches: boolean, received?: any, log?: string[], timedOut?: boolean }>;\n}\n\nexport interface FrameEx extends Frame {\n  _expect(expression: string, options: FrameExpectParams): Promise<{ matches: boolean, received?: any, log?: string[], timedOut?: boolean }>;\n}\n\ninterface APIResponseEx extends APIResponse {\n  _fetchLog(): Promise<string[]>;\n}\n\nexport function toBeAttached(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { attached?: boolean, timeout?: number },\n) {\n  const attached = !options || options.attached === undefined || options.attached;\n  const expected = attached ? 'attached' : 'detached';\n  const arg = attached ? '' : '{ attached: false }';\n  return toBeTruthy.call(this, 'toBeAttached', locator, 'Locator', expected, arg, async (isNot, timeout) => {\n    return await locator._expect(attached ? 'to.be.attached' : 'to.be.detached', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeChecked(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { checked?: boolean, indeterminate?: boolean, timeout?: number },\n) {\n  const checked = options?.checked;\n  const indeterminate = options?.indeterminate;\n  const expectedValue = {\n    checked,\n    indeterminate,\n  };\n  let expected: string;\n  let arg: string;\n  if (options?.indeterminate) {\n    expected = 'indeterminate';\n    arg = `{ indeterminate: true }`;\n  } else {\n    expected = options?.checked === false ? 'unchecked' : 'checked';\n    arg = options?.checked === false ? `{ checked: false }` : '';\n  }\n  return toBeTruthy.call(this, 'toBeChecked', locator, 'Locator', expected, arg, async (isNot, timeout) => {\n    return await locator._expect('to.be.checked', { isNot, timeout, expectedValue });\n  }, options);\n}\n\nexport function toBeDisabled(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { timeout?: number },\n) {\n  return toBeTruthy.call(this, 'toBeDisabled', locator, 'Locator', 'disabled', '', async (isNot, timeout) => {\n    return await locator._expect('to.be.disabled', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeEditable(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { editable?: boolean, timeout?: number },\n) {\n  const editable = !options || options.editable === undefined || options.editable;\n  const expected = editable ? 'editable' : 'readOnly';\n  const arg = editable ? '' : '{ editable: false }';\n  return toBeTruthy.call(this, 'toBeEditable', locator, 'Locator', expected, arg, async (isNot, timeout) => {\n    return await locator._expect(editable ? 'to.be.editable' : 'to.be.readonly', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeEmpty(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { timeout?: number },\n) {\n  return toBeTruthy.call(this, 'toBeEmpty', locator, 'Locator', 'empty', '', async (isNot, timeout) => {\n    return await locator._expect('to.be.empty', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeEnabled(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { enabled?: boolean, timeout?: number },\n) {\n  const enabled = !options || options.enabled === undefined || options.enabled;\n  const expected = enabled ? 'enabled' : 'disabled';\n  const arg = enabled ? '' : '{ enabled: false }';\n  return toBeTruthy.call(this, 'toBeEnabled', locator, 'Locator', expected, arg, async (isNot, timeout) => {\n    return await locator._expect(enabled ? 'to.be.enabled' : 'to.be.disabled', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeFocused(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { timeout?: number },\n) {\n  return toBeTruthy.call(this, 'toBeFocused', locator, 'Locator', 'focused', '', async (isNot, timeout) => {\n    return await locator._expect('to.be.focused', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeHidden(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { timeout?: number },\n) {\n  return toBeTruthy.call(this, 'toBeHidden', locator, 'Locator', 'hidden', '', async (isNot, timeout) => {\n    return await locator._expect('to.be.hidden', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeVisible(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { visible?: boolean, timeout?: number },\n) {\n  const visible = !options || options.visible === undefined || options.visible;\n  const expected = visible ? 'visible' : 'hidden';\n  const arg = visible ? '' : '{ visible: false }';\n  return toBeTruthy.call(this, 'toBeVisible', locator, 'Locator', expected, arg, async (isNot, timeout) => {\n    return await locator._expect(visible ? 'to.be.visible' : 'to.be.hidden', { isNot, timeout });\n  }, options);\n}\n\nexport function toBeInViewport(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  options?: { timeout?: number, ratio?: number },\n) {\n  return toBeTruthy.call(this, 'toBeInViewport', locator, 'Locator', 'in viewport', '', async (isNot, timeout) => {\n    return await locator._expect('to.be.in.viewport', { isNot, expectedNumber: options?.ratio, timeout });\n  }, options);\n}\n\nexport function toContainText(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp | (string | RegExp)[],\n  options: { timeout?: number, useInnerText?: boolean, ignoreCase?: boolean } = {},\n) {\n  if (Array.isArray(expected)) {\n    return toEqual.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues(expected, { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });\n      return await locator._expect('to.contain.text.array', { expectedText, isNot, useInnerText: options.useInnerText, timeout });\n    }, expected, { ...options, contains: true });\n  } else {\n    return toMatchText.call(this, 'toContainText', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues([expected], { matchSubstring: true, normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });\n      return await locator._expect('to.have.text', { expectedText, isNot, useInnerText: options.useInnerText, timeout });\n    }, expected, options);\n  }\n}\n\nexport function toHaveAccessibleDescription(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp,\n  options?: { timeout?: number, ignoreCase?: boolean },\n) {\n  return toMatchText.call(this, 'toHaveAccessibleDescription', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });\n    return await locator._expect('to.have.accessible.description', { expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveAccessibleName(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp,\n  options?: { timeout?: number, ignoreCase?: boolean },\n) {\n  return toMatchText.call(this, 'toHaveAccessibleName', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });\n    return await locator._expect('to.have.accessible.name', { expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveAccessibleErrorMessage(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp,\n  options?: { timeout?: number; ignoreCase?: boolean },\n) {\n  return toMatchText.call(this, 'toHaveAccessibleErrorMessage', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase, normalizeWhiteSpace: true });\n    return await locator._expect('to.have.accessible.error.message', { expectedText: expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveAttribute(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  name: string,\n  expected: string | RegExp | undefined | { timeout?: number },\n  options?: { timeout?: number, ignoreCase?: boolean },\n) {\n  if (!options) {\n    // Update params for the case toHaveAttribute(name, options);\n    if (typeof expected === 'object' && !isRegExp(expected)) {\n      options = expected;\n      expected = undefined;\n    }\n  }\n  if (expected === undefined) {\n    return toBeTruthy.call(this, 'toHaveAttribute', locator, 'Locator', 'have attribute', '', async (isNot, timeout) => {\n      return await locator._expect('to.have.attribute', { expressionArg: name, isNot, timeout });\n    }, options);\n  }\n  return toMatchText.call(this, 'toHaveAttribute', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected as (string | RegExp)], { ignoreCase: options?.ignoreCase });\n    return await locator._expect('to.have.attribute.value', { expressionArg: name, expectedText, isNot, timeout });\n  }, expected as (string | RegExp), options);\n}\n\nexport function toHaveClass(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp | (string | RegExp)[],\n  options?: { timeout?: number },\n) {\n  if (Array.isArray(expected)) {\n    return toEqual.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues(expected);\n      return await locator._expect('to.have.class.array', { expectedText, isNot, timeout });\n    }, expected, options, true);\n  } else {\n    return toMatchText.call(this, 'toHaveClass', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues([expected]);\n      return await locator._expect('to.have.class', { expectedText, isNot, timeout });\n    }, expected, options);\n  }\n}\n\nexport function toContainClass(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | string[],\n  options?: { timeout?: number },\n) {\n  if (Array.isArray(expected)) {\n    if (expected.some(e => isRegExp(e)))\n      throw new Error(`\"expected\" argument in toContainClass cannot contain RegExp values`);\n    return toEqual.call(this, 'toContainClass', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues(expected);\n      return await locator._expect('to.contain.class.array', { expectedText, isNot, timeout });\n    }, expected, options, true);\n  } else {\n    if (isRegExp(expected))\n      throw new Error(`\"expected\" argument in toContainClass cannot be a RegExp value`);\n    return toMatchText.call(this, 'toContainClass', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues([expected]);\n      return await locator._expect('to.contain.class', { expectedText, isNot, timeout });\n    }, expected, options);\n  }\n}\n\nexport function toHaveCount(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: number,\n  options?: { timeout?: number },\n) {\n  return toEqual.call(this, 'toHaveCount', locator, 'Locator', async (isNot, timeout) => {\n    return await locator._expect('to.have.count', { expectedNumber: expected, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveCSS(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  name: string,\n  expected: string | RegExp,\n  options?: { timeout?: number },\n) {\n  return toMatchText.call(this, 'toHaveCSS', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected]);\n    return await locator._expect('to.have.css', { expressionArg: name, expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveId(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp,\n  options?: { timeout?: number },\n) {\n  return toMatchText.call(this, 'toHaveId', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected]);\n    return await locator._expect('to.have.id', { expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveJSProperty(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  name: string,\n  expected: any,\n  options?: { timeout?: number },\n) {\n  return toEqual.call(this, 'toHaveJSProperty', locator, 'Locator', async (isNot, timeout) => {\n    return await locator._expect('to.have.property', { expressionArg: name, expectedValue: expected, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveRole(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string,\n  options?: { timeout?: number, ignoreCase?: boolean },\n) {\n  if (!isString(expected))\n    throw new Error(`\"role\" argument in toHaveRole must be a string`);\n  return toMatchText.call(this, 'toHaveRole', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected]);\n    return await locator._expect('to.have.role', { expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveText(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp | (string | RegExp)[],\n  options: { timeout?: number, useInnerText?: boolean, ignoreCase?: boolean } = {},\n) {\n  if (Array.isArray(expected)) {\n    return toEqual.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues(expected, { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });\n      return await locator._expect('to.have.text.array', { expectedText, isNot, useInnerText: options?.useInnerText, timeout });\n    }, expected, options);\n  } else {\n    return toMatchText.call(this, 'toHaveText', locator, 'Locator', async (isNot, timeout) => {\n      const expectedText = serializeExpectedTextValues([expected], { normalizeWhiteSpace: true, ignoreCase: options.ignoreCase });\n      return await locator._expect('to.have.text', { expectedText, isNot, useInnerText: options?.useInnerText, timeout });\n    }, expected, options);\n  }\n}\n\nexport function toHaveValue(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: string | RegExp,\n  options?: { timeout?: number },\n) {\n  return toMatchText.call(this, 'toHaveValue', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected]);\n    return await locator._expect('to.have.value', { expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveValues(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expected: (string | RegExp)[],\n  options?: { timeout?: number },\n) {\n  return toEqual.call(this, 'toHaveValues', locator, 'Locator', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues(expected);\n    return await locator._expect('to.have.values', { expectedText, isNot, timeout });\n  }, expected, options);\n}\n\nexport function toHaveTitle(\n  this: ExpectMatcherState,\n  page: Page,\n  expected: string | RegExp,\n  options: { timeout?: number } = {},\n) {\n  return toMatchText.call(this, 'toHaveTitle', page, 'Page', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected], { normalizeWhiteSpace: true });\n    return await (page.mainFrame() as FrameEx)._expect('to.have.title', { expectedText, isNot, timeout });\n  }, expected, { receiverLabel: 'page', ...options });\n}\n\nexport function toHaveURL(\n  this: ExpectMatcherState,\n  page: Page,\n  expected: string | RegExp | ((url: URL) => boolean),\n  options?: { ignoreCase?: boolean; timeout?: number },\n) {\n  // Ports don't support predicates. Keep separate server and client codepaths\n  if (typeof expected === 'function')\n    return toHaveURLWithPredicate.call(this, page, expected, options);\n\n  const baseURL = (page.context() as any)._options.baseURL;\n  expected = typeof expected === 'string' ? constructURLBasedOnBaseURL(baseURL, expected) : expected;\n  return toMatchText.call(this, 'toHaveURL', page, 'Page', async (isNot, timeout) => {\n    const expectedText = serializeExpectedTextValues([expected], { ignoreCase: options?.ignoreCase });\n    return await (page.mainFrame() as FrameEx)._expect('to.have.url', { expectedText, isNot, timeout });\n  }, expected, { receiverLabel: 'page', ...options });\n}\n\nexport async function toBeOK(\n  this: ExpectMatcherState,\n  response: APIResponseEx\n) {\n  const matcherName = 'toBeOK';\n  expectTypes(response, ['APIResponse'], matcherName);\n\n  const contentType = response.headers()['content-type'];\n  const isTextEncoding = contentType && isTextualMimeType(contentType);\n  const [log, text] = (this.isNot === response.ok()) ? await Promise.all([\n    response._fetchLog(),\n    isTextEncoding ? response.text() : null\n  ]) : [];\n\n  const message = () => this.utils.matcherHint(matcherName, undefined, '', { isNot: this.isNot }) +\n    callLogText(log) +\n    (text === null ? '' : `\\nResponse text:\\n${colors.dim(text?.substring(0, 1000) || '')}`);\n\n  const pass = response.ok();\n  return { message, pass };\n}\n\nexport async function toPass(\n  this: ExpectMatcherState,\n  callback: () => any,\n  options: {\n    intervals?: number[];\n    timeout?: number,\n  } = {},\n) {\n  const testInfo = currentTestInfo();\n  const timeout = takeFirst(options.timeout, testInfo?._projectInternal.expect?.toPass?.timeout, 0);\n  const intervals = takeFirst(options.intervals, testInfo?._projectInternal.expect?.toPass?.intervals, [100, 250, 500, 1000]);\n\n  const { deadline, timeoutMessage } = testInfo ? testInfo._deadlineForMatcher(timeout) : TestInfoImpl._defaultDeadlineForMatcher(timeout);\n  const result = await pollAgainstDeadline<Error|undefined>(async () => {\n    if (testInfo && currentTestInfo() !== testInfo)\n      return { continuePolling: false, result: undefined };\n    try {\n      await callback();\n      return { continuePolling: !!this.isNot, result: undefined };\n    } catch (e) {\n      return { continuePolling: !this.isNot, result: e };\n    }\n  }, deadline, intervals);\n\n  if (result.timedOut) {\n    const message = result.result ? [\n      result.result.message,\n      '',\n      `Call Log:`,\n      `- ${timeoutMessage}`,\n    ].join('\\n') : timeoutMessage;\n    return { message: () => message, pass: !!this.isNot };\n  }\n  return { pass: !this.isNot, message: () => '' };\n}\n"],
+  "mappings": "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",
+  "names": ["import_utils"]
+}

package/lib/matchers/toBeTruthy.js

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toBeTruthy_exports = {};
+__export(toBeTruthy_exports, {
+  toBeTruthy: () => toBeTruthy
+});
+module.exports = __toCommonJS(toBeTruthy_exports);
+var import_util = require("../util");
+var import_matcherHint = require("./matcherHint");
+async function toBeTruthy(matcherName, locator, receiverType, expected, arg, query, options = {}) {
+  (0, import_util.expectTypes)(locator, [receiverType], matcherName);
+  const timeout = options.timeout ?? this.timeout;
+  const { matches: pass, log, timedOut, received, errorMessage } = await query(!!this.isNot, timeout);
+  if (pass === !this.isNot) {
+    return {
+      name: matcherName,
+      message: () => "",
+      pass,
+      expected
+    };
+  }
+  let printedReceived;
+  let printedExpected;
+  if (pass) {
+    printedExpected = `Expected: not ${expected}`;
+    printedReceived = errorMessage ? "" : `Received: ${expected}`;
+  } else {
+    printedExpected = `Expected: ${expected}`;
+    printedReceived = errorMessage ? "" : `Received: ${received}`;
+  }
+  const message = () => {
+    return (0, import_matcherHint.formatMatcherMessage)(this, {
+      matcherName,
+      expectation: arg,
+      locator,
+      timeout,
+      timedOut,
+      printedExpected,
+      printedReceived,
+      errorMessage,
+      log
+    });
+  };
+  return {
+    message,
+    pass,
+    actual: received,
+    name: matcherName,
+    expected,
+    log,
+    timeout: timedOut ? timeout : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toBeTruthy
+});

package/lib/matchers/toBeTruthy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/matchers/toBeTruthy.ts"],
+  "sourcesContent": ["/**\n * Copyright Microsoft Corporation. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { callLogText, expectTypes } from '../util';\nimport { kNoElementsFoundError, matcherHint } from './matcherHint';\nimport { runBrowserBackendOnError } from '../mcp/browser/backend';\n\nimport type { MatcherResult } from './matcherHint';\nimport type { ExpectMatcherState } from '../../types/test';\nimport type { Locator } from 'playwright-core';\n\nexport async function toBeTruthy(\n  this: ExpectMatcherState,\n  matcherName: string,\n  receiver: Locator,\n  receiverType: string,\n  expected: string,\n  arg: string,\n  query: (isNot: boolean, timeout: number) => Promise<{ matches: boolean, log?: string[], received?: any, timedOut?: boolean }>,\n  options: { timeout?: number } = {},\n): Promise<MatcherResult<any, any>> {\n  expectTypes(receiver, [receiverType], matcherName);\n\n  const matcherOptions = {\n    isNot: this.isNot,\n    promise: this.promise,\n  };\n\n  const timeout = options.timeout ?? this.timeout;\n\n  const { matches: pass, log, timedOut, received } = await query(!!this.isNot, timeout).catch(async error => {\n    // FIXME: query should not throw, but it does for strict mode violations for example.\n    await runBrowserBackendOnError(receiver.page(), () => error.message);\n    throw error;\n  });\n\n  if (pass === !this.isNot) {\n    return {\n      name: matcherName,\n      message: () => '',\n      pass,\n      expected\n    };\n  }\n\n  const notFound = received === kNoElementsFoundError ? received : undefined;\n  let printedReceived: string | undefined;\n  let printedExpected: string | undefined;\n  if (pass) {\n    printedExpected = `Expected: not ${expected}`;\n    printedReceived = `Received: ${notFound ? kNoElementsFoundError : expected}`;\n  } else {\n    printedExpected = `Expected: ${expected}`;\n    printedReceived = `Received: ${notFound ? kNoElementsFoundError : received}`;\n  }\n  const message = () => {\n    const header = matcherHint(this, receiver, matcherName, 'locator', arg, matcherOptions, timedOut ? timeout : undefined, `${printedExpected}\\n${printedReceived}`);\n    const logText = callLogText(log);\n    return `${header}${logText}`;\n  };\n\n  await runBrowserBackendOnError(receiver.page(), message);\n\n  return {\n    message,\n    pass,\n    actual: received,\n    name: matcherName,\n    expected,\n    log,\n    timeout: timedOut ? timeout : undefined,\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,kBAAyC;AACzC,yBAAmD;AACnD,qBAAyC;AAMzC,eAAsB,WAEpB,aACA,UACA,cACA,UACA,KACA,OACA,UAAgC,CAAC,GACC;AAClC,+BAAY,UAAU,CAAC,YAAY,GAAG,WAAW;AAEjD,QAAM,iBAAiB;AAAA,IACrB,OAAO,KAAK;AAAA,IACZ,SAAS,KAAK;AAAA,EAChB;AAEA,QAAM,UAAU,QAAQ,WAAW,KAAK;AAExC,QAAM,EAAE,SAAS,MAAM,KAAK,UAAU,SAAS,IAAI,MAAM,MAAM,CAAC,CAAC,KAAK,OAAO,OAAO,EAAE,MAAM,OAAM,UAAS;AAEzG,cAAM,yCAAyB,SAAS,KAAK,GAAG,MAAM,MAAM,OAAO;AACnE,UAAM;AAAA,EACR,CAAC;AAED,MAAI,SAAS,CAAC,KAAK,OAAO;AACxB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS,MAAM;AAAA,MACf;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,WAAW,aAAa,2CAAwB,WAAW;AACjE,MAAI;AACJ,MAAI;AACJ,MAAI,MAAM;AACR,sBAAkB,iBAAiB,QAAQ;AAC3C,sBAAkB,aAAa,WAAW,2CAAwB,QAAQ;AAAA,EAC5E,OAAO;AACL,sBAAkB,aAAa,QAAQ;AACvC,sBAAkB,aAAa,WAAW,2CAAwB,QAAQ;AAAA,EAC5E;AACA,QAAM,UAAU,MAAM;AACpB,UAAM,aAAS,gCAAY,MAAM,UAAU,aAAa,WAAW,KAAK,gBAAgB,WAAW,UAAU,QAAW,GAAG,eAAe;AAAA,EAAK,eAAe,EAAE;AAChK,UAAM,cAAU,yBAAY,GAAG;AAC/B,WAAO,GAAG,MAAM,GAAG,OAAO;AAAA,EAC5B;AAEA,YAAM,yCAAyB,SAAS,KAAK,GAAG,OAAO;AAEvD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,SAAS,WAAW,UAAU;AAAA,EAChC;AACF;",
+  "names": []
+}

package/lib/matchers/toEqual.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toEqual_exports = {};
+__export(toEqual_exports, {
+  toEqual: () => toEqual
+});
+module.exports = __toCommonJS(toEqual_exports);
+var import_utils = require("playwright-core/lib/utils");
+var import_util = require("../util");
+var import_matcherHint = require("./matcherHint");
+const EXPECTED_LABEL = "Expected";
+const RECEIVED_LABEL = "Received";
+async function toEqual(matcherName, locator, receiverType, query, expected, options = {}) {
+  (0, import_util.expectTypes)(locator, [receiverType], matcherName);
+  const timeout = options.timeout ?? this.timeout;
+  const { matches: pass, received, log, timedOut, errorMessage } = await query(!!this.isNot, timeout);
+  if (pass === !this.isNot) {
+    return {
+      name: matcherName,
+      message: () => "",
+      pass,
+      expected
+    };
+  }
+  let printedReceived;
+  let printedExpected;
+  let printedDiff;
+  if (pass) {
+    printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;
+    printedReceived = errorMessage ? "" : `Received: ${this.utils.printReceived(received)}`;
+  } else if (errorMessage) {
+    printedExpected = `Expected: ${this.utils.printExpected(expected)}`;
+  } else if (Array.isArray(expected) && Array.isArray(received)) {
+    const normalizedExpected = expected.map((exp, index) => {
+      const rec = received[index];
+      if ((0, import_utils.isRegExp)(exp))
+        return exp.test(rec) ? rec : exp;
+      return exp;
+    });
+    printedDiff = this.utils.printDiffOrStringify(
+      normalizedExpected,
+      received,
+      EXPECTED_LABEL,
+      RECEIVED_LABEL,
+      false
+    );
+  } else {
+    printedDiff = this.utils.printDiffOrStringify(
+      expected,
+      received,
+      EXPECTED_LABEL,
+      RECEIVED_LABEL,
+      false
+    );
+  }
+  const message = () => {
+    return (0, import_matcherHint.formatMatcherMessage)(this, {
+      matcherName,
+      expectation: "expected",
+      locator,
+      timeout,
+      timedOut,
+      printedExpected,
+      printedReceived,
+      printedDiff,
+      errorMessage,
+      log
+    });
+  };
+  return {
+    actual: received,
+    expected,
+    message,
+    name: matcherName,
+    pass,
+    log,
+    timeout: timedOut ? timeout : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toEqual
+});

package/lib/matchers/toEqual.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/matchers/toEqual.ts"],
+  "sourcesContent": ["/**\n * Copyright Microsoft Corporation. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isRegExp } from 'playwright-core/lib/utils';\n\nimport { callLogText, expectTypes } from '../util';\nimport { matcherHint } from './matcherHint';\nimport { runBrowserBackendOnError } from '../mcp/browser/backend';\n\nimport type { MatcherResult } from './matcherHint';\nimport type { ExpectMatcherState } from '../../types/test';\nimport type { Locator } from 'playwright-core';\n\n// Omit colon and one or more spaces, so can call getLabelPrinter.\nconst EXPECTED_LABEL = 'Expected';\nconst RECEIVED_LABEL = 'Received';\n\nexport async function toEqual<T>(\n  this: ExpectMatcherState,\n  matcherName: string,\n  receiver: Locator,\n  receiverType: string,\n  query: (isNot: boolean, timeout: number) => Promise<{ matches: boolean, received?: any, log?: string[], timedOut?: boolean }>,\n  expected: T,\n  options: { timeout?: number, contains?: boolean } = {},\n  messagePreventExtraStatIndent?: boolean\n): Promise<MatcherResult<any, any>> {\n  expectTypes(receiver, [receiverType], matcherName);\n\n  const matcherOptions = {\n    comment: options.contains ? '' : 'deep equality',\n    isNot: this.isNot,\n    promise: this.promise,\n  };\n\n  const timeout = options.timeout ?? this.timeout;\n\n  const { matches: pass, received, log, timedOut } = await query(!!this.isNot, timeout).catch(async error => {\n    // FIXME: query should not throw, but it does for strict mode violations for example.\n    await runBrowserBackendOnError(receiver.page(), () => error.message);\n    throw error;\n  });\n\n  if (pass === !this.isNot) {\n    return {\n      name: matcherName,\n      message: () => '',\n      pass,\n      expected\n    };\n  }\n\n  let printedReceived: string | undefined;\n  let printedExpected: string | undefined;\n  let printedDiff: string | undefined;\n  if (pass) {\n    printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;\n    printedReceived = `Received: ${this.utils.printReceived(received)}`;\n  } else if (Array.isArray(expected) && Array.isArray(received)) {\n    const normalizedExpected = expected.map((exp, index) => {\n      const rec = received[index];\n      if (isRegExp(exp))\n        return exp.test(rec) ? rec : exp;\n\n      return exp;\n    });\n    printedDiff = this.utils.printDiffOrStringify(\n        normalizedExpected,\n        received,\n        EXPECTED_LABEL,\n        RECEIVED_LABEL,\n        false,\n    );\n  } else {\n    printedDiff = this.utils.printDiffOrStringify(\n        expected,\n        received,\n        EXPECTED_LABEL,\n        RECEIVED_LABEL,\n        false,\n    );\n  }\n  const message = () => {\n    const details = printedDiff || `${printedExpected}\\n${printedReceived}`;\n    const header = matcherHint(this, receiver, matcherName, 'locator', undefined, matcherOptions, timedOut ? timeout : undefined, details, messagePreventExtraStatIndent);\n    return `${header}${callLogText(log)}`;\n  };\n\n  await runBrowserBackendOnError(receiver.page(), message);\n\n  // Passing the actual and expected objects so that a custom reporter\n  // could access them, for example in order to display a custom visual diff,\n  // or create a different error message\n  return {\n    actual: received,\n    expected, message,\n    name: matcherName,\n    pass,\n    log,\n    timeout: timedOut ? timeout : undefined,\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,mBAAyB;AAEzB,kBAAyC;AACzC,yBAA4B;AAC5B,qBAAyC;AAOzC,MAAM,iBAAiB;AACvB,MAAM,iBAAiB;AAEvB,eAAsB,QAEpB,aACA,UACA,cACA,OACA,UACA,UAAoD,CAAC,GACrD,+BACkC;AAClC,+BAAY,UAAU,CAAC,YAAY,GAAG,WAAW;AAEjD,QAAM,iBAAiB;AAAA,IACrB,SAAS,QAAQ,WAAW,KAAK;AAAA,IACjC,OAAO,KAAK;AAAA,IACZ,SAAS,KAAK;AAAA,EAChB;AAEA,QAAM,UAAU,QAAQ,WAAW,KAAK;AAExC,QAAM,EAAE,SAAS,MAAM,UAAU,KAAK,SAAS,IAAI,MAAM,MAAM,CAAC,CAAC,KAAK,OAAO,OAAO,EAAE,MAAM,OAAM,UAAS;AAEzG,cAAM,yCAAyB,SAAS,KAAK,GAAG,MAAM,MAAM,OAAO;AACnE,UAAM;AAAA,EACR,CAAC;AAED,MAAI,SAAS,CAAC,KAAK,OAAO;AACxB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS,MAAM;AAAA,MACf;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI,MAAM;AACR,sBAAkB,iBAAiB,KAAK,MAAM,cAAc,QAAQ,CAAC;AACrE,sBAAkB,aAAa,KAAK,MAAM,cAAc,QAAQ,CAAC;AAAA,EACnE,WAAW,MAAM,QAAQ,QAAQ,KAAK,MAAM,QAAQ,QAAQ,GAAG;AAC7D,UAAM,qBAAqB,SAAS,IAAI,CAAC,KAAK,UAAU;AACtD,YAAM,MAAM,SAAS,KAAK;AAC1B,cAAI,uBAAS,GAAG;AACd,eAAO,IAAI,KAAK,GAAG,IAAI,MAAM;AAE/B,aAAO;AAAA,IACT,CAAC;AACD,kBAAc,KAAK,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACJ;AAAA,EACF,OAAO;AACL,kBAAc,KAAK,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACJ;AAAA,EACF;AACA,QAAM,UAAU,MAAM;AACpB,UAAM,UAAU,eAAe,GAAG,eAAe;AAAA,EAAK,eAAe;AACrE,UAAM,aAAS,gCAAY,MAAM,UAAU,aAAa,WAAW,QAAW,gBAAgB,WAAW,UAAU,QAAW,SAAS,6BAA6B;AACpK,WAAO,GAAG,MAAM,OAAG,yBAAY,GAAG,CAAC;AAAA,EACrC;AAEA,YAAM,yCAAyB,SAAS,KAAK,GAAG,OAAO;AAKvD,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IAAU;AAAA,IACV,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,SAAS,WAAW,UAAU;AAAA,EAChC;AACF;",
+  "names": []
+}