@stablyai/internal-playwright 0.1.12 → 0.1.13

package/lib/index.js

@@ -223,7 +223,7 @@ const playwrightFixtures = {
       testInfo._setDebugMode();
     if (autoHeal) {
       try {
-        const { setHealingConfig } = require("playwright-core/lib/server/stably/autohealing/healingService");
+        const { setHealingConfig } = require("playwright-core/lib/server/stably/auto_heal/healingService");
         setHealingConfig({
           enabled: autoHeal.enabled,
           model: autoHeal.model,

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/lib/server/stably/autohealing/healingService");
+var import_healingService = require("playwright-core/src/server/stably/auto_heal/healingService");
 var import_util = require("../util");
 var import_matcherHint = require("./matcherHint");
 var import_globals = require("../common/globals");
@@ -49,7 +49,7 @@ const NonConfigProperties = [
   "maskColor",
   "omitBackground",
   "timeout",
-  "autoheal"
+  "autoHeal"
 ];
 class SnapshotHelper {
   constructor(testInfo, matcherName, locator, anonymousSnapshotExtension, configOptions, nameOrOptions, optOptions) {
@@ -63,10 +63,17 @@ 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");
@@ -83,9 +90,13 @@ 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;
@@ -104,7 +115,9 @@ 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";
@@ -124,11 +137,18 @@ 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);
@@ -149,24 +169,38 @@ 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() {
@@ -178,9 +212,16 @@ 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,
@@ -194,7 +235,11 @@ 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))
@@ -205,28 +250,44 @@ 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 = {}) {
@@ -234,13 +295,30 @@ 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;
@@ -264,19 +342,38 @@ 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);
   }
@@ -287,7 +384,10 @@ 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)) {
@@ -297,30 +397,75 @@ 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 (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();
+        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 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 });
@@ -330,25 +475,27 @@ 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.12",
+  "version": "0.1.13",
   "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.12"
+    "playwright-core": "npm:@stablyai/internal-playwright-core@0.1.13"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/types/test.d.ts

@@ -10049,7 +10049,7 @@ export interface PageAssertionsToHaveScreenshotOptions {
    * Whether to attempt auto-healing using AI when screenshot comparison fails.  Defaults to the global healing
    * configuration.
    */
-  autoheal?: boolean;
+  autoHeal?: boolean;
 
   /**
    * When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be