ts-client-lib 0.0.7

package/utils/TSLog.d.ts

@@ -0,0 +1,40 @@
+import 'reflect-metadata';
+/**
+ * Log instance of a class
+ *
+ * @example @TSLogClass
+ *
+ * @param target
+ * @constructor
+ */
+export declare function TSLogClass<T extends new (...args: any[]) => any>(target: T): T;
+/**
+ * Log and measure performance of a function
+ *
+ * @example @TSLogMethod
+ *
+ * @param target
+ * @param key
+ * @param descriptor
+ * @constructor
+ */
+export declare function TSLogMethod(target: any, key: string, descriptor: PropertyDescriptor): PropertyDescriptor | undefined;
+/**
+ * Log property state
+ *
+ * @example @TSLogProperty
+ *
+ * @param target
+ * @param key
+ * @constructor
+ */
+export declare function TSLogProperty(target: any, key: string): void;
+/**
+ * Log factory that automatically detect kind signature
+ *
+ * @example @TSLog
+ *
+ * @param args
+ * @constructor
+ */
+export declare function TSLog(...args: Array<any>): void;

package/utils/TSLog.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSLogClass = TSLogClass;
+exports.TSLogMethod = TSLogMethod;
+exports.TSLogProperty = TSLogProperty;
+exports.TSLog = TSLog;
+require("reflect-metadata");
+/**
+ * Log instance of a class
+ *
+ * @example @TSLogClass
+ *
+ * @param target
+ * @constructor
+ */
+function TSLogClass(target) {
+    return function _a() {
+        var _newTarget = this && this instanceof _a ? this.constructor : void 0;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        console.log("[TSLogClass::".concat(target.name, "] is created"));
+        return Reflect.construct(target, args, _newTarget);
+    };
+}
+/**
+ * Log and measure performance of a function
+ *
+ * @example @TSLogMethod
+ *
+ * @param target
+ * @param key
+ * @param descriptor
+ * @constructor
+ */
+function TSLogMethod(target, key, descriptor) {
+    if (descriptor) {
+        var method_1 = descriptor.value;
+        descriptor.value = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var measure = function () { return (typeof performance !== 'undefined' ? performance.now() : Number(new Date())); }, start = measure(), params = args.map(function (a) { return JSON.stringify(a); }).join(), result = method_1.apply(this, args);
+            console.log("[TSLogMethod::".concat(key, "] (").concat(params, ") => ").concat(JSON.stringify(result, null, 2)));
+            console.log("[TSLogMethod::".concat(key, "] stats: ").concat((measure() - start).toFixed(2), " ms"));
+            return result;
+        };
+        return descriptor;
+    }
+    return undefined;
+}
+/**
+ * Log property state
+ *
+ * @example @TSLogProperty
+ *
+ * @param target
+ * @param key
+ * @constructor
+ */
+function TSLogProperty(target, key) {
+    var v = target[key];
+    var t = Reflect.getMetadata('design:type', target, key);
+    var getter = function () {
+        console.log("[TSLogProperty::Get:".concat(t.name, "] ").concat(key, " => ").concat(JSON.stringify(v, null, 2)));
+        return v;
+    };
+    var setter = function (nv) {
+        console.log("[TSLogProperty::Set:".concat(t.name, "] ").concat(key, " => ").concat(JSON.stringify(nv, null, 2)));
+        v = nv;
+    };
+    if (delete target[key]) {
+        Object.defineProperty(target, key, {
+            get: getter, set: setter, enumerable: true, configurable: true
+        });
+    }
+}
+/**
+ * Log factory that automatically detect kind signature
+ *
+ * @example @TSLog
+ *
+ * @param args
+ * @constructor
+ */
+function TSLog() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    switch (args.length) {
+        case 3:
+            if (typeof args[2] === 'undefined') {
+                TSLogProperty.apply(void 0, args);
+                return;
+            }
+            TSLogMethod.apply(void 0, args);
+            return;
+        case 2:
+            TSLogProperty.apply(void 0, args);
+            return;
+        case 1:
+            TSLogClass.apply(void 0, args);
+            return;
+        default:
+            throw new Error('Not a valid decorator');
+    }
+}

package/utils/TSNumber.d.ts

@@ -0,0 +1,6 @@
+export declare class TSNumber {
+    static roundBy(n: any, d?: number, type?: 'round' | 'floor' | 'ceil'): number;
+    static random(from: number, to: number): number;
+    static humanize(number: number, options?: any): string;
+    private static humanizeWithUnit;
+}

package/utils/TSNumber.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSNumber = void 0;
+var TSNumber = /** @class */ (function () {
+    function TSNumber() {
+    }
+    TSNumber.roundBy = function (n, d, type) {
+        if (d === void 0) { d = 5; }
+        if (type === void 0) { type = 'round'; }
+        return Math[type](n / d) * d;
+    };
+    TSNumber.random = function (from, to) {
+        return Math.floor(from + (Math.random() * (to - from + 1)));
+    };
+    TSNumber.humanize = function (number, options) {
+        if (options === void 0) { options = {}; }
+        options = options || {};
+        var result;
+        if (Object.hasOwn(options, 'unit')) {
+            return TSNumber.humanizeWithUnit(number, options);
+        }
+        else {
+            var d = options.delimiter || ',';
+            var s = options.separator || '.';
+            var f = options.fixed || 3;
+            result = number.toString().split('.');
+            result[0] = result[0].replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + d);
+            if (result[1]) {
+                result[1] = result[1].substring(0, f);
+            }
+            if (d === s) {
+                return result[0];
+            }
+            return result.join(s);
+        }
+    };
+    TSNumber.humanizeWithUnit = function (number, options) {
+        var s = options.separator || '';
+        var result = parseInt(number.toString(), 10);
+        var cultureTable = {
+            en: {
+                '': ['', 0], 'Thousand': ['K', 3], 'Million': ['M', 6], 'Billion': ['B', 9],
+                'Trillion': ['T', 12], 'Quadrillion': ['q', 15], 'Quintillion': ['Q', 18]
+            },
+            fr: {
+                '': ['', 0], 'Mille': ['K', 3], 'Million': ['M', 6], 'Milliard': ['Md', 9],
+                'Mille Milliards': ['T', 12], 'Quadrillion': ['q', 15], 'Quintillion': ['Q', 18]
+            }
+        };
+        var cultures = cultureTable[options.culture || 'en'] || cultureTable.en;
+        var zeroes = 0;
+        var sM = {};
+        var lM = {};
+        for (var c in cultures) {
+            if (Object.hasOwn(cultures, c)) {
+                sM[c] = cultures[c][0];
+                lM[cultures[c][1]] = c;
+            }
+        }
+        while (parseInt((result / 1000).toString(), 10) !== 0) {
+            result /= 1000;
+            zeroes += 3;
+        }
+        return [!options.fixed ? Math.floor(result) : result.toFixed(options.fixed), options.unit !== 'long' ? sM[lM[zeroes]] : lM[zeroes]].join(s);
+    };
+    return TSNumber;
+}());
+exports.TSNumber = TSNumber;

package/utils/TSObject.d.ts

@@ -0,0 +1,29 @@
+export declare class TSObject {
+    static empty(object?: any): boolean;
+    static value(object?: any): any;
+    static fcAsKey(key: string): Record<string, string>;
+    static paths(text: string): RegExpMatchArray | null;
+    static property(text: string): string;
+    static propertyEscape(text: string): string;
+    static getBy(object: any, path: string, value?: null): any;
+    static setBy(o: any, s: any, path?: string): any;
+    static mergeBy(o: any, s: any, path?: string): any;
+    static updateBy(o: any, s: any, path?: string): any;
+    static deleteBy(object: any, pathToDelete: string, pathToReturn?: string): any;
+    static copyProperties(target: any, source: any, force?: boolean): void;
+    static cleanProperties(source: any, properties?: any): any;
+    static propertySet(o: any, k: string, v?: unknown): string;
+    static forOwn(object: any, callback: (v: any, k: string | number) => void): void;
+    static operateBy(o: any, s: any, type?: string, p0?: any, p1?: any, p2?: any, p3?: any): any;
+    private static operateByWorkDeep;
+    static workBy(o: any, s: any, type?: string): any;
+    static merge(target: any, source: any, full?: boolean): any;
+    static clone(object: any): any;
+    static flat(current: any, property?: string, paths?: string[], cb?: (id: unknown, data: Record<string, unknown>) => void): Record<string, unknown>;
+    static enumValues(entity: any, type?: 'string'): string[];
+    static enumValues(entity: any, type?: 'number'): number[];
+    static toDictionary(array: Array<any>, kName: string | number, vName: string | number, ...args: unknown[]): any;
+    static reduceObject(object: any, ...args: unknown[]): any;
+    static normalizeObject(object: any): any;
+    static valueOrArrayValue(object: any, key: string | number): any;
+}

package/utils/TSObject.js

@@ -0,0 +1,312 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSObject = void 0;
+var TSObject = /** @class */ (function () {
+    function TSObject() {
+    }
+    TSObject.empty = function (object) {
+        if (object === void 0) { object = {}; }
+        for (var p in object) {
+            return false;
+        }
+        return true;
+    };
+    TSObject.value = function (object) {
+        if (object === void 0) { object = {}; }
+        for (var p in object) {
+            return object[p];
+        }
+        return undefined;
+    };
+    TSObject.fcAsKey = function (key) {
+        return key.split('|').reduce(function (a, c) { return (a[c.charAt(0)] = c.substring(1), a); }, {});
+    };
+    TSObject.paths = function (text) {
+        return text.match(/(?:\\.|[^.])+/g);
+    };
+    TSObject.property = function (text) {
+        return text.replace(/\\./g, '.');
+    };
+    TSObject.propertyEscape = function (text) {
+        return text.replace(/\./g, '\\.');
+    };
+    TSObject.getBy = function (object, path, value) {
+        if (value === void 0) { value = null; }
+        var a = TSObject.paths(path);
+        if (!a)
+            return value;
+        while (a.length && (object = object[TSObject.property(a.shift())])) { /** Walk on object */ }
+        return ['null', 'undefined'].indexOf(typeof object) === -1 ? object : value;
+    };
+    TSObject.setBy = function (o, s, path) {
+        return TSObject.operateBy.apply(TSObject, __spreadArray([o, s, 'set'], (path ? path.split('.') : []), false));
+    };
+    TSObject.mergeBy = function (o, s, path) {
+        return TSObject.operateBy.apply(TSObject, __spreadArray([o, s, 'merge'], (path ? path.split('.') : []), false));
+    };
+    TSObject.updateBy = function (o, s, path) {
+        return TSObject.operateBy.apply(TSObject, __spreadArray([o, s, 'update'], (path ? path.split('.') : []), false));
+    };
+    TSObject.deleteBy = function (object, pathToDelete, pathToReturn) {
+        if (pathToReturn === void 0) { pathToReturn = ''; }
+        var path = function (p) { var _a; return ((_a = TSObject.paths(p)) !== null && _a !== void 0 ? _a : []).map(function (p) { return "?.['".concat(TSObject.property(p), "']"); }).join(''); };
+        if (!pathToReturn.length && pathToDelete.indexOf(pathToReturn) !== 0) {
+            pathToReturn = '';
+        }
+        else if (pathToReturn.length) {
+            pathToReturn = path(pathToReturn);
+        }
+        return new Function('_', "delete _".concat(path(pathToDelete), ";return _").concat(pathToReturn, ";"))(object);
+    };
+    TSObject.copyProperties = function (target, source, force) {
+        TSObject.forOwn(source, function (v, k) {
+            if (Object.hasOwn(target, k) || force) {
+                target[k] = source[k];
+            }
+        });
+    };
+    TSObject.cleanProperties = function (source, properties) {
+        if (properties === void 0) { properties = []; }
+        TSObject.forOwn(source, function (v, k) {
+            if ([null, '', undefined, NaN].indexOf(source[k]) > -1 ||
+                Array.isArray(source[k]) && !source[k].length ||
+                typeof source[k] === 'object' && TSObject.empty(source[k])) {
+                delete source[k];
+            }
+        });
+        TSObject.forOwn(properties, function (v) {
+            if (Object.hasOwn(source, v)) {
+                delete source[v];
+            }
+        });
+        return source;
+    };
+    TSObject.propertySet = function (o, k, v) {
+        var keys = k.split(',');
+        for (var i = 0; i < keys.length; i++) {
+            if (typeof v !== 'undefined' && o && Object.hasOwn(o, keys[i]) && o[keys[i]] === v) {
+                return v;
+            }
+            else if (o && o[keys[i]]) {
+                return keys[i];
+            }
+        }
+        return keys[keys.length - 1];
+    };
+    TSObject.forOwn = function (object, callback) {
+        for (var k in object) {
+            if (Object.hasOwn(object, k)) {
+                callback(object[k], k);
+            }
+        }
+    };
+    TSObject.operateBy = function (o, s, type, p0, p1, p2, p3) {
+        if (type === void 0) { type = 'merge'; }
+        if (!p0) {
+            return TSObject.workBy(o, s, type);
+        }
+        if (!o[p0]) {
+            o[p0] = s;
+            return o;
+        }
+        if (p1 && !o[p0][p1]) {
+            o[p0][p1] = s;
+            return o;
+        }
+        if (p2 && !o[p0][p1][p2]) {
+            o[p0][p1][p2] = s;
+            return o;
+        }
+        if (p3 && !o[p0][p1][p2][p3]) {
+            o[p0][p1][p2][p3] = s;
+            return o;
+        }
+        return TSObject.operateByWorkDeep(o, s, type, p0, p1, p2, p3);
+    };
+    TSObject.operateByWorkDeep = function (o, s, type, p0, p1, p2, p3) {
+        if (o[p0] && o[p0][p1] && o[p0][p1][p2] && o[p0][p1][p2][p3]) {
+            o[p0][p1][p2][p3] = TSObject.workBy(o[p0][p1][p2][p3], s, type);
+            return o;
+        }
+        if (o[p0] && o[p0][p1] && o[p0][p1][p2]) {
+            o[p0][p1][p2] = TSObject.workBy(o[p0][p1][p2], s, type);
+            return o;
+        }
+        if (o[p0] && o[p0][p1]) {
+            o[p0][p1] = TSObject.workBy(o[p0][p1], s, type);
+            return o;
+        }
+        if (o[p0]) {
+            o[p0] = TSObject.workBy(o[p0], s, type);
+        }
+        return o;
+    };
+    TSObject.workBy = function (o, s, type) {
+        if (type === void 0) { type = 'merge'; }
+        if (type === 'merge') {
+            return TSObject.merge(o, s);
+        }
+        else if (type === 'update') {
+            return __assign(__assign({}, o), s);
+        }
+        else {
+            return s;
+        }
+    };
+    TSObject.merge = function (target, source, full) {
+        if (full === void 0) { full = true; }
+        if (!source) {
+            return target;
+        }
+        for (var _i = 0, _a = Object.keys(source); _i < _a.length; _i++) {
+            var key = _a[_i];
+            if (target[key] instanceof Object && source[key] instanceof Object && key in target) {
+                if (full) {
+                    Object.assign(source[key], TSObject.merge(target[key], source[key], full));
+                }
+                else {
+                    TSObject.merge(target[key], source[key], full);
+                }
+            }
+            else if (source[key] instanceof Object && key in target) {
+                target[key] = source[key];
+            }
+        }
+        Object.assign(target || {}, source);
+        return target;
+    };
+    TSObject.clone = function (object) {
+        var cloned = (object && object.constructor) ? new object.constructor() : {};
+        for (var attribute in object) {
+            if (Array.isArray(object[attribute])) {
+                cloned[attribute] = object[attribute].slice(0);
+            }
+            else if (typeof object[attribute] === 'object') {
+                cloned[attribute] = TSObject.clone(object[attribute]);
+            }
+            else {
+                cloned[attribute] = object[attribute];
+            }
+        }
+        return cloned;
+    };
+    TSObject.flat = function (current, property, paths, cb) {
+        if (property === void 0) { property = 'k'; }
+        if (paths === void 0) { paths = ['s', 'c', 't', 'e']; }
+        var result = {}, stack = [{ current: current, path: {} }];
+        var _loop_1 = function () {
+            var item = stack.pop();
+            if (!item)
+                return "continue";
+            var current_1 = item.current, path = item.path;
+            if (typeof current_1 !== 'object' || current_1 === null)
+                return "continue";
+            var keys = Object.keys(current_1);
+            if (keys.length === 0)
+                return "continue";
+            if (property in current_1) {
+                var _a = path, _b = paths[paths.length - 1], id = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+                if (cb) {
+                    cb(id, __assign(__assign({}, rest), current_1));
+                }
+                else {
+                    result[String(id)] = __assign(__assign({}, rest), current_1);
+                }
+                return "continue";
+            }
+            keys.forEach(function (k) {
+                var p = __assign({}, path);
+                for (var i = 0; i < paths.length; i++) {
+                    if (!path[paths[i]]) {
+                        p[paths[i]] = k;
+                        break;
+                    }
+                }
+                stack.push({ current: current_1[k], path: p });
+            });
+        };
+        while (stack.length > 0) {
+            _loop_1();
+        }
+        return result;
+    };
+    TSObject.enumValues = function (entity, type) {
+        if (type === void 0) { type = 'string'; }
+        var values = [];
+        for (var i in entity) {
+            if (type === 'number' && !isNaN(Number([entity[i]])) || type === 'string' && typeof entity[i] === 'string') {
+                values.push(entity[i]);
+            }
+        }
+        return values;
+    };
+    /* --------- [XML] --------- */
+    TSObject.toDictionary = function (array, kName, vName) {
+        var args = [];
+        for (var _i = 3; _i < arguments.length; _i++) {
+            args[_i - 3] = arguments[_i];
+        }
+        var result = {};
+        var value;
+        for (var i in array) {
+            if (array[i] != null) {
+                value = this.valueOrArrayValue(array[i], vName);
+                result[this.valueOrArrayValue(array[i], kName)] = !args ? value : TSObject.reduceObject.apply(TSObject, __spreadArray([value], args, false));
+            }
+        }
+        return result;
+    };
+    TSObject.reduceObject = function (object) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        for (var i = 0; i < args.length; i++) {
+            var key = args[i];
+            if (Object.hasOwn(object, key)) {
+                object = TSObject.valueOrArrayValue(object, key);
+            }
+        }
+        return object;
+    };
+    TSObject.normalizeObject = function (object) {
+        TSObject.forOwn(object, function (v, k) { return object[k] = TSObject.valueOrArrayValue(object, k); });
+        return object;
+    };
+    TSObject.valueOrArrayValue = function (object, key) {
+        return Array.isArray(object[key]) ? object[key][0] : object[key];
+    };
+    return TSObject;
+}());
+exports.TSObject = TSObject;