pp-robot-module 0.2.14

package/dist/MR/Http.js

@@ -0,0 +1,121 @@
+"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 node_fetch_1 = require("node-fetch");
+const fs = require("fs");
+const Log_1 = require("./Log");
+const userAgents = require('top-user-agents');
+const { URLSearchParams } = require('url');
+var MR;
+(function (MR) {
+    class Http {
+        constructor() { }
+        static addContentType(headers) {
+            let ct = true;
+            if (headers) {
+                var keys = Object.keys(headers);
+                if (keys.includes("Content-Type")) {
+                    ct = false;
+                }
+            }
+            if (ct) {
+                headers['Content-Type'] = 'application/json';
+            }
+            return headers;
+        }
+        static getUserAgent() {
+            return userAgents;
+        }
+        static addUserAgent(headers) {
+            let ua = true;
+            if (headers) {
+                var keys = Object.keys(headers);
+                if (keys.includes("User-Agent")) {
+                    ua = false;
+                }
+            }
+            if (ua) {
+                const userAgent = userAgents[0];
+                headers['User-Agent'] = userAgent.toString();
+            }
+            return headers;
+        }
+        static get(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Http.get", params);
+                const response = yield (0, node_fetch_1.default)(params._url, {
+                    method: 'get',
+                    headers: Http.addUserAgent(params._headers)
+                });
+                return yield response.text();
+            });
+        }
+        static post(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Http.post", params);
+                let headers = Http.addContentType(params._headers);
+                const response = yield (0, node_fetch_1.default)(params._url, {
+                    method: 'post',
+                    body: JSON.stringify(params._body),
+                    headers: Http.addUserAgent(headers)
+                });
+                const data = yield response.text();
+                return data;
+            });
+        }
+        static form(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Http.form", params);
+                const param = new URLSearchParams();
+                Object.keys(params._body).forEach((key) => {
+                    param.append(key, params._body[key]);
+                });
+                const response = yield (0, node_fetch_1.default)(params._url, {
+                    method: params._method || 'POST',
+                    body: param,
+                    headers: Http.addUserAgent(params._headers)
+                });
+                const data = yield response.text();
+                return data;
+            });
+        }
+        static parseCookies(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Http.parseCookies", params);
+                const raw = params._response.headers.raw()['set-cookie'];
+                return raw.map((entry) => {
+                    const parts = entry.split(';');
+                    const cookiePart = parts[0];
+                    return cookiePart;
+                }).join(';');
+            });
+        }
+        static download(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Http.download", params);
+                const res = yield (0, node_fetch_1.default)(params._url);
+                const fileStream = fs.createWriteStream(params._filename);
+                return new Promise((resolve, reject) => {
+                    res.body.pipe(fileStream);
+                    res.body.on("error", (err) => {
+                        reject(err);
+                    });
+                    fileStream.on("finish", () => {
+                        resolve();
+                    });
+                });
+            });
+        }
+    }
+    MR.Http = Http;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Http;

package/dist/MR/Imap.d.ts

@@ -0,0 +1,15 @@
+export declare namespace MR {
+    class ImapClass {
+        private constructor();
+        private static _host;
+        private static _port;
+        private static _username;
+        private static _password;
+        private static _netType;
+        private static _service;
+        private static _secure;
+        static receive(): Promise<any>;
+    }
+}
+declare const _default: typeof MR.ImapClass;
+export default _default;

package/dist/MR/Imap.js

@@ -0,0 +1,52 @@
+"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 MailListener = require('mail-listener2');
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class ImapClass {
+        constructor() { }
+        static receive() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const config = {
+                    username: ImapClass._username,
+                    password: ImapClass._password,
+                    host: ImapClass._host,
+                    port: ImapClass._port,
+                    tls: ImapClass._secure
+                };
+                Log_1.default.debug("ImapClass.receive", config);
+                const mailListener = new MailListener(config);
+                // 启动邮件监听器并返回 Promise
+                return new Promise((resolve, reject) => {
+                    mailListener.on('mail', (mail, seqno, attributes) => {
+                        resolve(mail);
+                    });
+                    mailListener.on('error', (err) => {
+                        reject(err);
+                    });
+                    mailListener.start();
+                });
+            });
+        }
+    }
+    ImapClass._host = process.env.IMAP_HOST;
+    ImapClass._port = Number(process.env.IMAP_PORT);
+    ImapClass._username = process.env.IMAP_USERNAME;
+    ImapClass._password = process.env.IMAP_PASSWORD;
+    ImapClass._netType = process.env.IMAP_NETTYPE;
+    ImapClass._service = process.env.IMAP_SERVICE;
+    ImapClass._secure = Boolean(process.env.IMAP_SECURE);
+    MR.ImapClass = ImapClass;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.ImapClass;

package/dist/MR/Ini.d.ts

@@ -0,0 +1,31 @@
+export declare namespace MR {
+    class Ini {
+        private constructor();
+        static readFile(params: {
+            _filename: string;
+        }): any;
+        static writeFile(params: {
+            _iniobj: any;
+            _filename: string;
+            _section?: string;
+        }): void;
+        static getValue(params: {
+            _config: any;
+            _key: string;
+            _section?: string;
+        }): any;
+        static setValue(params: {
+            _config: any;
+            _key: string;
+            _value: string;
+            _section?: string;
+        }): void;
+        static delete(params: {
+            _config: any;
+            _key: string;
+            _section?: string;
+        }): void;
+    }
+}
+declare const _default: typeof MR.Ini;
+export default _default;

package/dist/MR/Ini.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const fs = require("fs");
+const Log_1 = require("./Log");
+const _ini = require('ini');
+var MR;
+(function (MR) {
+    class Ini {
+        constructor() { }
+        static readFile(params) {
+            Log_1.default.debug("Ini.readFile", params);
+            const config = _ini.parse(fs.readFileSync(params._filename, 'utf-8'));
+            return config;
+        }
+        static writeFile(params) {
+            Log_1.default.debug("Ini.writeFile", params);
+            fs.writeFileSync(params._filename, _ini.stringify(params._iniobj, { section: params._section }));
+        }
+        static getValue(params) {
+            Log_1.default.debug("Ini.getValue", params);
+            const __key = params._key;
+            if (params._section !== undefined) {
+                const __section = params._section;
+                return (params._config).__section.__key;
+            }
+            else {
+                return (params._config).__key;
+            }
+        }
+        static setValue(params) {
+            Log_1.default.debug("Ini.setValue", params);
+            const __key = params._key;
+            if (params._section !== undefined) {
+                (params._config).params.section.__key = params._value;
+            }
+            else {
+                (params._config).__key = params._value;
+            }
+        }
+        static delete(params) {
+            Log_1.default.debug("Ini.delete", params);
+            const __key = params._key;
+            if (params._section !== undefined) {
+                const __section = params._section;
+                delete (params._config).__section.__key;
+            }
+            else {
+                delete (params._config).__key;
+            }
+        }
+    }
+    MR.Ini = Ini;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Ini;

package/dist/MR/Keyboard.d.ts

@@ -0,0 +1,59 @@
+export declare namespace MR {
+    class Keyboard {
+        private constructor();
+        static get(): Promise<import("@nut-tree/nut-js").KeyboardClass>;
+        private static isFileExist;
+        private static copyFile;
+        static password(params: {
+            _msg: string;
+            _debug?: boolean;
+        }): Promise<void>;
+        static str(params: {
+            _msg: string;
+        }): Promise<import("@nut-tree/nut-js").KeyboardClass>;
+        private static convert;
+        static press(params: {
+            _key: string;
+        }): Promise<void>;
+        static hotkey(params: {
+            _keys: string[];
+        }): Promise<void>;
+        static Win_D(): Promise<void>;
+        static Alt_F4(): Promise<void>;
+        static Ctrl_C(): Promise<void>;
+        static Ctrl_V(): Promise<void>;
+        static Ctrl_Shift(): Promise<void>;
+        static Home(): Promise<void>;
+        static End(): Promise<void>;
+        static Down(): Promise<void>;
+        static Left(): Promise<void>;
+        static Up(): Promise<void>;
+        static Right(): Promise<void>;
+        static CapsLock(): Promise<void>;
+        static Shift(): Promise<void>;
+        static Ctrl(): Promise<void>;
+        static Alt(): Promise<void>;
+        static Tab(): Promise<void>;
+        static Space(): Promise<void>;
+        static Backspace(): Promise<void>;
+        static Delete(): Promise<void>;
+        static Enter(): Promise<void>;
+        static Escape(): Promise<void>;
+        static F1(): Promise<void>;
+        static F2(): Promise<void>;
+        static F3(): Promise<void>;
+        static F4(): Promise<void>;
+        static F5(): Promise<void>;
+        static F6(): Promise<void>;
+        static F7(): Promise<void>;
+        static F8(): Promise<void>;
+        static F9(): Promise<void>;
+        static F10(): Promise<void>;
+        static F11(): Promise<void>;
+        static F12(): Promise<void>;
+        private static getKeyEnum;
+        private static InnerKeyEnums;
+    }
+}
+declare const _default: typeof MR.Keyboard;
+export default _default;