pp-robot-module 0.2.14

package/dist/MR/Mouse.js

@@ -0,0 +1,152 @@
+"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 nut_js_1 = require("@nut-tree/nut-js");
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class Mouse {
+        constructor() { }
+        static setPosition(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.setPosition", params);
+                const p = new nut_js_1.Point(params._x, params._y);
+                return yield nut_js_1.mouse.setPosition(p);
+            });
+        }
+        static get() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.get");
+                return nut_js_1.mouse;
+            });
+        }
+        static getPosition() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.getPosition", '');
+                return yield nut_js_1.mouse.getPosition();
+            });
+        }
+        static getScreenCenterPosition() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.getScreenCenterPosition", '');
+                let h = yield nut_js_1.screen.height();
+                let w = yield nut_js_1.screen.width();
+                return Promise.resolve(new nut_js_1.Point(w / 2, h / 2));
+            });
+        }
+        /**
+         * @param params
+         * @returns
+         */
+        static click(params = { _button: "left", _count: 1, _delay: 10 }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.click", params);
+                let BntEnum = nut_js_1.Button.LEFT;
+                if (params._button === "middle")
+                    BntEnum = nut_js_1.Button.MIDDLE;
+                if (params._button === "right")
+                    BntEnum = nut_js_1.Button.RIGHT;
+                for (let index = 0; index < params._count; index++) {
+                    yield nut_js_1.mouse.click(BntEnum);
+                    yield (0, nut_js_1.sleep)(params._delay);
+                }
+            });
+        }
+        static doubleClick(params = { _button: "left", _count: 1, _delay: 10 }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.doubleClick", params);
+                let BntEnum = nut_js_1.Button.LEFT;
+                if (params._button === "middle")
+                    BntEnum = nut_js_1.Button.MIDDLE;
+                if (params._button === "right")
+                    BntEnum = nut_js_1.Button.RIGHT;
+                for (let index = 0; index < params._count; index++) {
+                    yield nut_js_1.mouse.doubleClick(BntEnum);
+                    yield (0, nut_js_1.sleep)(params._delay);
+                }
+            });
+        }
+        static leftClick() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.mouse.click(nut_js_1.Button.LEFT);
+            });
+        }
+        static leftDoubleClick() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.mouse.doubleClick(nut_js_1.Button.LEFT);
+            });
+        }
+        static rightClick() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.mouse.click(nut_js_1.Button.RIGHT);
+            });
+        }
+        static drag(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.drag", params);
+                return yield nut_js_1.mouse.drag((0, nut_js_1.straightTo)((0, nut_js_1.centerOf)(new nut_js_1.Region(params._x, params._y, params._width, params._height))));
+            });
+        }
+        static move(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.move", params);
+                return yield nut_js_1.mouse.move((0, nut_js_1.straightTo)(new nut_js_1.Point(params._x, params._y)));
+            });
+        }
+        static scroll(params = { _direction: 'Down', _amount: 1 }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Mouse.scroll", params);
+                switch (params._direction) {
+                    case "Down":
+                        yield nut_js_1.mouse.scrollDown(params._amount);
+                        break;
+                    case "Up":
+                        yield nut_js_1.mouse.scrollUp(params._amount);
+                        break;
+                    case "Left":
+                        yield nut_js_1.mouse.scrollLeft(params._amount);
+                        break;
+                    case "Right":
+                        yield nut_js_1.mouse.scrollRight(params._amount);
+                        break;
+                }
+            });
+        }
+        static moveLeft(offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.mouse.move((0, nut_js_1.left)(offset));
+            });
+        }
+        static moveRight(offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.mouse.move((0, nut_js_1.right)(offset));
+            });
+        }
+        static moveDown(offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.mouse.move((0, nut_js_1.down)(offset));
+            });
+        }
+        static moveUp(offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.mouse.move((0, nut_js_1.up)(offset));
+            });
+        }
+        static scrollLeft(offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // return await mouse.scrollLeft(up(offset));
+            });
+        }
+    }
+    MR.Mouse = Mouse;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Mouse;

package/dist/MR/Net.d.ts

@@ -0,0 +1,17 @@
+export declare namespace MR {
+    class Net {
+        private constructor();
+        static address(params?: {
+            _iface?: string;
+        }): Promise<any>;
+        static mac(): Promise<any>;
+        static ip4(): Promise<any>;
+        static ip6(): Promise<any>;
+        static gateway(): Promise<any>;
+        static checkSite(params: {
+            _url: string;
+        }): Promise<any>;
+    }
+}
+declare const _default: typeof MR.Net;
+export default _default;

package/dist/MR/Net.js

@@ -0,0 +1,74 @@
+"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 Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class Net {
+        constructor() { }
+        static address(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Net.address", params);
+                if (params === null || params === void 0 ? void 0 : params._iface) {
+                    return yield si.networkInterfaces(params._iface);
+                }
+                return yield si.networkInterfaces('default');
+            });
+        }
+        /*  public static async macaddress() {
+           return new Promise((resolve, reject) => {
+             address(function (err, addr) {
+               if (err) {
+                 return reject(err);
+               }
+               resolve(addr);
+             });
+           });
+         } */
+        static mac() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Net.mac");
+                const net = yield si.networkInterfaces('default');
+                return net.mac;
+            });
+        }
+        static ip4() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Net.ip4");
+                const net = yield si.networkInterfaces('default');
+                return net.ip4;
+            });
+        }
+        static ip6() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Net.ip6");
+                const net = yield si.networkInterfaces('default');
+                return net.ip6;
+            });
+        }
+        static gateway() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Net.gateway");
+                return yield si.networkGatewayDefault();
+            });
+        }
+        static checkSite(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Net.checkSite");
+                return yield si.inetChecksite(params._url);
+            });
+        }
+    }
+    MR.Net = Net;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Net;

package/dist/MR/Pdf.d.ts

@@ -0,0 +1,113 @@
+export declare namespace MR {
+    class Pdf {
+        static text(params: {
+            _filename: string;
+        }): Promise<string>;
+        static json(params: {
+            _filename: string;
+        }): Promise<string>;
+        static create(params: {
+            _filename: string;
+            _text?: {
+                _str: string;
+                _x: number;
+                _y: number;
+            };
+            _comment?: {
+                _str: string;
+                _x: number;
+                _y: number;
+            };
+            _image?: {
+                _imagefile: string;
+                _x: number;
+                _y: number;
+                _width: number;
+                _height: number;
+            };
+            _rect?: {
+                _x: number;
+                _y: number;
+                _width: number;
+                _height: number;
+            };
+        }): void;
+        static modify(params: {
+            _filename: string;
+            _pageno: number;
+            _text: {
+                _str: string;
+                _x: number;
+                _y: number;
+            };
+            _comment: {
+                _str: string;
+                _x: number;
+                _y: number;
+            };
+            _image: {
+                _imagefile: string;
+                _x: number;
+                _y: number;
+                _width: number;
+                _height: number;
+            };
+            _rect: {
+                _x: number;
+                _y: number;
+                _width: number;
+                _height: number;
+            };
+        }): void;
+        static split(params: {
+            _filename: string;
+            _prefix?: string;
+        }): string;
+        structure(params: {
+            _filename: string;
+        }): Promise<void>;
+        static insert(params: {
+            _filename: string;
+            _insertfile: string;
+            _pageno: number;
+        }): void;
+        static append(params: {
+            _filename: string;
+            _appendfile: string;
+        }): void;
+        static count(params: {
+            _filename: string;
+        }): any;
+        static encrypt(params: {
+            _filename: string;
+            _password: string;
+        }): string;
+        static toImg(params: {
+            _filename: string;
+        }): Promise<any[]>;
+        static coordinate(params: {
+            _filename: string;
+            _keyword: string[];
+        }): Promise<{
+            x: number;
+            y: number;
+            kw: string;
+            width: number;
+            height: number;
+            pageWidth: number;
+            pageHeight: number;
+        }[]>;
+        static splitByRects(params: {
+            _filename: string;
+            _coordinate: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                keyword: string;
+            }[];
+        }): Promise<any[]>;
+    }
+}
+declare const _default: typeof MR.Pdf;
+export default _default;

package/dist/MR/Pdf.js

@@ -0,0 +1,197 @@
+"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 { PDFDocument } = require('pdf-lib');
+const Recipe = require("muhammara").Recipe;
+const pdf_js_extract_1 = require("pdf.js-extract");
+var MR;
+(function (MR) {
+    class Pdf {
+        static text(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Pdf.text", params);
+                return '';
+            });
+        }
+        static json(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Pdf.json", params);
+                const pdfExtract = new pdf_js_extract_1.PDFExtract();
+                const options = {};
+                const data = yield pdfExtract.extract(params._filename, options);
+                return JSON.stringify(data);
+            });
+        }
+        static create(params) {
+            Log_1.default.debug("Pdf.create", params);
+            const pdfDoc = new Recipe("new", params._filename);
+            pdfDoc.createPage("letter-size");
+            if (params._text)
+                pdfDoc.text(params._text._str, params._text._x, params._text._y);
+            if (params._rect)
+                pdfDoc.rectangle(params._rect._x, params._rect._y, params._rect._width, params._rect._height);
+            if (params._comment)
+                pdfDoc.comment(params._comment._str, params._comment._x, params._comment._y);
+            if (params._image)
+                pdfDoc.image(params._image._imagefile, params._image._x, params._image._y, { width: params._image._width, height: params._image._height, keepAspectRatio: true });
+            pdfDoc.endPage();
+            // end and save
+            pdfDoc.endPDF();
+        }
+        static modify(params) {
+            Log_1.default.debug("Pdf.modify", 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 pdfDoc = new Recipe(params._filename, output);
+            pdfDoc.editPage(params._pageno);
+            if (params._text)
+                pdfDoc.text(params._text._str, params._text._x, params._text._y);
+            if (params._rect)
+                pdfDoc.rectangle(params._rect._x, params._rect._y, params._rect._width, params._rect._height);
+            if (params._comment)
+                pdfDoc.comment(params._comment._str, params._comment._x, params._comment._y);
+            if (params._image)
+                pdfDoc.image(params._image._imagefile, params._image._x, params._image._y, { width: params._image._width, height: params._image._height, keepAspectRatio: true });
+            pdfDoc.endPage();
+            // end and save
+            pdfDoc.endPDF();
+        }
+        static split(params) {
+            Log_1.default.debug("Pdf.split", params);
+            const pdfDoc = new Recipe(params._filename);
+            const parentPath = path.dirname(params._filename);
+            const outputDir = path.join(parentPath);
+            const fileNameWithoutExt = path.basename(params._filename, path.extname(params._filename));
+            let pre = params._prefix || fileNameWithoutExt;
+            pdfDoc.split(outputDir, pre).endPDF();
+            return outputDir;
+        }
+        structure(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Pdf.structure", params);
+                const pdfDoc = new Recipe(params._filename);
+                pdfDoc.structure("pdf-structure.txt").endPDF();
+            });
+        }
+        static insert(params) {
+            Log_1.default.debug("Pdf.insert", 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 pdfDoc = new Recipe(params._filename, output);
+            const insertPdfDoc = new Recipe(params._insertfile);
+            const pages = insertPdfDoc.metadata.pages;
+            for (let i = 1; i <= pages; i++) {
+                pdfDoc.insertPage(params._pageno, params._insertfile, i);
+            }
+            pdfDoc.endPDF();
+        }
+        static append(params) {
+            Log_1.default.debug("Pdf.append", 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 pdfDoc = new Recipe(params._filename, output);
+            const insertPdfDoc = new Recipe(params._appendfile);
+            const pages = insertPdfDoc.metadata.pages;
+            for (let i = 1; i <= pages; i++) {
+                pdfDoc.appendPage(params._appendfile, i);
+            }
+            pdfDoc.endPDF();
+        }
+        static count(params) {
+            const pdfDoc = new Recipe(params._filename);
+            const pages = pdfDoc.metadata.pages;
+            return pages;
+        }
+        static encrypt(params) {
+            Log_1.default.debug("Pdf.encrypt", 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");
+            console.log(output);
+            const pdfDoc = new Recipe(params._filename, output);
+            pdfDoc
+                .encrypt({
+                userPassword: params._password,
+                ownerPassword: params._password,
+                userProtectionFlag: 4,
+            })
+                .endPDF();
+            return output;
+        }
+        static toImg(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Pdf.toImg", params);
+                const output = [];
+                //TODO
+                return output;
+            });
+        }
+        static coordinate(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Pdf.coordinate", params);
+                const pdfExtract = new pdf_js_extract_1.PDFExtract();
+                const options = {};
+                const data = yield pdfExtract.extract(params._filename, options);
+                //只提取第一页
+                const pageInfo = data.pages[0].pageInfo;
+                const content = data.pages[0].content;
+                const match = content.filter((item) => params._keyword.includes(item.str)).map((item) => ({ x: item.x, y: item.y, kw: item.str, width: item.width, height: item.height, pageWidth: pageInfo.width, pageHeight: pageInfo.height }));
+                return match;
+            });
+        }
+        static splitByRects(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Pdf.splitByRects", params);
+                const coordinateList = params._coordinate;
+                const inputPath = params._filename;
+                const parentPath = path.dirname(params._filename);
+                const outputPath = path.join(parentPath);
+                const pdfBytes = fs.readFileSync(inputPath);
+                const pdfDoc = yield PDFDocument.load(pdfBytes);
+                const page = pdfDoc.getPages()[0];
+                if (!coordinateList || coordinateList.length <= 0) {
+                    return;
+                }
+                const subDocs = [];
+                for (let j = 0; j < coordinateList.length; j++) {
+                    const coordinate = coordinateList[j];
+                    const subDoc = yield PDFDocument.create();
+                    const [subPage] = yield subDoc.copyPages(pdfDoc, [0]);
+                    subPage.setSize(coordinate.width, coordinate.height);
+                    subPage.setMediaBox(coordinate.x, page.getHeight() - coordinate.y - coordinate.height, coordinate.width, coordinate.height);
+                    subPage.setCropBox(coordinate.x, page.getHeight() - coordinate.y - coordinate.height, coordinate.width, coordinate.height);
+                    subDoc.addPage(subPage);
+                    subDocs.push({ doc: subDoc, key: coordinate.keyword });
+                }
+                const fileNameWithoutExt = path.basename(params._filename, path.extname(params._filename));
+                const outputFilePaths = [];
+                if (subDocs.length > 0) {
+                    for (let k = 0; k < subDocs.length; k++) {
+                        const subPdfData = yield subDocs[k].doc.save();
+                        const outputFilePath = path.join(outputPath, `${fileNameWithoutExt}-${subDocs[k].key}-${k + 1}.pdf`);
+                        outputFilePaths.push(outputFilePath);
+                        fs.writeFileSync(outputFilePath, subPdfData);
+                    }
+                }
+                return outputFilePaths;
+            });
+        }
+    }
+    MR.Pdf = Pdf;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Pdf;

package/dist/MR/Process.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+export declare namespace MR {
+    class Process {
+        private constructor();
+        static envs(params?: {
+            _type: 'Object' | 'Array';
+        }): NodeJS.ProcessEnv | {
+            name: string;
+            value: string;
+        }[];
+        static env(params: {
+            _key: string;
+        }): string;
+        static cwd(): string;
+        static echo(params: {
+            _content: string;
+            _newline?: boolean;
+        }): any;
+        static exec(params: {
+            _cmd: string;
+            _silent?: boolean;
+        }): Promise<string>;
+        static kill(params: {
+            _pid?: number;
+            _name?: string;
+            _port?: number;
+        }): Promise<void>;
+        static capture(params?: {
+            _filePath?: string;
+            _fileName?: string;
+            _fileType?: 'PNG' | 'JPG';
+        }): Promise<string>;
+        static captureRegion(params?: {
+            _x?: number;
+            _y?: number;
+            _width?: number;
+            _height?: number;
+            _filePath?: string;
+            _fileName?: string;
+            _fileType?: 'PNG' | 'JPG';
+        }): Promise<string>;
+        static test1(): Promise<void>;
+    }
+}
+declare const _default: typeof MR.Process;
+export default _default;