@stablyai/internal-playwright 0.1.0

package/lib/matchers/toMatchSnapshot.js

@@ -0,0 +1,359 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toMatchSnapshot_exports = {};
+__export(toMatchSnapshot_exports, {
+  toHaveScreenshot: () => toHaveScreenshot,
+  toHaveScreenshotStepTitle: () => toHaveScreenshotStepTitle,
+  toMatchSnapshot: () => toMatchSnapshot
+});
+module.exports = __toCommonJS(toMatchSnapshot_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+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_healingService = require("playwright-core/lib/server/stably/autohealing/healingService");
+var import_util = require("../util");
+var import_matcherHint = require("./matcherHint");
+var import_globals = require("../common/globals");
+const NonConfigProperties = [
+  "clip",
+  "fullPage",
+  "mask",
+  "maskColor",
+  "omitBackground",
+  "timeout",
+  "autoheal"
+];
+class SnapshotHelper {
+  constructor(testInfo, matcherName, locator, anonymousSnapshotExtension, configOptions, nameOrOptions, optOptions) {
+    let name;
+    if (Array.isArray(nameOrOptions) || typeof nameOrOptions === "string") {
+      name = nameOrOptions;
+      this.options = { ...optOptions };
+    } else {
+      const { name: nameFromOptions, ...options } = nameOrOptions;
+      this.options = options;
+      name = nameFromOptions;
+    }
+    this.name = Array.isArray(name) ? name.join(import_path.default.sep) : name || "";
+    const resolvedPaths = testInfo._resolveSnapshotPaths(matcherName === "toHaveScreenshot" ? "screenshot" : "snapshot", name, "updateSnapshotIndex", anonymousSnapshotExtension);
+    this.expectedPath = resolvedPaths.absoluteSnapshotPath;
+    this.attachmentBaseName = resolvedPaths.relativeOutputPath;
+    const outputBasePath = testInfo._getOutputPath(resolvedPaths.relativeOutputPath);
+    this.legacyExpectedPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-expected");
+    this.previousPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-previous");
+    this.actualPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-actual");
+    this.diffPath = (0, import_util.addSuffixToFilePath)(outputBasePath, "-diff");
+    const filteredConfigOptions = { ...configOptions };
+    for (const prop of NonConfigProperties)
+      delete filteredConfigOptions[prop];
+    this.options = {
+      ...filteredConfigOptions,
+      ...this.options
+    };
+    if (this.options._comparator) {
+      this.options.comparator = this.options._comparator;
+      delete this.options._comparator;
+    }
+    if (this.options.maxDiffPixels !== void 0 && this.options.maxDiffPixels < 0)
+      throw new Error("`maxDiffPixels` option value must be non-negative integer");
+    if (this.options.maxDiffPixelRatio !== void 0 && (this.options.maxDiffPixelRatio < 0 || this.options.maxDiffPixelRatio > 1))
+      throw new Error("`maxDiffPixelRatio` option value must be between 0 and 1");
+    this.matcherName = matcherName;
+    this.locator = locator;
+    this.updateSnapshots = testInfo.config.updateSnapshots;
+    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.kind = this.mimeType.startsWith("image/") ? "Screenshot" : "Snapshot";
+  }
+  createMatcherResult(message, pass, log) {
+    const unfiltered = {
+      name: this.matcherName,
+      expected: this.expectedPath,
+      actual: this.actualPath,
+      diff: this.diffPath,
+      pass,
+      message: () => message,
+      log
+    };
+    return Object.fromEntries(Object.entries(unfiltered).filter(([_, v]) => v !== void 0));
+  }
+  handleMissingNegated() {
+    const isWriteMissingMode = this.updateSnapshots !== "none";
+    const message = `A snapshot doesn't exist at ${this.expectedPath}${isWriteMissingMode ? `, matchers using ".not" won't write them automatically.` : "."}`;
+    return this.createMatcherResult(message, true);
+  }
+  handleDifferentNegated() {
+    return this.createMatcherResult("", false);
+  }
+  handleMatchingNegated() {
+    const message = [
+      import_utils2.colors.red(`${this.kind} comparison failed:`),
+      "",
+      indent("Expected result should be different from the actual one.", "  ")
+    ].join("\n");
+    return this.createMatcherResult(message, true);
+  }
+  handleMissing(actual, step) {
+    const isWriteMissingMode = this.updateSnapshots !== "none";
+    if (isWriteMissingMode)
+      writeFileSync(this.expectedPath, actual);
+    step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-expected"), contentType: this.mimeType, path: this.expectedPath });
+    writeFileSync(this.actualPath, actual);
+    step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-actual"), contentType: this.mimeType, path: this.actualPath });
+    const message = `A snapshot doesn't exist at ${this.expectedPath}${isWriteMissingMode ? ", writing actual." : "."}`;
+    if (this.updateSnapshots === "all" || this.updateSnapshots === "changed") {
+      console.log(message);
+      return this.createMatcherResult(message, true);
+    }
+    if (this.updateSnapshots === "missing") {
+      this.testInfo._hasNonRetriableError = true;
+      this.testInfo._failWithError(new Error(message));
+      return this.createMatcherResult("", true);
+    }
+    return this.createMatcherResult(message, false);
+  }
+  handleDifferent(actual, expected, previous, diff, header, diffError, log, step) {
+    const output = [`${header}${indent(diffError, "  ")}`];
+    if (this.name) {
+      output.push("");
+      output.push(`  Snapshot: ${this.name}`);
+    }
+    if (expected !== void 0) {
+      writeFileSync(this.legacyExpectedPath, expected);
+      step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-expected"), contentType: this.mimeType, path: this.expectedPath });
+    }
+    if (previous !== void 0) {
+      writeFileSync(this.previousPath, previous);
+      step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-previous"), contentType: this.mimeType, path: this.previousPath });
+    }
+    if (actual !== void 0) {
+      writeFileSync(this.actualPath, actual);
+      step?._attachToStep({ name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-actual"), contentType: this.mimeType, path: this.actualPath });
+    }
+    if (diff !== void 0) {
+      writeFileSync(this.diffPath, diff);
+      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));
+    else
+      output.push("");
+    return this.createMatcherResult(output.join("\n"), false, log);
+  }
+  handleMatching() {
+    return this.createMatcherResult("", true);
+  }
+}
+function toMatchSnapshot(received, nameOrOptions = {}, optOptions = {}) {
+  const testInfo = (0, import_globals.currentTestInfo)();
+  if (!testInfo)
+    throw new Error(`toMatchSnapshot() must be called during the test`);
+  if (received instanceof Promise)
+    throw new Error("An unresolved Promise was passed to toMatchSnapshot(), make sure to resolve it by adding await to it.");
+  if (testInfo._projectInternal.ignoreSnapshots)
+    return { pass: !this.isNot, message: () => "", name: "toMatchSnapshot", expected: nameOrOptions };
+  const configOptions = testInfo._projectInternal.expect?.toMatchSnapshot || {};
+  const helper = new SnapshotHelper(
+    testInfo,
+    "toMatchSnapshot",
+    void 0,
+    "." + determineFileExtension(received),
+    configOptions,
+    nameOrOptions,
+    optOptions
+  );
+  if (this.isNot) {
+    if (!import_fs.default.existsSync(helper.expectedPath))
+      return helper.handleMissingNegated();
+    const isDifferent = !!helper.comparator(received, import_fs.default.readFileSync(helper.expectedPath), helper.options);
+    return isDifferent ? helper.handleDifferentNegated() : helper.handleMatchingNegated();
+  }
+  if (!import_fs.default.existsSync(helper.expectedPath))
+    return helper.handleMissing(received, this._stepInfo);
+  const expected = import_fs.default.readFileSync(helper.expectedPath);
+  if (helper.updateSnapshots === "all") {
+    if (!(0, import_utils.compareBuffersOrStrings)(received, expected))
+      return helper.handleMatching();
+    writeFileSync(helper.expectedPath, received);
+    console.log(helper.expectedPath + " is not the same, writing actual.");
+    return helper.createMatcherResult(helper.expectedPath + " running with --update-snapshots, writing actual.", true);
+  }
+  if (helper.updateSnapshots === "changed") {
+    const result2 = helper.comparator(received, expected, helper.options);
+    if (!result2)
+      return helper.handleMatching();
+    writeFileSync(helper.expectedPath, received);
+    console.log(helper.expectedPath + " does not match, writing actual.");
+    return helper.createMatcherResult(helper.expectedPath + " running with --update-snapshots, writing actual.", true);
+  }
+  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" });
+  return helper.handleDifferent(received, expected, void 0, result.diff, header, result.errorMessage, void 0, this._stepInfo);
+}
+function toHaveScreenshotStepTitle(nameOrOptions = {}, optOptions = {}) {
+  let name;
+  if (typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions))
+    name = nameOrOptions.name;
+  else
+    name = nameOrOptions;
+  return Array.isArray(name) ? name.join(import_path.default.sep) : name || "";
+}
+async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions = {}) {
+  const testInfo = (0, import_globals.currentTestInfo)();
+  if (!testInfo)
+    throw new Error(`toHaveScreenshot() must be called during the test`);
+  if (testInfo._projectInternal.ignoreSnapshots)
+    return { pass: !this.isNot, message: () => "", name: "toHaveScreenshot", expected: nameOrOptions };
+  (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);
+  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");
+  const style = await loadScreenshotStyles(helper.options.stylePath);
+  const timeout = helper.options.timeout ?? this.timeout;
+  const expectScreenshotOptions = {
+    locator,
+    animations: helper.options.animations ?? "disabled",
+    caret: helper.options.caret ?? "hide",
+    clip: helper.options.clip,
+    fullPage: helper.options.fullPage,
+    mask: helper.options.mask,
+    maskColor: helper.options.maskColor,
+    omitBackground: helper.options.omitBackground,
+    scale: helper.options.scale ?? "css",
+    style,
+    isNot: !!this.isNot,
+    timeout,
+    comparator: helper.options.comparator,
+    maxDiffPixels: helper.options.maxDiffPixels,
+    maxDiffPixelRatio: helper.options.maxDiffPixelRatio,
+    threshold: helper.options.threshold
+  };
+  const hasSnapshot = import_fs.default.existsSync(helper.expectedPath);
+  if (this.isNot) {
+    if (!hasSnapshot)
+      return helper.handleMissingNegated();
+    expectScreenshotOptions.expected = await import_fs.default.promises.readFile(helper.expectedPath);
+    const isDifferent = !(await page._expectScreenshot(expectScreenshotOptions)).errorMessage;
+    return isDifferent ? helper.handleDifferentNegated() : helper.handleMatchingNegated();
+  }
+  if (helper.updateSnapshots === "none" && !hasSnapshot)
+    return helper.createMatcherResult(`A snapshot doesn't exist at ${helper.expectedPath}.`, false);
+  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 });
+      return helper.handleDifferent(actual2, void 0, previous2, diff2, header2, errorMessage2, log2, this._stepInfo);
+    }
+    return helper.handleMissing(actual2, this._stepInfo);
+  }
+  const expected = await import_fs.default.promises.readFile(helper.expectedPath);
+  expectScreenshotOptions.expected = helper.updateSnapshots === "all" ? void 0 : expected;
+  const { actual, previous, diff, errorMessage, log, timedOut } = await page._expectScreenshot(expectScreenshotOptions);
+  const writeFiles = (actualBuffer) => {
+    writeFileSync(helper.expectedPath, actualBuffer);
+    writeFileSync(helper.actualPath, actualBuffer);
+    console.log(helper.expectedPath + " is re-generated, writing actual.");
+    return helper.createMatcherResult(helper.expectedPath + " running with --update-snapshots, writing actual.", true);
+  };
+  if (!errorMessage) {
+    if (helper.updateSnapshots === "all" && actual && (0, import_utils.compareBuffersOrStrings)(actual, expected)) {
+      console.log(helper.expectedPath + " is re-generated, writing actual.");
+      return writeFiles(actual);
+    }
+    return helper.handleMatching();
+  }
+  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 });
+    header2 += "  Failed to re-generate expected.\n";
+    return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header2, errorMessage, log, this._stepInfo);
+  }
+  if (helper.options.autoheal ?? (0, import_healingService.isHealingEnabled)()) {
+    if (actual && expected) {
+      try {
+        const aiScreenshotMatchJudgement = await (0, import_healingService.attemptToHaveScreenshotHealing)({
+          actualScreenshot: actual,
+          expectedScreenshot: expected
+        });
+        if (aiScreenshotMatchJudgement)
+          return helper.handleMatching();
+      } catch (healingError) {
+        const header2 = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut });
+        const healErrorMessage = `Screenshot healing failed: ${healingError instanceof Error ? healingError.message : String(healingError)}`;
+        return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header2, healErrorMessage, log, this._stepInfo);
+      }
+    }
+  }
+  const header = (0, import_matcherHint.formatMatcherMessage)(this, { matcherName: "toHaveScreenshot", locator, expectation: "expected", timeout, timedOut });
+  return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);
+}
+function writeFileSync(aPath, content) {
+  import_fs.default.mkdirSync(import_path.default.dirname(aPath), { recursive: true });
+  import_fs.default.writeFileSync(aPath, content);
+}
+function indent(lines, tab) {
+  return lines.replace(/^(?=.+$)/gm, tab);
+}
+function determineFileExtension(file) {
+  if (typeof file === "string")
+    return "txt";
+  if (compareMagicBytes(file, [137, 80, 78, 71, 13, 10, 26, 10]))
+    return "png";
+  if (compareMagicBytes(file, [255, 216, 255]))
+    return "jpg";
+  return "dat";
+}
+function compareMagicBytes(file, magicBytes) {
+  return Buffer.compare(Buffer.from(magicBytes), file.slice(0, magicBytes.length)) === 0;
+}
+async function loadScreenshotStyles(stylePath) {
+  if (!stylePath)
+    return;
+  const stylePaths = Array.isArray(stylePath) ? stylePath : [stylePath];
+  const styles = await Promise.all(stylePaths.map(async (stylePath2) => {
+    const text = await import_fs.default.promises.readFile(stylePath2, "utf8");
+    return text.trim();
+  }));
+  return styles.join("\n").trim() || void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toHaveScreenshot,
+  toHaveScreenshotStepTitle,
+  toMatchSnapshot
+});

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, callLogText, expectTypes } from '../util';\nimport {  matcherHint } 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 receiver = isString(received) ? 'string' : 'Buffer';\n  const header = matcherHint(this, undefined, 'toMatchSnapshot', receiver, undefined, undefined, undefined);\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  const receiver = locator ? 'locator' : 'page';\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 = matcherHint(this, locator, 'toHaveScreenshot', receiver, undefined, undefined, timedOut ? timeout : undefined);\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 = matcherHint(this, undefined, 'toHaveScreenshot', receiver, undefined, undefined, timedOut ? timeout : undefined);\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 = matcherHint(this, undefined, 'toHaveScreenshot', receiver, undefined, undefined, timedOut ? timeout : undefined);\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

@@ -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 toMatchText_exports = {};
+__export(toMatchText_exports, {
+  toMatchText: () => toMatchText
+});
+module.exports = __toCommonJS(toMatchText_exports);
+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
+${this.utils.printWithType("Expected", expected, this.utils.printExpected)}`;
+    throw new Error((0, import_matcherHint.formatMatcherMessage)(this, { locator, matcherName, expectation: "expected", errorMessage: errorMessage2 }));
+  }
+  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
+    };
+  }
+  const expectedSuffix = typeof expected === "string" ? options.matchSubstring ? " substring" : "" : " pattern";
+  const receivedSuffix = typeof expected === "string" ? options.matchSubstring ? " string" : "" : " string";
+  const receivedString = received || "";
+  let printedReceived;
+  let printedExpected;
+  let printedDiff;
+  if (pass) {
+    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);
+        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);
+        printedReceived = `Received${receivedSuffix}: ${formattedReceived}`;
+      }
+    }
+  } else {
+    if (errorMessage)
+      printedExpected = `Expected${expectedSuffix}: ${this.utils.printExpected(expected)}`;
+    else
+      printedDiff = this.utils.printDiffOrStringify(expected, receivedString, `Expected${expectedSuffix}`, `Received${receivedSuffix}`, false);
+  }
+  const message = () => {
+    return (0, import_matcherHint.formatMatcherMessage)(this, {
+      matcherName,
+      expectation: "expected",
+      locator,
+      timeout,
+      timedOut,
+      printedExpected,
+      printedReceived,
+      printedDiff,
+      log,
+      errorMessage
+    });
+  };
+  return {
+    name: matcherName,
+    expected,
+    message,
+    pass,
+    actual: received,
+    log,
+    timeout: timedOut ? timeout : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toMatchText
+});

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 { colors } from 'playwright-core/lib/utils';\n\nimport { callLogText, expectTypes } from '../util';\nimport {\n  printReceivedStringContainExpectedResult,\n  printReceivedStringContainExpectedSubstring\n} from './expect';\nimport { kNoElementsFoundError, matcherHint } from './matcherHint';\nimport { EXPECTED_COLOR } from '../common/expectBundle';\nimport { runBrowserBackendOnError } from '../mcp/browser/backend';\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 }>,\n  expected: string | RegExp,\n  options: { timeout?: number, matchSubstring?: boolean, receiverLabel?: string } = {},\n): Promise<MatcherResult<string | RegExp, string>> {\n  expectTypes(receiver, [receiverType], matcherName);\n\n  const matcherOptions = {\n    isNot: this.isNot,\n    promise: this.promise,\n  };\n\n  if (\n    !(typeof expected === 'string') &&\n    !(expected && typeof expected.test === 'function')\n  ) {\n    // Same format as jest's matcherErrorMessage\n    throw new Error([\n      matcherHint(this, receiverType === 'Locator' ? receiver as Locator : undefined, matcherName, options.receiverLabel ?? receiver, expected, matcherOptions, undefined, undefined, true),\n      `${colors.bold('Matcher error')}: ${EXPECTED_COLOR('expected',)} value must be a string or regular expression`,\n      this.utils.printWithType('Expected', expected, this.utils.printExpected)\n    ].join('\\n\\n'));\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    if (receiverType === 'Locator')\n      await runBrowserBackendOnError((receiver as Locator).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 stringSubstring = options.matchSubstring ? 'substring' : 'string';\n  const receivedString = received || '';\n  const notFound = received === kNoElementsFoundError;\n\n  let printedReceived: string | undefined;\n  let printedExpected: string | undefined;\n  let printedDiff: string | undefined;\n  if (pass) {\n    if (typeof expected === 'string') {\n      if (notFound) {\n        printedExpected = `Expected ${stringSubstring}: not ${this.utils.printExpected(expected)}`;\n        printedReceived = `Received: ${received}`;\n      } else {\n        printedExpected = `Expected ${stringSubstring}: not ${this.utils.printExpected(expected)}`;\n        const formattedReceived = printReceivedStringContainExpectedSubstring(receivedString, receivedString.indexOf(expected), expected.length);\n        printedReceived = `Received string: ${formattedReceived}`;\n      }\n    } else {\n      if (notFound) {\n        printedExpected = `Expected pattern: not ${this.utils.printExpected(expected)}`;\n        printedReceived = `Received: ${received}`;\n      } else {\n        printedExpected = `Expected pattern: not ${this.utils.printExpected(expected)}`;\n        const formattedReceived = printReceivedStringContainExpectedResult(receivedString, typeof expected.exec === 'function' ? expected.exec(receivedString) : null);\n        printedReceived = `Received string: ${formattedReceived}`;\n      }\n    }\n  } else {\n    const labelExpected = `Expected ${typeof expected === 'string' ? stringSubstring : 'pattern'}`;\n    if (notFound) {\n      printedExpected = `${labelExpected}: ${this.utils.printExpected(expected)}`;\n      printedReceived = `Received: ${received}`;\n    } else {\n      printedDiff = this.utils.printDiffOrStringify(expected, receivedString, labelExpected, 'Received string', false);\n    }\n  }\n\n  const message = () => {\n    const resultDetails = printedDiff ? printedDiff : printedExpected + '\\n' + printedReceived;\n    const hints = matcherHint(this, receiverType === 'Locator' ? receiver as Locator : undefined, matcherName, options.receiverLabel ?? 'locator', undefined, matcherOptions, timedOut ? timeout : undefined, resultDetails, true);\n    return hints + callLogText(log);\n  };\n\n  if (receiverType === 'Locator')\n    await runBrowserBackendOnError((receiver as Locator).page(), message);\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": "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",
+  "names": []
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 actions_d_exports = {};
+module.exports = __toCommonJS(actions_d_exports);