@iflyrpa/playwright 1.1.2-beta.1 → 1.1.2-beta.3

package/dist/index.d.ts

@@ -1,86 +1,93 @@
-import { Action } from '@iflyrpa/actions';
-export { ActionMethodParams } from '@iflyrpa/actions';
-import * as playwright_core from 'playwright-core';
-import { LoggerImplement, AutomateTask, ElectronApplication, PageParams } from '@iflyrpa/share';
-
-declare class Logger implements LoggerImplement {
-    static instance: Logger | null;
-    private stream;
-    constructor(cachePath: string);
-    static getInstance(cachePath: string): Logger;
-    debug(...msg: any[]): void;
-    info(...msg: any[]): void;
-    warn(...msg: any[]): void;
-    error(prefix: string, err?: unknown): void;
-    close(): void;
-}
-
-declare class PackageManager {
-    private task;
-    constructor(task: Task);
-    private getManifest;
-    private extract;
-    require(module: string): any;
-    install(name: string, version: string): Promise<void>;
-    update(name: string): Promise<string>;
-}
-
-interface TaskParams {
-    debug?: boolean;
-    cachePath: string;
-    forceUpdate?: boolean;
-}
-declare class Task implements AutomateTask {
-    logger: Logger;
-    cachePath: string;
-    debug: boolean;
-    packagesDir: string;
-    packageManager: PackageManager;
-    private playwrightPackage;
-    private electronPackage;
-    private _electronApp;
-    /**
-     * 应用是否已关闭
-     */
-    isClosed: boolean;
-    constructor({ cachePath, debug }: TaskParams);
-    /**
-     * 安装 playwright
-     * @returns
-     */
-    private installPlaywright;
-    /**
-     * 安装 electron
-     * @returns
-     */
-    private installElectron;
-    /**
-     * 启动 Electron
-     * @returns
-     */
-    launchApp(): Promise<ElectronApplication>;
-    /**
-     * 临时文件目录
-     * @returns
-     */
-    getTmpPath(): string;
-    /**
-     * 清空临时文件
-     */
-    private clearTmpPath;
-    /**
-     * 关闭 playwright 启动的 electron 客户端
-     * @returns
-     */
-    close(): Promise<void>;
-    createPage(pageParams: PageParams): Promise<playwright_core.Page>;
-}
-
-declare class RpaTask extends Task {
-    actions: Action;
-    constructor(params: TaskParams);
-    private update;
-}
-declare const version: string;
-
-export { RpaTask, version };
+import { Action } from '@iflyrpa/actions';
+import { ActionMethodParams } from '@iflyrpa/actions';
+import type { AutomateTask } from '@iflyrpa/share';
+import type { ElectronApplication } from '@iflyrpa/share';
+import { LoggerImplement } from '@iflyrpa/share';
+import { Page } from 'playwright-core';
+import type { PageParams } from '@iflyrpa/share';
+
+export { ActionMethodParams }
+
+declare class Logger implements LoggerImplement {
+    static instance: Logger | null;
+    private stream;
+    constructor(cachePath: string);
+    static getInstance(cachePath: string): Logger;
+    debug(...msg: any[]): void;
+    info(...msg: any[]): void;
+    warn(...msg: any[]): void;
+    error(prefix: string, err?: unknown): void;
+    close(): void;
+}
+
+declare class PackageManager {
+    private task;
+    constructor(task: Task);
+    private getManifest;
+    private extract;
+    require(module: string): any;
+    install(name: string, version: string): Promise<void>;
+    update(name: string): Promise<string>;
+}
+
+export declare class RpaTask extends Task {
+    actions: Action;
+    constructor(params: TaskParams);
+    private update;
+}
+
+declare class Task implements AutomateTask {
+    logger: Logger;
+    cachePath: string;
+    debug: boolean;
+    packagesDir: string;
+    packageManager: PackageManager;
+    private playwrightPackage;
+    private electronPackage;
+    private _electronApp;
+    /**
+     * 应用是否已关闭
+     */
+    isClosed: boolean;
+    constructor({ cachePath, debug }: TaskParams);
+    /**
+     * 安装 playwright
+     * @returns
+     */
+    private installPlaywright;
+    /**
+     * 安装 electron
+     * @returns
+     */
+    private installElectron;
+    /**
+     * 启动 Electron
+     * @returns
+     */
+    launchApp(): Promise<ElectronApplication>;
+    /**
+     * 临时文件目录
+     * @returns
+     */
+    getTmpPath(): string;
+    /**
+     * 清空临时文件
+     */
+    private clearTmpPath;
+    /**
+     * 关闭 playwright 启动的 electron 客户端
+     * @returns
+     */
+    close(): Promise<void>;
+    createPage(pageParams: PageParams): Promise<Page>;
+}
+
+declare interface TaskParams {
+    debug?: boolean;
+    cachePath: string;
+    forceUpdate?: boolean;
+}
+
+export declare const version: string;
+
+export { }

package/dist/index.js

@@ -0,0 +1,391 @@
+import * as __WEBPACK_EXTERNAL_MODULE__iflyrpa_actions_bd801d6f__ from "@iflyrpa/actions";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__ from "node:child_process";
+import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
+import * as __WEBPACK_EXTERNAL_MODULE__electron_get_e4875702__ from "@electron/get";
+import * as __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__ from "extract-zip";
+import * as __WEBPACK_EXTERNAL_MODULE__iflyrpa_share_f7afdc8c__ from "@iflyrpa/share";
+import * as __WEBPACK_EXTERNAL_MODULE_loglevel__ from "loglevel";
+import * as __WEBPACK_EXTERNAL_MODULE__sentry_node_4658624b__ from "@sentry/node";
+import * as __WEBPACK_EXTERNAL_MODULE__iflyrpa_pacote_56da1cff__ from "@iflyrpa/pacote";
+var package_namespaceObject = JSON.parse('{"i8":"1.1.2-beta.3"}');
+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 {
+    isInstalled() {
+        try {
+            if (__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["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 || __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(this.rootDir, this.platformPath);
+        return __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(electronPath);
+    }
+    getPlatformPath() {
+        const platform = process.env.npm_config_platform || __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["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} 是否已安装：${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 = __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__["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, __WEBPACK_EXTERNAL_MODULE__electron_get_e4875702__.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 (0, __WEBPACK_EXTERNAL_MODULE_extract_zip_c4acec5a__["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;
+        }
+    }
+    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 = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(task.packagesDir, `electron@${this.version}`);
+        this.electronPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(this.rootDir, this.platformPath);
+    }
+}
+function sentry_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 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 __WEBPACK_EXTERNAL_MODULE__sentry_node_4658624b__.NodeClient({
+            dsn,
+            defaultIntegrations: false
+        });
+    }
+}
+const sentry = new SentryInstance(process.env.RPA_SENTRY_DSN);
+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;
+    }
+    debug(...msg) {
+        __WEBPACK_EXTERNAL_MODULE_loglevel__["default"].debug(...msg);
+    }
+    info(...msg) {
+        __WEBPACK_EXTERNAL_MODULE_loglevel__["default"].info(...msg);
+    }
+    warn(...msg) {
+        __WEBPACK_EXTERNAL_MODULE_loglevel__["default"].warn(...msg);
+    }
+    error(prefix, err) {
+        const error = err || prefix;
+        if (err instanceof Error) err.message = `${prefix}：${err.message}`;
+        __WEBPACK_EXTERNAL_MODULE_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 = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cachePath, "rpa.log");
+        (0, __WEBPACK_EXTERNAL_MODULE__iflyrpa_share_f7afdc8c__.ensureFileSync)(logFile);
+        this.stream = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].createWriteStream(logFile, {
+            flags: "a"
+        });
+        __WEBPACK_EXTERNAL_MODULE_loglevel__["default"].setLevel("debug");
+        __WEBPACK_EXTERNAL_MODULE_loglevel__["default"].methodFactory = (methodName)=>(message)=>{
+                this.stream.write(`[${new Date().toLocaleString()}] ${methodName.toUpperCase()}: ${message}\n`);
+            };
+        __WEBPACK_EXTERNAL_MODULE_loglevel__["default"].setLevel(__WEBPACK_EXTERNAL_MODULE_loglevel__["default"].getLevel());
+        Logger.instance = this;
+    }
+}
+logger_define_property(Logger, "instance", null);
+const template = `
+const { app } = require("electron");
+
+app.whenReady().then(() => {});
+
+app.on("window-all-closed", (e) => e.preventDefault());
+`;
+const generateFile = async (dir)=>{
+    const filePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(dir, "main.js");
+    const isPathExists = await (0, __WEBPACK_EXTERNAL_MODULE__iflyrpa_share_f7afdc8c__.pathExists)(filePath);
+    if (!isPathExists) {
+        await (0, __WEBPACK_EXTERNAL_MODULE__iflyrpa_share_f7afdc8c__.ensureFile)(filePath);
+        await (0, __WEBPACK_EXTERNAL_MODULE__iflyrpa_share_f7afdc8c__.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,
+            args: [
+                mainPath
+            ],
+            cwd: cachePath
+        });
+        logger.info(`electron 启动成功：${electronPath} ${mainPath}`);
+        return electronApp;
+    } catch (error) {
+        logger.error("electron 启动失败：", error);
+        throw error;
+    }
+};
+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 {
+    async getManifest(module) {
+        try {
+            return __WEBPACK_EXTERNAL_MODULE__iflyrpa_pacote_56da1cff__["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} 开始安装`);
+            await __WEBPACK_EXTERNAL_MODULE__iflyrpa_pacote_56da1cff__["default"].extract(packageName, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["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(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["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} 是否已安装：${!!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);
+        return version;
+    }
+    constructor(task){
+        packageManager_define_property(this, "task", void 0);
+        this.task = task;
+    }
+}
+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 {
+    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 __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(this.cachePath, "tmp");
+    }
+    clearTmpPath() {
+        const tmpPath = this.getTmpPath();
+        return __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["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;
+    }
+    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 = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["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
+    });
+    else obj[key] = value;
+    return obj;
+}
+class RpaTask extends Task {
+    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 __WEBPACK_EXTERNAL_MODULE__iflyrpa_actions_bd801d6f__.Action(this);
+        params.forceUpdate && this.update();
+    }
+}
+const src_version = package_namespaceObject.i8;
+export { RpaTask, src_version as version };

package/package.json

@@ -1,38 +1,38 @@
 {
   "name": "@iflyrpa/playwright",
   "type": "module",
-  "version": "1.1.2-beta.1",
+  "version": "1.1.2-beta.3",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
   "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "author": "bijinfeng",
-  "license": "ISC",
   "files": [
     "dist"
   ],
-  "peerDependencies": {
-    "playwright": "^1.46.1"
-  },
   "devDependencies": {
-    "@types/pacote": "^11.1.8",
-    "esno": "^4.7.0",
-    "pacote": "^20.0.0",
-    "playwright": "^1.46.1",
-    "typescript": "^5.5.2",
-    "unbuild": "^2.0.0",
-    "@iflyrpa/share": "0.0.2"
+    "@microsoft/api-extractor": "^7.49.1",
+    "@rslib/core": "^0.3.1",
+    "@types/node": "^22.8.1",
+    "playwright-core": "^1.46.1",
+    "typescript": "^5.5.2"
   },
   "dependencies": {
     "@electron/get": "^2.0.0",
     "@sentry/node": "^5.5.0",
     "extract-zip": "^2.0.1",
     "loglevel": "^1.9.2",
+    "@iflyrpa/pacote": "1.0.0",
     "@iflyrpa/actions": "1.0.2",
     "@iflyrpa/share": "0.0.2"
   },
   "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "start": "esno src/index.ts"
+    "build": "rslib build",
+    "dev": "rslib build --watch"
   }
 }