pp-robot-module 0.2.14

package/dist/MR/File.js

@@ -0,0 +1,399 @@
+"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 Log_1 = require("./Log");
+const fse = require('fs-extra');
+const iconvLite = require('iconv-lite');
+var SortType;
+(function (SortType) {
+    SortType["Name"] = "name";
+    SortType["Birthtime"] = "birthtime";
+    SortType["Ctime"] = "ctime";
+    SortType["Mtime"] = "mtime";
+    SortType["Size"] = "size";
+})(SortType || (SortType = {}));
+var OrderBy;
+(function (OrderBy) {
+    OrderBy[OrderBy["ASC"] = 0] = "ASC";
+    OrderBy[OrderBy["DESC"] = 1] = "DESC";
+})(OrderBy || (OrderBy = {}));
+var MR;
+(function (MR) {
+    class File {
+        constructor() { }
+        // 目标文件夹不存在的话, 会自动创建
+        static copy(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.copy", params);
+                try {
+                    return yield fse.copy(params._srcFile, params._destFile);
+                }
+                catch (err) {
+                    console.error(err);
+                    return false;
+                }
+            });
+        }
+        // 如果文件夹不存在, 会创建空文件夹
+        // 文件夹中含有其他文件或文件夹时会清空所有
+        // 创建时返回文件夹绝对路径
+        static emptyDir(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.emptyDir", params);
+                try {
+                    yield fse.emptyDir(params._dir);
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            });
+        }
+        // 文件不存在则创建空文件, 存在时不做修改
+        // 永远返回undefined
+        static ensureFile(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.ensureFile", params);
+                try {
+                    return yield fse.ensureFile(params._filename);
+                }
+                catch (err) {
+                    return false;
+                }
+            });
+        }
+        // 文件夹如果存在, 不做修改, 返回null
+        // 不存在时创建, 并返回文件夹绝对路径
+        static ensureDir(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.ensureDir", params);
+                try {
+                    yield fse.ensureDir(params._dir, params._options);
+                    console.log('success!');
+                    return true;
+                }
+                catch (err) {
+                    console.error(err);
+                    return false;
+                }
+            });
+        }
+        // 创建返回绝对路径
+        // 已经存在返回null
+        static mkdirp(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.mkdirp", params);
+                try {
+                    return yield fse.mkdirp(params._dir, params._options);
+                }
+                catch (err) {
+                    console.error(err);
+                    return false;
+                }
+            });
+        }
+        // 移动文件夹或文件, 源必须存在
+        // 无返回值
+        static move(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.move", params);
+                try {
+                    yield fse.move(params._srcFile, params._destFile, { overwrite: true });
+                    console.log('success!');
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        }
+        // 文件夹或文件路径是否存在
+        static pathExists(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.pathExists", params);
+                const exists = yield fse.pathExists(params._filename);
+                return exists;
+            });
+        }
+        // 写
+        static outputFile(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.outputFile", [params._filename, params._encoding]);
+                try {
+                    let _opt = {};
+                    if (params._encoding)
+                        _opt = { encoding: params._encoding };
+                    return yield fse.outputFile(params._filename, params._data, _opt);
+                }
+                catch (err) {
+                    console.error(err);
+                    return false;
+                }
+            });
+        }
+        static readFile(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.readFile", [params._filename, params._encoding]);
+                try {
+                    let data = yield fse.readFile(params._filename);
+                    if (params._encoding) {
+                        data = iconvLite.decode(data, params._encoding);
+                    }
+                    return data;
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        }
+        // 写json
+        static outputJson(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.outputJson", params._filename);
+                try {
+                    let _opt = {};
+                    if (params._encoding)
+                        _opt = { encoding: params._encoding };
+                    yield fse.outputJson(params._filename, params._data, _opt);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        }
+        //读 json
+        static readJson(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.readJson", params);
+                try {
+                    let data = yield fse.readJson(params._filename);
+                    if (params._encoding) {
+                        data = iconvLite.decode(data, params._encoding);
+                    }
+                    return data;
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        }
+        // 无返回值, 移除文件夹或文件, 递归式
+        static remove(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.remove", params);
+                try {
+                    if (File.pathExists({ _filename: params._filename }))
+                        return yield fse.remove(params._filename);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        }
+        static detail(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.detail", params);
+                try {
+                    const stats = yield fs.promises.stat(params._filename);
+                    const fileInfo = path.parse(params._filename);
+                    const fileDetails = {
+                        isFile: stats.isFile(),
+                        isDirectory: stats.isDirectory(),
+                        sizeForamt: this.formatFileSize(stats.size),
+                        size: stats.size,
+                        birthtime: stats.birthtime,
+                        modifytime: stats.mtime,
+                        filename: fileInfo.name,
+                        extname: fileInfo.ext,
+                        dirname: fileInfo.dir,
+                        fullpath: path.resolve(params._filename),
+                    };
+                    return fileDetails;
+                }
+                catch (err) {
+                    console.error(err);
+                    throw err;
+                }
+            });
+        }
+        static folderSize(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.folderSize", params);
+                try {
+                    const folderSize = this.getFolderSize(params._dir);
+                    return folderSize;
+                }
+                catch (err) {
+                    console.error(err);
+                    throw err;
+                }
+            });
+        }
+        static getFolderSize(folderPath) {
+            let totalSize = 0;
+            function calculateSize(filePath) {
+                const stats = fs.statSync(filePath);
+                if (stats.isDirectory()) {
+                    const subFiles = fs.readdirSync(filePath);
+                    subFiles.forEach((subFile) => {
+                        calculateSize(path.join(filePath, subFile));
+                    });
+                }
+                else if (stats.isFile()) {
+                    totalSize += stats.size;
+                }
+            }
+            calculateSize(folderPath);
+            // 将文件夹大小转换为人类可读的格式
+            const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+            let size = totalSize;
+            let unitIndex = 0;
+            while (size >= 1024 && unitIndex < units.length - 1) {
+                size /= 1024;
+                unitIndex++;
+            }
+            const formattedSize = size.toFixed(2) + ' ' + units[unitIndex];
+            return formattedSize;
+        }
+        static getLastedFile(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("File.getLastedFile", params);
+                try {
+                    const newestFile = this.getNewestFileInDirectory(params._dir);
+                    return newestFile;
+                }
+                catch (err) {
+                    console.error(err);
+                    throw err;
+                }
+            });
+        }
+        static getNewestFileInDirectory(directoryPath) {
+            const files = fs.readdirSync(directoryPath);
+            let newestFile = null;
+            let newestDate = null;
+            files.forEach((file) => {
+                const filePath = path.join(directoryPath, file);
+                const stats = fs.statSync(filePath);
+                if (stats.isFile()) {
+                    const fileDate = stats.mtime;
+                    if (!newestDate || fileDate > newestDate) {
+                        newestDate = fileDate;
+                        newestFile = file;
+                    }
+                }
+            });
+            return newestFile;
+        }
+        /**
+         * Change the name or location of a file or directory.
+         * @param params
+         */
+        static rename(params) {
+            Log_1.default.debug("File.rename", params);
+            if (File.pathExists({ _filename: params._oldFile }))
+                return fs.renameSync(params._oldFile, params._newFile);
+        }
+        /**
+         * Write data to a file, replacing the file if it already exists.
+         * @param params
+         */
+        static write(params) {
+            Log_1.default.debug("File.write", params._filename);
+            fs.writeFileSync(params._filename, params._data);
+        }
+        /**
+         * Create a directory.
+         * @param params
+         */
+        static makeDir(params) {
+            Log_1.default.debug("File.makeDir", params);
+            return fs.mkdirSync(params._dir);
+        }
+        /**
+         * Get file status.
+         * @param params
+         */
+        static getStats(params) {
+            Log_1.default.debug("File.getStats", params);
+            return fs.statSync(params._filename);
+        }
+        /**
+         * Lists files or directories in a directory.
+         * @param params
+         */
+        static list(params) {
+            Log_1.default.debug("File.list", params);
+            const fileList = fs.readdirSync(params._dir);
+            if (params && params.sortType) {
+                Log_1.default.debug("File.list->sort", { params });
+                if (params.sortType === SortType.Name) {
+                    fileList.sort(new Intl.Collator(undefined, { numeric: true, sensitivity: "base" })
+                        .compare);
+                    if (params.orderBy === OrderBy.DESC) {
+                        fileList.reverse();
+                    }
+                }
+                else {
+                    return fileList
+                        .map(filename => {
+                        return {
+                            filename,
+                            value: this.getStats({ _filename: filename })[params.sortType]
+                        };
+                    })
+                        .sort((a, b) => params.orderBy === OrderBy.DESC
+                        ? b.value - a.value
+                        : a.value - b.value)
+                        .map(v => v.filename);
+                }
+            }
+            return fileList;
+        }
+        /**
+         * Lists only files in a directory.
+         * @param params
+         */
+        static listFiles(params) {
+            const dirname = (params && params._dir) || "./";
+            Log_1.default.debug("File.listFiles", { dirname });
+            return File.list(params).filter((filename) => File.isFile({ _filename: path.join(dirname, filename) }));
+        }
+        /**
+         * Tests whether the given path is a file.
+         * @param params
+         */
+        static isFile(params) {
+            Log_1.default.debug("File.isFile", params);
+            return File.pathExists({ _filename: params._filename }) && fs.lstatSync(params._filename).isFile();
+        }
+        static isDir(params) {
+            Log_1.default.debug("File.isDir", params);
+            return File.pathExists({ _filename: params._filename }) && fs.lstatSync(params._filename).isDirectory();
+        }
+    }
+    File.SortType = SortType;
+    File.OrderBy = OrderBy;
+    // 转换文件大小为可读格式（例如：KB、MB、GB）
+    File.formatFileSize = (bytes) => {
+        if (bytes === 0) {
+            return '0 Bytes';
+        }
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    };
+    MR.File = File;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.File;

package/dist/MR/Hash.d.ts

@@ -0,0 +1,12 @@
+export declare namespace MR {
+    class Hash {
+        private constructor();
+        /**
+         * Calculate the md5 hash of a string.
+         * @param msg
+         */
+        static md5(msg: string): string;
+    }
+}
+declare const _default: typeof MR.Hash;
+export default _default;

package/dist/MR/Hash.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const forge = require("node-forge");
+var MR;
+(function (MR) {
+    class Hash {
+        constructor() { } // eslint-disable-line no-useless-constructor, no-empty-function
+        /**
+         * Calculate the md5 hash of a string.
+         * @param msg
+         */
+        static md5(msg) {
+            const md = forge.md.md5.create();
+            md.update(msg);
+            return md.digest().toHex();
+        }
+    }
+    MR.Hash = Hash;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Hash;

package/dist/MR/Html.d.ts

@@ -0,0 +1,38 @@
+export declare namespace MR {
+    class Html {
+        private constructor();
+        static extract(params: {
+            _html: string;
+            _json?: any;
+        }): Promise<any>;
+        static image(params: {
+            _html: string;
+        }): Promise<any[]>;
+        static link(params: {
+            _html: string;
+        }): Promise<any[]>;
+        static text(params: {
+            _html: string;
+        }): Promise<any>;
+        static element(params: {
+            _html: string;
+            _selector: string;
+        }): any;
+        static table(params: {
+            _html: string;
+            _selector?: string;
+        }): any;
+        static struct(params: {
+            _html: string;
+            _selector: string;
+        }): any[];
+        static structOne(params: {
+            _html: string;
+            _selector: string;
+        }): any[];
+        private static stringifyValue;
+        private static flattenObjectValues;
+    }
+}
+declare const _default: typeof MR.Html;
+export default _default;

package/dist/MR/Html.js

@@ -0,0 +1,163 @@
+"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 Log_1 = require("./Log");
+const htmlparser2 = require('htmlparser2');
+const cheerio = require('cheerio');
+const tabletojson = require('tabletojson').Tabletojson;
+//const tableify = require('tableify');
+var MR;
+(function (MR) {
+    class Html {
+        constructor() { }
+        //TODO
+        static extract(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Html.extract", params);
+                const handler = new htmlparser2.DomHandler();
+                const parser = new htmlparser2.Parser(handler);
+                parser.write(params._html);
+                parser.end();
+                const $ = cheerio.load(params._html);
+                const data = $.extract({
+                    red: '.red',
+                });
+                return data;
+            });
+        }
+        static image(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Html.image", params);
+                const result = [];
+                const parser = new htmlparser2.Parser({
+                    onopentag: (tagName, attrs) => {
+                        if (tagName === 'img' && attrs.src) {
+                            const src = attrs.src;
+                            result.push(src);
+                        }
+                    }
+                });
+                parser.write(params._html);
+                parser.end();
+                return result;
+            });
+        }
+        static link(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Html.a", params);
+                const result = [];
+                const parser = new htmlparser2.Parser({
+                    onopentag: (tagName, attrs) => {
+                        if (tagName === 'a' && attrs.href) {
+                            const src = attrs.href;
+                            result.push(src);
+                        }
+                    }
+                });
+                parser.write(params._html);
+                parser.end();
+                return result;
+            });
+        }
+        static text(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Html.text", params);
+                const handler = new htmlparser2.DomHandler();
+                const parser = new htmlparser2.Parser(handler);
+                parser.write(params._html);
+                parser.end();
+                return htmlparser2.DomUtils.textContent(handler.root.childNodes);
+            });
+        }
+        // 通过返回值可以进行 ele.text(); ele.attr('class'); ele.html();
+        static element(params) {
+            Log_1.default.debug("Html.element", params);
+            const $ = cheerio.load(params._html);
+            const ele = $(params._selector);
+            return ele;
+        }
+        static table(params) {
+            Log_1.default.debug("Html.table", params);
+            const $ = cheerio.load(params._html);
+            let tableHtml = undefined;
+            if (params._selector) {
+                tableHtml = $(params._selector).html();
+            }
+            else {
+                tableHtml = $('table').html();
+            }
+            let json = undefined;
+            if (tableHtml) {
+                json = tabletojson.convert(`<table>${tableHtml}</table>`, { useFirstRowForHeadings: true });
+            }
+            return json;
+        }
+        static struct(params) {
+            const $ = cheerio.load(params._html);
+            const lis = $(params._selector);
+            const result = [];
+            lis.each((i, li) => {
+                const oneResult = this.structOne({ _html: $.html(li), _selector: params._selector });
+                result.push(oneResult);
+            });
+            return result;
+        }
+        static structOne(params) {
+            Log_1.default.debug("Html.struct", params);
+            const $ = cheerio.load(params._html);
+            const result = [];
+            $(params._selector).each((i, el) => {
+                const item = {};
+                $(el).find('*').each((j, subEl) => {
+                    if (subEl.attribs && Object.keys(subEl.attribs).length > 0) {
+                        const attrs = Object.fromEntries(Object.entries(subEl.attribs).filter(([key]) => !key.startsWith('class')));
+                        if (Object.keys(attrs).length > 0) {
+                            item[j] = attrs;
+                        }
+                        item[String(j) + '_text'] = $(subEl).text();
+                    }
+                    else {
+                        item[j] = $(subEl).text().trim();
+                    }
+                });
+                result.push(item);
+            });
+            let uniqueValues = [];
+            if (result.length > 0) {
+                const flatValues = result.flatMap(item => Object.values(item).flatMap(value => this.flattenObjectValues(value)));
+                if (flatValues && flatValues.length > 0) {
+                    uniqueValues = Array.from(new Set(flatValues));
+                }
+            }
+            //console.log(uniqueValues);
+            return uniqueValues;
+        }
+        static stringifyValue(value) {
+            if (typeof value === 'string') {
+                return value;
+            }
+            else {
+                return JSON.stringify(value);
+            }
+        }
+        static flattenObjectValues(value) {
+            if (typeof value === 'object' && value !== null) {
+                return Object.values(value).flatMap(this.flattenObjectValues);
+            }
+            else {
+                return [String(value)];
+            }
+        }
+    }
+    MR.Html = Html;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Html;

package/dist/MR/Http.d.ts

@@ -0,0 +1,33 @@
+export declare namespace MR {
+    class Http {
+        private constructor();
+        private static addContentType;
+        static getUserAgent(): any;
+        private static addUserAgent;
+        static get(params: {
+            _url: string;
+            _headers?: {};
+        }): Promise<string>;
+        static post(params: {
+            _url: string;
+            _body?: {};
+            _headers?: {};
+        }): Promise<string>;
+        static form(params: {
+            _url: string;
+            _method?: 'post' | 'get';
+            _body?: {};
+            _headers?: {};
+        }): Promise<string>;
+        static parseCookies(params: {
+            _response: any;
+        }): Promise<any>;
+        static download(params: {
+            _url: string;
+            _filename: string;
+            _headers?: {};
+        }): Promise<void>;
+    }
+}
+declare const _default: typeof MR.Http;
+export default _default;