topkat-utils 1.1.13 → 1.2.1

package/dist/src/timer-utils.js

@@ -0,0 +1,146 @@
+"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());
+    });
+};
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeInDelayedLoop = exports.waitUntilTrue = exports.runAsync = exports.timeout = void 0;
+//----------------------------------------
+// TIMEOUT UTILS
+//----------------------------------------
+var logger_utils_1 = require("./logger-utils");
+var error_utils_1 = require("./error-utils");
+function timeout(ms, fn) {
+    if (fn === void 0) { fn = function () { }; }
+    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, new Promise(function (res) { return setTimeout(res, ms); }).then(fn)];
+    }); });
+}
+exports.timeout = timeout;
+function runAsync(callback, milliseconds$) {
+    if (milliseconds$ === void 0) { milliseconds$ = 1; }
+    return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, timeout(milliseconds$, callback)];
+    }); });
+}
+exports.runAsync = runAsync;
+/**
+ *
+ * @param {Function} callback function that shall return ===true asynchronously
+ * @param {Number} timeoutSec default:10; general timeout in seconds
+ * @param {Boolean|String} errorAfterNSeconds default:true output an error in case of timeout, can be the displayed error message
+ * @param {*} cliOutput write a cli progress to show that a process is running
+ */
+function waitUntilTrue(callback, timeoutSec, errorAfterNSeconds, cliOutput) {
+    if (timeoutSec === void 0) { timeoutSec = 10; }
+    if (errorAfterNSeconds === void 0) { errorAfterNSeconds = true; }
+    if (cliOutput === void 0) { cliOutput = true; }
+    return __awaiter(this, void 0, void 0, function () {
+        var generalTimeout, step, errMess;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    generalTimeout = true;
+                    step = 3;
+                    errMess = typeof errorAfterNSeconds === 'string' ? 'Timeout: ' + errorAfterNSeconds : 'Timeout for waitUntilTrue() callback';
+                    if (timeoutSec)
+                        setTimeout(function () { return generalTimeout = false; }, timeoutSec * 1000);
+                    _a.label = 1;
+                case 1:
+                    if (!(callback() !== true && generalTimeout)) return [3 /*break*/, 3];
+                    if (cliOutput)
+                        (0, logger_utils_1.cliProgressBar)(step++);
+                    return [4 /*yield*/, timeout(300)];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3:
+                    if (cliOutput)
+                        process.stdout.write("\n");
+                    if (!generalTimeout && errorAfterNSeconds)
+                        throw new error_utils_1.DescriptiveError(errMess, { code: 500 });
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.waitUntilTrue = waitUntilTrue;
+var delayedLoopParams = [];
+var isExecuting = false;
+/** Allow to perform an action in a delayed loop, useful for example to avoid reaching limits on servers. This function can be securely called multiple times.
+ * @param {Function} callback
+ * @param {Number} time default: 500ms;
+ * @param {Function} errorCallback default: e => C.error(e)
+ */
+function executeInDelayedLoop(callback, time, errorCallback) {
+    if (time === void 0) { time = 500; }
+    if (errorCallback === void 0) { errorCallback = function (e) { return logger_utils_1.C.error(e); }; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, callback_1, time_1, errorCallback_1, err_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    delayedLoopParams.push([callback, time, errorCallback]);
+                    if (isExecuting)
+                        return [2 /*return*/];
+                    isExecuting = true;
+                    _b.label = 1;
+                case 1:
+                    if (!delayedLoopParams.length) return [3 /*break*/, 7];
+                    _a = delayedLoopParams.shift(), callback_1 = _a[0], time_1 = _a[1], errorCallback_1 = _a[2];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 5, , 6]);
+                    return [4 /*yield*/, callback_1()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, timeout(time_1)];
+                case 4:
+                    _b.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    err_1 = _b.sent();
+                    errorCallback_1(err_1);
+                    return [3 /*break*/, 6];
+                case 6: return [3 /*break*/, 1];
+                case 7:
+                    isExecuting = false;
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.executeInDelayedLoop = executeInDelayedLoop;
+//# sourceMappingURL=timer-utils.js.map

package/dist/src/timer-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer-utils.js","sourceRoot":"","sources":["../../src/timer-utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,0CAA0C;AAC1C,gBAAgB;AAChB,0CAA0C;AAC1C,+CAAkD;AAClD,6CAAgD;AAGhD,SAAsB,OAAO,CAAC,EAAE,EAAE,EAAc;IAAd,mBAAA,EAAA,mBAAa,CAAC;;QAAI,sBAAO,IAAI,OAAO,CAAC,UAAA,GAAG,IAAI,OAAA,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,EAAnB,CAAmB,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAA;;CAAE;AAA7G,0BAA6G;AAE7G,SAAsB,QAAQ,CAAC,QAAQ,EAAE,aAAiB;IAAjB,8BAAA,EAAA,iBAAiB;;QAAI,sBAAO,OAAO,CAAC,aAAa,EAAE,QAAQ,CAAC,EAAA;;CAAE;AAAvG,4BAAuG;AAEvG;;;;;;GAMG;AACH,SAAsB,aAAa,CAAC,QAAQ,EAAE,UAAe,EAAE,kBAAyB,EAAE,SAAgB;IAA5D,2BAAA,EAAA,eAAe;IAAE,mCAAA,EAAA,yBAAyB;IAAE,0BAAA,EAAA,gBAAgB;;;;;;oBAClG,cAAc,GAAG,IAAI,CAAA;oBACrB,IAAI,GAAG,CAAC,CAAA;oBACN,OAAO,GAAG,OAAO,kBAAkB,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,GAAG,kBAAkB,CAAC,CAAC,CAAC,sCAAsC,CAAA;oBAElI,IAAI,UAAU;wBAAE,UAAU,CAAC,cAAM,OAAA,cAAc,GAAG,KAAK,EAAtB,CAAsB,EAAE,UAAU,GAAG,IAAI,CAAC,CAAA;;;yBAEpE,CAAA,QAAQ,EAAE,KAAK,IAAI,IAAI,cAAc,CAAA;oBACxC,IAAI,SAAS;wBAAE,IAAA,6BAAc,EAAC,IAAI,EAAE,CAAC,CAAA;oBACrC,qBAAM,OAAO,CAAC,GAAG,CAAC,EAAA;;oBAAlB,SAAkB,CAAA;;;oBAEtB,IAAI,SAAS;wBAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;oBACzC,IAAI,CAAC,cAAc,IAAI,kBAAkB;wBAAE,MAAM,IAAI,8BAAgB,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAA;;;;;CAChG;AAbD,sCAaC;AAGD,IAAM,iBAAiB,GAAG,EAAE,CAAA;AAC5B,IAAI,WAAW,GAAG,KAAK,CAAA;AAEvB;;;;GAIG;AACH,SAAsB,oBAAoB,CAAC,QAAQ,EAAE,IAAU,EAAE,aAA+B;IAA3C,qBAAA,EAAA,UAAU;IAAE,8BAAA,EAAA,0BAAgB,CAAC,IAAI,OAAA,gBAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAV,CAAU;;;;;;oBAC5F,iBAAiB,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAA;oBACvD,IAAI,WAAW;wBAAE,sBAAM;oBACvB,WAAW,GAAG,IAAI,CAAA;;;yBACX,iBAAiB,CAAC,MAAM;oBACrB,KAAkC,iBAAiB,CAAC,KAAK,EAAE,EAA1D,kBAAQ,EAAE,cAAI,EAAE,uBAAa,CAA6B;;;;oBAE7D,qBAAM,UAAQ,EAAE,EAAA;;oBAAhB,SAAgB,CAAA;oBAChB,qBAAM,OAAO,CAAC,MAAI,CAAC,EAAA;;oBAAnB,SAAmB,CAAA;;;;oBAEnB,eAAa,CAAC,KAAG,CAAC,CAAA;;;;oBAG1B,WAAW,GAAG,KAAK,CAAA;;;;;CACtB;AAdD,oDAcC"}

package/dist/src/transaction-utils.d.ts

@@ -0,0 +1,14 @@
+/** Allow to perform async functions in a defined order
+ * This adds the callback to a queue and is resolved when ALL previous callbacks with same name are executed
+ * Use it like: await transaction('nameOfTheFlow', async () => { ...myFunction })
+ * @param {String|Function} name name for the actions that should never happen concurrently
+ * @param {Function} asyncCallback
+ * @param {Number} timeout default: 120000 (120s) will throw an error if transaction time is higher that this amount of ms
+ * @returns {Promise}
+ */
+export declare function transaction(name: any, asyncCallback: any, timeout?: number, doNotThrow?: boolean): Promise<unknown>;
+export declare function removeItemFromQueue(name: any): Promise<void>;
+/** Wait for a transaction to complete without creating a new transaction
+ *
+ */
+export declare function waitForTransaction(transactionName: any, forceReleaseInSeconds?: number): Promise<void>;

package/dist/src/transaction-utils.js

@@ -0,0 +1,157 @@
+"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());
+    });
+};
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForTransaction = exports.removeItemFromQueue = exports.transaction = void 0;
+//----------------------------------------
+// TRANSACTION
+//----------------------------------------
+var isset_1 = require("./isset");
+var logger_utils_1 = require("./logger-utils");
+var timer_utils_1 = require("./timer-utils");
+var transactionRunning = { __default: false };
+var queue = { __default: [] };
+/** Allow to perform async functions in a defined order
+ * This adds the callback to a queue and is resolved when ALL previous callbacks with same name are executed
+ * Use it like: await transaction('nameOfTheFlow', async () => { ...myFunction })
+ * @param {String|Function} name name for the actions that should never happen concurrently
+ * @param {Function} asyncCallback
+ * @param {Number} timeout default: 120000 (120s) will throw an error if transaction time is higher that this amount of ms
+ * @returns {Promise}
+ */
+function transaction(name, asyncCallback, timeout, doNotThrow) {
+    if (timeout === void 0) { timeout = 120000; }
+    if (doNotThrow === void 0) { doNotThrow = false; }
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (typeof name === 'function') {
+                        asyncCallback = name;
+                        name = '__default';
+                    }
+                    if (!(0, isset_1.isset)(queue[name]))
+                        queue[name] = [];
+                    if (!(0, isset_1.isset)(transactionRunning[name]))
+                        transactionRunning[name] = false;
+                    return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            if (doNotThrow)
+                                reject = logger_utils_1.C.error;
+                            queue[name].push(function () { return __awaiter(_this, void 0, void 0, function () {
+                                var res, err_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            setTimeout(function () {
+                                                logger_utils_1.C.warning('Transaction Timout'); // in case not catched
+                                                reject(new Error('transactionTimeout'));
+                                            }, timeout);
+                                            return [4 /*yield*/, asyncCallback()];
+                                        case 1:
+                                            res = _a.sent();
+                                            resolve(res);
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            err_1 = _a.sent();
+                                            reject(err_1);
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); });
+                            removeItemFromQueue(name);
+                        })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+exports.transaction = transaction;
+function removeItemFromQueue(name) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (transactionRunning[name] === true)
+                        return [2 /*return*/]; //       v 
+                    transactionRunning[name] = true; //               A  A       /\
+                    _a.label = 1;
+                case 1:
+                    if (!queue[name].length) return [3 /*break*/, 3];
+                    return [4 /*yield*/, queue[name].shift()()]; //   II
+                case 2:
+                    _a.sent(); //   II
+                    return [3 /*break*/, 1];
+                case 3:
+                    transactionRunning[name] = false; //              \==/_______II
+                    return [2 /*return*/];
+            }
+        });
+    });
+} //                                                    l  v_v_v _I
+exports.removeItemFromQueue = removeItemFromQueue;
+//                                                       11    11
+/** Wait for a transaction to complete without creating a new transaction
+ *
+ */
+function waitForTransaction(transactionName, forceReleaseInSeconds) {
+    if (forceReleaseInSeconds === void 0) { forceReleaseInSeconds = 30; }
+    return __awaiter(this, void 0, void 0, function () {
+        var brk;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    brk = false;
+                    setTimeout(function () { return brk = true; }, forceReleaseInSeconds * 1000);
+                    _a.label = 1;
+                case 1:
+                    if (!((0, isset_1.isset)(transactionRunning[transactionName]) && transactionRunning[transactionName] === true)) return [3 /*break*/, 3];
+                    if (brk)
+                        return [3 /*break*/, 3];
+                    return [4 /*yield*/, (0, timer_utils_1.timeout)(15)];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.waitForTransaction = waitForTransaction;
+//# sourceMappingURL=transaction-utils.js.map

package/dist/src/transaction-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-utils.js","sourceRoot":"","sources":["../../src/transaction-utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0CAA0C;AAC1C,cAAc;AACd,0CAA0C;AAC1C,iCAA+B;AAC/B,+CAAkC;AAClC,6CAAuC;AAEvC,IAAM,kBAAkB,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,CAAA;AAC/C,IAAM,KAAK,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,CAAA;AAE/B;;;;;;;GAOG;AACH,SAAsB,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,OAAgB,EAAE,UAAkB;IAApC,wBAAA,EAAA,gBAAgB;IAAE,2BAAA,EAAA,kBAAkB;;;;;;oBACvF,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE;wBAC5B,aAAa,GAAG,IAAI,CAAA;wBACpB,IAAI,GAAG,WAAW,CAAA;qBACrB;oBACD,IAAI,CAAC,IAAA,aAAK,EAAC,KAAK,CAAC,IAAI,CAAC,CAAC;wBAAE,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAA;oBACzC,IAAI,CAAC,IAAA,aAAK,EAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;wBAAE,kBAAkB,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;oBAE/D,qBAAM,IAAI,OAAO,CAAC,UAAC,OAAO,EAAE,MAAM;4BACrC,IAAI,UAAU;gCAAE,MAAM,GAAG,gBAAC,CAAC,KAAK,CAAA;4BAChC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;;;;;;4CAET,UAAU,CAAC;gDACP,gBAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA,CAAC,sBAAsB;gDACtD,MAAM,CAAC,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAA;4CAC3C,CAAC,EAAE,OAAO,CAAC,CAAA;4CACC,qBAAM,aAAa,EAAE,EAAA;;4CAA3B,GAAG,GAAG,SAAqB;4CACjC,OAAO,CAAC,GAAG,CAAC,CAAA;;;;4CAEZ,MAAM,CAAC,KAAG,CAAC,CAAA;;;;;iCAElB,CAAC,CAAA;4BACF,mBAAmB,CAAC,IAAI,CAAC,CAAA;wBAC7B,CAAC,CAAC,EAAA;wBAfF,sBAAO,SAeL,EAAA;;;;CACL;AAxBD,kCAwBC;AAED,SAAsB,mBAAmB,CAAC,IAAI;;;;;oBAC1C,IAAI,kBAAkB,CAAC,IAAI,CAAC,KAAK,IAAI;wBAAE,sBAAM,CAAC,WAAW;oBACzD,kBAAkB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA,CAAC,8BAA8B;;;yBACvD,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM;oBAAE,qBAAM,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,EAAA,CAAC,OAAO;;oBAAnC,SAA2B,CAAA,CAAC,OAAO;;;oBAC9D,kBAAkB,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA,CAAC,6BAA6B;;;;;CACjE,CAAC,iEAAiE;AALnE,kDAKC;AACD,iEAAiE;AAEjE;;GAEG;AACH,SAAsB,kBAAkB,CAAC,eAAe,EAAE,qBAA0B;IAA1B,sCAAA,EAAA,0BAA0B;;;;;;oBAC5E,GAAG,GAAG,KAAK,CAAA;oBACf,UAAU,CAAC,cAAM,OAAA,GAAG,GAAG,IAAI,EAAV,CAAU,EAAE,qBAAqB,GAAG,IAAI,CAAC,CAAA;;;yBACnD,CAAA,IAAA,aAAK,EAAC,kBAAkB,CAAC,eAAe,CAAC,CAAC,IAAI,kBAAkB,CAAC,eAAe,CAAC,KAAK,IAAI,CAAA;oBAC7F,IAAI,GAAG;wBAAE,wBAAK;oBACd,qBAAM,IAAA,qBAAO,EAAC,EAAE,CAAC,EAAA;;oBAAjB,SAAiB,CAAA;;;;;;CAExB;AAPD,gDAOC"}

package/dist/src/types.d.ts

@@ -0,0 +1,5 @@
+export declare type ObjectGeneric = {
+    [k: string]: any;
+};
+export declare type Color = [number, number, number];
+export declare type Override<T1, T2> = Omit<T1, keyof T2> & T2;

package/dist/src/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":""}

package/dist/src/validation-utils.d.ts

@@ -0,0 +1,80 @@
+export declare type BaseTypes = 'objectId' | 'dateInt6' | 'dateInt' | 'dateInt8' | 'dateInt12' | 'time' | 'humanReadableTimestamp' | 'date' | 'dateObject' | 'array' | 'object' | 'buffer' | 'string' | 'function' | 'boolean' | 'number' | 'bigint' | 'year' | 'email' | 'any';
+export declare function issetOr(...elms: any[]): boolean;
+export declare function isEmptyOrNotSet(...elms: any[]): boolean;
+export declare function isDateObject(variable: any): boolean;
+/** Check all values are set */
+export declare function checkAllObjectValuesAreEmpty(o: any): boolean;
+/** Throw an error in case data passed is not a valid ctx */
+export declare function checkCtxIntegrity(ctx: any): void;
+/**
+## VALIDATOR
+
+@name validator
+
+@description support multiple names, multiple values and multiple type check
+@option if nameString ends by $ sign it is considered optional
+
+@function validator([Objects])
+@return {error|true/false|testMode} depend on mode (see prop mode)
+@param {} mode normal (default) | test (TODO) | boolean
+@param {} name 'myName' || [{myVar1: 'blah, myvar2: myvar2}], support multiple names / values
+@param {} value myVar,
+@param {string} myVar myVar, instead of name / value
+@param {array} in ['blah', 'otherPossibleValue', true], equal ONE OF THESE values
+@param {any} eq exactly equal to in, both support string or array of values
+@param {any} neq not in, both support string or array of values
+@param {number} lte 3, less than or equal
+@param {number} gte 1, greater or equal
+@param {number} lt 3, less than
+@param {number} gt 1, greater
+@param {string|string[]} type
+ * possibleTypes: object, number, string, boolean, array, date, dateInt8, dateInt12, dateInt6, time, objectId (mongo), humanReadableTimestamp, buffer
+ * Notes: multiples value is an OR, /!\ Array is type 'array' and not 'object' like in real JS /!\
+@param {regExp} regexp /regexp/, test against regexp
+@param {number} minLength for string, array or number length
+@param {number} maxLength
+@param {number} length
+@param {boolean} optional default false
+@param {boolean} emptyAllowed default false (to use if must be set but can be empty)
+@param {boolean} mustNotBeSet this one must not be set
+@param {any} includes check if array or string includes value (like js .includes())
+
+@example
+    validator(
+        { myNumber : 3, type: 'number', gte: 1, lte: 3 }, // use the name directly as a param
+        { name: 'email', value: 'nameATsite.com', regexp: /[^\sAT]+AT[^\sAT]+\.[^\sAT]/},
+        { name: [{'blahVar': blahVarValue, 'myOtherVar': myOtherVarValue}], type: 'string'} // multiple names for same check
+    )
+----------------------------------------*/
+export declare type ValidatorObject = {
+    name?: string;
+    value?: any;
+    type?: BaseTypes;
+    eq?: any;
+    neq?: any;
+    in?: any[];
+    lt?: number;
+    gt?: number;
+    lte?: number;
+    gte?: number;
+    length?: number;
+    minLength?: number;
+    maxLength?: number;
+    emptyAllowed?: boolean;
+    regexp?: RegExp;
+    mustNotBeSet?: boolean;
+    isset?: boolean;
+    optional?: boolean;
+    isArray?: boolean;
+    [k: string]: any;
+};
+export declare function validator(...paramsToValidate: ValidatorObject[]): void;
+/** Same as validator but return a boolean
+ * See {@link validator}
+ */
+export declare function isValid(...paramsToValidate: any[]): boolean;
+/** Default types + custom types
+ * 'objectId','dateInt6','dateInt','dateInt8','dateInt12','time','humanReadableTimestamp','date','array','object','buffer','string','function','boolean','number','bigint',
+ */
+export declare function isType(value: any, type: BaseTypes): boolean;
+export declare function validatorReturnErrArray(...paramsToValidate: ValidatorObject[]): [string?, object?];