@iflyrpa/playwright 1.1.2 → 1.2.0

package/dist/index.cjs

@@ -1,253 +1,238 @@
-'use strict';
-
-const actions = require('@iflyrpa/actions');
-const fs = require('node:fs');
-const path = require('node:path');
-const childProcess = require('node:child_process');
-const os = require('node:os');
-const get = require('@electron/get');
-const extract = require('extract-zip');
-const share = require('@iflyrpa/share');
-const log = require('loglevel');
-const node = require('@sentry/node');
-const pacote = require('pacote');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-const path__default = /*#__PURE__*/_interopDefaultCompat(path);
-const childProcess__default = /*#__PURE__*/_interopDefaultCompat(childProcess);
-const os__default = /*#__PURE__*/_interopDefaultCompat(os);
-const extract__default = /*#__PURE__*/_interopDefaultCompat(extract);
-const log__default = /*#__PURE__*/_interopDefaultCompat(log);
-const pacote__default = /*#__PURE__*/_interopDefaultCompat(pacote);
-
-const name = "@iflyrpa/playwright";
-const type = "module";
-const version$1 = "1.1.2";
-const main = "./dist/index.cjs";
-const module$1 = "./dist/index.mjs";
-const types = "./dist/index.d.ts";
-const scripts = {
-	build: "unbuild",
-	dev: "unbuild --stub",
-	start: "esno src/index.ts"
-};
-const author = "bijinfeng";
-const license = "ISC";
-const files = [
-	"dist"
-];
-const peerDependencies = {
-	playwright: "^1.46.1"
-};
-const devDependencies = {
-	"@iflyrpa/share": "workspace:*",
-	"@types/pacote": "^11.1.8",
-	esno: "^4.7.0",
-	playwright: "^1.46.1",
-	typescript: "^5.5.2",
-	unbuild: "^2.0.0"
-};
-const dependencies = {
-	"@iflyrpa/actions": "workspace:*",
-	"@iflyrpa/share": "workspace:*",
-	"@electron/get": "^2.0.0",
-	"@sentry/node": "^5.5.0",
-	"extract-zip": "^2.0.1",
-	loglevel: "^1.9.2",
-	pacote: "^20.0.0"
-};
-const packageJson = {
-	name: name,
-	type: type,
-	version: version$1,
-	main: main,
-	module: module$1,
-	types: types,
-	scripts: scripts,
-	author: author,
-	license: license,
-	files: files,
-	peerDependencies: peerDependencies,
-	devDependencies: devDependencies,
-	dependencies: dependencies
-};
-
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    version: ()=>src_version,
+    RpaTask: ()=>RpaTask
+});
+const actions_namespaceObject = require("@iflyrpa/actions");
+var package_namespaceObject = {
+    i8: "1.2.0"
 };
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_child_process_namespaceObject = require("node:child_process");
+var external_node_child_process_default = /*#__PURE__*/ __webpack_require__.n(external_node_child_process_namespaceObject);
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const get_namespaceObject = require("@electron/get");
+const external_extract_zip_namespaceObject = require("extract-zip");
+var external_extract_zip_default = /*#__PURE__*/ __webpack_require__.n(external_extract_zip_namespaceObject);
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
 const ELECTRON_MIRROR = "http://npmmirror.com/mirrors/electron/";
 const ELECTRON_VERSION = "22.3.27";
 class ElectronInstall {
-  constructor(task) {
-    this.task = task;
-    __publicField$4(this, "rootDir");
-    __publicField$4(this, "electronPath");
-    __publicField$4(this, "platformPath");
-    __publicField$4(this, "version", ELECTRON_VERSION);
-    this.platformPath = this.getPlatformPath();
-    this.rootDir = path__default.join(task.packagesDir, `electron@${this.version}`);
-    this.electronPath = path__default.join(this.rootDir, this.platformPath);
-  }
-  isInstalled() {
-    try {
-      if (fs__default.readFileSync(path__default.join(this.rootDir, "version"), "utf-8").replace(/^v/, "") !== this.version) {
-        return false;
-      }
-    } catch (ignored) {
-      return false;
+    isInstalled() {
+        try {
+            if (external_node_fs_default().readFileSync(external_node_path_default().join(this.rootDir, "version"), "utf-8").replace(/^v/, "") !== this.version) return false;
+        } catch (ignored) {
+            return false;
+        }
+        const electronPath = process.env.ELECTRON_OVERRIDE_DIST_PATH || external_node_path_default().join(this.rootDir, this.platformPath);
+        return external_node_fs_default().existsSync(electronPath);
     }
-    const electronPath = process.env.ELECTRON_OVERRIDE_DIST_PATH || path__default.join(this.rootDir, this.platformPath);
-    return fs__default.existsSync(electronPath);
-  }
-  getPlatformPath() {
-    const platform = process.env.npm_config_platform || os__default.platform();
-    switch (platform) {
-      case "mas":
-      case "darwin":
-        return "Electron.app/Contents/MacOS/Electron";
-      case "freebsd":
-      case "openbsd":
-      case "linux":
-        return "electron";
-      case "win32":
-        return "electron.exe";
-      default:
-        throw new Error(
-          `Electron builds are not available on platform: ${platform}`
-        );
+    getPlatformPath() {
+        const platform = process.env.npm_config_platform || external_node_os_default().platform();
+        switch(platform){
+            case "mas":
+            case "darwin":
+                return "Electron.app/Contents/MacOS/Electron";
+            case "freebsd":
+            case "openbsd":
+            case "linux":
+                return "electron";
+            case "win32":
+                return "electron.exe";
+            default:
+                throw new Error(`Electron builds are not available on platform: ${platform}`);
+        }
     }
-  }
-  async install() {
-    const installed = this.isInstalled();
-    this.task.logger.info(`electron@${this.version} \u662F\u5426\u5DF2\u5B89\u88C5\uFF1A${installed}`);
-    if (installed)
-      return this.electronPath;
-    const platform = process.env.npm_config_platform || process.platform;
-    let arch = process.env.npm_config_arch || process.arch;
-    if (platform === "darwin" && process.platform === "darwin" && arch === "x64" && process.env.npm_config_arch === void 0) {
-      try {
-        const output = childProcess__default.execSync(
-          "sysctl -in sysctl.proc_translated"
-        );
-        if (output.toString().trim() === "1") {
-          arch = "arm64";
+    async install() {
+        const installed = this.isInstalled();
+        this.task.logger.info(`electron@${this.version} 是否已安装：${installed}`);
+        if (installed) return this.electronPath;
+        const platform = process.env.npm_config_platform || process.platform;
+        let arch = process.env.npm_config_arch || process.arch;
+        if ("darwin" === platform && "darwin" === process.platform && "x64" === arch && void 0 === process.env.npm_config_arch) try {
+            const output = external_node_child_process_default().execSync("sysctl -in sysctl.proc_translated");
+            if ("1" === output.toString().trim()) arch = "arm64";
+        } catch  {}
+        try {
+            this.task.logger.info(`electron@${this.version} 开始下载资源`);
+            const zipPath = await (0, get_namespaceObject.downloadArtifact)({
+                version: this.version,
+                artifactName: "electron",
+                force: "true" === process.env.force_no_cache,
+                cacheRoot: process.env.electron_config_cache,
+                checksums: void 0,
+                mirrorOptions: {
+                    mirror: ELECTRON_MIRROR
+                },
+                platform,
+                arch
+            });
+            this.task.logger.info(`electron@${this.version} 开始解压资源`);
+            process.noAsar = true;
+            await external_extract_zip_default()(zipPath, {
+                dir: this.rootDir
+            });
+            this.task.logger.info(`electron@${this.version} 下载成功`);
+            return this.electronPath;
+        } catch (error) {
+            this.task.logger.error(`electron@${this.version} 下载失败`, error);
+            throw error;
         }
-      } catch {
-      }
     }
-    try {
-      this.task.logger.info(`electron@${this.version} \u5F00\u59CB\u4E0B\u8F7D\u8D44\u6E90`);
-      const zipPath = await get.downloadArtifact({
-        version: this.version,
-        artifactName: "electron",
-        force: process.env.force_no_cache === "true",
-        cacheRoot: process.env.electron_config_cache,
-        checksums: void 0,
-        mirrorOptions: { mirror: ELECTRON_MIRROR },
-        // 使用国内镜像下载
-        platform,
-        arch
-      });
-      this.task.logger.info(`electron@${this.version} \u5F00\u59CB\u89E3\u538B\u8D44\u6E90`);
-      process.noAsar = true;
-      await extract__default(zipPath, { dir: this.rootDir });
-      this.task.logger.info(`electron@${this.version} \u4E0B\u8F7D\u6210\u529F`);
-      return this.electronPath;
-    } catch (error) {
-      this.task.logger.error(`electron@${this.version} \u4E0B\u8F7D\u5931\u8D25`, error);
-      throw error;
+    constructor(task){
+        _define_property(this, "task", void 0);
+        _define_property(this, "rootDir", void 0);
+        _define_property(this, "electronPath", void 0);
+        _define_property(this, "platformPath", void 0);
+        _define_property(this, "version", void 0);
+        this.task = task;
+        this.version = ELECTRON_VERSION;
+        this.platformPath = this.getPlatformPath();
+        this.rootDir = external_node_path_default().join(task.packagesDir, `electron@${this.version}`);
+        this.electronPath = external_node_path_default().join(this.rootDir, this.platformPath);
     }
-  }
 }
-
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class SentryInstance {
-  constructor(dsn) {
-    __publicField$3(this, "sentry");
-    if (!dsn)
-      return;
-    this.sentry = new node.NodeClient({
-      dsn,
-      defaultIntegrations: false
+const share_namespaceObject = require("@iflyrpa/share");
+const external_loglevel_namespaceObject = require("loglevel");
+var external_loglevel_default = /*#__PURE__*/ __webpack_require__.n(external_loglevel_namespaceObject);
+const node_namespaceObject = require("@sentry/node");
+function sentry_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
     });
-  }
-  captureException(error) {
-    this.sentry?.captureException(error);
-  }
+    else obj[key] = value;
+    return obj;
+}
+class SentryInstance {
+    captureException(error) {
+        var _this_sentry;
+        null === (_this_sentry = this.sentry) || void 0 === _this_sentry || _this_sentry.captureException(error);
+    }
+    constructor(dsn){
+        sentry_define_property(this, "sentry", void 0);
+        if (!dsn) return;
+        this.sentry = new node_namespaceObject.NodeClient({
+            dsn,
+            defaultIntegrations: false
+        });
+    }
 }
 const sentry = new SentryInstance(process.env.RPA_SENTRY_DSN);
-
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-const _Logger = class _Logger {
-  constructor(cachePath) {
-    __publicField$2(this, "stream");
-    if (_Logger.instance) {
-      return _Logger.instance;
+function logger_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class Logger {
+    static getInstance(cachePath) {
+        if (!Logger.instance) Logger.instance = new Logger(cachePath);
+        return Logger.instance;
     }
-    const logFile = path__default.join(cachePath, "rpa.log");
-    share.ensureFileSync(logFile);
-    this.stream = fs__default.createWriteStream(logFile, { flags: "a" });
-    log__default.setLevel("debug");
-    log__default.methodFactory = (methodName) => {
-      return (message) => {
-        this.stream.write(
-          `[${( new Date()).toLocaleString()}] ${methodName.toUpperCase()}: ${message}
-`
-        );
-      };
-    };
-    log__default.setLevel(log__default.getLevel());
-    _Logger.instance = this;
-  }
-  static getInstance(cachePath) {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger(cachePath);
+    debug(...msg) {
+        external_loglevel_default().debug(...msg);
     }
-    return _Logger.instance;
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  debug(...msg) {
-    log__default.debug(...msg);
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  info(...msg) {
-    log__default.info(...msg);
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  warn(...msg) {
-    log__default.warn(...msg);
-  }
-  // error 级别的日志上报 sentry
-  error(prefix, err) {
-    const error = err || prefix;
-    if (err instanceof Error) {
-      err.message = `${prefix}\uFF1A${err.message}`;
+    info(...msg) {
+        external_loglevel_default().info(...msg);
     }
-    log__default.error(error);
-    sentry.captureException(error);
-  }
-  close() {
-    this.stream.end();
-  }
-};
-__publicField$2(_Logger, "instance", null);
-let Logger = _Logger;
-
+    warn(...msg) {
+        external_loglevel_default().warn(...msg);
+    }
+    error(prefix, err) {
+        let error = err || prefix;
+        if (err instanceof Error) err.message = `${prefix}：${err.message}`;
+        if ("object" == typeof err) error = `${prefix}：${JSON.stringify(err)}`;
+        external_loglevel_default().error(error);
+        sentry.captureException(error);
+    }
+    close() {
+        this.stream.end();
+    }
+    constructor(cachePath){
+        logger_define_property(this, "stream", void 0);
+        if (Logger.instance) return Logger.instance;
+        const logFile = external_node_path_default().join(cachePath, "rpa.log");
+        (0, share_namespaceObject.ensureFileSync)(logFile);
+        this.stream = external_node_fs_default().createWriteStream(logFile, {
+            flags: "a"
+        });
+        external_loglevel_default().setLevel("debug");
+        const logToFile = (level, message)=>{
+            const timestamp = new Date().toLocaleString();
+            this.stream.write(`[${timestamp}] ${level.toUpperCase()} ${message}\n`);
+        };
+        external_loglevel_default().methodFactory = (methodName, _level, _logger)=>(...messages)=>{
+                const formattedMessage = messages.map((message)=>{
+                    if (message instanceof Error) return `${message.name}: ${message.message}\n${message.stack}`;
+                    if ("object" == typeof message) return JSON.stringify(message);
+                    return message;
+                }).join(" ");
+                logToFile(methodName, formattedMessage);
+            };
+        external_loglevel_default().setLevel(external_loglevel_default().getLevel());
+        Logger.instance = this;
+    }
+}
+logger_define_property(Logger, "instance", null);
 const template = `
 const { app } = require("electron");
 
@@ -255,245 +240,223 @@ app.whenReady().then(() => {});
 
 app.on("window-all-closed", (e) => e.preventDefault());
 `;
-const generateFile = async (dir) => {
-  const filePath = path__default.join(dir, "main.js");
-  const isPathExists = await share.pathExists(filePath);
-  if (!isPathExists) {
-    await share.ensureFile(filePath);
-    await share.writeFile(filePath, template);
-  }
-  return filePath;
+const generateFile = async (dir)=>{
+    const filePath = external_node_path_default().join(dir, "main.js");
+    const isPathExists = await (0, share_namespaceObject.pathExists)(filePath);
+    if (!isPathExists) {
+        await (0, share_namespaceObject.ensureFile)(filePath);
+        await (0, share_namespaceObject.writeFile)(filePath, template);
+    }
+    return filePath;
 };
-const launchElectronApp = async (cachePath, playwright, electronPath) => {
-  const logger = Logger.getInstance(cachePath);
-  try {
-    const mainPath = await generateFile(cachePath);
-    const electronApp = await playwright._electron.launch({
-      executablePath: electronPath,
-      // 获取 Electron 可执行文件的路径
-      args: [mainPath],
-      cwd: cachePath
-    });
-    logger.info(`electron \u542F\u52A8\u6210\u529F\uFF1A${electronPath} ${mainPath}`);
-    return electronApp;
-  } catch (error) {
-    logger.error("electron \u542F\u52A8\u5931\u8D25\uFF1A", error);
-    throw error;
-  }
+const launchElectronApp = async (cachePath, playwright, electronPath)=>{
+    const logger = Logger.getInstance(cachePath);
+    try {
+        const mainPath = await generateFile(cachePath);
+        const electronApp = await playwright._electron.launch({
+            executablePath: electronPath,
+            args: [
+                mainPath
+            ],
+            cwd: cachePath
+        });
+        logger.info(`electron 启动成功：${electronPath} ${mainPath}`);
+        return electronApp;
+    } catch (error) {
+        logger.error("electron 启动失败：", error);
+        throw error;
+    }
 };
-
+const pacote_namespaceObject = require("@iflyrpa/pacote");
+var pacote_default = /*#__PURE__*/ __webpack_require__.n(pacote_namespaceObject);
+function packageManager_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
 const NPM_REGISTRY = "https://registry.npmmirror.com/";
 class PackageManager {
-  constructor(task) {
-    this.task = task;
-  }
-  // 获取依赖信息
-  async getManifest(module) {
-    try {
-      return pacote__default.manifest(module, { registry: NPM_REGISTRY });
-    } catch (error) {
-      this.task.logger.error("\u83B7\u53D6\u4F9D\u8D56\u4FE1\u606F\u5931\u8D25", error);
-      throw error;
+    async getManifest(module) {
+        try {
+            return pacote_default().manifest(module, {
+                registry: NPM_REGISTRY
+            });
+        } catch (error) {
+            this.task.logger.error("获取依赖信息失败", error);
+            throw error;
+        }
     }
-  }
-  // 安装依赖
-  async extract(name, version = "latest") {
-    const packageName = `${name}@${version}`;
-    try {
-      this.task.logger.info(`${packageName} \u5F00\u59CB\u5B89\u88C5`);
-      await pacote__default.extract(
-        packageName,
-        path__default.join(this.task.packagesDir, packageName),
-        { registry: NPM_REGISTRY }
-      );
-      this.task.logger.info(`${packageName} \u5B89\u88C5\u6210\u529F`);
-    } catch (error) {
-      this.task.logger.error(`${packageName} \u5B89\u88C5\u5931\u8D25`, error);
+    async extract(name, version = "latest") {
+        const packageName = `${name}@${version}`;
+        try {
+            this.task.logger.info(`${packageName} 开始安装`);
+            await pacote_default().extract(packageName, external_node_path_default().join(this.task.packagesDir, packageName), {
+                registry: NPM_REGISTRY
+            });
+            this.task.logger.info(`${packageName} 安装成功`);
+        } catch (error) {
+            this.task.logger.error(`${packageName} 安装失败`, error);
+        }
     }
-  }
-  // 查询本地安装的依赖
-  require(module) {
-    try {
-      return require(path__default.join(this.task.packagesDir, module));
-    } catch (error) {
-      return null;
+    require(module) {
+        try {
+            return require(external_node_path_default().join(this.task.packagesDir, module));
+        } catch (error) {
+            return null;
+        }
     }
-  }
-  // 安装依赖
-  async install(name, version) {
-    const packageName = `${name}@${version}`;
-    const plugin = this.require(packageName);
-    this.task.logger.info(`${packageName} \u662F\u5426\u5DF2\u5B89\u88C5\uFF1A${!!plugin}`);
-    if (!plugin) {
-      await this.extract(name, version);
+    async install(name, version) {
+        const packageName = `${name}@${version}`;
+        const plugin = this.require(packageName);
+        this.task.logger.info(`${packageName} 是否已安装：${!!plugin}`);
+        if (!plugin) await this.extract(name, version);
     }
-  }
-  // 更新依赖
-  async update(name) {
-    const manifest = await this.getManifest(`${name}@latest`);
-    const version = manifest.version;
-    const plugin = this.require(`${name}@${version}`);
-    if (!plugin) {
-      await this.extract(name, version);
+    async update(name) {
+        const manifest = await this.getManifest(`${name}@latest`);
+        const version = manifest.version;
+        const plugin = this.require(`${name}@${version}`);
+        if (plugin) this.task.logger.info(`${name}@${version} 已是最新版本`);
+        else {
+            await this.extract(name, version);
+            this.task.logger.info(`${name}@${version} 安装成功`);
+        }
+        return version;
+    }
+    constructor(task){
+        packageManager_define_property(this, "task", void 0);
+        this.task = task;
     }
-    return version;
-  }
 }
-
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => {
-  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+function task_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
 const PLAYWRIGHT_VERSION = "1.46.1";
 const PLAYWRIGHT_NAME = "playwright-core";
 class Task {
-  constructor({ cachePath, debug }) {
-    __publicField$1(this, "logger");
-    __publicField$1(this, "cachePath");
-    __publicField$1(this, "debug");
-    __publicField$1(this, "packagesDir");
-    // 依赖安装目录
-    __publicField$1(this, "packageManager");
-    __publicField$1(this, "playwrightPackage");
-    __publicField$1(this, "electronPackage");
-    __publicField$1(this, "_electronApp", null);
-    /**
-     * 应用是否已关闭
-     */
-    __publicField$1(this, "isClosed", false);
-    this.cachePath = cachePath;
-    this.packagesDir = path__default.join(cachePath, "packages");
-    this.debug = debug || false;
-    this.logger = Logger.getInstance(cachePath);
-    this.packageManager = new PackageManager(this);
-    this.playwrightPackage = this.installPlaywright();
-    this.electronPackage = this.installElectron();
-  }
-  /**
-   * 安装 playwright
-   * @returns
-   */
-  async installPlaywright() {
-    const packageName = `${PLAYWRIGHT_NAME}@${PLAYWRIGHT_VERSION}`;
-    await this.packageManager.install(PLAYWRIGHT_NAME, PLAYWRIGHT_VERSION);
-    return this.packageManager.require(packageName);
-  }
-  /**
-   * 安装 electron
-   * @returns
-   */
-  installElectron() {
-    return new ElectronInstall(this).install();
-  }
-  /**
-   * 启动 Electron
-   * @returns
-   */
-  async launchApp() {
-    if (!this._electronApp) {
-      const [playwright, electronPath] = await Promise.all([
-        this.playwrightPackage,
-        this.electronPackage
-      ]);
-      this._electronApp = await launchElectronApp(
-        this.cachePath,
-        playwright,
-        electronPath
-      );
+    async installPlaywright() {
+        const packageName = `${PLAYWRIGHT_NAME}@${PLAYWRIGHT_VERSION}`;
+        await this.packageManager.install(PLAYWRIGHT_NAME, PLAYWRIGHT_VERSION);
+        return this.packageManager.require(packageName);
+    }
+    installElectron() {
+        return new ElectronInstall(this).install();
+    }
+    async launchApp() {
+        if (!this._electronApp) {
+            const [playwright, electronPath] = await Promise.all([
+                this.playwrightPackage,
+                this.electronPackage
+            ]);
+            this._electronApp = await launchElectronApp(this.cachePath, playwright, electronPath);
+        }
+        return this._electronApp;
+    }
+    getTmpPath() {
+        return external_node_path_default().join(this.cachePath, "tmp");
+    }
+    clearTmpPath() {
+        const tmpPath = this.getTmpPath();
+        return external_node_fs_default().rm(tmpPath, {
+            recursive: true,
+            force: true
+        }, (err)=>{
+            if (err) this.logger.error("删除临时文件失败，", err);
+            else this.logger.info("删除临时文件成功");
+        });
+    }
+    async close() {
+        var _this__electronApp;
+        this.logger.info("关闭应用");
+        this.clearTmpPath();
+        this.logger.close();
+        await (null === (_this__electronApp = this._electronApp) || void 0 === _this__electronApp ? void 0 : _this__electronApp.close());
+        this.isClosed = true;
+        this._electronApp = null;
+    }
+    async createPage(pageParams) {
+        const electronApp = await this.launchApp();
+        const [page] = await Promise.all([
+            electronApp.waitForEvent("window"),
+            electronApp.evaluate(async (electron, { pageParams })=>{
+                await electron.app.whenReady();
+                const window = new electron.BrowserWindow({
+                    show: pageParams.show,
+                    width: 1500,
+                    height: 800,
+                    webPreferences: {
+                        nodeIntegration: true,
+                        contextIsolation: false
+                    }
+                });
+                if (pageParams.cookies) await Promise.all(pageParams.cookies.map((cookie)=>electron.session.defaultSession.cookies.set(cookie)));
+                await window.loadURL(pageParams.url);
+            }, {
+                pageParams
+            })
+        ]);
+        return page;
     }
-    return this._electronApp;
-  }
-  /**
-   * 临时文件目录
-   * @returns
-   */
-  getTmpPath() {
-    return path__default.join(this.cachePath, "tmp");
-  }
-  /**
-   * 清空临时文件
-   */
-  clearTmpPath() {
-    const tmpPath = this.getTmpPath();
-    return fs__default.rm(tmpPath, { recursive: true, force: true }, (err) => {
-      if (err) {
-        this.logger.error("\u5220\u9664\u4E34\u65F6\u6587\u4EF6\u5931\u8D25\uFF0C", err);
-      } else {
-        this.logger.info("\u5220\u9664\u4E34\u65F6\u6587\u4EF6\u6210\u529F");
-      }
+    constructor({ cachePath, debug }){
+        task_define_property(this, "logger", void 0);
+        task_define_property(this, "cachePath", void 0);
+        task_define_property(this, "debug", void 0);
+        task_define_property(this, "packagesDir", void 0);
+        task_define_property(this, "packageManager", void 0);
+        task_define_property(this, "playwrightPackage", void 0);
+        task_define_property(this, "electronPackage", void 0);
+        task_define_property(this, "_electronApp", null);
+        task_define_property(this, "isClosed", false);
+        this.cachePath = cachePath;
+        this.packagesDir = external_node_path_default().join(cachePath, "packages");
+        this.debug = debug || false;
+        this.logger = Logger.getInstance(cachePath);
+        this.packageManager = new PackageManager(this);
+        this.playwrightPackage = this.installPlaywright();
+        this.electronPackage = this.installElectron();
+    }
+}
+function src_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
     });
-  }
-  /**
-   * 关闭 playwright 启动的 electron 客户端
-   * @returns
-   */
-  async close() {
-    this.logger.info("\u5173\u95ED\u5E94\u7528");
-    this.clearTmpPath();
-    this.logger.close();
-    await this._electronApp?.close();
-    this.isClosed = true;
-    this._electronApp = null;
-  }
-  async createPage(pageParams) {
-    const electronApp = await this.launchApp();
-    const [page] = await Promise.all([
-      electronApp.waitForEvent("window"),
-      electronApp.evaluate(
-        async (electron, { pageParams: pageParams2 }) => {
-          await electron.app.whenReady();
-          const window = new electron.BrowserWindow({
-            show: pageParams2.show,
-            width: 1500,
-            height: 800,
-            webPreferences: {
-              nodeIntegration: true,
-              contextIsolation: false
-            }
-          });
-          if (pageParams2.cookies) {
-            await Promise.all(
-              pageParams2.cookies.map(
-                (cookie) => electron.session.defaultSession.cookies.set(cookie)
-              )
-            );
-          }
-          await window.loadURL(pageParams2.url);
-        },
-        { pageParams }
-      )
-    ]);
-    return page;
-  }
+    else obj[key] = value;
+    return obj;
 }
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 class RpaTask extends Task {
-  constructor(params) {
-    super(params);
-    __publicField(this, "actions");
-    this.actions = new actions.Action(this);
-    params.forceUpdate && this.update();
-  }
-  async update() {
-    try {
-      const name = "@iflyrpa/actions";
-      const version2 = await this.packageManager.update(name);
-      const actionPackage = this.packageManager.require(`${name}@${version2}`);
-      actionPackage?.actions && (this.actions = actionPackage.actions);
-    } catch (error) {
-      this.logger.error("\u66F4\u65B0\u4F9D\u8D56\u5931\u8D25", error);
+    async update() {
+        try {
+            const name = "@iflyrpa/actions";
+            const version = await this.packageManager.update(name);
+            const actionPackage = this.packageManager.require(`${name}@${version}`);
+            (null == actionPackage ? void 0 : actionPackage.actions) && (this.actions = actionPackage.actions);
+        } catch (error) {
+            this.logger.error("更新依赖失败", error);
+        }
+    }
+    constructor(params){
+        super(params), src_define_property(this, "actions", void 0);
+        this.actions = new actions_namespaceObject.Action(this);
+        params.forceUpdate && this.update();
     }
-  }
 }
-const version = packageJson.version;
-
-exports.RpaTask = RpaTask;
-exports.version = version;
+const src_version = package_namespaceObject.i8;
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});