@zwa73/utils 1.0.206 → 1.0.208

package/dist/test/dist/testStream.js

@@ -0,0 +1,286 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (b.hasOwnProperty(p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function () { if (t[0] & 1)
+            throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (_)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return { value: op[1], done: false };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [0];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [6, e];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+        s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+exports.__esModule = true;
+var __1 = require("../");
+/**并行流 */
+var TStream = /** @class */ (function (_super) {
+    __extends(TStream, _super);
+    function TStream(base, concurrent) {
+        if (concurrent === void 0) {
+            concurrent = 1;
+        }
+        var _this = this;
+        /**加工函数列表*/
+        _this._operation = [];
+        if (base == undefined)
+            _this = _super.call(this) || this;
+        else if (typeof base === 'number')
+            _this = _super.call(this, base) || this;
+        else
+            _this = _super.apply(this, base) || this;
+        _this._concurrent = concurrent;
+        return _this;
+    }
+    /**平分数组
+     * @param count - 份数
+     * @param mode  - 模式 average:轮询平均分 chunk:切块均分
+     * @returns 新数组
+     */
+    TStream.prototype.divide = function (count, mode) {
+        var _this = this;
+        if (mode === void 0) {
+            mode = "average";
+        }
+        if (count <= 0)
+            return [];
+        if (count == 1)
+            return [__spreadArrays(this)];
+        var size = this.length;
+        var result = [];
+        __1.matchProc(mode, {
+            //轮询平均分
+            'average': function () {
+                for (var i = 0; i < count; i++) {
+                    var clist = [];
+                    for (var j = i; j < size; j += count)
+                        clist.push(_this[j]);
+                    result.push(clist);
+                }
+            },
+            //切块均分
+            'chunk': function () {
+                var chunkSize = Math.ceil(size / count);
+                for (var i = 0; i < count; i++) {
+                    var start = i * chunkSize;
+                    var end = (i + 1) * chunkSize;
+                    if (end > size)
+                        end = size;
+                    result.push(_this.slice(start, end));
+                }
+            }
+        });
+        return result;
+    };
+    /**流映射加工
+     * @param  operation - 加工函数
+     * @returns 新流
+     */
+    TStream.prototype.stmMap = function (operation) {
+        this._operation.push(operation);
+        return this;
+    };
+    /**流遍历
+     * 返回自身
+     * @param  operation - 遍历函数
+     * @returns 自身
+     */
+    TStream.prototype.stmEach = function (operation) {
+        var _this = this;
+        var opera = function (item) {
+            return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    operation(item);
+                    return [2 /*return*/, item];
+                });
+            });
+        };
+        this._operation.push(opera);
+        return this;
+    };
+    //终结操作
+    /**应用加工
+     * @returns 自身
+     */
+    TStream.prototype.stmAppend = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var promiseList, sliceList, _loop_1, i, nlist, result, i, subList, subSize, j;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._operation.length == 0)
+                            return [2 /*return*/, this];
+                        promiseList = [];
+                        sliceList = this.divide(this._concurrent);
+                        _loop_1 = function (i) {
+                            var subList = sliceList[i];
+                            if (!subList)
+                                return "continue";
+                            promiseList.push(new Promise(function (reslove) {
+                                return __awaiter(_this, void 0, void 0, function () {
+                                    var result, _i, subList_1, item, _a, _b, operation;
+                                    return __generator(this, function (_c) {
+                                        switch (_c.label) {
+                                            case 0:
+                                                result = [];
+                                                _i = 0, subList_1 = subList;
+                                                _c.label = 1;
+                                            case 1:
+                                                if (!(_i < subList_1.length))
+                                                    return [3 /*break*/, 7];
+                                                item = subList_1[_i];
+                                                if (!item)
+                                                    return [3 /*break*/, 6];
+                                                _a = 0, _b = this._operation;
+                                                _c.label = 2;
+                                            case 2:
+                                                if (!(_a < _b.length))
+                                                    return [3 /*break*/, 5];
+                                                operation = _b[_a];
+                                                return [4 /*yield*/, operation(item)];
+                                            case 3:
+                                                item = _c.sent();
+                                                _c.label = 4;
+                                            case 4:
+                                                _a++;
+                                                return [3 /*break*/, 2];
+                                            case 5:
+                                                result.push(item);
+                                                _c.label = 6;
+                                            case 6:
+                                                _i++;
+                                                return [3 /*break*/, 1];
+                                            case 7:
+                                                reslove(result);
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                });
+                            }));
+                        };
+                        for (i = 0; i < this._concurrent; i++) {
+                            _loop_1(i);
+                        }
+                        return [4 /*yield*/, Promise.all(promiseList)];
+                    case 1:
+                        nlist = _a.sent();
+                        result = new Array(this.length).fill(undefined);
+                        for (i = 0; i < this._concurrent; i++) {
+                            subList = nlist[i];
+                            if (!subList)
+                                continue;
+                            subSize = subList.length;
+                            for (j = 0; j < subSize; j++)
+                                result[i + j * this._concurrent] = subList[j];
+                        }
+                        this.splice(0, this.length);
+                        this.push.apply(this, result);
+                        this._operation = [];
+                        return [2 /*return*/, this];
+                }
+            });
+        });
+    };
+    return TStream;
+}(Array));
+__1.UtilCodec.decodeHtmlEntities('112233'); //?

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.206",
+	"version": "1.0.208",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {
@@ -17,6 +17,8 @@
 	"license": "ISC",
 	"dependencies": {
 		"@deepkit/type": "^1.0.1-alpha.153",
+		"@zwa73/js-utils": "^1.0.0",
+		"@zwa73/modular-mixer": "^1.0.2",
 		"form-data": "^4.0.2",
 		"glob": "^10.4.1",
 		"handlebars": "^4.7.8",