@stablyai/internal-playwright 0.1.13 → 0.1.15

package/lib/matchers/toMatchSnapshot.js

@@ -38,7 +38,7 @@ 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/src/server/stably/auto_heal/healingService");
+var import_healingService = require("playwright-core/lib/server/stably/auto_heal/healingService");
 var import_util = require("../util");
 var import_matcherHint = require("./matcherHint");
 var import_globals = require("../common/globals");
@@ -63,17 +63,10 @@ class SnapshotHelper {
       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
-    );
+    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
-    );
+    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");
@@ -90,13 +83,9 @@ class SnapshotHelper {
       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"
-      );
+      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"
-      );
+      throw new Error("`maxDiffPixelRatio` option value must be between 0 and 1");
     this.matcherName = matcherName;
     this.locator = locator;
     this.updateSnapshots = testInfo.config.updateSnapshots;
@@ -115,9 +104,7 @@ class SnapshotHelper {
       message: () => message,
       log
     };
-    return Object.fromEntries(
-      Object.entries(unfiltered).filter(([_, v]) => v !== void 0)
-    );
+    return Object.fromEntries(Object.entries(unfiltered).filter(([_, v]) => v !== void 0));
   }
   handleMissingNegated() {
     const isWriteMissingMode = this.updateSnapshots !== "none";
@@ -137,18 +124,11 @@ class SnapshotHelper {
   }
   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
-    });
+    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
-    });
+    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);
@@ -169,38 +149,24 @@ class SnapshotHelper {
     }
     if (expected !== void 0) {
       writeFileSync(this.legacyExpectedPath, expected);
-      step?._attachToStep({
-        name: (0, import_util.addSuffixToFilePath)(this.attachmentBaseName, "-expected"),
-        contentType: this.mimeType,
-        path: this.expectedPath
-      });
+      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
-      });
+      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
-      });
+      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
-      });
+      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("");
+    if (log?.length)
+      output.push((0, import_matcherHint.callLogText)(log));
+    else
+      output.push("");
     return this.createMatcherResult(output.join("\n"), false, log);
   }
   handleMatching() {
@@ -212,16 +178,9 @@ function toMatchSnapshot(received, nameOrOptions = {}, optOptions = {}) {
   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."
-    );
+    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
-    };
+    return { pass: !this.isNot, message: () => "", name: "toMatchSnapshot", expected: nameOrOptions };
   const configOptions = testInfo._projectInternal.expect?.toMatchSnapshot || {};
   const helper = new SnapshotHelper(
     testInfo,
@@ -235,11 +194,7 @@ function toMatchSnapshot(received, 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
-    );
+    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))
@@ -250,44 +205,28 @@ function toMatchSnapshot(received, nameOrOptions = {}, optOptions = {}) {
       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
-    );
+    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();
+    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
-    );
+    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
-  );
+  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;
+  else
+    name = nameOrOptions;
   return Array.isArray(name) ? name.join(import_path.default.sep) : name || "";
 }
 async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions = {}) {
@@ -295,30 +234,13 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
   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
-    };
+    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
-  );
+  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`
-    );
+    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;
@@ -342,38 +264,19 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
   };
   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
-    );
+    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
-    );
+    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
-      );
+      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);
   }
@@ -384,10 +287,7 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
     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
-    );
+    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)) {
@@ -397,75 +297,30 @@ async function toHaveScreenshot(pageOrLocator, nameOrOptions = {}, optOptions =
     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
-    });
+    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
-    );
+    return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header2, errorMessage, log, this._stepInfo);
   }
   if (helper.options.autoHeal ?? (0, import_healingService.isScreenshotHealingEnabled)()) {
     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 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
-        );
+        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
-  );
+  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 });
@@ -475,27 +330,25 @@ function indent(lines, tab) {
   return lines.replace(/^(?=.+$)/gm, tab);
 }
 function determineFileExtension(file) {
-  if (typeof file === "string") return "txt";
+  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";
+  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;
+  return Buffer.compare(Buffer.from(magicBytes), file.slice(0, magicBytes.length)) === 0;
 }
 async function loadScreenshotStyles(stylePath) {
-  if (!stylePath) return;
+  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();
-    })
-  );
+  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:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stablyai/internal-playwright",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -66,7 +66,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "npm:@stablyai/internal-playwright-core@0.1.13"
+    "playwright-core": "npm:@stablyai/internal-playwright-core@0.1.15"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"