flashwright 0.0.0-stage → 1.64.1-flashwright.1

package/lib/runner/index.js.txt

@@ -0,0 +1,64 @@
+# packages/playwright/lib/runner/index.js
+# total: 321.2 KB
+
+## Inlined (49)
+   1.3 KB  packages/playwright/src/isomorphic/events.ts
+   0.1 KB  packages/playwright/src/isomorphic/folders.ts
+   0.9 KB  packages/playwright/src/isomorphic/stringInternPool.ts
+  16.1 KB  packages/playwright/src/isomorphic/teleReceiver.ts
+   3.9 KB  packages/playwright/src/isomorphic/teleSuiteUpdater.ts
+   4.8 KB  packages/playwright/src/isomorphic/testServerConnection.ts
+   0.0 KB  packages/playwright/src/isomorphic/testTree.ts
+   5.4 KB  packages/playwright/src/plugins/gitCommitInfoPlugin.ts
+   8.6 KB  packages/playwright/src/plugins/webServerPlugin.ts
+  21.7 KB  packages/playwright/src/reporters/base.ts
+   4.0 KB  packages/playwright/src/reporters/blob.ts
+   6.6 KB  packages/playwright/src/reporters/coverage.ts
+   2.5 KB  packages/playwright/src/reporters/dot.ts
+   0.1 KB  packages/playwright/src/reporters/empty.ts
+   3.7 KB  packages/playwright/src/reporters/github.ts
+  26.6 KB  packages/playwright/src/reporters/html.ts
+   3.3 KB  packages/playwright/src/reporters/internalReporter.ts
+   7.2 KB  packages/playwright/src/reporters/json.ts
+  10.5 KB  packages/playwright/src/reporters/junit.ts
+   4.0 KB  packages/playwright/src/reporters/line.ts
+   9.6 KB  packages/playwright/src/reporters/list.ts
+   1.4 KB  packages/playwright/src/reporters/listModeReporter.ts
+  18.5 KB  packages/playwright/src/reporters/merge.ts
+   3.0 KB  packages/playwright/src/reporters/multiplexer.ts
+   9.0 KB  packages/playwright/src/reporters/perfetto.ts
+   2.1 KB  packages/playwright/src/reporters/reporterV2.ts
+   8.8 KB  packages/playwright/src/reporters/teleEmitter.ts
+  20.6 KB  packages/playwright/src/runner/dispatcher.ts
+   1.8 KB  packages/playwright/src/runner/fsWatcher.ts
+   0.5 KB  packages/playwright/src/runner/index.ts
+   1.7 KB  packages/playwright/src/runner/lastRun.ts
+   1.6 KB  packages/playwright/src/runner/loaderHost.ts
+  13.3 KB  packages/playwright/src/runner/loadUtils.ts
+   6.3 KB  packages/playwright/src/runner/processHost.ts
+   7.9 KB  packages/playwright/src/runner/projectUtils.ts
+   5.5 KB  packages/playwright/src/runner/rebase.ts
+   3.4 KB  packages/playwright/src/runner/reporters.ts
+   2.4 KB  packages/playwright/src/runner/reporterTestRun.ts
+   1.6 KB  packages/playwright/src/runner/sigIntWatcher.ts
+   3.5 KB  packages/playwright/src/runner/taskRunner.ts
+  15.9 KB  packages/playwright/src/runner/tasks.ts
+   2.6 KB  packages/playwright/src/runner/testDurations.ts
+   4.4 KB  packages/playwright/src/runner/testGroups.ts
+  13.2 KB  packages/playwright/src/runner/testRunner.ts
+   9.3 KB  packages/playwright/src/runner/testServer.ts
+   0.2 KB  packages/playwright/src/runner/uiModeReporter.ts
+   1.7 KB  packages/playwright/src/runner/vcs.ts
+  13.0 KB  packages/playwright/src/runner/watchMode.ts
+   2.1 KB  packages/playwright/src/runner/workerHost.ts
+
+## External (9)
+  ../common
+  ../loader/loaderProcessEntry.js
+  ../transform/babelBundle
+  ../util
+  ../worker/workerProcessEntry.js
+  ./workerStandby
+  playwright-core
+  playwright-core/lib/coreBundle
+  playwright-core/lib/utilsBundle

package/lib/runner/workerStandby.js

@@ -0,0 +1,197 @@
+"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);
+
+// packages/playwright/src/runner/workerStandby.ts
+var workerStandby_exports = {};
+__export(workerStandby_exports, {
+  discardStandbys: () => discardStandbys,
+  ensureStandbys: () => ensureStandbys,
+  ensureStandbysForConfig: () => ensureStandbysForConfig,
+  prespawnWorkerForTestCommand: () => prespawnWorkerForTestCommand,
+  recordWorkerCount: () => recordWorkerCount,
+  recordWorkerRestart: () => recordWorkerRestart,
+  takeStandby: () => takeStandby,
+  workerEntryScript: () => workerEntryScript,
+  workerEnv: () => workerEnv
+});
+module.exports = __toCommonJS(workerStandby_exports);
+var import_child_process = __toESM(require("child_process"));
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var standbys = [];
+var enabled = false;
+var hintKey;
+var workerCount = 0;
+var restartCount = 0;
+var keepSpare = false;
+var cpus = 1;
+var hadHint = false;
+var loadTimeEnvPattern = /^(PW|PLAYWRIGHT|DEBUG|NODE|FORCE_COLOR|TS_NODE|TSX)/;
+function workerEntryScript() {
+  return import_path.default.join(__dirname, "..", "worker", "workerProcessEntry.js");
+}
+function workerEnv(extraEnv) {
+  return {
+    ...process.env,
+    ...extraEnv,
+    FORCE_COLOR: "1",
+    DEBUG_COLORS: process.env.DEBUG_COLORS === void 0 ? "1" : process.env.DEBUG_COLORS
+  };
+}
+function prespawnWorkerForTestCommand(argv) {
+  if (enabled || argv[2] !== "test" || process.env.PW_DISABLE_WORKER_STANDBY || process.env.PWDEBUG)
+    return;
+  const interactive = ["--list", "--ui", "--ui-host", "--ui-port", "--debug", "-h", "--help", "--last-failed"];
+  if (argv.some((arg) => interactive.includes(arg.split("=")[0])))
+    return;
+  enabled = true;
+  hintKey = workerCountHintKey(argv);
+  process.env.FLASHWRIGHT_CONTEXT_HINT_KEY = hintKey;
+  cpus = import_os.default.availableParallelism?.() ?? import_os.default.cpus().length;
+  const hint = readWorkerCountHints()[hintKey];
+  hadHint = !!hint;
+  const count = Math.max(1, Math.min(hint?.workers || 1, cpus));
+  keepSpare = !!hint?.restarts && count < cpus;
+  for (let i = 0; i < count + (keepSpare ? 1 : 0); i++)
+    spawnStandby();
+  process.once("exit", () => {
+    discardStandbys();
+    writeWorkerCountHint();
+  });
+}
+function spawnStandby(waitsForNextPhase = false) {
+  const entryScript = workerEntryScript();
+  const env = { ...workerEnv({}), PLAYWRIGHT_TEST: "1", FLASHWRIGHT_SPECULATIVE_BROWSER: waitsForNextPhase ? "next-phase" : "1" };
+  const child = import_child_process.default.fork(entryScript, {
+    detached: false,
+    env,
+    stdio: ["ignore", "pipe", "pipe", "ipc"]
+  });
+  child.on("error", () => {
+  });
+  const ready = new Promise((resolve) => {
+    const onMessage = (message) => {
+      if (message?.method === "ready") {
+        child.off("message", onMessage);
+        resolve(true);
+      }
+    };
+    child.on("message", onMessage);
+    child.once("exit", () => resolve(false));
+  });
+  standbys.push({ child, entryScript, env, ready });
+  child.unref();
+  child.channel?.unref?.();
+}
+function recordWorkerRestart(moreTestsToRun) {
+  restartCount++;
+  if (!moreTestsToRun)
+    return;
+  keepSpare = keepSpare || workerCount < cpus;
+  setImmediate(() => ensureStandbys(1));
+}
+function ensureStandbys(count, forNextPhase = false) {
+  if (!enabled)
+    return;
+  while (standbys.length < count)
+    spawnStandby(forNextPhase);
+}
+function ensureStandbysForConfig(configuredWorkers) {
+  if (enabled && !hadHint)
+    ensureStandbys(Math.min(configuredWorkers, cpus));
+}
+function recordWorkerCount(count) {
+  workerCount = Math.max(workerCount, count);
+}
+function discardStandbys() {
+  for (const standby of standbys.splice(0))
+    release(standby.child);
+}
+function release(child) {
+  if (child.connected)
+    child.disconnect();
+}
+async function takeStandby(entryScript, env) {
+  const standby = standbys.shift();
+  if (!standby)
+    return;
+  if (keepSpare)
+    setImmediate(() => ensureStandbys(1));
+  const keys = /* @__PURE__ */ new Set([...Object.keys(env), ...Object.keys(standby.env)]);
+  const compatible = standby.entryScript === entryScript && [...keys].every((key) => !loadTimeEnvPattern.test(key) || env[key] === standby.env[key]);
+  if (!compatible || !await standby.ready) {
+    release(standby.child);
+    return;
+  }
+  standby.child.ref();
+  standby.child.channel?.ref?.();
+  return standby.child;
+}
+var hintFile = import_path.default.join(import_os.default.tmpdir(), "flashwright-worker-hints.json");
+var maxHints = 500;
+function workerCountHintKey(argv) {
+  const configIndex = argv.findIndex((arg) => arg === "-c" || arg === "--config" || arg.startsWith("--config="));
+  const config = configIndex === -1 ? "" : argv[configIndex].startsWith("--config=") ? argv[configIndex] : argv[configIndex + 1];
+  const workers = argv.find((arg) => arg.startsWith("--workers") || arg === "-j") ?? "";
+  return import_crypto.default.createHash("sha1").update([process.cwd(), config, workers].join("\0")).digest("hex").slice(0, 16);
+}
+function readWorkerCountHints() {
+  try {
+    return JSON.parse(import_fs.default.readFileSync(hintFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeWorkerCountHint() {
+  if (!workerCount || !hintKey)
+    return;
+  try {
+    const hints = readWorkerCountHints();
+    hints[hintKey] = { workers: workerCount, restarts: restartCount, usedAt: Date.now() };
+    const recent = Object.entries(hints).sort((a, b) => b[1].usedAt - a[1].usedAt).slice(0, maxHints);
+    const temporary = `${hintFile}.${process.pid}`;
+    import_fs.default.writeFileSync(temporary, JSON.stringify(Object.fromEntries(recent)));
+    import_fs.default.renameSync(temporary, hintFile);
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  discardStandbys,
+  ensureStandbys,
+  ensureStandbysForConfig,
+  prespawnWorkerForTestCommand,
+  recordWorkerCount,
+  recordWorkerRestart,
+  takeStandby,
+  workerEntryScript,
+  workerEnv
+});

package/lib/runner/workerStandby.js.txt

@@ -0,0 +1,7 @@
+# packages/playwright/lib/runner/workerStandby.js
+# total: 7.2 KB
+
+## Inlined (1)
+  5.5 KB  packages/playwright/src/runner/workerStandby.ts
+
+## External (0)

package/lib/speculativeBrowser.js

@@ -0,0 +1,128 @@
+"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 speculativeBrowser_exports = {};
+__export(speculativeBrowser_exports, {
+  launchSpeculativeBrowser: () => launchSpeculativeBrowser,
+  prepareSpeculativeContext: () => prepareSpeculativeContext,
+  rememberRecycledContext: () => rememberRecycledContext,
+  takeSpeculativeBrowser: () => takeSpeculativeBrowser
+});
+module.exports = __toCommonJS(speculativeBrowser_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_util = require("util");
+const speculativeOptions = { handleSIGINT: false, headless: true, ...process.env.FLASHWRIGHT_ISOLATION === "strict" ? {} : { recycleContexts: true } };
+const speculativeKey = /* @__PURE__ */ Symbol.for("flashwright.speculativeBrowser");
+function launchSpeculativeBrowser() {
+  const playwright = require("playwright-core");
+  const launch = playwright.chromium.launch(speculativeOptions).catch(() => void 0);
+  globalThis[speculativeKey] = launch;
+  return launch;
+}
+function prepareSpeculativeContext() {
+  const launch = globalThis[speculativeKey];
+  const hint = speculativeOptions.recycleContexts ? readContextHint() : void 0;
+  if (!launch || !hint)
+    return;
+  globalThis[speculativeKey] = launch.then(async (browser) => {
+    const serverBrowser = browser && browser._connection.toImpl?.(browser);
+    await serverBrowser?.prepareRecycledContext(hint.params, { storageState: hint.storageState }).catch(() => {
+    });
+    return browser;
+  });
+}
+const contextHintFile = import_path.default.join(import_os.default.tmpdir(), "flashwright-context-hints.json");
+const maxContextHints = 200;
+let rememberedContextHint = false;
+function readContextHints() {
+  try {
+    return JSON.parse(import_fs.default.readFileSync(contextHintFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function readContextHint() {
+  const key = process.env.FLASHWRIGHT_CONTEXT_HINT_KEY;
+  return key ? readContextHints()[key] : void 0;
+}
+function rememberRecycledContext(browser) {
+  const key = process.env.FLASHWRIGHT_CONTEXT_HINT_KEY;
+  const params = { ...browser._lastRecycleParams };
+  const storageState = !!params.storageState;
+  delete params.storageState;
+  const mayHoldSecrets = params.httpCredentials || params.extraHTTPHeaders?.length || params.proxy || params.clientCertificates?.length;
+  if (rememberedContextHint || !key || !Object.keys(params).length || mayHoldSecrets || !isPlainJSON(params))
+    return;
+  rememberedContextHint = true;
+  try {
+    const hints = readContextHints();
+    if (JSON.stringify(hints[key]?.params) === JSON.stringify(params) && hints[key]?.storageState === storageState)
+      return;
+    hints[key] = { params, storageState, usedAt: Date.now() };
+    const recent = Object.entries(hints).sort((a, b) => b[1].usedAt - a[1].usedAt).slice(0, maxContextHints);
+    const temporary = `${contextHintFile}.${process.pid}`;
+    import_fs.default.writeFileSync(temporary, JSON.stringify(Object.fromEntries(recent)), { mode: 384 });
+    import_fs.default.renameSync(temporary, contextHintFile);
+  } catch {
+  }
+}
+function isPlainJSON(value) {
+  if (value === null || ["string", "number", "boolean", "undefined"].includes(typeof value))
+    return true;
+  if (Array.isArray(value))
+    return value.every(isPlainJSON);
+  return typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every(isPlainJSON);
+}
+async function takeSpeculativeBrowser(browserName, options) {
+  const launch = globalThis[speculativeKey];
+  if (!launch)
+    return;
+  delete globalThis[speculativeKey];
+  const { tracesDir, artifactsDir, ...rest } = options;
+  const browser = await launch;
+  if (!browser)
+    return;
+  const serverBrowser = browser._connection.toImpl?.(browser);
+  if (browserName !== "chromium" || !(0, import_util.isDeepStrictEqual)(rest, speculativeOptions) || !serverBrowser || !artifactsDir) {
+    browser._wrapApiCall(() => browser.close(), { internal: true }).catch(() => {
+    });
+    return;
+  }
+  await serverBrowser.setOutputDirs(artifactsDir, tracesDir || artifactsDir);
+  browser._connectToBrowserType(browser.browserType(), options, void 0);
+  return browser;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  launchSpeculativeBrowser,
+  prepareSpeculativeContext,
+  rememberRecycledContext,
+  takeSpeculativeBrowser
+});