pp-robot-module 0.2.14

package/dist/MR/String.d.ts

@@ -0,0 +1,104 @@
+export declare namespace MR {
+    class StringClass {
+        private constructor();
+        static between(params: {
+            _str: string;
+            _left: string;
+            _right: string;
+        }): any;
+        static include(params: {
+            _str: string;
+            _char: string;
+        }): any;
+        static contains(params: {
+            _str: string;
+            _char: string;
+        }): any;
+        static count(params: {
+            _str: string;
+            _char: string;
+        }): any;
+        static lines(params: {
+            _str: string;
+        } | string): any;
+        static collapseWhitespace(params: {
+            _str: string;
+        } | string): any;
+        static replaceAll(params: {
+            _str: string;
+            _oldChar: string;
+            _newChar: string;
+        }): any;
+        static stripPunctuation(params: {
+            _str: string;
+        } | string): any;
+        static stripTags(params: {
+            _str: string;
+        } | string): any;
+        static titleCase(params: {
+            _str: string;
+        } | string): any;
+        static toBoolean(params: {
+            _str: string;
+        } | string): any;
+        static unescapeHTML(params: {
+            _str: string;
+        } | string): any;
+        static escapeHTML(params: {
+            _str: string;
+        } | string): any;
+        static trim(params: {
+            _str: string;
+        } | string): any;
+        static len(params: {
+            _str: string;
+        } | string): any;
+        static isEmpty(params: {
+            _str: string;
+        } | string): any;
+        static isAlpha(params: {
+            _str: string;
+        } | string): any;
+        static isAlphaNumeric(params: {
+            _str: string;
+        } | string): any;
+        static humanize(params: {
+            _str: string;
+        } | string): any;
+        static isNumeric(params: {
+            _str: string;
+        } | string): any;
+        static isLower(params: {
+            _str: string;
+        } | string): any;
+        static isUpper(params: {
+            _str: string;
+        } | string): any;
+        static left(params: {
+            _str: string;
+            _count: number;
+        }): any;
+        static right(params: {
+            _str: string;
+            _count: number;
+        }): any;
+        static startsWith(params: {
+            _str: string;
+            _char: string;
+        }): any;
+        static endsWith(params: {
+            _str: string;
+            _char: string;
+        }): any;
+        static template(params: {
+            _str: string;
+            _json: any;
+        }): any;
+        /**
+         * @param str
+         */
+        static halveZenkakuAscii(str: string): string;
+    }
+}
+declare const _default: typeof MR.StringClass;
+export default _default;

package/dist/MR/String.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const Log_1 = require("./Log");
+var S = require('string');
+var MR;
+(function (MR) {
+    class StringClass {
+        constructor() { }
+        static between(params) {
+            Log_1.default.debug("String.between", params);
+            return S(params._str).between(params._left, params._right).s;
+        }
+        static include(params) {
+            Log_1.default.debug("String.include", params);
+            return S(params._str).include(params._char).s;
+        }
+        static contains(params) {
+            Log_1.default.debug("String.contains", params);
+            return S(params._str).contains(params._char).s;
+        }
+        static count(params) {
+            Log_1.default.debug("String.count", params);
+            return S(params._str).count(params._char);
+        }
+        static lines(params) {
+            Log_1.default.debug("String.lines", params);
+            if (typeof params == 'string')
+                return S(params).lines();
+            return S(params._str).lines();
+        }
+        static collapseWhitespace(params) {
+            Log_1.default.debug("String.collapseWhitespace", params);
+            if (typeof params == 'string')
+                return S(params).collapseWhitespace().s;
+            return S(params._str).collapseWhitespace().s;
+        }
+        static replaceAll(params) {
+            Log_1.default.debug("String.replaceAll", params);
+            return S(params._str).replaceAll(params._oldChar, params._newChar).s;
+        }
+        static stripPunctuation(params) {
+            Log_1.default.debug("String.stripPunctuation", params);
+            if (typeof params == 'string')
+                return S(params).stripPunctuation().s;
+            return S(params._str).stripPunctuation().s;
+        }
+        static stripTags(params) {
+            Log_1.default.debug("String.stripTags", params);
+            if (typeof params == 'string')
+                return S(params).stripTags().s;
+            return S(params._str).stripTags().s;
+        }
+        static titleCase(params) {
+            Log_1.default.debug("String.titleCase", params);
+            if (typeof params == 'string')
+                return S(params).titleCase().s;
+            return S(params._str).titleCase().s;
+        }
+        static toBoolean(params) {
+            Log_1.default.debug("String.toBoolean", params);
+            if (typeof params == 'string')
+                return S(params).toBoolean();
+            return S(params._str).toBoolean();
+        }
+        static unescapeHTML(params) {
+            Log_1.default.debug("String.unescapeHTML", params);
+            if (typeof params == 'string')
+                return S(params).unescapeHTML().s;
+            return S(params._str).unescapeHTML().s;
+        }
+        static escapeHTML(params) {
+            Log_1.default.debug("String.escapeHTML", params);
+            if (typeof params == 'string')
+                return S(params).escapeHTML().s;
+            return S(params._str).escapeHTML().s;
+        }
+        static trim(params) {
+            Log_1.default.debug("String.trim", params);
+            if (typeof params == 'string')
+                return S(params).trim().s;
+            return S(params._str).trim().s;
+        }
+        static len(params) {
+            Log_1.default.debug("String.len", params);
+            if (typeof params == 'string')
+                return S(params).length;
+            return S(params._str).length;
+        }
+        static isEmpty(params) {
+            Log_1.default.debug("String.isEmpty", params);
+            if (typeof params == 'string')
+                return S(params).isEmpty();
+            return S(params._str).isEmpty();
+        }
+        static isAlpha(params) {
+            Log_1.default.debug("String.isAlpha", params);
+            if (typeof params == 'string')
+                return S(params).isAlpha();
+            return S(params._str).isAlpha();
+        }
+        static isAlphaNumeric(params) {
+            Log_1.default.debug("String.isAlphaNumeric", params);
+            if (typeof params == 'string')
+                return S(params).isAlphaNumeric();
+            return S(params._str).isAlphaNumeric();
+        }
+        static humanize(params) {
+            Log_1.default.debug("String.humanize", params);
+            if (typeof params == 'string')
+                return S(params).humanize().s;
+            return S(params._str).humanize().s;
+        }
+        static isNumeric(params) {
+            Log_1.default.debug("String.isNumeric", params);
+            if (typeof params == 'string')
+                return S(params).isNumeric();
+            return S(params._str).isNumeric();
+        }
+        static isLower(params) {
+            Log_1.default.debug("String.isLower", params);
+            if (typeof params == 'string')
+                return S(params).isLower();
+            return S(params._str).isLower();
+        }
+        static isUpper(params) {
+            Log_1.default.debug("String.isUpper", params);
+            if (typeof params == 'string')
+                return S(params).isUpper();
+            return S(params._str).isUpper();
+        }
+        static left(params) {
+            Log_1.default.debug("String.left", params);
+            return S(params._str).left(params._count).s;
+        }
+        static right(params) {
+            Log_1.default.debug("String.right", params);
+            return S(params._str).right(params._count).s;
+        }
+        static startsWith(params) {
+            Log_1.default.debug("String.startsWith", params);
+            return S(params._str).startsWith(params._char);
+        }
+        static endsWith(params) {
+            Log_1.default.debug("String.trim", params);
+            return S(params._str).endsWith(params._char);
+        }
+        static template(params) {
+            Log_1.default.debug("String.template", params);
+            return S(params._str).template(params._json).s;
+        }
+        /**
+         * @param str
+         */
+        static halveZenkakuAscii(str) {
+            Log_1.default.debug("String.halveZenkakuAscii", str);
+            return (str
+                // ascii
+                .replace(/[\uff01-\uff5e]/g, (c) => String.fromCodePoint(c.codePointAt(0) - 0xfee0))
+                // full-width space
+                .replace(/\u3000/g, " "));
+        }
+    }
+    MR.StringClass = StringClass;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.StringClass;

package/dist/MR/System.d.ts

@@ -0,0 +1,31 @@
+export declare namespace MR {
+    class System {
+        private constructor();
+        private static isFileExist;
+        private static copyFile;
+        static inputer(params?: {
+            _debug?: boolean;
+        }): Promise<void>;
+        static lock(params?: {
+            _debug?: boolean;
+        }): Promise<void>;
+        static printerPdf(params?: {
+            _debug?: boolean;
+        }): Promise<void>;
+        static info(): Promise<any>;
+        static system(): Promise<any>;
+        static uuid(): Promise<any>;
+        static bios(): Promise<any>;
+        static baseboard(): Promise<any>;
+        static cpu(): Promise<any>;
+        static mem(): Promise<any>;
+        static disk(): Promise<any>;
+        static usb(): Promise<any>;
+        static printer(): Promise<any>;
+        static bluetooth(): Promise<any>;
+        static docker(): Promise<any>;
+        static networkInterfaces(): Promise<any>;
+    }
+}
+declare const _default: typeof MR.System;
+export default _default;

package/dist/MR/System.js

@@ -0,0 +1,201 @@
+"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 si = require('systeminformation');
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const fsExt = require('fs-extra');
+const Log_1 = require("./Log");
+const INPUTTING_METHOD_EXE = 'inputting-method.exe';
+const LOCK_WINDOW_EXE = 'lock-window.exe';
+const PRINTER_PDF_EXE = 'printer-pdf.exe';
+const FOLDER_PATH = path.join(os.homedir(), '.makwing');
+const INPUTTING_METHOD_EXE_PATH = path.join(FOLDER_PATH, INPUTTING_METHOD_EXE);
+const LOCK_WINDOW_EXE_PATH = path.join(FOLDER_PATH, LOCK_WINDOW_EXE);
+const PRINTER_PDF_EXE_PATH = path.join(FOLDER_PATH, PRINTER_PDF_EXE);
+var MR;
+(function (MR) {
+    class System {
+        constructor() { }
+        static isFileExist(filePath) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield fs.promises.access(filePath, fs.constants.F_OK);
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            });
+        }
+        static copyFile(srcPath, destPath) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield fs.promises.copyFile(srcPath, destPath);
+                    Log_1.default.debug(`System文件复制成功：${srcPath} -> ${destPath}`);
+                }
+                catch (err) {
+                    Log_1.default.error(`System复制文件失败: ${err.message}`);
+                }
+            });
+        }
+        //切换输入法至英文
+        static inputer(params = { _debug: true }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.inputer");
+                let oriExe = path.join(__dirname, "../bin/inputting-method.exe");
+                let isDebug = params._debug;
+                if (!isDebug) {
+                    yield fsExt.ensureDir(FOLDER_PATH);
+                    let newExe = path.join(FOLDER_PATH, INPUTTING_METHOD_EXE);
+                    if (!(yield this.isFileExist(newExe))) {
+                        yield this.copyFile(oriExe, INPUTTING_METHOD_EXE_PATH);
+                    }
+                    oriExe = newExe;
+                }
+                const result = spawnSync(oriExe);
+                if (result.status === 0) {
+                    Log_1.default.debug(`System.inputer: stdout :  ${result.stdout}`);
+                }
+                else {
+                    Log_1.default.debug(`System.inputer: stderr :  ${result.stderr}`);
+                }
+            });
+        }
+        static lock(params = { _debug: true }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.lock");
+                let oriExe = path.join(__dirname, "../bin/lock-window.exe");
+                let isDebug = params._debug;
+                if (!isDebug) {
+                    yield fsExt.ensureDir(FOLDER_PATH);
+                    let newExe = path.join(FOLDER_PATH, LOCK_WINDOW_EXE);
+                    if (!(yield this.isFileExist(newExe))) {
+                        yield this.copyFile(oriExe, LOCK_WINDOW_EXE_PATH);
+                    }
+                    oriExe = newExe;
+                }
+                const result = spawnSync(oriExe, []);
+                if (result.status === 0) {
+                    Log_1.default.debug(`System.lock: stdout :  ${result.stdout}`);
+                }
+                else {
+                    Log_1.default.debug(`System.lock: stderr :  ${result.stderr}`);
+                }
+            });
+        }
+        static printerPdf(params = { _debug: true }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.printerPdf");
+                let oriExe = path.join(__dirname, "../bin/printer-pdf.exe");
+                let isDebug = params._debug;
+                if (!isDebug) {
+                    yield fsExt.ensureDir(FOLDER_PATH);
+                    let newExe = path.join(FOLDER_PATH, PRINTER_PDF_EXE);
+                    if (!(yield this.isFileExist(newExe))) {
+                        yield this.copyFile(oriExe, PRINTER_PDF_EXE_PATH);
+                    }
+                    oriExe = newExe;
+                }
+                const result = spawnSync(oriExe, []);
+                if (result.status === 0) {
+                    Log_1.default.debug(`System.printerPdf: stdout :  ${result.stdout}`);
+                }
+                else {
+                    Log_1.default.debug(`System.printerPdf: stderr :  ${result.stderr}`);
+                }
+            });
+        }
+        static info() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.info");
+                return yield si.osInfo();
+            });
+        }
+        static system() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.system");
+                return yield si.system();
+            });
+        }
+        static uuid() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.uuid");
+                return yield si.uuid();
+            });
+        }
+        static bios() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.bios");
+                return yield si.bios();
+            });
+        }
+        static baseboard() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.baseboard");
+                return yield si.baseboard();
+            });
+        }
+        static cpu() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.cpu");
+                return yield si.cpu();
+            });
+        }
+        static mem() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.mem");
+                return yield si.mem();
+            });
+        }
+        static disk() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.disk");
+                return yield si.diskLayout();
+            });
+        }
+        static usb() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.usb");
+                return yield si.usb();
+            });
+        }
+        static printer() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.printer");
+                return yield si.printer();
+            });
+        }
+        static bluetooth() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.bluetooth");
+                return yield si.bluetoothDevices();
+            });
+        }
+        static docker() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.docker");
+                return yield si.dockerInfo();
+            });
+        }
+        static networkInterfaces() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("System.networkInterfaces");
+                return yield si.networkInterfaces();
+            });
+        }
+    }
+    MR.System = System;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.System;

package/dist/MR/Validator.d.ts

@@ -0,0 +1,30 @@
+export declare namespace MR {
+    class Validator {
+        private constructor();
+        static get(): any;
+        static isHash(params: any): any;
+        static isBase64(params: any): any;
+        static isBoolean(params: any): any;
+        static isDate(params: any): any;
+        static isDecimal(params: any): any;
+        static isEmail(params: any): any;
+        static isEmpty(params: any): any;
+        static isFloat(params: any): any;
+        static isFullWidth(params: any): any;
+        static isHalfWidth(params: any): any;
+        static isIP(params: any): any;
+        static isIPRange(params: any): any;
+        static isJSON(params: any): any;
+        static isJWT(params: any): any;
+        static isMAC(params: any): any;
+        static isMD5(params: any): any;
+        static isMobilePhone(params: any): any;
+        static isNumeric(params: any): any;
+        static isStrongPassword(params: any): any;
+        static isPort(params: any): any;
+        static isURL(params: any): any;
+        static isUppercase(params: any): any;
+    }
+}
+declare const _default: typeof MR.Validator;
+export default _default;

package/dist/MR/Validator.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const validator_1 = require("validator");
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class Validator {
+        constructor() { }
+        static get() {
+            return validator_1.default;
+        }
+        static isHash(params) {
+            Log_1.default.debug("Validator.isHash", params);
+            return validator_1.default.isHash(params);
+        }
+        static isBase64(params) {
+            Log_1.default.debug("Validator.isBase64", params);
+            return validator_1.default.isBase64(params);
+        }
+        static isBoolean(params) {
+            Log_1.default.debug("Validator.isBoolean", params);
+            return validator_1.default.isBoolean(params);
+        }
+        static isDate(params) {
+            Log_1.default.debug("Validator.isDate", params);
+            return validator_1.default.isDate(params);
+        }
+        static isDecimal(params) {
+            Log_1.default.debug("Validator.isDecimal", params);
+            return validator_1.default.isDecimal(params);
+        }
+        static isEmail(params) {
+            Log_1.default.debug("Validator.isEmail", params);
+            return validator_1.default.isEmail(params);
+        }
+        static isEmpty(params) {
+            Log_1.default.debug("Validator.isEmpty", params);
+            return validator_1.default.isEmpty(params);
+        }
+        static isFloat(params) {
+            Log_1.default.debug("Validator.isFloat", params);
+            return validator_1.default.isFloat(params);
+        }
+        static isFullWidth(params) {
+            Log_1.default.debug("Validator.isFullWidth", params);
+            return validator_1.default.isFullWidth(params);
+        }
+        static isHalfWidth(params) {
+            Log_1.default.debug("Validator.isHalfWidth", params);
+            return validator_1.default.isHalfWidth(params);
+        }
+        static isIP(params) {
+            Log_1.default.debug("Validator.isIP", params);
+            return validator_1.default.isIP(params);
+        }
+        static isIPRange(params) {
+            Log_1.default.debug("Validator.isIPRange", params);
+            return validator_1.default.isIPRange(params);
+        }
+        static isJSON(params) {
+            Log_1.default.debug("Validator.isJSON", params);
+            return validator_1.default.isJSON(params);
+        }
+        static isJWT(params) {
+            Log_1.default.debug("Validator.isJWT", params);
+            return validator_1.default.isJWT(params);
+        }
+        static isMAC(params) {
+            Log_1.default.debug("Validator.isMAC", params);
+            return validator_1.default.isMACAddress(params);
+        }
+        static isMD5(params) {
+            Log_1.default.debug("Validator.isMD5", params);
+            return validator_1.default.isMD5(params);
+        }
+        static isMobilePhone(params) {
+            Log_1.default.debug("Validator.isMobilePhone", params);
+            return validator_1.default.isMobilePhone(params);
+        }
+        static isNumeric(params) {
+            Log_1.default.debug("Validator.isNumeric", params);
+            return validator_1.default.isNumeric(params);
+        }
+        static isStrongPassword(params) {
+            Log_1.default.debug("Validator.isStrongPassword", params);
+            return validator_1.default.isStrongPassword(params);
+        }
+        static isPort(params) {
+            Log_1.default.debug("Validator.isPort", params);
+            return validator_1.default.isPort(params);
+        }
+        static isURL(params) {
+            Log_1.default.debug("Validator.isURL", params);
+            return validator_1.default.isURL(params);
+        }
+        static isUppercase(params) {
+            Log_1.default.debug("Validator.isUppercase", params);
+            return validator_1.default.isUppercase(params);
+        }
+    }
+    MR.Validator = Validator;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Validator;