playwright-codegen-pro-core 1.0.0

package/lib/server/instrumentation.js

@@ -0,0 +1,72 @@
+"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 instrumentation_exports = {};
+__export(instrumentation_exports, {
+  SdkObject: () => SdkObject,
+  createInstrumentation: () => createInstrumentation,
+  createRootSdkObject: () => createRootSdkObject
+});
+module.exports = __toCommonJS(instrumentation_exports);
+var import_events = require("events");
+var import_crypto = require("./utils/crypto");
+class SdkObject extends import_events.EventEmitter {
+  constructor(parent, guidPrefix, guid) {
+    super();
+    this.guid = guid || `${guidPrefix || ""}@${(0, import_crypto.createGuid)()}`;
+    this.setMaxListeners(0);
+    this.attribution = { ...parent.attribution };
+    this.instrumentation = parent.instrumentation;
+  }
+  closeReason() {
+    return this.attribution.page?._closeReason || this.attribution.context?._closeReason || this.attribution.browser?._closeReason;
+  }
+}
+function createRootSdkObject() {
+  const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };
+  const root = new SdkObject(fakeParent);
+  root.guid = "";
+  return root;
+}
+function createInstrumentation() {
+  const listeners = /* @__PURE__ */ new Map();
+  return new Proxy({}, {
+    get: (obj, prop) => {
+      if (typeof prop !== "string")
+        return obj[prop];
+      if (prop === "addListener")
+        return (listener, context) => listeners.set(listener, context);
+      if (prop === "removeListener")
+        return (listener) => listeners.delete(listener);
+      if (!prop.startsWith("on"))
+        return obj[prop];
+      return async (sdkObject, ...params) => {
+        for (const [listener, context] of listeners) {
+          if (!context || sdkObject.attribution.context === context)
+            await listener[prop]?.(sdkObject, ...params);
+        }
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SdkObject,
+  createInstrumentation,
+  createRootSdkObject
+});

package/lib/server/javascript.js

@@ -0,0 +1,291 @@
+"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 javascript_exports = {};
+__export(javascript_exports, {
+  ExecutionContext: () => ExecutionContext,
+  JSHandle: () => JSHandle,
+  JavaScriptErrorInEvaluate: () => JavaScriptErrorInEvaluate,
+  evaluate: () => evaluate,
+  evaluateExpression: () => evaluateExpression,
+  isJavaScriptErrorInEvaluate: () => isJavaScriptErrorInEvaluate,
+  normalizeEvaluationExpression: () => normalizeEvaluationExpression,
+  parseUnserializableValue: () => parseUnserializableValue,
+  sparseArrayToString: () => sparseArrayToString
+});
+module.exports = __toCommonJS(javascript_exports);
+var import_instrumentation = require("./instrumentation");
+var rawUtilityScriptSource = __toESM(require("../generated/utilityScriptSource"));
+var import_utils = require("../utils");
+var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+class ExecutionContext extends import_instrumentation.SdkObject {
+  constructor(parent, delegate, worldNameForTest) {
+    super(parent, "execution-context");
+    this._contextDestroyedScope = new import_manualPromise.LongStandingScope();
+    this.worldNameForTest = worldNameForTest;
+    this.delegate = delegate;
+  }
+  contextDestroyed(reason) {
+    this._contextDestroyedScope.close(new Error(reason));
+  }
+  async _raceAgainstContextDestroyed(promise) {
+    return this._contextDestroyedScope.race(promise);
+  }
+  rawEvaluateJSON(expression) {
+    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateJSON(expression));
+  }
+  rawEvaluateHandle(expression) {
+    return this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, expression));
+  }
+  async evaluateWithArguments(expression, returnByValue, values, handles) {
+    const utilityScript = await this.utilityScript();
+    return this._raceAgainstContextDestroyed(this.delegate.evaluateWithArguments(expression, returnByValue, utilityScript, values, handles));
+  }
+  getProperties(object) {
+    return this._raceAgainstContextDestroyed(this.delegate.getProperties(object));
+  }
+  releaseHandle(handle) {
+    return this.delegate.releaseHandle(handle);
+  }
+  adoptIfNeeded(handle) {
+    return null;
+  }
+  utilityScript() {
+    if (!this._utilityScriptPromise) {
+      const source = `
+      (() => {
+        const module = {};
+        ${rawUtilityScriptSource.source}
+        return new (module.exports.UtilityScript())(globalThis, ${(0, import_utils.isUnderTest)()});
+      })();`;
+      this._utilityScriptPromise = this._raceAgainstContextDestroyed(this.delegate.rawEvaluateHandle(this, source)).then((handle) => {
+        handle._setPreview("UtilityScript");
+        return handle;
+      });
+    }
+    return this._utilityScriptPromise;
+  }
+  async doSlowMo() {
+  }
+}
+class JSHandle extends import_instrumentation.SdkObject {
+  constructor(context, type, preview, objectId, value) {
+    super(context, "handle");
+    this.__jshandle = true;
+    this._disposed = false;
+    this._context = context;
+    this._objectId = objectId;
+    this._value = value;
+    this._objectType = type;
+    this._preview = this._objectId ? preview || `JSHandle@${this._objectType}` : String(value);
+    if (this._objectId && globalThis.leakedJSHandles)
+      globalThis.leakedJSHandles.set(this, new Error("Leaked JSHandle"));
+  }
+  async evaluate(pageFunction, arg) {
+    return evaluate(this._context, true, pageFunction, this, arg);
+  }
+  async evaluateHandle(pageFunction, arg) {
+    return evaluate(this._context, false, pageFunction, this, arg);
+  }
+  async evaluateExpression(expression, options, arg) {
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
+    await this._context.doSlowMo();
+    return value;
+  }
+  async evaluateExpressionHandle(expression, options, arg) {
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);
+    await this._context.doSlowMo();
+    return value;
+  }
+  async getProperty(propertyName) {
+    const objectHandle = await this.evaluateHandle((object, propertyName2) => {
+      const result2 = { __proto__: null };
+      result2[propertyName2] = object[propertyName2];
+      return result2;
+    }, propertyName);
+    const properties = await objectHandle.getProperties();
+    const result = properties.get(propertyName);
+    objectHandle.dispose();
+    return result;
+  }
+  async getProperties() {
+    if (!this._objectId)
+      return /* @__PURE__ */ new Map();
+    return this._context.getProperties(this);
+  }
+  rawValue() {
+    return this._value;
+  }
+  async jsonValue() {
+    if (!this._objectId)
+      return this._value;
+    const script = `(utilityScript, ...args) => utilityScript.jsonValue(...args)`;
+    return this._context.evaluateWithArguments(script, true, [true], [this]);
+  }
+  asElement() {
+    return null;
+  }
+  dispose() {
+    if (this._disposed)
+      return;
+    this._disposed = true;
+    if (this._objectId) {
+      this._context.releaseHandle(this).catch((e) => {
+      });
+      if (globalThis.leakedJSHandles)
+        globalThis.leakedJSHandles.delete(this);
+    }
+  }
+  toString() {
+    return this._preview;
+  }
+  _setPreviewCallback(callback) {
+    this._previewCallback = callback;
+  }
+  preview() {
+    return this._preview;
+  }
+  worldNameForTest() {
+    return this._context.worldNameForTest;
+  }
+  _setPreview(preview) {
+    this._preview = preview;
+    if (this._previewCallback)
+      this._previewCallback(preview);
+  }
+}
+async function evaluate(context, returnByValue, pageFunction, ...args) {
+  return evaluateExpression(context, String(pageFunction), { returnByValue, isFunction: typeof pageFunction === "function" }, ...args);
+}
+async function evaluateExpression(context, expression, options, ...args) {
+  expression = normalizeEvaluationExpression(expression, options.isFunction);
+  const handles = [];
+  const toDispose = [];
+  const pushHandle = (handle) => {
+    handles.push(handle);
+    return handles.length - 1;
+  };
+  args = args.map((arg) => (0, import_utilityScriptSerializers.serializeAsCallArgument)(arg, (handle) => {
+    if (handle instanceof JSHandle) {
+      if (!handle._objectId)
+        return { fallThrough: handle._value };
+      if (handle._disposed)
+        throw new JavaScriptErrorInEvaluate("JSHandle is disposed!");
+      const adopted = context.adoptIfNeeded(handle);
+      if (adopted === null)
+        return { h: pushHandle(Promise.resolve(handle)) };
+      toDispose.push(adopted);
+      return { h: pushHandle(adopted) };
+    }
+    return { fallThrough: handle };
+  }));
+  const utilityScriptObjects = [];
+  for (const handle of await Promise.all(handles)) {
+    if (handle._context !== context)
+      throw new JavaScriptErrorInEvaluate("JSHandles can be evaluated only in the context they were created!");
+    utilityScriptObjects.push(handle);
+  }
+  const utilityScriptValues = [options.isFunction, options.returnByValue, expression, args.length, ...args];
+  const script = `(utilityScript, ...args) => utilityScript.evaluate(...args)`;
+  try {
+    return await context.evaluateWithArguments(script, options.returnByValue || false, utilityScriptValues, utilityScriptObjects);
+  } finally {
+    toDispose.map((handlePromise) => handlePromise.then((handle) => handle.dispose()));
+  }
+}
+function parseUnserializableValue(unserializableValue) {
+  if (unserializableValue === "NaN")
+    return NaN;
+  if (unserializableValue === "Infinity")
+    return Infinity;
+  if (unserializableValue === "-Infinity")
+    return -Infinity;
+  if (unserializableValue === "-0")
+    return -0;
+}
+function normalizeEvaluationExpression(expression, isFunction) {
+  expression = expression.trim();
+  if (isFunction) {
+    try {
+      new Function("(" + expression + ")");
+    } catch (e1) {
+      if (expression.startsWith("async "))
+        expression = "async function " + expression.substring("async ".length);
+      else
+        expression = "function " + expression;
+      try {
+        new Function("(" + expression + ")");
+      } catch (e2) {
+        throw new Error("Passed function is not well-serializable!");
+      }
+    }
+  }
+  if (/^(async)?\s*function(\s|\()/.test(expression))
+    expression = "(" + expression + ")";
+  return expression;
+}
+class JavaScriptErrorInEvaluate extends Error {
+}
+function isJavaScriptErrorInEvaluate(error) {
+  return error instanceof JavaScriptErrorInEvaluate;
+}
+function sparseArrayToString(entries) {
+  const arrayEntries = [];
+  for (const { name, value } of entries) {
+    const index = +name;
+    if (isNaN(index) || index < 0)
+      continue;
+    arrayEntries.push({ index, value });
+  }
+  arrayEntries.sort((a, b) => a.index - b.index);
+  let lastIndex = -1;
+  const tokens = [];
+  for (const { index, value } of arrayEntries) {
+    const emptyItems = index - lastIndex - 1;
+    if (emptyItems === 1)
+      tokens.push(`empty`);
+    else if (emptyItems > 1)
+      tokens.push(`empty x ${emptyItems}`);
+    tokens.push(String(value));
+    lastIndex = index;
+  }
+  return "[" + tokens.join(", ") + "]";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExecutionContext,
+  JSHandle,
+  JavaScriptErrorInEvaluate,
+  evaluate,
+  evaluateExpression,
+  isJavaScriptErrorInEvaluate,
+  normalizeEvaluationExpression,
+  parseUnserializableValue,
+  sparseArrayToString
+});

package/lib/server/launchApp.js

@@ -0,0 +1,127 @@
+"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 launchApp_exports = {};
+__export(launchApp_exports, {
+  launchApp: () => launchApp,
+  syncLocalStorageWithSettings: () => syncLocalStorageWithSettings
+});
+module.exports = __toCommonJS(launchApp_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("../utils");
+var import_registry = require("./registry");
+var import_registry2 = require("./registry");
+var import_progress = require("./progress");
+async function launchApp(browserType, options) {
+  const args = [...options.persistentContextOptions?.args ?? []];
+  let channel = options.persistentContextOptions?.channel;
+  if (browserType.name() === "chromium") {
+    args.push(
+      "--app=data:text/html,",
+      `--window-size=${options.windowSize.width},${options.windowSize.height}`,
+      ...options.windowPosition ? [`--window-position=${options.windowPosition.x},${options.windowPosition.y}`] : [],
+      "--test-type="
+    );
+    if (!channel && !options.persistentContextOptions?.executablePath)
+      channel = (0, import_registry.findChromiumChannelBestEffort)(options.sdkLanguage);
+  }
+  const controller = new import_progress.ProgressController();
+  let context;
+  try {
+    context = await controller.run((progress) => browserType.launchPersistentContext(progress, "", {
+      ignoreDefaultArgs: ["--enable-automation"],
+      ...options?.persistentContextOptions,
+      channel,
+      noDefaultViewport: options.persistentContextOptions?.noDefaultViewport ?? true,
+      acceptDownloads: options?.persistentContextOptions?.acceptDownloads ?? ((0, import_utils.isUnderTest)() ? "accept" : "internal-browser-default"),
+      colorScheme: options?.persistentContextOptions?.colorScheme ?? "no-override",
+      args
+    }), 0);
+  } catch (error) {
+    if (channel) {
+      error = (0, import_utils.rewriteErrorMessage)(error, [
+        `Failed to launch "${channel}" channel.`,
+        "Using custom channels could lead to unexpected behavior due to Enterprise policies (chrome://policy).",
+        "Install the default browser instead:",
+        (0, import_utils.wrapInASCIIBox)(`${(0, import_registry.buildPlaywrightCLICommand)(options.sdkLanguage, "install")}`, 2)
+      ].join("\n"));
+    }
+    throw error;
+  }
+  const [page] = context.pages();
+  if (browserType.name() === "chromium" && process.platform === "darwin") {
+    context.on("page", async (newPage) => {
+      if (newPage.mainFrame().url() === "chrome://new-tab-page/") {
+        await page.bringToFront();
+        await newPage.close();
+      }
+    });
+  }
+  if (browserType.name() === "chromium")
+    await installAppIcon(page);
+  return { context, page };
+}
+async function installAppIcon(page) {
+  const icon = await import_fs.default.promises.readFile(require.resolve("./chromium/appIcon.png"));
+  const crPage = page.delegate;
+  await crPage._mainFrameSession._client.send("Browser.setDockTile", {
+    image: icon.toString("base64")
+  });
+}
+async function syncLocalStorageWithSettings(page, appName) {
+  if ((0, import_utils.isUnderTest)())
+    return;
+  const settingsFile = import_path.default.join(import_registry2.registryDirectory, ".settings", `${appName}.json`);
+  const controller = new import_progress.ProgressController();
+  await controller.run(async (progress) => {
+    await page.exposeBinding(progress, "_saveSerializedSettings", false, (_, settings2) => {
+      import_fs.default.mkdirSync(import_path.default.dirname(settingsFile), { recursive: true });
+      import_fs.default.writeFileSync(settingsFile, settings2);
+    });
+    const settings = await import_fs.default.promises.readFile(settingsFile, "utf-8").catch(() => "{}");
+    await page.addInitScript(
+      `(${String((settings2) => {
+        if (location && location.protocol === "data:")
+          return;
+        if (window.top !== window)
+          return;
+        Object.entries(settings2).map(([k, v]) => localStorage[k] = v);
+        window.saveSettings = () => {
+          window._saveSerializedSettings(JSON.stringify({ ...localStorage }));
+        };
+      })})(${settings});
+    `
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  launchApp,
+  syncLocalStorageWithSettings
+});