pp-robot-module 0.2.14

package/README.md

@@ -0,0 +1,34 @@
+## Installation
+```
+npm i pp-robot-module
+```
+
+## Requirements
+### Installation
+- nodejs v16.20
+- vscode v1.75+
+- vscode extension pp-robot-ide v1.0.0+
+
+### Enviroment
+```
+查看.env文件
+```
+
+## Sample
+```js
+const { MR } = require('pp-robot-module');
+(async () => {
+    await MR.Web.launch()
+    await MR.Web.goto('http://example.com/')
+    await MR.sleep(3000)
+    const headerFrame = await MR.Web.frame('headerFrame')
+    await headerFrame.getByRole('link', { name: '登录' }).click()
+    const cs= await MR.Web.cookies()
+    console.log(cs)
+    const conFrame = await MR.Web.frame('conFrame')
+    await conFrame.locator('#loginname').fill('test')
+    await MR.Web.close()
+})()
+
+
+```

package/dist/MR/Ai.d.ts

@@ -0,0 +1,8 @@
+export declare namespace MR {
+    class Ai {
+        private constructor();
+        static do(): Promise<void>;
+    }
+}
+declare const _default: typeof MR.Ai;
+export default _default;

package/dist/MR/Ai.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+var MR;
+(function (MR) {
+    class Ai {
+        constructor() { }
+        static do() {
+            return __awaiter(this, void 0, void 0, function* () {
+            });
+        }
+    }
+    MR.Ai = Ai;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Ai;

package/dist/MR/Clipboard.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+export declare namespace MR {
+    class Clipboard {
+        private constructor();
+        static copy(params: {
+            _msg?: string;
+            _file?: string;
+        }): Promise<void>;
+        static paste(): Promise<void>;
+        static copyImg(params: {
+            _imgPath: string;
+        }): Promise<void>;
+        static saveImg(params: {
+            _imgPath: string;
+        }): Promise<Buffer>;
+        static getContent(): Promise<string>;
+    }
+}
+declare const _default: typeof MR.Clipboard;
+export default _default;

package/dist/MR/Clipboard.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const clipboard_sys_1 = require("clipboard-sys");
+const Keyboard_1 = require("./Keyboard");
+const Log_1 = require("./Log");
+const File_1 = require("./File");
+var MR;
+(function (MR) {
+    class Clipboard {
+        constructor() { }
+        static copy(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Clipboard.copy", params);
+                if (params._msg)
+                    return yield clipboard_sys_1.clipboard.writeText(params._msg);
+                if (params._file) {
+                    //readfile
+                    const _data = yield File_1.default.readFile({ _filename: params._file });
+                    return yield clipboard_sys_1.clipboard.writeText(_data);
+                }
+            });
+        }
+        static paste() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Clipboard.paste");
+                yield Keyboard_1.default.Ctrl_V();
+            });
+        }
+        static copyImg(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Clipboard.copyImg", params);
+                return yield clipboard_sys_1.clipboard.writeImage(params._imgPath);
+            });
+        }
+        static saveImg(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Clipboard.saveImg");
+                return yield clipboard_sys_1.clipboard.readImage(params._imgPath);
+            });
+        }
+        static getContent() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Clipboard.getContent");
+                return yield clipboard_sys_1.clipboard.readText();
+            });
+        }
+    }
+    MR.Clipboard = Clipboard;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Clipboard;

package/dist/MR/Csv.d.ts

@@ -0,0 +1,20 @@
+export declare namespace MR {
+    class Csv {
+        private constructor();
+        static fileToJson(params: {
+            _filename: string;
+            _isHeader?: boolean;
+            _delimiter?: string;
+            _flatKeys?: boolean;
+        }): Promise<any[]>;
+        static strToJson(params: {
+            _str: string;
+        }): Promise<any[]>;
+        static jsonToFile(params: {
+            _json: any;
+            _filename: string;
+        }): Promise<any>;
+    }
+}
+declare const _default: typeof MR.Csv;
+export default _default;

package/dist/MR/Csv.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const _csv = require("csvtojson");
+const File_1 = require("./File");
+const json_2_csv_1 = require("json-2-csv");
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class Csv {
+        constructor() { }
+        static fileToJson(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Csv.fileToJson", params._filename);
+                const opt = {};
+                if (params._isHeader)
+                    opt['noheader'] = params._isHeader;
+                if (params._delimiter)
+                    opt['delimiter'] = params._delimiter;
+                if (params._flatKeys)
+                    opt['flatKeys'] = params._flatKeys;
+                const jsonArray = yield _csv(opt).fromFile(params._filename);
+                return jsonArray;
+            });
+        }
+        static strToJson(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Csv.strToJson", params);
+                const csvRow = yield _csv({
+                    noheader: true,
+                    output: "csv"
+                }).fromString(params._str);
+                return csvRow;
+            });
+        }
+        //json数组保存到 csv
+        static jsonToFile(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Csv.jsonToFile", params._filename);
+                const csv = yield (0, json_2_csv_1.json2csv)(params._json);
+                return yield File_1.default.outputFile({ _filename: params._filename, _data: csv });
+            });
+        }
+    }
+    MR.Csv = Csv;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Csv;

package/dist/MR/Date.d.ts

@@ -0,0 +1,60 @@
+export declare namespace MR {
+    class DateClass {
+        private constructor();
+        static get(): any;
+        static all(): any;
+        static now(params?: {
+            _format?: string;
+        }): any;
+        static today(params?: {
+            _format?: string;
+        }): any;
+        static stamp(params?: {
+            _type?: 'second' | 'millisecond';
+        }): any;
+        static strToDate(params: {
+            _time: string;
+            _format: string;
+        }): any;
+        static fromNow(params: {
+            _time: string;
+        }): any;
+        static diff(params: {
+            _left: string;
+            _right: string;
+            _type: "day" | "week" | "month" | "year" | "hour" | "minute" | "second" | "millisecond";
+        }): any;
+        static add(params: {
+            _time: string;
+            _value: number;
+            _type: "day" | "week" | "month" | "year" | "hour" | "minute" | "second" | "millisecond";
+        }): any;
+        static subtract(params: {
+            _time: string;
+            _value: number;
+            _type: "day" | "week" | "month" | "year" | "hour" | "minute" | "second" | "millisecond";
+        }): any;
+        static daysInMonth(params: {
+            _time: string;
+        }): any;
+        static compare(params: {
+            _action: "same" | "after" | "before";
+            _left: string;
+            _right: string;
+        }): any;
+        static isSame(params: {
+            _left: string;
+            _right: string;
+        }): any;
+        static isAfter(params: {
+            _left: string;
+            _right: string;
+        }): any;
+        static isBefore(params: {
+            _left: string;
+            _right: string;
+        }): any;
+    }
+}
+declare const _default: typeof MR.DateClass;
+export default _default;

package/dist/MR/Date.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+var dayjs = require('dayjs');
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class DateClass {
+        constructor() { }
+        static get() {
+            Log_1.default.debug("Date.get");
+            return dayjs;
+        }
+        static all() {
+            Log_1.default.debug("Date.all");
+            return dayjs();
+        }
+        static now(params = {}) {
+            Log_1.default.debug("Date.now", params);
+            if (params._format) {
+                return dayjs().format(params._format);
+            }
+            else {
+                return dayjs().format('YYYY-MM-DD HH:mm:ss');
+            }
+        }
+        static today(params = {}) {
+            Log_1.default.debug("Date.today", params);
+            if (params._format) {
+                return dayjs().format(params._format);
+            }
+            else {
+                return dayjs().format('YYYY-MM-DD');
+            }
+        }
+        static stamp(params = { _type: 'second' }) {
+            Log_1.default.debug("Date.stamp", params);
+            if (params._type === 'second') {
+                return dayjs().unix();
+            }
+            else {
+                return dayjs().valueOf();
+            }
+        }
+        static strToDate(params) {
+            Log_1.default.debug("Date.strToDate", params);
+            return dayjs(params._time).format(params._format);
+        }
+        static fromNow(params) {
+            Log_1.default.debug("Date.fromNow", params);
+            return dayjs(params._time).fromNow();
+        }
+        static diff(params) {
+            Log_1.default.debug("Date.diff", params);
+            const date1 = dayjs(params._left);
+            return date1.diff(params._right, params._type);
+        }
+        static add(params) {
+            Log_1.default.debug("Date.add", params);
+            return dayjs(params._time).add(params._value, params._type);
+        }
+        static subtract(params) {
+            Log_1.default.debug("Date.subtract", params);
+            return dayjs(params._time).subtract(params._value, params._type);
+        }
+        static daysInMonth(params) {
+            Log_1.default.debug("Date.daysInMonth", params);
+            return dayjs(params._time).daysInMonth();
+        }
+        static compare(params) {
+            Log_1.default.debug("Date.compare", params);
+            if (params._action === 'same')
+                return dayjs(params._left).isSame(dayjs(params._right));
+            if (params._action === 'after')
+                return dayjs(params._left).isAfter(dayjs(params._right));
+            if (params._action === 'before')
+                return dayjs(params._left).isBefore(dayjs(params._right));
+        }
+        static isSame(params) {
+            Log_1.default.debug("Date.isSame", params);
+            return dayjs(params._left).isSame(dayjs(params._right));
+        }
+        static isAfter(params) {
+            Log_1.default.debug("Date.isAfter", params);
+            return dayjs(params._left).isAfter(dayjs(params._right));
+        }
+        static isBefore(params) {
+            Log_1.default.debug("Date.isBefore", params);
+            return dayjs(params._left).isBefore(dayjs(params._right));
+        }
+    }
+    MR.DateClass = DateClass;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.DateClass;

package/dist/MR/DbClient.d.ts

@@ -0,0 +1,97 @@
+export declare namespace MR {
+    class DbClient {
+        private static dbClient;
+        _knex: any;
+        static get instance(): DbClient;
+        private static _dbType;
+        private static _dbHost;
+        private static _dbPort;
+        private static _dbUser;
+        private static _dbPassword;
+        private static _dbName;
+        private static _dbDebug;
+        private constructor();
+        config(): Promise<void>;
+        do(): Promise<void>;
+        close(): Promise<void>;
+        select(params: {
+            _table: string;
+            _column?: string;
+            _where?: string;
+            _limit?: number;
+            _offset?: number;
+        }): Promise<any>;
+        insert(params: {
+            _table: string;
+            _data: {} | {}[];
+        }): Promise<any>;
+        update(params: {
+            _table: string;
+            _data: {};
+            _where?: string;
+        }): Promise<any>;
+        delete(params: {
+            _table: string;
+            _where?: string;
+        }): Promise<any>;
+        raw(params: {
+            _sql: string;
+        } | string): Promise<any>;
+        avg(params: {
+            _table: string;
+            _column: string;
+            _where?: string;
+        }): Promise<any>;
+        count(params: {
+            _table: string;
+            _column: string;
+            _where?: string;
+        }): Promise<any>;
+        sum(params: {
+            _table: string;
+            _column: string;
+            _where?: string;
+        }): Promise<any>;
+        min(params: {
+            _table: string;
+            _column: string;
+            _where?: string;
+        }): Promise<any>;
+        max(params: {
+            _table: string;
+            _column: string;
+            _where?: string;
+        }): Promise<any>;
+        trx(params?: {}): Promise<any>;
+        join(params?: {}): Promise<any>;
+        alterTable(params: {
+            _table: string;
+        }, _callback: Function): Promise<any>;
+        createTable(params: {
+            _table: string;
+            _callback: Function;
+        }): Promise<any>;
+        schema(params: {
+            _table: string;
+        }): Promise<any>;
+        truncate(params: {
+            _table: string;
+        }): Promise<any>;
+        hasTable(params: {
+            _table: string;
+        }): Promise<any>;
+        dropTable(params: {
+            _table: string;
+        }): Promise<any>;
+        createTableLike(params: {
+            _newTable: string;
+            _oldTable: string;
+        }): Promise<any>;
+        renameTable(params: {
+            _oldTable: string;
+            _newTable: string;
+        }): Promise<any>;
+    }
+}
+declare const _default: MR.DbClient;
+export default _default;