@smoothdeploy/playwright 1.57.1 → 1.58.1-beta-1770383926000

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 { asLocatorDescription, constructURLBasedOnBaseURL, isRegExp, isString, isTextualMimeType, pollAgainstDeadline, serializeExpectedTextValues } from 'playwright-core/lib/utils';\nimport { colors } from 'playwright-core/lib/utils';\n\nimport { expectTypes } from '../util';\nimport { toBeTruthy } from './toBeTruthy';\nimport { toEqual } from './toEqual';\nimport { toHaveURLWithPredicate } from './toHaveURL';\nimport { toMatchText } from './toMatchText';\nimport { toHaveScreenshotStepTitle } from './toMatchSnapshot';\nimport { takeFirst } from '../common/config';\nimport { currentTestInfo } from '../common/globals';\nimport { TestInfoImpl } from '../worker/testInfo';\nimport { formatMatcherMessage } from './matcherHint';\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  _selector: string;\n  _expect(expression: string, options: FrameExpectParams): Promise<{ matches: boolean, received?: any, log?: string[], timedOut?: boolean, errorMessage?: string }>;\n}\n\nexport interface FrameEx extends Frame {\n  _expect(expression: string, options: FrameExpectParams): Promise<{ matches: boolean, received?: any, log?: string[], timedOut?: boolean, errorMessage?: string }>;\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, matchSubstring: true });\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);\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);\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, 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, 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 = () => formatMatcherMessage(this, {\n    matcherName,\n    receiver: 'response',\n    expectation: '',\n    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\nexport function computeMatcherTitleSuffix(matcherName: string, receiver: any, args: any[]): { short?: string, long?: string } {\n  if (matcherName === 'toHaveScreenshot') {\n    const title = toHaveScreenshotStepTitle(...args);\n    return { short: title ? `(${title})` : '' };\n  }\n  if (receiver && typeof receiver === 'object' && receiver.constructor?.name === 'Locator') {\n    try {\n      return { long: ' ' + asLocatorDescription('javascript', (receiver as LocatorEx)._selector) };\n    } catch {\n    }\n  }\n  return {};\n}\n"],
+  "mappings": "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",
+  "names": ["import_utils"]
+}

package/lib/matchers/toBeTruthy.js

@@ -21,8 +21,8 @@ __export(toBeTruthy_exports, {
   toBeTruthy: () => toBeTruthy
 });
 module.exports = __toCommonJS(toBeTruthy_exports);
+var import_utils = require("playwright-core/lib/utils");
 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;
@@ -45,10 +45,12 @@ async function toBeTruthy(matcherName, locator, receiverType, expected, arg, que
     printedReceived = errorMessage ? "" : `Received: ${received}`;
   }
   const message = () => {
-    return (0, import_matcherHint.formatMatcherMessage)(this, {
+    return (0, import_utils.formatMatcherMessage)(this.utils, {
+      isNot: this.isNot,
+      promise: this.promise,
       matcherName,
       expectation: arg,
-      locator,
+      locator: locator.toString(),
       timeout,
       timedOut,
       printedExpected,

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 { expectTypes } from '../util';\nimport { formatMatcherMessage } from './matcherHint';\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  locator: 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, errorMessage?: string }>,\n  options: { timeout?: number } = {},\n): Promise<MatcherResult<any, any>> {\n  expectTypes(locator, [receiverType], matcherName);\n\n  const timeout = options.timeout ?? this.timeout;\n\n  const { matches: pass, log, timedOut, received, errorMessage } = await query(!!this.isNot, timeout);\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  if (pass) {\n    printedExpected = `Expected: not ${expected}`;\n    printedReceived = errorMessage ? '' : `Received: ${expected}`;\n  } else {\n    printedExpected = `Expected: ${expected}`;\n    printedReceived = errorMessage ? '' : `Received: ${received}`;\n  }\n  const message = () => {\n    return formatMatcherMessage(this, {\n      matcherName,\n      expectation: arg,\n      locator,\n      timeout,\n      timedOut,\n      printedExpected,\n      printedReceived,\n      errorMessage,\n      log,\n    });\n  };\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,kBAA4B;AAC5B,yBAAqC;AAMrC,eAAsB,WAEpB,aACA,SACA,cACA,UACA,KACA,OACA,UAAgC,CAAC,GACC;AAClC,+BAAY,SAAS,CAAC,YAAY,GAAG,WAAW;AAEhD,QAAM,UAAU,QAAQ,WAAW,KAAK;AAExC,QAAM,EAAE,SAAS,MAAM,KAAK,UAAU,UAAU,aAAa,IAAI,MAAM,MAAM,CAAC,CAAC,KAAK,OAAO,OAAO;AAElG,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,MAAM;AACR,sBAAkB,iBAAiB,QAAQ;AAC3C,sBAAkB,eAAe,KAAK,aAAa,QAAQ;AAAA,EAC7D,OAAO;AACL,sBAAkB,aAAa,QAAQ;AACvC,sBAAkB,eAAe,KAAK,aAAa,QAAQ;AAAA,EAC7D;AACA,QAAM,UAAU,MAAM;AACpB,eAAO,yCAAqB,MAAM;AAAA,MAChC;AAAA,MACA,aAAa;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAEA,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

@@ -23,7 +23,6 @@ __export(toEqual_exports, {
 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 = {}) {
@@ -70,10 +69,12 @@ async function toEqual(matcherName, locator, receiverType, query, expected, opti
     );
   }
   const message = () => {
-    return (0, import_matcherHint.formatMatcherMessage)(this, {
+    return (0, import_utils.formatMatcherMessage)(this.utils, {
+      isNot: this.isNot,
+      promise: this.promise,
       matcherName,
       expectation: "expected",
-      locator,
+      locator: locator.toString(),
       timeout,
       timedOut,
       printedExpected,

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 { expectTypes } from '../util';\nimport { formatMatcherMessage } from './matcherHint';\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  locator: Locator,\n  receiverType: string,\n  query: (isNot: boolean, timeout: number) => Promise<{ matches: boolean, received?: any, log?: string[], timedOut?: boolean, errorMessage?: string }>,\n  expected: T,\n  options: { timeout?: number, contains?: boolean } = {},\n): Promise<MatcherResult<any, any>> {\n  expectTypes(locator, [receiverType], matcherName);\n\n  const timeout = options.timeout ?? this.timeout;\n\n  const { matches: pass, received, log, timedOut, errorMessage } = await query(!!this.isNot, timeout);\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 = errorMessage ? '' : `Received: ${this.utils.printReceived(received)}`;\n  } else if (errorMessage) {\n    printedExpected = `Expected: ${this.utils.printExpected(expected)}`;\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    return formatMatcherMessage(this, {\n      matcherName,\n      expectation: 'expected',\n      locator,\n      timeout,\n      timedOut,\n      printedExpected,\n      printedReceived,\n      printedDiff,\n      errorMessage,\n      log,\n    });\n  };\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,kBAA4B;AAC5B,yBAAqC;AAOrC,MAAM,iBAAiB;AACvB,MAAM,iBAAiB;AAEvB,eAAsB,QAEpB,aACA,SACA,cACA,OACA,UACA,UAAoD,CAAC,GACnB;AAClC,+BAAY,SAAS,CAAC,YAAY,GAAG,WAAW;AAEhD,QAAM,UAAU,QAAQ,WAAW,KAAK;AAExC,QAAM,EAAE,SAAS,MAAM,UAAU,KAAK,UAAU,aAAa,IAAI,MAAM,MAAM,CAAC,CAAC,KAAK,OAAO,OAAO;AAElG,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,eAAe,KAAK,aAAa,KAAK,MAAM,cAAc,QAAQ,CAAC;AAAA,EACvF,WAAW,cAAc;AACvB,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,eAAO,yCAAqB,MAAM;AAAA,MAChC;AAAA,MACA,aAAa;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAKA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR;AAAA,IAAU;AAAA,IACV,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,SAAS,WAAW,UAAU;AAAA,EAChC;AACF;",
+  "names": []
+}

package/lib/matchers/toHaveURL.js

@@ -22,9 +22,6 @@ __export(toHaveURL_exports, {
 });
 module.exports = __toCommonJS(toHaveURL_exports);
 var import_utils = require("playwright-core/lib/utils");
-var import_expect = require("./expect");
-var import_matcherHint = require("./matcherHint");
-var import_expectBundle = require("../common/expectBundle");
 async function toHaveURLWithPredicate(page, expected, options) {
   const matcherName = "toHaveURL";
   const timeout = options?.timeout ?? this.timeout;
@@ -75,18 +72,20 @@ function toHaveURLMessage(state, matcherName, expected, received, pass, timedOut
   let printedDiff;
   if (typeof expected === "function") {
     printedExpected = `Expected: predicate to ${!state.isNot ? "succeed" : "fail"}`;
-    printedReceived = `Received: ${(0, import_expectBundle.printReceived)(receivedString)}`;
+    printedReceived = `Received: ${state.utils.printReceived(receivedString)}`;
   } else {
     if (pass) {
       printedExpected = `Expected pattern: not ${state.utils.printExpected(expected)}`;
-      const formattedReceived = (0, import_expect.printReceivedStringContainExpectedResult)(receivedString, null);
+      const formattedReceived = (0, import_utils.printReceivedStringContainExpectedResult)(state.utils, receivedString, null);
       printedReceived = `Received string: ${formattedReceived}`;
     } else {
       const labelExpected = `Expected ${typeof expected === "string" ? "string" : "pattern"}`;
       printedDiff = state.utils.printDiffOrStringify(expected, receivedString, labelExpected, "Received string", false);
     }
   }
-  return (0, import_matcherHint.formatMatcherMessage)(state, {
+  return (0, import_utils.formatMatcherMessage)(state.utils, {
+    isNot: state.isNot,
+    promise: state.promise,
     matcherName,
     expectation: "expected",
     timeout,

package/lib/matchers/toHaveURL.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/matchers/toHaveURL.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\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 { urlMatches } from 'playwright-core/lib/utils';\n\nimport { printReceivedStringContainExpectedResult } from './expect';\nimport { formatMatcherMessage } from './matcherHint';\nimport { printReceived } from '../common/expectBundle';\n\nimport type { MatcherResult } from './matcherHint';\nimport type { ExpectMatcherState } from '../../types/test';\nimport type { Page } from 'playwright-core';\n\nexport async function toHaveURLWithPredicate(\n  this: ExpectMatcherState,\n  page: Page,\n  expected: (url: URL) => boolean,\n  options?: { ignoreCase?: boolean; timeout?: number },\n): Promise<MatcherResult<string | RegExp, string>> {\n  const matcherName = 'toHaveURL';\n  const timeout = options?.timeout ?? this.timeout;\n  const baseURL: string | undefined = (page.context() as any)._options.baseURL;\n  let conditionSucceeded = false;\n  let lastCheckedURLString: string | undefined = undefined;\n  try {\n    await page.mainFrame().waitForURL(\n        url => {\n          lastCheckedURLString = url.toString();\n\n          if (options?.ignoreCase) {\n            return (\n              !this.isNot ===\n              urlMatches(\n                  baseURL?.toLocaleLowerCase(),\n                  lastCheckedURLString.toLocaleLowerCase(),\n                  expected,\n              )\n            );\n          }\n\n          return (\n            !this.isNot === urlMatches(baseURL, lastCheckedURLString, expected)\n          );\n        },\n        { timeout },\n    );\n\n    conditionSucceeded = true;\n  } catch (e) {\n    conditionSucceeded = false;\n  }\n\n  if (conditionSucceeded)\n    return { name: matcherName, pass: !this.isNot, message: () => '' };\n\n  return {\n    name: matcherName,\n    pass: this.isNot,\n    message: () =>\n      toHaveURLMessage(\n          this,\n          matcherName,\n          expected,\n          lastCheckedURLString,\n          this.isNot,\n          true,\n          timeout,\n      ),\n    actual: lastCheckedURLString,\n    timeout,\n  };\n}\n\nfunction toHaveURLMessage(\n  state: ExpectMatcherState,\n  matcherName: string,\n  expected: Function,\n  received: string | undefined,\n  pass: boolean,\n  timedOut: boolean,\n  timeout: number,\n): string {\n  const receivedString = received || '';\n\n  let printedReceived: string | undefined;\n  let printedExpected: string | undefined;\n  let printedDiff: string | undefined;\n  if (typeof expected === 'function') {\n    printedExpected = `Expected: predicate to ${!state.isNot ? 'succeed' : 'fail'}`;\n    printedReceived = `Received: ${printReceived(receivedString)}`;\n  } else {\n    if (pass) {\n      printedExpected = `Expected pattern: not ${state.utils.printExpected(expected)}`;\n      const formattedReceived = printReceivedStringContainExpectedResult(receivedString, null);\n      printedReceived = `Received string: ${formattedReceived}`;\n    } else {\n      const labelExpected = `Expected ${typeof expected === 'string' ? 'string' : 'pattern'}`;\n      printedDiff = state.utils.printDiffOrStringify(expected, receivedString, labelExpected, 'Received string', false);\n    }\n  }\n\n  return formatMatcherMessage(state, {\n    matcherName,\n    expectation: 'expected',\n    timeout,\n    timedOut,\n    printedExpected,\n    printedReceived,\n    printedDiff,\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,mBAA2B;AAE3B,oBAAyD;AACzD,yBAAqC;AACrC,0BAA8B;AAM9B,eAAsB,uBAEpB,MACA,UACA,SACiD;AACjD,QAAM,cAAc;AACpB,QAAM,UAAU,SAAS,WAAW,KAAK;AACzC,QAAM,UAA+B,KAAK,QAAQ,EAAU,SAAS;AACrE,MAAI,qBAAqB;AACzB,MAAI,uBAA2C;AAC/C,MAAI;AACF,UAAM,KAAK,UAAU,EAAE;AAAA,MACnB,SAAO;AACL,+BAAuB,IAAI,SAAS;AAEpC,YAAI,SAAS,YAAY;AACvB,iBACE,CAAC,KAAK,cACN;AAAA,YACI,SAAS,kBAAkB;AAAA,YAC3B,qBAAqB,kBAAkB;AAAA,YACvC;AAAA,UACJ;AAAA,QAEJ;AAEA,eACE,CAAC,KAAK,cAAU,yBAAW,SAAS,sBAAsB,QAAQ;AAAA,MAEtE;AAAA,MACA,EAAE,QAAQ;AAAA,IACd;AAEA,yBAAqB;AAAA,EACvB,SAAS,GAAG;AACV,yBAAqB;AAAA,EACvB;AAEA,MAAI;AACF,WAAO,EAAE,MAAM,aAAa,MAAM,CAAC,KAAK,OAAO,SAAS,MAAM,GAAG;AAEnE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,KAAK;AAAA,IACX,SAAS,MACP;AAAA,MACI;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,KAAK;AAAA,MACL;AAAA,MACA;AAAA,IACJ;AAAA,IACF,QAAQ;AAAA,IACR;AAAA,EACF;AACF;AAEA,SAAS,iBACP,OACA,aACA,UACA,UACA,MACA,UACA,SACQ;AACR,QAAM,iBAAiB,YAAY;AAEnC,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI,OAAO,aAAa,YAAY;AAClC,sBAAkB,0BAA0B,CAAC,MAAM,QAAQ,YAAY,MAAM;AAC7E,sBAAkB,iBAAa,mCAAc,cAAc,CAAC;AAAA,EAC9D,OAAO;AACL,QAAI,MAAM;AACR,wBAAkB,yBAAyB,MAAM,MAAM,cAAc,QAAQ,CAAC;AAC9E,YAAM,wBAAoB,wDAAyC,gBAAgB,IAAI;AACvF,wBAAkB,oBAAoB,iBAAiB;AAAA,IACzD,OAAO;AACL,YAAM,gBAAgB,YAAY,OAAO,aAAa,WAAW,WAAW,SAAS;AACrF,oBAAc,MAAM,MAAM,qBAAqB,UAAU,gBAAgB,eAAe,mBAAmB,KAAK;AAAA,IAClH;AAAA,EACF;AAEA,aAAO,yCAAqB,OAAO;AAAA,IACjC;AAAA,IACA,aAAa;AAAA,IACb;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/lib/matchers/toMatchAriaSnapshot.js

@@ -34,9 +34,7 @@ module.exports = __toCommonJS(toMatchAriaSnapshot_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_utils = require("playwright-core/lib/utils");
-var import_matcherHint = require("./matcherHint");
 var import_util = require("../util");
-var import_expect = require("./expect");
 var import_globals = require("../common/globals");
 async function toMatchAriaSnapshot(locator, expectedParam, options = {}) {
   const matcherName = "toMatchAriaSnapshot";
@@ -79,16 +77,18 @@ async function toMatchAriaSnapshot(locator, expectedParam, options = {}) {
     if (errorMessage) {
       printedExpected = `Expected: ${this.isNot ? "not " : ""}${this.utils.printExpected(expected)}`;
     } else if (pass) {
-      const receivedString = (0, import_expect.printReceivedStringContainExpectedSubstring)(typedReceived.raw, typedReceived.raw.indexOf(expected), expected.length);
+      const receivedString = (0, import_utils.printReceivedStringContainExpectedSubstring)(this.utils, typedReceived.raw, typedReceived.raw.indexOf(expected), expected.length);
       printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;
       printedReceived = `Received: ${receivedString}`;
     } else {
       printedDiff = this.utils.printDiffOrStringify(expected, typedReceived.raw, "Expected", "Received", false);
     }
-    return (0, import_matcherHint.formatMatcherMessage)(this, {
+    return (0, import_utils.formatMatcherMessage)(this.utils, {
+      isNot: this.isNot,
+      promise: this.promise,
       matcherName,
       expectation: "expected",
-      locator,
+      locator: locator.toString(),
       timeout,
       timedOut,
       printedExpected,

package/lib/matchers/toMatchAriaSnapshot.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/matchers/toMatchAriaSnapshot.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\n\nimport fs from 'fs';\nimport path from 'path';\n\nimport { escapeTemplateString, isString } from 'playwright-core/lib/utils';\n\nimport { formatMatcherMessage } from './matcherHint';\nimport { fileExistsAsync } from '../util';\nimport { printReceivedStringContainExpectedSubstring } from './expect';\nimport { currentTestInfo } from '../common/globals';\n\nimport type { MatcherResult } from './matcherHint';\nimport type { LocatorEx } from './matchers';\nimport type { ExpectMatcherState } from '../../types/test';\nimport type { MatcherReceived } from '@injected/ariaSnapshot';\n\n\ntype ToMatchAriaSnapshotExpected = {\n  name?: string;\n  path?: string;\n  timeout?: number;\n} | string;\n\nexport async function toMatchAriaSnapshot(\n  this: ExpectMatcherState,\n  locator: LocatorEx,\n  expectedParam?: ToMatchAriaSnapshotExpected,\n  options: { timeout?: number } = {},\n): Promise<MatcherResult<string | RegExp, string>> {\n  const matcherName = 'toMatchAriaSnapshot';\n\n  const testInfo = currentTestInfo();\n  if (!testInfo)\n    throw new Error(`toMatchAriaSnapshot() must be called during the test`);\n\n  if (testInfo._projectInternal.ignoreSnapshots)\n    return { pass: !this.isNot, message: () => '', name: 'toMatchAriaSnapshot', expected: '' };\n\n  const updateSnapshots = testInfo.config.updateSnapshots;\n\n  let expected: string;\n  let timeout: number;\n  let expectedPath: string | undefined;\n  if (isString(expectedParam)) {\n    expected = expectedParam;\n    timeout = options.timeout ?? this.timeout;\n  } else {\n    const legacyPath = testInfo._resolveSnapshotPaths('aria', expectedParam?.name, 'dontUpdateSnapshotIndex', '.yml').absoluteSnapshotPath;\n    expectedPath = testInfo._resolveSnapshotPaths('aria', expectedParam?.name, 'updateSnapshotIndex').absoluteSnapshotPath;\n    // in 1.51, we changed the default template to use .aria.yml extension\n    // for backwards compatibility, we check for the legacy .yml extension\n    if (!(await fileExistsAsync(expectedPath)) && await fileExistsAsync(legacyPath))\n      expectedPath = legacyPath;\n    expected = await fs.promises.readFile(expectedPath, 'utf8').catch(() => '');\n    timeout = expectedParam?.timeout ?? this.timeout;\n  }\n\n  const generateMissingBaseline = updateSnapshots === 'missing' && !expected;\n  if (generateMissingBaseline) {\n    if (this.isNot) {\n      const message = `Matchers using \".not\" can't generate new baselines`;\n      return { pass: this.isNot, message: () => message, name: 'toMatchAriaSnapshot' };\n    } else {\n      // When generating new baseline, run entire pipeline against impossible match.\n      expected = `- none \"Generating new baseline\"`;\n    }\n  }\n\n  expected = unshift(expected);\n  const { matches: pass, received, log, timedOut, errorMessage } = await locator._expect('to.match.aria', { expectedValue: expected, isNot: this.isNot, timeout });\n  const typedReceived = received as MatcherReceived;\n\n  const message = () => {\n    let printedExpected: string | undefined;\n    let printedReceived: string | undefined;\n    let printedDiff: string | undefined;\n    if (errorMessage) {\n      printedExpected = `Expected: ${this.isNot ? 'not ' : ''}${this.utils.printExpected(expected)}`;\n    } else if (pass) {\n      const receivedString = printReceivedStringContainExpectedSubstring(typedReceived.raw, typedReceived.raw.indexOf(expected), expected.length);\n      printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;\n      printedReceived = `Received: ${receivedString}`;\n    } else {\n      printedDiff = this.utils.printDiffOrStringify(expected, typedReceived.raw, 'Expected', 'Received', false);\n    }\n    return formatMatcherMessage(this, {\n      matcherName,\n      expectation: 'expected',\n      locator,\n      timeout,\n      timedOut,\n      printedExpected,\n      printedReceived,\n      printedDiff,\n      errorMessage,\n      log,\n    });\n  };\n\n  if (errorMessage)\n    return { pass: this.isNot, message, name: 'toMatchAriaSnapshot', expected };\n\n  if (!this.isNot) {\n    if ((updateSnapshots === 'all') ||\n        (updateSnapshots === 'changed' && pass === this.isNot) ||\n        generateMissingBaseline) {\n      if (expectedPath) {\n        await fs.promises.mkdir(path.dirname(expectedPath), { recursive: true });\n        await fs.promises.writeFile(expectedPath, typedReceived.regex, 'utf8');\n        const relativePath = path.relative(process.cwd(), expectedPath);\n        if (updateSnapshots === 'missing') {\n          const message = `A snapshot doesn't exist at ${relativePath}, writing actual.`;\n          testInfo._hasNonRetriableError = true;\n          testInfo._failWithError(new Error(message));\n        } else {\n          const message = `A snapshot is generated at ${relativePath}.`;\n          /* eslint-disable no-console */\n          console.log(message);\n        }\n        return { pass: true, message: () => '', name: 'toMatchAriaSnapshot' };\n      } else {\n        const suggestedRebaseline = `\\`\\n${escapeTemplateString(indent(typedReceived.regex, '{indent}  '))}\\n{indent}\\``;\n        if (updateSnapshots === 'missing') {\n          const message = 'A snapshot is not provided, generating new baseline.';\n          testInfo._hasNonRetriableError = true;\n          testInfo._failWithError(new Error(message));\n        }\n        // TODO: ideally, we should return \"pass: true\" here because this matcher passes\n        // when regenerating baselines. However, we can only access suggestedRebaseline in case\n        // of an error, so we fail here and workaround it in the expect implementation.\n        return { pass: false, message: () => '', name: 'toMatchAriaSnapshot', suggestedRebaseline };\n      }\n    }\n  }\n\n  return {\n    name: matcherName,\n    expected,\n    message,\n    pass,\n    actual: received,\n    log,\n    timeout: timedOut ? timeout : undefined,\n  };\n}\n\nfunction unshift(snapshot: string): string {\n  const lines = snapshot.split('\\n');\n  let whitespacePrefixLength = 100;\n  for (const line of lines) {\n    if (!line.trim())\n      continue;\n    const match = line.match(/^(\\s*)/);\n    if (match && match[1].length < whitespacePrefixLength)\n      whitespacePrefixLength = match[1].length;\n  }\n  return lines.filter(t => t.trim()).map(line => line.substring(whitespacePrefixLength)).join('\\n');\n}\n\nfunction indent(snapshot: string, indent: string): string {\n  return snapshot.split('\\n').map(line => indent + line).join('\\n');\n}\n"],
+  "mappings": "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",
+  "names": ["fs", "message", "path", "indent"]
+}

package/lib/matchers/toMatchSnapshot.js

@@ -39,7 +39,6 @@ var import_utils = require("playwright-core/lib/utils");
 var import_utils2 = require("playwright-core/lib/utils");
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_util = require("../util");
-var import_matcherHint = require("./matcherHint");
 var import_globals = require("../common/globals");
 const NonConfigProperties = [
   "clip",
@@ -50,7 +49,7 @@ const NonConfigProperties = [
   "timeout"
 ];
 class SnapshotHelper {
-  constructor(testInfo, matcherName, locator, anonymousSnapshotExtension, configOptions, nameOrOptions, optOptions) {
+  constructor(state, testInfo, matcherName, locator, anonymousSnapshotExtension, configOptions, nameOrOptions, optOptions) {
     let name;
     if (Array.isArray(nameOrOptions) || typeof nameOrOptions === "string") {
       name = nameOrOptions;
@@ -90,6 +89,7 @@ class SnapshotHelper {
     this.mimeType = import_utilsBundle.mime.getType(import_path.default.basename(this.expectedPath)) ?? "application/octet-stream";
     this.comparator = (0, import_utils.getComparator)(this.mimeType);
     this.testInfo = testInfo;
+    this.state = state;
     this.kind = this.mimeType.startsWith("image/") ? "Screenshot" : "Snapshot";
   }
   createMatcherResult(message, pass, log) {
@@ -162,7 +162,7 @@ class SnapshotHelper {
       step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-diff"), contentType: this.mimeType, path: this.diffPath });
     }
     if (log?.length)
-      output.push((0, import_matcherHint.callLogText)(log));
+      output.push((0, import_utils.callLogText)(this.state.utils, log));
     else
       output.push("");
     return this.createMatcherResult(output.join("\n"), false, log);
@@ -181,6 +181,7 @@ function toMatchSnapshot(received, nameOrOptions = {}, optOptions = {}) {
     return { pass: !this.isNot, message: () => "", name: "toMatchSnapshot", expected: nameOrOptions };
   const configOptions = testInfo._projectInternal.expect?.toMatchSnapshot || {};
   const helper = new SnapshotHelper(
+    this,
     testInfo,
     "toMatchSnapshot",
     void 0,
@@ -216,7 +217,7 @@ function toMatchSnapshot(received, nameOrOptions = {}, optOptions = {}) {
   const result = helper.comparator(received, expected, helper.options);
   if (!result)
     return helper.handleMatching();
-  const header = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toMatchSnapshot", receiver: (0, import_utils.isString)(received) ? "string" : "Buffer", expectation: "expected" });
+  const header = (0, import_utils.formatMatcherMessage)(this.utils, { promise: this.promise, isNot: this.isNot, matcherName: "toMatchSnapshot", receiver: (0, import_utils.isString)(received) ? "string" : "Buffer", expectation: "expected" });
   return helper.handleDifferent(received, expected, void 0, result.diff, header, result.errorMessage, void 0, this._stepInfo);
 }
 function toHaveScreenshotStepTitle(nameOrOptions = {}, optOptions = {}) {
@@ -236,7 +237,7 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
   (0, import_util.expectTypes)(pageOrLocator, ["Page", "Locator"], "toHaveScreenshot");
   const [page, locator] = pageOrLocator.constructor.name === "Page" ? [pageOrLocator, void 0] : [pageOrLocator.page(), pageOrLocator];
   const configOptions = testInfo._projectInternal.expect?.toHaveScreenshot || {};
-  const helper = new SnapshotHelper(testInfo, "toHaveScreenshot", locator, void 0, configOptions, nameOrOptions, optOptions);
+  const helper = new SnapshotHelper(this, testInfo, "toHaveScreenshot", locator, void 0, configOptions, nameOrOptions, optOptions);
   if (!helper.expectedPath.toLowerCase().endsWith(".png"))
     throw new Error(`Screenshot name "${import_path.default.basename(helper.expectedPath)}" must have '.png' extension`);
   (0, import_util.expectTypes)(pageOrLocator, ["Page", "Locator"], "toHaveScreenshot");
@@ -273,7 +274,7 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
   if (!hasSnapshot) {
     const { actual: actual2, previous: previous2, diff: diff2, errorMessage: errorMessage2, log: log2, timedOut: timedOut2 } = await page._expectScreenshot(expectScreenshotOptions);
     if (errorMessage2) {
-      const header2 = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut: timedOut2 });
+      const header2 = (0, import_utils.formatMatcherMessage)(this.utils, { promise: this.promise, isNot: this.isNot, matcherName: "toHaveScreenshot", locator: locator?.toString(), expectation: "expected", timeout, timedOut: timedOut2 });
       return helper.handleDifferent(actual2, void 0, previous2, diff2, header2, errorMessage2, log2, this._stepInfo);
     }
     return helper.handleMissing(actual2, this._stepInfo);
@@ -297,11 +298,11 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
   if (helper.updateSnapshots === "changed" || helper.updateSnapshots === "all") {
     if (actual)
       return writeFiles(actual);
-    let header2 = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut });
+    let header2 = (0, import_utils.formatMatcherMessage)(this.utils, { promise: this.promise, isNot: this.isNot, matcherName: "toHaveScreenshot", locator: locator?.toString(), expectation: "expected", timeout, timedOut });
     header2 += "  Failed to re-generate expected.\n";
     return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header2, errorMessage, log, this._stepInfo);
   }
-  const header = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut });
+  const header = (0, import_utils.formatMatcherMessage)(this.utils, { promise: this.promise, isNot: this.isNot, matcherName: "toHaveScreenshot", locator: locator?.toString(), expectation: "expected", timeout, timedOut });
   return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);
 }
 function writeFileSync(aPath, content) {

package/lib/matchers/toMatchSnapshot.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/matchers/toMatchSnapshot.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 fs from 'fs';\nimport path from 'path';\n\nimport { compareBuffersOrStrings, getComparator, isString } from 'playwright-core/lib/utils';\nimport { colors } from 'playwright-core/lib/utils';\nimport { mime } from 'playwright-core/lib/utilsBundle';\n\nimport { addSuffixToFilePath, expectTypes } from '../util';\nimport { callLogText, formatMatcherMessage } from './matcherHint';\nimport { currentTestInfo } from '../common/globals';\n\nimport type { MatcherResult } from './matcherHint';\nimport type { ExpectMatcherStateInternal } from './matchers';\nimport type { FullProjectInternal } from '../common/config';\nimport type { TestInfoImpl, TestStepInfoImpl } from '../worker/testInfo';\nimport type { Locator, Page } from 'playwright-core';\nimport type { ExpectScreenshotOptions, Page as PageEx } from 'playwright-core/lib/client/page';\nimport type { Comparator, ImageComparatorOptions } from 'playwright-core/lib/utils';\n\ntype NameOrSegments = string | string[];\n\ntype ImageMatcherResult = MatcherResult<string, string> & { diff?: string };\n\ntype ToHaveScreenshotConfigOptions = NonNullable<NonNullable<FullProjectInternal['expect']>['toHaveScreenshot']> & {\n  _comparator?: string;\n};\n\ntype ToHaveScreenshotOptions = ToHaveScreenshotConfigOptions & {\n  clip?: {\n    x: number;\n    y: number;\n    width: number;\n    height: number;\n  };\n  fullPage?: boolean;\n  mask?: Array<Locator>;\n  maskColor?: string;\n  omitBackground?: boolean;\n  timeout?: number;\n};\n\n// Keep in sync with above (begin).\nconst NonConfigProperties: (keyof ToHaveScreenshotOptions)[] = [\n  'clip',\n  'fullPage',\n  'mask',\n  'maskColor',\n  'omitBackground',\n  'timeout',\n];\n// Keep in sync with above (end).\n\nclass SnapshotHelper {\n  readonly testInfo: TestInfoImpl;\n  readonly name: string;\n  readonly attachmentBaseName: string;\n  readonly legacyExpectedPath: string;\n  readonly previousPath: string;\n  readonly expectedPath: string;\n  readonly actualPath: string;\n  readonly diffPath: string;\n  readonly mimeType: string;\n  readonly kind: 'Screenshot'|'Snapshot';\n  readonly updateSnapshots: 'all' | 'changed' | 'missing' | 'none';\n  readonly comparator: Comparator;\n  readonly options: Omit<ToHaveScreenshotOptions, '_comparator'> & { comparator?: string };\n  readonly matcherName: string;\n  readonly locator: Locator | undefined;\n\n  constructor(\n    testInfo: TestInfoImpl,\n    matcherName: 'toMatchSnapshot' | 'toHaveScreenshot',\n    locator: Locator | undefined,\n    anonymousSnapshotExtension: string | undefined,\n    configOptions: ToHaveScreenshotConfigOptions,\n    nameOrOptions: NameOrSegments | { name?: NameOrSegments } & ToHaveScreenshotOptions,\n    optOptions: ToHaveScreenshotOptions,\n  ) {\n    let name: NameOrSegments | undefined;\n    if (Array.isArray(nameOrOptions) || typeof nameOrOptions === 'string') {\n      name = nameOrOptions;\n      this.options = { ...optOptions };\n    } else {\n      const { name: nameFromOptions, ...options } = nameOrOptions;\n      this.options = options;\n      name = nameFromOptions;\n    }\n\n    this.name = Array.isArray(name) ? name.join(path.sep) : name || '';\n    const resolvedPaths = testInfo._resolveSnapshotPaths(matcherName === 'toHaveScreenshot' ? 'screenshot' : 'snapshot', name, 'updateSnapshotIndex', anonymousSnapshotExtension);\n    this.expectedPath = resolvedPaths.absoluteSnapshotPath;\n    this.attachmentBaseName = resolvedPaths.relativeOutputPath;\n\n    const outputBasePath = testInfo._getOutputPath(resolvedPaths.relativeOutputPath);\n    this.legacyExpectedPath = addSuffixToFilePath(outputBasePath, '-expected');\n    this.previousPath = addSuffixToFilePath(outputBasePath, '-previous');\n    this.actualPath = addSuffixToFilePath(outputBasePath, '-actual');\n    this.diffPath = addSuffixToFilePath(outputBasePath, '-diff');\n\n    const filteredConfigOptions = { ...configOptions };\n    for (const prop of NonConfigProperties)\n      delete (filteredConfigOptions as any)[prop];\n    this.options = {\n      ...filteredConfigOptions,\n      ...this.options,\n    };\n\n    // While comparator is not a part of the public API, it is translated here.\n    if ((this.options as any)._comparator) {\n      this.options.comparator = (this.options as any)._comparator;\n      delete (this.options as any)._comparator;\n    }\n\n    if (this.options.maxDiffPixels !== undefined && this.options.maxDiffPixels < 0)\n      throw new Error('`maxDiffPixels` option value must be non-negative integer');\n\n    if (this.options.maxDiffPixelRatio !== undefined && (this.options.maxDiffPixelRatio < 0 || this.options.maxDiffPixelRatio > 1))\n      throw new Error('`maxDiffPixelRatio` option value must be between 0 and 1');\n\n    this.matcherName = matcherName;\n    this.locator = locator;\n\n    this.updateSnapshots = testInfo.config.updateSnapshots;\n    this.mimeType = mime.getType(path.basename(this.expectedPath)) ?? 'application/octet-stream';\n    this.comparator = getComparator(this.mimeType);\n\n    this.testInfo = testInfo;\n    this.kind = this.mimeType.startsWith('image/') ? 'Screenshot' : 'Snapshot';\n  }\n\n  createMatcherResult(message: string, pass: boolean, log?: string[]): ImageMatcherResult {\n    const unfiltered: ImageMatcherResult = {\n      name: this.matcherName,\n      expected: this.expectedPath,\n      actual: this.actualPath,\n      diff: this.diffPath,\n      pass,\n      message: () => message,\n      log,\n    };\n    return Object.fromEntries(Object.entries(unfiltered).filter(([_, v]) => v !== undefined)) as ImageMatcherResult;\n  }\n\n  handleMissingNegated(): ImageMatcherResult {\n    const isWriteMissingMode = this.updateSnapshots !== 'none';\n    const message = `A snapshot doesn't exist at ${this.expectedPath}${isWriteMissingMode ? ', matchers using \".not\" won\\'t write them automatically.' : '.'}`;\n    // NOTE: 'isNot' matcher implies inversed value.\n    return this.createMatcherResult(message, true);\n  }\n\n  handleDifferentNegated(): ImageMatcherResult {\n    // NOTE: 'isNot' matcher implies inversed value.\n    return this.createMatcherResult('', false);\n  }\n\n  handleMatchingNegated(): ImageMatcherResult {\n    const message = [\n      colors.red(`${this.kind} comparison failed:`),\n      '',\n      indent('Expected result should be different from the actual one.', '  '),\n    ].join('\\n');\n    // NOTE: 'isNot' matcher implies inversed value.\n    return this.createMatcherResult(message, true);\n  }\n\n  handleMissing(actual: Buffer | string, step: TestStepInfoImpl | undefined): ImageMatcherResult {\n    const isWriteMissingMode = this.updateSnapshots !== 'none';\n    if (isWriteMissingMode)\n      writeFileSync(this.expectedPath, actual);\n    step?._attachToStep({ name: addSuffixToFilePath(this.attachmentBaseName, '-expected'), contentType: this.mimeType, path: this.expectedPath });\n    writeFileSync(this.actualPath, actual);\n    step?._attachToStep({ name: addSuffixToFilePath(this.attachmentBaseName, '-actual'), contentType: this.mimeType, path: this.actualPath });\n    const message = `A snapshot doesn't exist at ${this.expectedPath}${isWriteMissingMode ? ', writing actual.' : '.'}`;\n    if (this.updateSnapshots === 'all' || this.updateSnapshots === 'changed') {\n      /* eslint-disable no-console */\n      console.log(message);\n      return this.createMatcherResult(message, true);\n    }\n    if (this.updateSnapshots === 'missing') {\n      this.testInfo._hasNonRetriableError = true;\n      this.testInfo._failWithError(new Error(message));\n      return this.createMatcherResult('', true);\n    }\n    return this.createMatcherResult(message, false);\n  }\n\n  handleDifferent(\n    actual: Buffer | string | undefined,\n    expected: Buffer | string | undefined,\n    previous: Buffer | string | undefined,\n    diff: Buffer | string | undefined,\n    header: string,\n    diffError: string,\n    log: string[] | undefined,\n    step: TestStepInfoImpl | undefined): ImageMatcherResult {\n    const output = [`${header}${indent(diffError, '  ')}`];\n    if (this.name) {\n      output.push('');\n      output.push(`  Snapshot: ${this.name}`);\n    }\n    if (expected !== undefined) {\n      // Copy the expectation inside the `test-results/` folder for backwards compatibility,\n      // so that one can upload `test-results/` directory and have all the data inside.\n      writeFileSync(this.legacyExpectedPath, expected);\n      step?._attachToStep({ name: addSuffixToFilePath(this.attachmentBaseName, '-expected'), contentType: this.mimeType, path: this.expectedPath });\n    }\n    if (previous !== undefined) {\n      writeFileSync(this.previousPath, previous);\n      step?._attachToStep({ name: addSuffixToFilePath(this.attachmentBaseName, '-previous'), contentType: this.mimeType, path: this.previousPath });\n    }\n    if (actual !== undefined) {\n      writeFileSync(this.actualPath, actual);\n      step?._attachToStep({ name: addSuffixToFilePath(this.attachmentBaseName, '-actual'), contentType: this.mimeType, path: this.actualPath });\n    }\n    if (diff !== undefined) {\n      writeFileSync(this.diffPath, diff);\n      step?._attachToStep({ name: addSuffixToFilePath(this.attachmentBaseName, '-diff'), contentType: this.mimeType, path: this.diffPath });\n    }\n\n    if (log?.length)\n      output.push(callLogText(log));\n    else\n      output.push('');\n\n    return this.createMatcherResult(output.join('\\n'), false, log);\n  }\n\n  handleMatching(): ImageMatcherResult {\n    return this.createMatcherResult('', true);\n  }\n}\n\nexport function toMatchSnapshot(\n  this: ExpectMatcherStateInternal,\n  received: Buffer | string,\n  nameOrOptions: NameOrSegments | { name?: NameOrSegments } & ImageComparatorOptions = {},\n  optOptions: ImageComparatorOptions = {}\n): MatcherResult<NameOrSegments | { name?: NameOrSegments }, string> {\n  const testInfo = currentTestInfo();\n  if (!testInfo)\n    throw new Error(`toMatchSnapshot() must be called during the test`);\n  if (received instanceof Promise)\n    throw new Error('An unresolved Promise was passed to toMatchSnapshot(), make sure to resolve it by adding await to it.');\n\n  if (testInfo._projectInternal.ignoreSnapshots)\n    return { pass: !this.isNot, message: () => '', name: 'toMatchSnapshot', expected: nameOrOptions };\n\n  const configOptions = testInfo._projectInternal.expect?.toMatchSnapshot || {};\n  const helper = new SnapshotHelper(\n      testInfo, 'toMatchSnapshot', undefined, '.' + determineFileExtension(received),\n      configOptions, nameOrOptions, optOptions);\n\n  if (this.isNot) {\n    if (!fs.existsSync(helper.expectedPath))\n      return helper.handleMissingNegated();\n    const isDifferent = !!helper.comparator(received, fs.readFileSync(helper.expectedPath), helper.options);\n    return isDifferent ? helper.handleDifferentNegated() : helper.handleMatchingNegated();\n  }\n\n  if (!fs.existsSync(helper.expectedPath))\n    return helper.handleMissing(received, this._stepInfo);\n\n  const expected = fs.readFileSync(helper.expectedPath);\n\n  if (helper.updateSnapshots === 'all') {\n    if (!compareBuffersOrStrings(received, expected))\n      return helper.handleMatching();\n    writeFileSync(helper.expectedPath, received);\n    /* eslint-disable no-console */\n    console.log(helper.expectedPath + ' is not the same, writing actual.');\n    return helper.createMatcherResult(helper.expectedPath + ' running with --update-snapshots, writing actual.', true);\n  }\n\n  if (helper.updateSnapshots === 'changed') {\n    const result = helper.comparator(received, expected, helper.options);\n    if (!result)\n      return helper.handleMatching();\n    writeFileSync(helper.expectedPath, received);\n    /* eslint-disable no-console */\n    console.log(helper.expectedPath + ' does not match, writing actual.');\n    return helper.createMatcherResult(helper.expectedPath + ' running with --update-snapshots, writing actual.', true);\n  }\n\n  const result = helper.comparator(received, expected, helper.options);\n  if (!result)\n    return helper.handleMatching();\n\n  const header = formatMatcherMessage(this, { matcherName: 'toMatchSnapshot', receiver: isString(received) ? 'string' : 'Buffer', expectation: 'expected' });\n  return helper.handleDifferent(received, expected, undefined, result.diff, header, result.errorMessage, undefined, this._stepInfo);\n}\n\nexport function toHaveScreenshotStepTitle(\n  nameOrOptions: NameOrSegments | { name?: NameOrSegments } & ToHaveScreenshotOptions = {},\n  optOptions: ToHaveScreenshotOptions = {}\n): string {\n  let name: NameOrSegments | undefined;\n  if (typeof nameOrOptions === 'object' && !Array.isArray(nameOrOptions))\n    name = nameOrOptions.name;\n  else\n    name = nameOrOptions;\n  return Array.isArray(name) ? name.join(path.sep) : name || '';\n}\n\nexport async function toHaveScreenshot(\n  this: ExpectMatcherStateInternal,\n  pageOrLocator: Page | Locator,\n  nameOrOptions: NameOrSegments | { name?: NameOrSegments } & ToHaveScreenshotOptions = {},\n  optOptions: ToHaveScreenshotOptions = {}\n): Promise<MatcherResult<NameOrSegments | { name?: NameOrSegments }, string>> {\n  const testInfo = currentTestInfo();\n  if (!testInfo)\n    throw new Error(`toHaveScreenshot() must be called during the test`);\n\n  if (testInfo._projectInternal.ignoreSnapshots)\n    return { pass: !this.isNot, message: () => '', name: 'toHaveScreenshot', expected: nameOrOptions };\n\n  expectTypes(pageOrLocator, ['Page', 'Locator'], 'toHaveScreenshot');\n  const [page, locator] = pageOrLocator.constructor.name === 'Page' ? [(pageOrLocator as PageEx), undefined] : [(pageOrLocator as Locator).page() as PageEx, pageOrLocator as Locator];\n  const configOptions = testInfo._projectInternal.expect?.toHaveScreenshot || {};\n  const helper = new SnapshotHelper(testInfo, 'toHaveScreenshot', locator, undefined, configOptions, nameOrOptions, optOptions);\n  if (!helper.expectedPath.toLowerCase().endsWith('.png'))\n    throw new Error(`Screenshot name \"${path.basename(helper.expectedPath)}\" must have '.png' extension`);\n  expectTypes(pageOrLocator, ['Page', 'Locator'], 'toHaveScreenshot');\n  const style = await loadScreenshotStyles(helper.options.stylePath);\n  const timeout = helper.options.timeout ?? this.timeout;\n  const expectScreenshotOptions: ExpectScreenshotOptions = {\n    locator,\n    animations: helper.options.animations ?? 'disabled',\n    caret: helper.options.caret ?? 'hide',\n    clip: helper.options.clip,\n    fullPage: helper.options.fullPage,\n    mask: helper.options.mask,\n    maskColor: helper.options.maskColor,\n    omitBackground: helper.options.omitBackground,\n    scale: helper.options.scale ?? 'css',\n    style,\n    isNot: !!this.isNot,\n    timeout,\n    comparator: helper.options.comparator,\n    maxDiffPixels: helper.options.maxDiffPixels,\n    maxDiffPixelRatio: helper.options.maxDiffPixelRatio,\n    threshold: helper.options.threshold,\n  };\n\n  const hasSnapshot = fs.existsSync(helper.expectedPath);\n  if (this.isNot) {\n    if (!hasSnapshot)\n      return helper.handleMissingNegated();\n\n    // Having `errorMessage` means we timed out while waiting\n    // for screenshots not to match, so screenshots\n    // are actually the same in the end.\n    expectScreenshotOptions.expected = await fs.promises.readFile(helper.expectedPath);\n    const isDifferent = !(await page._expectScreenshot(expectScreenshotOptions)).errorMessage;\n    return isDifferent ? helper.handleDifferentNegated() : helper.handleMatchingNegated();\n  }\n\n  // Fast path: there's no screenshot and we don't intend to update it.\n  if (helper.updateSnapshots === 'none' && !hasSnapshot)\n    return helper.createMatcherResult(`A snapshot doesn't exist at ${helper.expectedPath}.`, false);\n\n  if (!hasSnapshot) {\n    // Regenerate a new screenshot by waiting until two screenshots are the same.\n    const { actual, previous, diff, errorMessage, log, timedOut } = await page._expectScreenshot(expectScreenshotOptions);\n    // We tried re-generating new snapshot but failed.\n    // This can be due to e.g. spinning animation, so we want to show it as a diff.\n    if (errorMessage) {\n      const header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout, timedOut });\n      return helper.handleDifferent(actual, undefined, previous, diff, header, errorMessage, log, this._stepInfo);\n    }\n\n    // We successfully generated new screenshot.\n    return helper.handleMissing(actual!, this._stepInfo);\n  }\n\n  // General case:\n  // - snapshot exists\n  // - regular matcher (i.e. not a `.not`)\n  const expected = await fs.promises.readFile(helper.expectedPath);\n  expectScreenshotOptions.expected = helper.updateSnapshots === 'all' ? undefined : expected;\n\n  const { actual, previous, diff, errorMessage, log, timedOut } = await page._expectScreenshot(expectScreenshotOptions);\n  const writeFiles = (actualBuffer: Buffer) => {\n    writeFileSync(helper.expectedPath, actualBuffer);\n    writeFileSync(helper.actualPath, actualBuffer);\n    /* eslint-disable no-console */\n    console.log(helper.expectedPath + ' is re-generated, writing actual.');\n    return helper.createMatcherResult(helper.expectedPath + ' running with --update-snapshots, writing actual.', true);\n  };\n\n  if (!errorMessage) {\n    // Screenshot is matching, but is not necessarily the same as the expected.\n    if (helper.updateSnapshots === 'all' && actual && compareBuffersOrStrings(actual, expected)) {\n      console.log(helper.expectedPath + ' is re-generated, writing actual.');\n      return writeFiles(actual);\n    }\n    return helper.handleMatching();\n  }\n\n  if (helper.updateSnapshots === 'changed' || helper.updateSnapshots === 'all') {\n    if (actual)\n      return writeFiles(actual);\n    let header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout, timedOut });\n    header += '  Failed to re-generate expected.\\n';\n    return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);\n  }\n\n  const header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout, timedOut });\n  return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);\n}\n\nfunction writeFileSync(aPath: string, content: Buffer | string) {\n  fs.mkdirSync(path.dirname(aPath), { recursive: true });\n  fs.writeFileSync(aPath, content);\n}\n\nfunction indent(lines: string, tab: string) {\n  return lines.replace(/^(?=.+$)/gm, tab);\n}\n\nfunction determineFileExtension(file: string | Buffer): string {\n  if (typeof file === 'string')\n    return 'txt';\n  if (compareMagicBytes(file, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))\n    return 'png';\n  if (compareMagicBytes(file, [0xff, 0xd8, 0xff]))\n    return 'jpg';\n  return 'dat';\n}\n\nfunction compareMagicBytes(file: Buffer, magicBytes: number[]): boolean {\n  return Buffer.compare(Buffer.from(magicBytes), file.slice(0, magicBytes.length)) === 0;\n}\n\nasync function loadScreenshotStyles(stylePath?: string | string[]): Promise<string | undefined> {\n  if (!stylePath)\n    return;\n\n  const stylePaths = Array.isArray(stylePath) ? stylePath : [stylePath];\n  const styles = await Promise.all(stylePaths.map(async stylePath => {\n    const text = await fs.promises.readFile(stylePath, 'utf8');\n    return text.trim();\n  }));\n  return styles.join('\\n').trim() || undefined;\n}\n"],
+  "mappings": "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",
+  "names": ["import_utils", "path", "fs", "result", "actual", "previous", "diff", "errorMessage", "log", "timedOut", "header", "stylePath"]
+}

package/lib/matchers/toMatchText.js

@@ -21,17 +21,15 @@ __export(toMatchText_exports, {
   toMatchText: () => toMatchText
 });
 module.exports = __toCommonJS(toMatchText_exports);
+var import_utils = require("playwright-core/lib/utils");
 var import_util = require("../util");
-var import_expect = require("./expect");
-var import_matcherHint = require("./matcherHint");
-var import_expectBundle = require("../common/expectBundle");
 async function toMatchText(matcherName, receiver, receiverType, query, expected, options = {}) {
   (0, import_util.expectTypes)(receiver, [receiverType], matcherName);
   const locator = receiverType === "Locator" ? receiver : void 0;
   if (!(typeof expected === "string") && !(expected && typeof expected.test === "function")) {
-    const errorMessage2 = `Error: ${(0, import_expectBundle.EXPECTED_COLOR)("expected")} value must be a string or regular expression
+    const errorMessage2 = `Error: ${this.utils.EXPECTED_COLOR("expected")} value must be a string or regular expression
 ${this.utils.printWithType("Expected", expected, this.utils.printExpected)}`;
-    throw new Error((0, import_matcherHint.formatMatcherMessage)(this, { locator, matcherName, expectation: "expected", errorMessage: errorMessage2 }));
+    throw new Error((0, import_utils.formatMatcherMessage)(this.utils, { promise: this.promise, isNot: this.isNot, locator: locator?.toString(), matcherName, expectation: "expected", errorMessage: errorMessage2 }));
   }
   const timeout = options.timeout ?? this.timeout;
   const { matches: pass, received, log, timedOut, errorMessage } = await query(!!this.isNot, timeout);
@@ -53,13 +51,13 @@ ${this.utils.printWithType("Expected", expected, this.utils.printExpected)}`;
     if (typeof expected === "string") {
       printedExpected = `Expected${expectedSuffix}: not ${this.utils.printExpected(expected)}`;
       if (!errorMessage) {
-        const formattedReceived = (0, import_expect.printReceivedStringContainExpectedSubstring)(receivedString, receivedString.indexOf(expected), expected.length);
+        const formattedReceived = (0, import_utils.printReceivedStringContainExpectedSubstring)(this.utils, receivedString, receivedString.indexOf(expected), expected.length);
         printedReceived = `Received${receivedSuffix}: ${formattedReceived}`;
       }
     } else {
       printedExpected = `Expected${expectedSuffix}: not ${this.utils.printExpected(expected)}`;
       if (!errorMessage) {
-        const formattedReceived = (0, import_expect.printReceivedStringContainExpectedResult)(receivedString, typeof expected.exec === "function" ? expected.exec(receivedString) : null);
+        const formattedReceived = (0, import_utils.printReceivedStringContainExpectedResult)(this.utils, receivedString, typeof expected.exec === "function" ? expected.exec(receivedString) : null);
         printedReceived = `Received${receivedSuffix}: ${formattedReceived}`;
       }
     }
@@ -70,10 +68,12 @@ ${this.utils.printWithType("Expected", expected, this.utils.printExpected)}`;
       printedDiff = this.utils.printDiffOrStringify(expected, receivedString, `Expected${expectedSuffix}`, `Received${receivedSuffix}`, false);
   }
   const message = () => {
-    return (0, import_matcherHint.formatMatcherMessage)(this, {
+    return (0, import_utils.formatMatcherMessage)(this.utils, {
+      promise: this.promise,
+      isNot: this.isNot,
       matcherName,
       expectation: "expected",
-      locator,
+      locator: locator?.toString(),
       timeout,
       timedOut,
       printedExpected,

package/lib/matchers/toMatchText.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/matchers/toMatchText.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\n\nimport { expectTypes } from '../util';\nimport {\n  printReceivedStringContainExpectedResult,\n  printReceivedStringContainExpectedSubstring\n} from './expect';\nimport { formatMatcherMessage } from './matcherHint';\nimport { EXPECTED_COLOR } from '../common/expectBundle';\n\nimport type { MatcherResult } from './matcherHint';\nimport type { ExpectMatcherState } from '../../types/test';\nimport type { Page, Locator } from 'playwright-core';\n\nexport async function toMatchText(\n  this: ExpectMatcherState,\n  matcherName: string,\n  receiver: Locator | Page,\n  receiverType: 'Locator' | 'Page',\n  query: (isNot: boolean, timeout: number) => Promise<{ matches: boolean, received?: string, log?: string[], timedOut?: boolean, errorMessage?: string }>,\n  expected: string | RegExp,\n  options: { timeout?: number, matchSubstring?: boolean } = {},\n): Promise<MatcherResult<string | RegExp, string>> {\n  expectTypes(receiver, [receiverType], matcherName);\n  const locator = receiverType === 'Locator' ? receiver as Locator : undefined;\n\n  if (\n    !(typeof expected === 'string') &&\n    !(expected && typeof expected.test === 'function')\n  ) {\n    const errorMessage = `Error: ${EXPECTED_COLOR('expected')} value must be a string or regular expression\\n${this.utils.printWithType('Expected', expected, this.utils.printExpected)}`;\n    throw new Error(formatMatcherMessage(this, { locator, matcherName, expectation: 'expected', errorMessage }));\n  }\n\n  const timeout = options.timeout ?? this.timeout;\n\n  const { matches: pass, received, log, timedOut, errorMessage } = await query(!!this.isNot, timeout);\n\n  if (pass === !this.isNot) {\n    return {\n      name: matcherName,\n      message: () => '',\n      pass,\n      expected\n    };\n  }\n\n  const expectedSuffix = typeof expected === 'string' ? (options.matchSubstring ? ' substring' : '') : ' pattern';\n  const receivedSuffix = typeof expected === 'string' ? (options.matchSubstring ? ' string' : '') : ' string';\n  const receivedString = received || '';\n  let printedReceived: string | undefined;\n  let printedExpected: string | undefined;\n  let printedDiff: string | undefined;\n  if (pass) {\n    if (typeof expected === 'string') {\n      printedExpected = `Expected${expectedSuffix}: not ${this.utils.printExpected(expected)}`;\n      if (!errorMessage) {\n        const formattedReceived = printReceivedStringContainExpectedSubstring(receivedString, receivedString.indexOf(expected), expected.length);\n        printedReceived = `Received${receivedSuffix}: ${formattedReceived}`;\n      }\n    } else {\n      printedExpected = `Expected${expectedSuffix}: not ${this.utils.printExpected(expected)}`;\n      if (!errorMessage) {\n        const formattedReceived = printReceivedStringContainExpectedResult(receivedString, typeof expected.exec === 'function' ? expected.exec(receivedString) : null);\n        printedReceived = `Received${receivedSuffix}: ${formattedReceived}`;\n      }\n    }\n  } else {\n    if (errorMessage)\n      printedExpected = `Expected${expectedSuffix}: ${this.utils.printExpected(expected)}`;\n    else\n      printedDiff = this.utils.printDiffOrStringify(expected, receivedString, `Expected${expectedSuffix}`, `Received${receivedSuffix}`, false);\n  }\n\n  const message = () => {\n    return formatMatcherMessage(this, {\n      matcherName,\n      expectation: 'expected',\n      locator,\n      timeout,\n      timedOut,\n      printedExpected,\n      printedReceived,\n      printedDiff,\n      log,\n      errorMessage,\n    });\n  };\n\n  return {\n    name: matcherName,\n    expected,\n    message,\n    pass,\n    actual: received,\n    log,\n    timeout: timedOut ? timeout : undefined,\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,kBAA4B;AAC5B,oBAGO;AACP,yBAAqC;AACrC,0BAA+B;AAM/B,eAAsB,YAEpB,aACA,UACA,cACA,OACA,UACA,UAA0D,CAAC,GACV;AACjD,+BAAY,UAAU,CAAC,YAAY,GAAG,WAAW;AACjD,QAAM,UAAU,iBAAiB,YAAY,WAAsB;AAEnE,MACE,EAAE,OAAO,aAAa,aACtB,EAAE,YAAY,OAAO,SAAS,SAAS,aACvC;AACA,UAAMA,gBAAe,cAAU,oCAAe,UAAU,CAAC;AAAA,EAAkD,KAAK,MAAM,cAAc,YAAY,UAAU,KAAK,MAAM,aAAa,CAAC;AACnL,UAAM,IAAI,UAAM,yCAAqB,MAAM,EAAE,SAAS,aAAa,aAAa,YAAY,cAAAA,cAAa,CAAC,CAAC;AAAA,EAC7G;AAEA,QAAM,UAAU,QAAQ,WAAW,KAAK;AAExC,QAAM,EAAE,SAAS,MAAM,UAAU,KAAK,UAAU,aAAa,IAAI,MAAM,MAAM,CAAC,CAAC,KAAK,OAAO,OAAO;AAElG,MAAI,SAAS,CAAC,KAAK,OAAO;AACxB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS,MAAM;AAAA,MACf;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,iBAAiB,OAAO,aAAa,WAAY,QAAQ,iBAAiB,eAAe,KAAM;AACrG,QAAM,iBAAiB,OAAO,aAAa,WAAY,QAAQ,iBAAiB,YAAY,KAAM;AAClG,QAAM,iBAAiB,YAAY;AACnC,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI,MAAM;AACR,QAAI,OAAO,aAAa,UAAU;AAChC,wBAAkB,WAAW,cAAc,SAAS,KAAK,MAAM,cAAc,QAAQ,CAAC;AACtF,UAAI,CAAC,cAAc;AACjB,cAAM,wBAAoB,2DAA4C,gBAAgB,eAAe,QAAQ,QAAQ,GAAG,SAAS,MAAM;AACvI,0BAAkB,WAAW,cAAc,KAAK,iBAAiB;AAAA,MACnE;AAAA,IACF,OAAO;AACL,wBAAkB,WAAW,cAAc,SAAS,KAAK,MAAM,cAAc,QAAQ,CAAC;AACtF,UAAI,CAAC,cAAc;AACjB,cAAM,wBAAoB,wDAAyC,gBAAgB,OAAO,SAAS,SAAS,aAAa,SAAS,KAAK,cAAc,IAAI,IAAI;AAC7J,0BAAkB,WAAW,cAAc,KAAK,iBAAiB;AAAA,MACnE;AAAA,IACF;AAAA,EACF,OAAO;AACL,QAAI;AACF,wBAAkB,WAAW,cAAc,KAAK,KAAK,MAAM,cAAc,QAAQ,CAAC;AAAA;AAElF,oBAAc,KAAK,MAAM,qBAAqB,UAAU,gBAAgB,WAAW,cAAc,IAAI,WAAW,cAAc,IAAI,KAAK;AAAA,EAC3I;AAEA,QAAM,UAAU,MAAM;AACpB,eAAO,yCAAqB,MAAM;AAAA,MAChC;AAAA,MACA,aAAa;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA,SAAS,WAAW,UAAU;AAAA,EAChC;AACF;",
+  "names": ["errorMessage"]
+}

package/lib/mcp/browser/actions.d.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/browser/actions.d.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\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\ntype Point = { x: number, y: number };\n\nexport type ActionName =\n  'check' |\n  'click' |\n  'closePage' |\n  'fill' |\n  'navigate' |\n  'openPage' |\n  'press' |\n  'select' |\n  'uncheck' |\n  'setInputFiles' |\n  'assertText' |\n  'assertValue' |\n  'assertChecked' |\n  'assertVisible' |\n  'assertSnapshot';\n\nexport type ActionBase = {\n  name: ActionName,\n  signals: Signal[],\n  ariaSnapshot?: string,\n};\n\nexport type ActionWithSelector = ActionBase & {\n  selector: string,\n  ref?: string,\n  screenshotFull?: {\n    buffer: string;\n    mimeType: string;\n    timestamp: number;\n  };\n  screenshotElement?: {\n    buffer: string;\n    mimeType: string;\n    timestamp: number;\n  };\n};\n\nexport type ClickAction = ActionWithSelector & {\n  name: 'click',\n  button: 'left' | 'middle' | 'right',\n  modifiers: number,\n  clickCount: number,\n  position?: Point,\n};\n\nexport type CheckAction = ActionWithSelector & {\n  name: 'check',\n};\n\nexport type UncheckAction = ActionWithSelector & {\n  name: 'uncheck',\n};\n\nexport type FillAction = ActionWithSelector & {\n  name: 'fill',\n  text: string,\n};\n\nexport type NavigateAction = ActionBase & {\n  name: 'navigate',\n  url: string,\n};\n\nexport type OpenPageAction = ActionBase & {\n  name: 'openPage',\n  url: string,\n};\n\nexport type ClosesPageAction = ActionBase & {\n  name: 'closePage',\n};\n\nexport type PressAction = ActionWithSelector & {\n  name: 'press',\n  key: string,\n  modifiers: number,\n};\n\nexport type SelectAction = ActionWithSelector & {\n  name: 'select',\n  options: string[],\n};\n\nexport type SetInputFilesAction = ActionWithSelector & {\n  name: 'setInputFiles',\n  files: string[],\n  fullFiles?: {\n    name: string,\n    mimeType: string,\n    buffer: string,\n    lastModifiedMs?: number,\n  }[],\n};\n\nexport type AssertTextAction = ActionWithSelector & {\n  name: 'assertText',\n  text: string,\n  substring: boolean,\n};\n\nexport type AssertValueAction = ActionWithSelector & {\n  name: 'assertValue',\n  value: string,\n};\n\nexport type AssertCheckedAction = ActionWithSelector & {\n  name: 'assertChecked',\n  checked: boolean,\n};\n\nexport type AssertVisibleAction = ActionWithSelector & {\n  name: 'assertVisible',\n};\n\nexport type AssertSnapshotAction = ActionWithSelector & {\n  name: 'assertSnapshot',\n  ariaSnapshot: string,\n};\n\nexport type Action = ClickAction | CheckAction | ClosesPageAction | OpenPageAction | UncheckAction | FillAction | NavigateAction | PressAction | SelectAction | SetInputFilesAction | AssertTextAction | AssertValueAction | AssertCheckedAction | AssertVisibleAction | AssertSnapshotAction;\nexport type AssertAction = AssertCheckedAction | AssertValueAction | AssertTextAction | AssertVisibleAction | AssertSnapshotAction;\nexport type PerformOnRecordAction = ClickAction | CheckAction | UncheckAction | PressAction | SelectAction;\n\n// Signals.\n\nexport type BaseSignal = {\n};\n\nexport type NavigationSignal = BaseSignal & {\n  name: 'navigation',\n  url: string,\n};\n\nexport type PopupSignal = BaseSignal & {\n  name: 'popup',\n  popupAlias: string,\n};\n\nexport type DownloadSignal = BaseSignal & {\n  name: 'download',\n  downloadAlias: string,\n};\n\nexport type DialogSignal = BaseSignal & {\n  name: 'dialog',\n  dialogAlias: string,\n};\n\nexport type Signal = NavigationSignal | PopupSignal | DownloadSignal | DialogSignal;\n\nexport type FrameDescription = {\n  pageGuid: string;\n  pageAlias: string;\n  framePath: string[];\n};\n\nexport type ActionInContext = {\n  frame: FrameDescription;\n  description?: string;\n  action: Action;\n  startTime: number;\n  endTime?: number;\n};\n\nexport type SignalInContext = {\n  frame: FrameDescription;\n  signal: Signal;\n  timestamp: number;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}