pp-robot-module 0.2.14

package/dist/MR/Word.js

@@ -0,0 +1,220 @@
+"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 fs = require("fs");
+const path = require("path");
+const Log_1 = require("./Log");
+const docx_1 = require("docx");
+const mammoth = require("mammoth");
+var MR;
+(function (MR) {
+    class Word {
+        constructor() { }
+        static text(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Word.text", params);
+                const result = yield mammoth.extractRawText({ path: params._filename });
+                const _text = result.value;
+                return _text;
+                //var messages = result.messages;
+            });
+        }
+        static toHtml(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Word.toHtml", params);
+                const parentPath = path.dirname(params._filename);
+                const fileNameWithoutExt = path.basename(params._filename, path.extname(params._filename));
+                const output = path.join(parentPath, fileNameWithoutExt + "-output.pdf");
+                const result = yield mammoth.convertToHtml({ path: params._filename });
+                const _text = result.value;
+                fs.writeFileSync(output, _text);
+                return output;
+            });
+        }
+        static buildHeaderFooter(params) {
+            Log_1.default.debug("Word.buildHeaderFooter", params);
+            //TODO
+        }
+        static buildImage(params) {
+            Log_1.default.debug("Word.buildImage", params);
+            const image = new docx_1.ImageRun({
+                data: fs.readFileSync(params._filename),
+                transformation: {
+                    width: params._width || 100,
+                    height: params._height || 100,
+                }
+            });
+            return image;
+        }
+        static buildTable(params) {
+            Log_1.default.debug("Word.buildTable", params);
+            if (!Array.isArray(params._rows)) {
+                return;
+            }
+            let mutli = false;
+            for (let i = 0; i < params._rows.length; i++) {
+                if (Array.isArray(params._rows[i])) {
+                    mutli = true;
+                }
+            }
+            let _rows_ = [];
+            if (!mutli) {
+                let cells = [];
+                for (let i = 0; i < params._rows.length; i++) {
+                    if (params._rows instanceof Array) { }
+                    else {
+                        let str = params._rows[i] || '';
+                        let cell = new docx_1.TableCell({
+                            children: [new docx_1.Paragraph(str)],
+                        });
+                        cells.push(cell);
+                    }
+                }
+                _rows_.push(new docx_1.TableRow({ children: cells }));
+            }
+            else {
+                //二维数组
+                for (let i = 0; i < params._rows.length; i++) {
+                    if (Array.isArray(params._rows[i])) {
+                        let cells = [];
+                        for (let j = 0; j < params._rows[i].length; j++) {
+                            let str = params._rows[i][j] || '';
+                            let cell = new docx_1.TableCell({ children: [new docx_1.Paragraph(str)], });
+                            cells.push(cell);
+                        }
+                        _rows_.push(new docx_1.TableRow({ children: cells }));
+                    }
+                }
+            }
+            const opt = { rows: _rows_ };
+            if (params._width) {
+                opt['width'] = {
+                    size: params._width,
+                    type: docx_1.WidthType.DXA,
+                };
+            }
+            if (params._indent) {
+                opt['indent'] = {
+                    size: params._indent,
+                    type: docx_1.WidthType.DXA,
+                };
+            }
+            return new docx_1.Table(opt);
+        }
+        static buildText(params) {
+            Log_1.default.debug("Word.buildText", params);
+            const opt = {};
+            opt['text'] = params._str;
+            if (params._bold)
+                opt['bold'] = params._bold;
+            if (params._italics)
+                opt['italics'] = params._italics;
+            if (params._strike)
+                opt['strike'] = params._strike;
+            if (params._doubleStrike)
+                opt['doubleStrike'] = params._doubleStrike;
+            if (params._superScript)
+                opt['superScript'] = params._superScript;
+            if (params._subScript)
+                opt['subScript'] = params._subScript;
+            if (params._allCaps)
+                opt['allCaps'] = params._allCaps;
+            if (params._smallCaps)
+                opt['smallCaps'] = params._smallCaps;
+            if (params._break)
+                opt['break'] = params._break;
+            if (params._emphasisMark)
+                opt['emphasisMark'] = params._emphasisMark;
+            if (params._underline)
+                opt['underline'] = params._underline;
+            if (params._shading)
+                opt['shading'] = params._shading;
+            const text = new docx_1.TextRun(opt);
+            return text;
+        }
+        static buildParagraph(params) {
+            Log_1.default.debug("Word.buildParagraph", params);
+            const children = [];
+            if (params._text) {
+                if (params._text instanceof Array) {
+                    params._text.forEach((element, index, array) => {
+                        children.push(element);
+                    });
+                }
+                else {
+                    children.push(params._text);
+                }
+            }
+            if (params._image) {
+                if (params._image instanceof Array) {
+                    params._image.forEach((element, index, array) => {
+                        children.push(element);
+                    });
+                }
+                else {
+                    children.push(params._image);
+                }
+            }
+            if (params._table) {
+                if (params._table instanceof Array) {
+                    params._table.forEach((element, index, array) => {
+                        children.push(element);
+                    });
+                }
+                else {
+                    children.push(params._table);
+                }
+            }
+            const para = new docx_1.Paragraph({
+                children
+            });
+            return para;
+        }
+        static create(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Word.create", params);
+                const doc = new docx_1.Document({
+                    sections: [
+                        {
+                            properties: {},
+                            children: params._para,
+                        },
+                    ],
+                });
+                const buffer = yield docx_1.Packer.toBuffer(doc);
+                fs.writeFileSync(params._filename, buffer);
+            });
+        }
+        static template(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Word.template", params);
+                const getPatches = (fields) => {
+                    const patches = {};
+                    for (const field in fields) {
+                        patches[field] = {
+                            type: docx_1.PatchType.PARAGRAPH,
+                            children: [new docx_1.TextRun({ text: fields[field] })],
+                        };
+                    }
+                    return patches;
+                };
+                const patches = getPatches(params._json);
+                const doc = yield (0, docx_1.patchDocument)(fs.readFileSync(params._tempfilename), {
+                    patches,
+                });
+                fs.writeFileSync(params._filename, doc);
+            });
+        }
+    }
+    MR.Word = Word;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Word;

package/dist/MR/Zip.d.ts

@@ -0,0 +1,25 @@
+export declare namespace MR {
+    class Zip {
+        private static outDir;
+        private constructor();
+        private static writeFileSync;
+        /**
+         * Decompresses the specified zip file.
+         */
+        static decompress(params: {
+            _filename: string;
+        }): Promise<string[]>;
+        private static readDir;
+        /**
+       * compresses the specified folder
+       */
+        static compress(params: {
+            _sourcePath: string;
+            _zipName: string;
+            _targetPath: string;
+            _filter?: Array<string>;
+        }): Promise<void>;
+    }
+}
+declare const _default: typeof MR.Zip;
+export default _default;

package/dist/MR/Zip.js

@@ -0,0 +1,89 @@
+"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 path = require("path");
+const fs = require("fs");
+const unzipper = require("unzipper");
+const Log_1 = require("./Log");
+var JSZip = require("jszip");
+var MR;
+(function (MR) {
+    class Zip {
+        constructor() { } // eslint-disable-line no-useless-constructor, no-empty-function
+        static writeFileSync(file) {
+            return __awaiter(this, void 0, void 0, function* () {
+                fs.writeFileSync(path.join(this.outDir, file.path), yield file.buffer());
+                return file.path;
+            });
+        }
+        /**
+         * Decompresses the specified zip file.
+         */
+        static decompress(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const filePath = path.join(this.outDir, params._filename);
+                Log_1.default.debug("Zip.decompress", params);
+                const directory = yield unzipper.Open.file(filePath);
+                const results = [];
+                for (let i = 0; i < directory.files.length; i += 1) {
+                    const file = directory.files[i];
+                    if (file.path.slice(-1) === "/") {
+                        fs.mkdirSync(path.join(this.outDir, file.path));
+                    }
+                    else {
+                        results.push(this.writeFileSync(file));
+                    }
+                }
+                return Promise.all(results);
+            });
+        }
+        // zip 递归读取文件夹下的文件流 排除部分文件或文件夹
+        static readDir(zip, nowPath, filterArr) {
+            // 同步操作
+            let files = fs.readdirSync(nowPath);
+            let exclude = name => !filterArr.includes(name);
+            files.filter(exclude).forEach((fileName, index) => {
+                console.log(fileName, index);
+                let fillPath = path.join(nowPath, fileName);
+                let file = fs.statSync(fillPath);
+                if (file.isDirectory()) {
+                    let dirlist = zip.folder(fileName);
+                    Zip.readDir(dirlist, fillPath, filterArr);
+                }
+                else {
+                    // 压缩目录添加文件
+                    zip.file(fileName, fs.readFileSync(fillPath));
+                }
+            });
+        }
+        /**
+       * compresses the specified folder
+       */
+        static compress(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const zip = new JSZip();
+                const output = params._targetPath + '/' + params._zipName;
+                Zip.readDir(zip, params._sourcePath, params._filter);
+                zip.generateAsync({
+                    type: 'nodebuffer',
+                    compression: 'DEFLATE',
+                    compressionOptions: { level: 9, },
+                }).then(content => {
+                    fs.writeFileSync(output, content, 'utf-8');
+                });
+            });
+        }
+    }
+    Zip.outDir = process.env.WORKSPACE_DIR || "./";
+    MR.Zip = Zip;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Zip;

package/dist/dotenv.js

@@ -0,0 +1,2 @@
+require('dotenv').config();
+console.log(process.env); // remove this after you've confirmed it is working

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import * as WebBrowserModule from "./MR/WebBrowser";
+import SystemModule from "./MR/System";
+import SmtpModule from "./MR/Smtp";
+import ImapModule from "./MR/Imap";
+import StringModule from "./MR/String";
+import MouseModule from "./MR/Mouse";
+import KeyboardModule from "./MR/Keyboard";
+import ScreenModule from "./MR/Screen";
+import WindowModule from "./MR/Window";
+import ClipboardModule from "./MR/Clipboard";
+import ZipModule from "./MR/Zip";
+import FileModule from "./MR/File";
+import ValidatorModule from "./MR/Validator";
+import NetModule from "./MR/Net";
+import CsvModule from "./MR/Csv";
+import PdfModule from "./MR/Pdf";
+import IniModule from "./MR/Ini";
+import DateModule from "./MR/Date";
+import ProcessModule from "./MR/Process";
+import HttpModule from "./MR/Http";
+import RegexModule from "./MR/Regex";
+import WordModule from "./MR/Word";
+import HtmlModule from "./MR/Html";
+export declare namespace MR {
+    const Word: typeof WordModule;
+    const Html: typeof HtmlModule;
+    const Regex: typeof RegexModule;
+    const Http: typeof HttpModule;
+    const Web: WebBrowserModule.MR.WebBrowser;
+    const System: typeof SystemModule;
+    const Excel: import("./MR/Excel").MR.Excel;
+    const Smtp: typeof SmtpModule;
+    const Imap: typeof ImapModule;
+    const Date: typeof DateModule;
+    const String: typeof StringModule;
+    const Pdf: typeof PdfModule;
+    const Csv: typeof CsvModule;
+    const Net: typeof NetModule;
+    const Redis: import("./MR/RedisClient").MR.MyRedis;
+    const Db: import("./MR/DbClient").MR.DbClient;
+    const Validator: typeof ValidatorModule;
+    const Ini: typeof IniModule;
+    const sleep: (msec: number) => Promise<void>, prompt: (question: string) => Promise<string>, retry: <T>(asyncFunc: () => Promise<T>, retryCount?: number) => Promise<T>;
+    const Mouse: typeof MouseModule;
+    const Keyboard: typeof KeyboardModule;
+    const Screen: typeof ScreenModule;
+    const Window: typeof WindowModule;
+    const Clipboard: typeof ClipboardModule;
+    const Log: import("log4js").Logger;
+    const Zip: typeof ZipModule;
+    const File: typeof FileModule;
+    const Process: typeof ProcessModule;
+}
+export default MR;

package/dist/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const WebBrowserModule = require("./MR/WebBrowser");
+const System_1 = require("./MR/System");
+const Smtp_1 = require("./MR/Smtp");
+const Imap_1 = require("./MR/Imap");
+const String_1 = require("./MR/String");
+const util_1 = require("./util");
+const Mouse_1 = require("./MR/Mouse");
+const Keyboard_1 = require("./MR/Keyboard");
+const Screen_1 = require("./MR/Screen");
+const Window_1 = require("./MR/Window");
+const Clipboard_1 = require("./MR/Clipboard");
+const Log_1 = require("./MR/Log");
+const Zip_1 = require("./MR/Zip");
+const RedisClient_1 = require("./MR/RedisClient");
+const DbClient_1 = require("./MR/DbClient");
+const File_1 = require("./MR/File");
+const Validator_1 = require("./MR/Validator");
+const Net_1 = require("./MR/Net");
+const Csv_1 = require("./MR/Csv");
+const Pdf_1 = require("./MR/Pdf");
+const Ini_1 = require("./MR/Ini");
+const Date_1 = require("./MR/Date");
+const Excel_1 = require("./MR/Excel");
+const Process_1 = require("./MR/Process");
+const Http_1 = require("./MR/Http");
+const Regex_1 = require("./MR/Regex");
+const Word_1 = require("./MR/Word");
+const Html_1 = require("./MR/Html");
+var MR;
+(function (MR) {
+    MR.Word = Word_1.default;
+    MR.Html = Html_1.default;
+    MR.Regex = Regex_1.default;
+    MR.Http = Http_1.default;
+    MR.Web = WebBrowserModule.default;
+    MR.System = System_1.default;
+    MR.Excel = Excel_1.default;
+    MR.Smtp = Smtp_1.default;
+    MR.Imap = Imap_1.default;
+    MR.Date = Date_1.default;
+    MR.String = String_1.default;
+    MR.Pdf = Pdf_1.default;
+    MR.Csv = Csv_1.default;
+    MR.Net = Net_1.default;
+    MR.Redis = RedisClient_1.default;
+    MR.Db = DbClient_1.default;
+    MR.Validator = Validator_1.default;
+    MR.Ini = Ini_1.default;
+    MR.sleep = util_1.default.sleep, MR.prompt = util_1.default.prompt, MR.retry = util_1.default.retry;
+    MR.Mouse = Mouse_1.default;
+    MR.Keyboard = Keyboard_1.default;
+    MR.Screen = Screen_1.default;
+    MR.Window = Window_1.default;
+    MR.Clipboard = Clipboard_1.default;
+    MR.Log = Log_1.default;
+    MR.Zip = Zip_1.default;
+    MR.File = File_1.default;
+    MR.Process = Process_1.default;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR;

package/dist/util.d.ts

@@ -0,0 +1,17 @@
+import * as lo from 'lodash';
+export declare namespace MR {
+    /**
+     * Suspends execution for an interval of time.
+     */
+    const sleep: (msec: number) => Promise<void>;
+    /**
+     * Waits for user input to be provided to stdin then returns that.
+     */
+    const prompt: (question: string) => Promise<string>;
+    /**
+     * Executes up to `retryCount` times until `asyncFunc` resolves
+     */
+    const retry: <T>(asyncFunc: () => Promise<T>, retryCount?: number) => Promise<T>;
+    const _: lo.LoDashStatic;
+}
+export default MR;

package/dist/util.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const readline = require("readline");
+const lo = require("lodash");
+var MR;
+(function (MR) {
+    /**
+     * Suspends execution for an interval of time.
+     */
+    MR.sleep = (msec) => new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, msec);
+    });
+    /**
+     * Waits for user input to be provided to stdin then returns that.
+     */
+    MR.prompt = (question) => {
+        const stdio = readline.createInterface(process.stdin, process.stdout);
+        return new Promise((resolve) => {
+            stdio.question(question, (answer) => {
+                stdio.close();
+                resolve(answer);
+            });
+        });
+    };
+    /**
+     * Executes up to `retryCount` times until `asyncFunc` resolves
+     */
+    MR.retry = (asyncFunc, retryCount = 3) => {
+        const nums = Array.from(Array(retryCount));
+        return nums.reduce((prm, _, i) => {
+            return prm.catch(() => MR.sleep(i * 1000).then(asyncFunc));
+        }, Promise.reject());
+    };
+    //适配gpt
+    //lodash 数组 集合 函数 语言 数学 对象 序列 字符串 
+    MR._ = lo;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR;

package/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "pp-robot-module",
+  "version": "0.2.14",
+  "description": "makwing for inner testting",
+  "main": "dist/index.js",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "rimraf ./dist && require-self && tsc && npm run copyFile",
+    "doc": "rimraf ./docs && typedoc",
+    "prepare": "npm run build",
+    "lint": "eslint '+(src|tests)/**' --ext .ts",
+    "fix": "eslint '+(src|tests)/**' --ext .ts --fix",
+    "test": "jest -w 1 --forceExit",
+    "copyFile": "xcopy /y /e /i .\\src\\bin .\\dist\\bin"
+  },
+  "jest": {
+    "testTimeout": 20000,
+    "testPathIgnorePatterns": [
+      "./dist/",
+      "./node_modules/"
+    ],
+    "transform": {
+      "^.+\\.(t|j)sx?$": "ts-jest"
+    },
+    "testRegex": "/test/.*\\.spec\\.(ts|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "js"
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsConfig": "tsconfig.json"
+      }
+    },
+    "setupFiles": [
+      "<rootDir>/jest-env.js"
+    ]
+  },
+  "pre-commit": [],
+  "author": "makwing",
+  "license": "ISC",
+  "dependencies": {
+    "@nut-tree/nut-js": "3.1.1",
+    "cheerio": "1.0.0-rc.12",
+    "clipboard-sys": "1.2.0",
+    "csv": "5.1.1",
+    "csvtojson": "2.0.10",
+    "dayjs": "1.11.7",
+    "docx": "8.0.4",
+    "dotenv": "16.0.3",
+    "excel4node": "1.8.2",
+    "express": "4.18.2",
+    "file-type": "12.0.1",
+    "fkill": "7.2.1",
+    "form-data": "4.0.0",
+    "htmlparser2": "9.0.0",
+    "iconv-lite": "0.6.3",
+    "ini": "4.0.0",
+    "ioredis": "5.3.1",
+    "is-utf8": "0.2.1",
+    "json-2-csv": "4.0.0",
+    "jszip": "3.10.1",
+    "knex": "2.4.2",
+    "lodash": "4.17.21",
+    "log4js": "6.8.0",
+    "mail-listener2": "0.3.1",
+    "mammoth": "1.5.1",
+    "mime-stream": "1.0.1",
+    "muhammara": "3.8.0",
+    "mysql": "2.18.1",
+    "node-fetch": "2.6.9",
+    "node-forge": "1.3.1",
+    "nodemailer": "6.9.1",
+    "pdf-lib": "1.17.1",
+    "pdf.js-extract": "0.2.1",
+    "pg": "8.10.0",
+    "pkg": "5.8.1",
+    "pkginfo": "0.4.1",
+    "playwright": "1.34.3",
+    "redis": "4.6.5",
+    "require-self": "0.2.3",
+    "rimraf": "4.1.2",
+    "shelljs": "0.8.5",
+    "string": "3.3.3",
+    "systeminformation": "5.17.12",
+    "tableify": "1.1.1",
+    "tabletojson": "2.0.7",
+    "top-user-agents": "1.0.52",
+    "typescript": "4.9.5",
+    "unzipper": "0.10.11",
+    "validator": "13.9.0",
+    "xlsx": "0.18.5"
+  },
+  "devDependencies": {
+    "@types/jest": "29.4.0",
+    "@types/lodash": "4.14.191",
+    "@types/node": "16.18.25",
+    "@types/node-fetch": "2.6.2",
+    "@types/node-forge": "1.3.1",
+    "@types/nodemailer": "6.4.7",
+    "@typescript-eslint/eslint-plugin": "5.54.0",
+    "@typescript-eslint/parser": "5.54.0",
+    "eslint": "8.35.0",
+    "eslint-config-airbnb-base": "15.0.0",
+    "eslint-config-prettier": "8.6.0",
+    "eslint-import-resolver-typescript": "3.5.3",
+    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-jest": "27.2.1",
+    "eslint-plugin-prettier": "4.2.1",
+    "jest": "29.4.3",
+    "pre-commit": "1.2.2",
+    "prettier": "2.8.4",
+    "ts-jest": "29.0.5",
+    "ts-node": "10.9.1",
+    "typedoc": "0.23.26",
+    "typedoc-plugin-localization": "2.4.0"
+  }
+}