@browsermation/browser-engine 0.0.12 → 0.0.16

package/dist/node_modules/playwright-core/lib/server/registry/oopDownloadBrowserMain.js

@@ -0,0 +1,124 @@
+"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 __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 oopDownloadBrowserMain_exports = {};
+module.exports = __toCommonJS(oopDownloadBrowserMain_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_manualPromise = require("../../utils/isomorphic/manualPromise");
+var import_network = require("../utils/network");
+var import_zipBundle = require("../../zipBundle");
+function log(message) {
+  process.send?.({ method: "log", params: { message } });
+}
+function progress(done, total) {
+  process.send?.({ method: "progress", params: { done, total } });
+}
+function browserDirectoryToMarkerFilePath(browserDirectory) {
+  return import_path.default.join(browserDirectory, "INSTALLATION_COMPLETE");
+}
+function downloadFile(options) {
+  let downloadedBytes = 0;
+  let totalBytes = 0;
+  let chunked = false;
+  const promise = new import_manualPromise.ManualPromise();
+  (0, import_network.httpRequest)({
+    url: options.url,
+    headers: {
+      "User-Agent": options.userAgent
+    },
+    socketTimeout: options.socketTimeout
+  }, (response) => {
+    log(`-- response status code: ${response.statusCode}`);
+    if (response.statusCode !== 200) {
+      let content = "";
+      const handleError = () => {
+        const error = new Error(`Download failed: server returned code ${response.statusCode} body '${content}'. URL: ${options.url}`);
+        response.resume();
+        promise.reject(error);
+      };
+      response.on("data", (chunk) => content += chunk).on("end", handleError).on("error", handleError);
+      return;
+    }
+    chunked = response.headers["transfer-encoding"] === "chunked";
+    log(`-- is chunked: ${chunked}`);
+    totalBytes = parseInt(response.headers["content-length"] || "0", 10);
+    log(`-- total bytes: ${totalBytes}`);
+    const file = import_fs.default.createWriteStream(options.zipPath);
+    file.on("finish", () => {
+      if (!chunked && downloadedBytes !== totalBytes) {
+        log(`-- download failed, size mismatch: ${downloadedBytes} != ${totalBytes}`);
+        promise.reject(new Error(`Download failed: size mismatch, file size: ${downloadedBytes}, expected size: ${totalBytes} URL: ${options.url}`));
+      } else {
+        log(`-- download complete, size: ${downloadedBytes}`);
+        promise.resolve();
+      }
+    });
+    file.on("error", (error) => promise.reject(error));
+    response.pipe(file);
+    response.on("data", onData);
+    response.on("error", (error) => {
+      file.close();
+      if (error?.code === "ECONNRESET") {
+        log(`-- download failed, server closed connection`);
+        promise.reject(new Error(`Download failed: server closed connection. URL: ${options.url}`));
+      } else {
+        log(`-- download failed, unexpected error`);
+        promise.reject(new Error(`Download failed: ${error?.message ?? error}. URL: ${options.url}`));
+      }
+    });
+  }, (error) => promise.reject(error));
+  return promise;
+  function onData(chunk) {
+    downloadedBytes += chunk.length;
+    if (!chunked)
+      progress(downloadedBytes, totalBytes);
+  }
+}
+async function main(options) {
+  await downloadFile(options);
+  log(`SUCCESS downloading ${options.title}`);
+  log(`extracting archive`);
+  await (0, import_zipBundle.extract)(options.zipPath, { dir: options.browserDirectory });
+  if (options.executablePath) {
+    log(`fixing permissions at ${options.executablePath}`);
+    await import_fs.default.promises.chmod(options.executablePath, 493);
+  }
+  await import_fs.default.promises.writeFile(browserDirectoryToMarkerFilePath(options.browserDirectory), "");
+}
+process.on("message", async (message) => {
+  const { method, params } = message;
+  if (method === "download") {
+    try {
+      await main(params);
+      process.exit(0);
+    } catch (e) {
+      console.error(e);
+      process.exit(1);
+    }
+  }
+});
+process.on("disconnect", () => {
+  process.exit(0);
+});

package/dist/node_modules/playwright-core/lib/server/screenshotter.js

@@ -0,0 +1,333 @@
+"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 screenshotter_exports = {};
+__export(screenshotter_exports, {
+  Screenshotter: () => Screenshotter,
+  validateScreenshotOptions: () => validateScreenshotOptions
+});
+module.exports = __toCommonJS(screenshotter_exports);
+var import_helper = require("./helper");
+var import_utils = require("../utils");
+var import_multimap = require("../utils/isomorphic/multimap");
+function inPagePrepareForScreenshots(screenshotStyle, hideCaret, disableAnimations, syncAnimations) {
+  if (syncAnimations) {
+    const style = document.createElement("style");
+    style.textContent = "body {}";
+    document.head.appendChild(style);
+    document.documentElement.getBoundingClientRect();
+    style.remove();
+  }
+  if (!screenshotStyle && !hideCaret && !disableAnimations)
+    return;
+  const collectRoots = (root, roots2 = []) => {
+    roots2.push(root);
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+    do {
+      const node = walker.currentNode;
+      const shadowRoot = node instanceof Element ? node.shadowRoot : null;
+      if (shadowRoot)
+        collectRoots(shadowRoot, roots2);
+    } while (walker.nextNode());
+    return roots2;
+  };
+  const roots = collectRoots(document);
+  const cleanupCallbacks = [];
+  if (screenshotStyle) {
+    for (const root of roots) {
+      const styleTag = document.createElement("style");
+      styleTag.textContent = screenshotStyle;
+      if (root === document)
+        document.documentElement.append(styleTag);
+      else
+        root.append(styleTag);
+      cleanupCallbacks.push(() => {
+        styleTag.remove();
+      });
+    }
+  }
+  if (hideCaret) {
+    const elements = /* @__PURE__ */ new Map();
+    for (const root of roots) {
+      root.querySelectorAll("input,textarea,[contenteditable]").forEach((element) => {
+        elements.set(element, {
+          value: element.style.getPropertyValue("caret-color"),
+          priority: element.style.getPropertyPriority("caret-color")
+        });
+        element.style.setProperty("caret-color", "transparent", "important");
+      });
+    }
+    cleanupCallbacks.push(() => {
+      for (const [element, value] of elements)
+        element.style.setProperty("caret-color", value.value, value.priority);
+    });
+  }
+  if (disableAnimations) {
+    const infiniteAnimationsToResume = /* @__PURE__ */ new Set();
+    const handleAnimations = (root) => {
+      for (const animation of root.getAnimations()) {
+        if (!animation.effect || animation.playbackRate === 0 || infiniteAnimationsToResume.has(animation))
+          continue;
+        const endTime = animation.effect.getComputedTiming().endTime;
+        if (Number.isFinite(endTime)) {
+          try {
+            animation.finish();
+          } catch (e) {
+          }
+        } else {
+          try {
+            animation.cancel();
+            infiniteAnimationsToResume.add(animation);
+          } catch (e) {
+          }
+        }
+      }
+    };
+    for (const root of roots) {
+      const handleRootAnimations = handleAnimations.bind(null, root);
+      handleRootAnimations();
+      root.addEventListener("transitionrun", handleRootAnimations);
+      root.addEventListener("animationstart", handleRootAnimations);
+      cleanupCallbacks.push(() => {
+        root.removeEventListener("transitionrun", handleRootAnimations);
+        root.removeEventListener("animationstart", handleRootAnimations);
+      });
+    }
+    cleanupCallbacks.push(() => {
+      for (const animation of infiniteAnimationsToResume) {
+        try {
+          animation.play();
+        } catch (e) {
+        }
+      }
+    });
+  }
+  window.__pwCleanupScreenshot = () => {
+    for (const cleanupCallback of cleanupCallbacks)
+      cleanupCallback();
+    delete window.__pwCleanupScreenshot;
+  };
+}
+class Screenshotter {
+  constructor(page) {
+    this._queue = new TaskQueue();
+    this._page = page;
+    this._queue = new TaskQueue();
+  }
+  async _originalViewportSize(progress) {
+    let viewportSize = this._page.emulatedSize()?.viewport;
+    if (!viewportSize)
+      viewportSize = await this._page.mainFrame().waitForFunctionValueInUtility(progress, () => ({ width: window.innerWidth, height: window.innerHeight }));
+    return viewportSize;
+  }
+  async _fullPageSize(progress) {
+    const fullPageSize = await this._page.mainFrame().waitForFunctionValueInUtility(progress, () => {
+      if (!document.body || !document.documentElement)
+        return null;
+      return {
+        width: Math.max(
+          document.body.scrollWidth,
+          document.documentElement.scrollWidth,
+          document.body.offsetWidth,
+          document.documentElement.offsetWidth,
+          document.body.clientWidth,
+          document.documentElement.clientWidth
+        ),
+        height: Math.max(
+          document.body.scrollHeight,
+          document.documentElement.scrollHeight,
+          document.body.offsetHeight,
+          document.documentElement.offsetHeight,
+          document.body.clientHeight,
+          document.documentElement.clientHeight
+        )
+      };
+    });
+    return fullPageSize;
+  }
+  async screenshotPage(progress, options) {
+    const format = validateScreenshotOptions(options);
+    return this._queue.postTask(async () => {
+      progress.log("taking page screenshot");
+      const viewportSize = await this._originalViewportSize(progress);
+      await this._preparePageForScreenshot(progress, this._page.mainFrame(), options.style, options.caret !== "initial", options.animations === "disabled");
+      try {
+        if (options.fullPage) {
+          const fullPageSize = await this._fullPageSize(progress);
+          let documentRect = { x: 0, y: 0, width: fullPageSize.width, height: fullPageSize.height };
+          const fitsViewport = fullPageSize.width <= viewportSize.width && fullPageSize.height <= viewportSize.height;
+          if (options.clip)
+            documentRect = trimClipToSize(options.clip, documentRect);
+          return await this._screenshot(progress, format, documentRect, void 0, fitsViewport, options);
+        }
+        const viewportRect = options.clip ? trimClipToSize(options.clip, viewportSize) : { x: 0, y: 0, ...viewportSize };
+        return await this._screenshot(progress, format, void 0, viewportRect, true, options);
+      } finally {
+        await this._restorePageAfterScreenshot();
+      }
+    });
+  }
+  async screenshotElement(progress, handle, options) {
+    const format = validateScreenshotOptions(options);
+    return this._queue.postTask(async () => {
+      progress.log("taking element screenshot");
+      const viewportSize = await this._originalViewportSize(progress);
+      await this._preparePageForScreenshot(progress, handle._frame, options.style, options.caret !== "initial", options.animations === "disabled");
+      try {
+        await handle._waitAndScrollIntoViewIfNeeded(
+          progress,
+          true
+          /* waitForVisible */
+        );
+        const boundingBox = await progress.race(handle.boundingBox());
+        (0, import_utils.assert)(boundingBox, "Node is either not visible or not an HTMLElement");
+        (0, import_utils.assert)(boundingBox.width !== 0, "Node has 0 width.");
+        (0, import_utils.assert)(boundingBox.height !== 0, "Node has 0 height.");
+        const fitsViewport = boundingBox.width <= viewportSize.width && boundingBox.height <= viewportSize.height;
+        const scrollOffset = await this._page.mainFrame().waitForFunctionValueInUtility(progress, () => ({ x: window.scrollX, y: window.scrollY }));
+        const documentRect = { ...boundingBox };
+        documentRect.x += scrollOffset.x;
+        documentRect.y += scrollOffset.y;
+        return await this._screenshot(progress, format, import_helper.helper.enclosingIntRect(documentRect), void 0, fitsViewport, options);
+      } finally {
+        await this._restorePageAfterScreenshot();
+      }
+    });
+  }
+  async _preparePageForScreenshot(progress, frame, screenshotStyle, hideCaret, disableAnimations) {
+    if (disableAnimations)
+      progress.log("  disabled all CSS animations");
+    const syncAnimations = this._page.delegate.shouldToggleStyleSheetToSyncAnimations();
+    await progress.race(this._page.safeNonStallingEvaluateInAllFrames("(" + inPagePrepareForScreenshots.toString() + `)(${JSON.stringify(screenshotStyle)}, ${hideCaret}, ${disableAnimations}, ${syncAnimations})`, "utility"));
+    try {
+      if (!process.env.PW_TEST_SCREENSHOT_NO_FONTS_READY) {
+        progress.log("waiting for fonts to load...");
+        await progress.race(frame.nonStallingEvaluateInExistingContext("document.fonts.ready", "utility").catch(() => {
+        }));
+        progress.log("fonts loaded");
+      }
+    } catch (error) {
+      await this._restorePageAfterScreenshot();
+      throw error;
+    }
+  }
+  async _restorePageAfterScreenshot() {
+    await this._page.safeNonStallingEvaluateInAllFrames("window.__pwCleanupScreenshot && window.__pwCleanupScreenshot()", "utility");
+  }
+  async _maskElements(progress, options) {
+    if (!options.mask || !options.mask.length)
+      return () => Promise.resolve();
+    const framesToParsedSelectors = new import_multimap.MultiMap();
+    await progress.race(Promise.all((options.mask || []).map(async ({ frame, selector }) => {
+      const pair = await frame.selectors.resolveFrameForSelector(selector);
+      if (pair)
+        framesToParsedSelectors.set(pair.frame, pair.info.parsed);
+    })));
+    const frames = [...framesToParsedSelectors.keys()];
+    const cleanup = async () => {
+      await Promise.all(frames.map((frame) => frame.hideHighlight()));
+    };
+    try {
+      const promises = frames.map((frame) => frame.maskSelectors(framesToParsedSelectors.get(frame), options.maskColor || "#F0F"));
+      await progress.race(Promise.all(promises));
+      return cleanup;
+    } catch (error) {
+      cleanup().catch(() => {
+      });
+      throw error;
+    }
+  }
+  async _screenshot(progress, format, documentRect, viewportRect, fitsViewport, options) {
+    if (options.__testHookBeforeScreenshot)
+      await progress.race(options.__testHookBeforeScreenshot());
+    const shouldSetDefaultBackground = options.omitBackground && format === "png";
+    if (shouldSetDefaultBackground)
+      await progress.race(this._page.delegate.setBackgroundColor({ r: 0, g: 0, b: 0, a: 0 }));
+    const cleanupHighlight = await this._maskElements(progress, options);
+    try {
+      const quality = format === "jpeg" ? options.quality ?? 80 : void 0;
+      const buffer = await this._page.delegate.takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, options.scale || "device");
+      await cleanupHighlight();
+      if (shouldSetDefaultBackground)
+        await this._page.delegate.setBackgroundColor();
+      if (options.__testHookAfterScreenshot)
+        await progress.race(options.__testHookAfterScreenshot());
+      return buffer;
+    } catch (error) {
+      cleanupHighlight().catch(() => {
+      });
+      if (shouldSetDefaultBackground)
+        this._page.delegate.setBackgroundColor().catch(() => {
+        });
+      throw error;
+    }
+  }
+}
+class TaskQueue {
+  constructor() {
+    this._chain = Promise.resolve();
+  }
+  postTask(task) {
+    const result = this._chain.then(task);
+    this._chain = result.catch(() => {
+    });
+    return result;
+  }
+}
+function trimClipToSize(clip, size) {
+  const p1 = {
+    x: Math.max(0, Math.min(clip.x, size.width)),
+    y: Math.max(0, Math.min(clip.y, size.height))
+  };
+  const p2 = {
+    x: Math.max(0, Math.min(clip.x + clip.width, size.width)),
+    y: Math.max(0, Math.min(clip.y + clip.height, size.height))
+  };
+  const result = { x: p1.x, y: p1.y, width: p2.x - p1.x, height: p2.y - p1.y };
+  (0, import_utils.assert)(result.width && result.height, "Clipped area is either empty or outside the resulting image");
+  return result;
+}
+function validateScreenshotOptions(options) {
+  let format = null;
+  if (options.type) {
+    (0, import_utils.assert)(options.type === "png" || options.type === "jpeg", "Unknown options.type value: " + options.type);
+    format = options.type;
+  }
+  if (!format)
+    format = "png";
+  if (options.quality !== void 0) {
+    (0, import_utils.assert)(format === "jpeg", "options.quality is unsupported for the " + format + " screenshots");
+    (0, import_utils.assert)(typeof options.quality === "number", "Expected options.quality to be a number but found " + typeof options.quality);
+    (0, import_utils.assert)(Number.isInteger(options.quality), "Expected options.quality to be an integer");
+    (0, import_utils.assert)(options.quality >= 0 && options.quality <= 100, "Expected options.quality to be between 0 and 100 (inclusive), got " + options.quality);
+  }
+  if (options.clip) {
+    (0, import_utils.assert)(typeof options.clip.x === "number", "Expected options.clip.x to be a number but found " + typeof options.clip.x);
+    (0, import_utils.assert)(typeof options.clip.y === "number", "Expected options.clip.y to be a number but found " + typeof options.clip.y);
+    (0, import_utils.assert)(typeof options.clip.width === "number", "Expected options.clip.width to be a number but found " + typeof options.clip.width);
+    (0, import_utils.assert)(typeof options.clip.height === "number", "Expected options.clip.height to be a number but found " + typeof options.clip.height);
+    (0, import_utils.assert)(options.clip.width !== 0, "Expected options.clip.width not to be 0.");
+    (0, import_utils.assert)(options.clip.height !== 0, "Expected options.clip.height not to be 0.");
+  }
+  return format;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Screenshotter,
+  validateScreenshotOptions
+});

package/dist/node_modules/playwright-core/lib/server/selectors.js

@@ -0,0 +1,112 @@
+"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 selectors_exports = {};
+__export(selectors_exports, {
+  Selectors: () => Selectors
+});
+module.exports = __toCommonJS(selectors_exports);
+var import_crypto = require("./utils/crypto");
+var import_selectorParser = require("../utils/isomorphic/selectorParser");
+class Selectors {
+  constructor(engines, testIdAttributeName) {
+    this.guid = `selectors@${(0, import_crypto.createGuid)()}`;
+    this._builtinEngines = /* @__PURE__ */ new Set([
+      "css",
+      "css:light",
+      "xpath",
+      "xpath:light",
+      "_react",
+      "_vue",
+      "text",
+      "text:light",
+      "id",
+      "id:light",
+      "data-testid",
+      "data-testid:light",
+      "data-test-id",
+      "data-test-id:light",
+      "data-test",
+      "data-test:light",
+      "nth",
+      "visible",
+      "internal:control",
+      "internal:has",
+      "internal:has-not",
+      "internal:has-text",
+      "internal:has-not-text",
+      "internal:and",
+      "internal:or",
+      "internal:chain",
+      "role",
+      "internal:attr",
+      "internal:label",
+      "internal:text",
+      "internal:role",
+      "internal:testid",
+      "internal:describe",
+      "aria-ref"
+    ]);
+    this._builtinEnginesInMainWorld = /* @__PURE__ */ new Set([
+      "_react",
+      "_vue"
+    ]);
+    this._engines = /* @__PURE__ */ new Map();
+    this._testIdAttributeName = testIdAttributeName ?? "data-testid";
+    for (const engine of engines)
+      this.register(engine);
+  }
+  register(engine) {
+    if (!engine.name.match(/^[a-zA-Z_0-9-]+$/))
+      throw new Error("Selector engine name may only contain [a-zA-Z0-9_] characters");
+    if (this._builtinEngines.has(engine.name) || engine.name === "zs" || engine.name === "zs:light")
+      throw new Error(`"${engine.name}" is a predefined selector engine`);
+    if (this._engines.has(engine.name))
+      throw new Error(`"${engine.name}" selector engine has been already registered`);
+    this._engines.set(engine.name, engine);
+  }
+  testIdAttributeName() {
+    return this._testIdAttributeName;
+  }
+  setTestIdAttributeName(testIdAttributeName) {
+    this._testIdAttributeName = testIdAttributeName;
+  }
+  parseSelector(selector, strict) {
+    const parsed = typeof selector === "string" ? (0, import_selectorParser.parseSelector)(selector) : selector;
+    let needsMainWorld = false;
+    (0, import_selectorParser.visitAllSelectorParts)(parsed, (part) => {
+      const name = part.name;
+      const custom = this._engines.get(name);
+      if (!custom && !this._builtinEngines.has(name))
+        throw new import_selectorParser.InvalidSelectorError(`Unknown engine "${name}" while parsing selector ${(0, import_selectorParser.stringifySelector)(parsed)}`);
+      if (custom && !custom.contentScript)
+        needsMainWorld = true;
+      if (this._builtinEnginesInMainWorld.has(name))
+        needsMainWorld = true;
+    });
+    return {
+      parsed,
+      world: needsMainWorld ? "main" : "utility",
+      strict
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Selectors
+});