@leyyo/common 1.3.18 → 1.3.19

package/dist/common/log.common.js

@@ -1,105 +1,66 @@
 import { FQN } from "../internal.js";
-import { getFqn, hasFqn, isEmpty, isFilledObj, isObj, onFqnSet, secureJson, testCase } from "../function/index.js";
+import { getFqn, hasFqn, isEmpty, isFilledObj, isObj, onFqnSet, secureJson, testCase, } from "../function/index.js";
 import { KEY_LOG_ALREADY } from "../const/index.js";
 const where = `${FQN}.LogCommon`;
-const emptyWhere = ''.padStart(20);
-// noinspection JSUnusedGlobalSymbols
+const emptyWhere = "".padStart(20);
 export class LogCommon {
     leyyo;
-    // region properties
-    /**
-     * Loggers
-     * */
     _loggers;
-    /**
-     * Local console colors
-     *
-     * @type {LocalColorLike}
-     * */
     _localColor = {
-        bold: '\x1b[1m',
-        normal: '\x1b[21m',
-        end: '\x1b[0m',
-        param: '\x1b[90m',
+        bold: "\x1b[1m",
+        normal: "\x1b[21m",
+        end: "\x1b[0m",
+        param: "\x1b[90m",
         levels: {
-            fatal: [true, '\x1b[31m', '\x1b[91m'], // bold red
-            error: [false, '\x1b[31m', '\x1b[91m'], // red
-            warn: [false, '\x1b[35m', '\x1b[95m'], // magenta
-            info: [false, '\x1b[32m', '\x1b[92m'], // green
-            debug: [false, '\x1b[33m', '\x1b[93m'], // yellow
-            trace: [false, '\x1b[36m', '\x1b[96m'], // yellow
-        }
+            fatal: [true, "\x1b[31m", "\x1b[91m"],
+            error: [false, "\x1b[31m", "\x1b[91m"],
+            warn: [false, "\x1b[35m", "\x1b[95m"],
+            info: [false, "\x1b[32m", "\x1b[92m"],
+            debug: [false, "\x1b[33m", "\x1b[93m"],
+            trace: [false, "\x1b[36m", "\x1b[96m"],
+        },
     };
     _logFormatter;
     _logDeploymentStyler;
     _logLocalStyler;
     _logStyler;
     _contextFinder;
-    // endregion properties
     constructor(leyyo) {
         this.leyyo = leyyo;
         this._loggers = this.leyyo.repoCommon.newMap(`${where}.loggers`);
         this._defaults();
     }
-    // region setters
-    /**
-     * Set formatter
-     *
-     * @param {function} fn - lambda for formatter
-     * */
     setLogFormatter(fn) {
-        if (typeof fn !== 'function') {
-            throw new this.leyyo.developerError('Invalid log formatter', testCase(FQN, 200), where);
+        if (typeof fn !== "function") {
+            throw new this.leyyo.developerError("Invalid log formatter", testCase(FQN, 200), where);
         }
         this._logFormatter = fn;
     }
-    /**
-     * Set deployment styler
-     *
-     * @param {function} fn - lambda for styler
-     * */
     setLogDeploymentStyler(fn) {
-        if (typeof fn !== 'function') {
-            throw new this.leyyo.developerError('Invalid log styler', testCase(FQN, 201), where);
+        if (typeof fn !== "function") {
+            throw new this.leyyo.developerError("Invalid log styler", testCase(FQN, 201), where);
         }
         this._logDeploymentStyler = fn;
-        if (process.env['NODE_ENV'] !== 'local') {
+        if (process.env["NODE_ENV"] !== "local") {
             this._logStyler = this._logDeploymentStyler;
         }
     }
-    /**
-     * Set local style
-     *
-     * @param {function} fn - lambda for styler
-     * */
     setLogLocalStyler(fn) {
-        if (typeof fn !== 'function') {
-            throw new this.leyyo.developerError('Invalid log local styler', testCase(FQN, 202), where);
+        if (typeof fn !== "function") {
+            throw new this.leyyo.developerError("Invalid log local styler", testCase(FQN, 202), where);
         }
         this._logLocalStyler = fn;
-        if (process.env['NODE_ENV'] === 'local') {
+        if (process.env["NODE_ENV"] === "local") {
             this._logStyler = this._logLocalStyler;
         }
     }
-    /**
-     * Set local style
-     *
-     * @param {function} fn - lambda for styler
-     * */
     setContextFinder(fn) {
-        if (typeof fn !== 'function') {
-            throw new this.leyyo.developerError('Invalid log local styler', testCase(FQN, 202), where);
+        if (typeof fn !== "function") {
+            throw new this.leyyo.developerError("Invalid log local styler", testCase(FQN, 202), where);
         }
         this._contextFinder = fn;
     }
-    // endregion setters
-    // region private
     _defaults() {
-        /**
-         * Default log formatter
-         *
-         * @param {LogItem} item
-         * */
         this._logFormatter = (item) => {
             if (item?.ctx) {
                 const ctx = item.ctx;
@@ -110,33 +71,27 @@ export class LogCommon {
             }
             item.paramStr = item.params ? secureJson(item.params) : undefined;
             delete item.params;
-            if (item.paramStr && ['{}', '[]'].includes(item.paramStr)) {
+            if (item.paramStr && ["{}", "[]"].includes(item.paramStr)) {
                 delete item.paramStr;
             }
         };
-        /**
-         * Default log deployment styler (on server)
-         *
-         * @param {LogItem} item
-         * @return {string}
-         * */
         this._logDeploymentStyler = (item) => {
             let message = item.now;
             if (item?.ctx) {
-                if (item.ctx['pid']) {
-                    message += ` [p:${item.ctx['pid']}]`;
+                if (item.ctx["pid"]) {
+                    message += ` [p:${item.ctx["pid"]}]`;
                 }
                 else {
                     message += ` [p:]`;
                 }
-                if (item.ctx['tid']) {
-                    message += ` [t:${item.ctx['tid']}]`;
+                if (item.ctx["tid"]) {
+                    message += ` [t:${item.ctx["tid"]}]`;
                 }
                 else {
                     message += ` [t:]`;
                 }
-                if (item.ctx['cid']) {
-                    message += ` [c:${item.ctx['cid']}]`;
+                if (item.ctx["cid"]) {
+                    message += ` [c:${item.ctx["cid"]}]`;
                 }
                 else {
                     message += ` [c:]`;
@@ -148,28 +103,22 @@ export class LogCommon {
             else {
                 message += ` [w:]`;
             }
-            message += ' ' + item.message;
-            return message + (item.paramStr ? ' ~^~ ' + item.paramStr : '');
+            message += " " + item.message;
+            return message + (item.paramStr ? " ~^~ " + item.paramStr : "");
         };
-        /**
-         * Default log locale styler (on local computer)
-         *
-         * @param {LogItem} item
-         * @return {string}
-         * */
         this._logLocalStyler = (item) => {
             const { bold, end, param } = this._localColor;
             const [isBold, regular, light] = this._localColor.levels[item.level] ?? this._localColor.levels.debug;
             let message = item.now.substring(10, 11) + ` ${param}[p:${process.pid}]${end}`;
             if (item?.ctx) {
-                if (item.ctx['tid']) {
-                    message += ` ${regular}[t:${item.ctx['tid']}]`;
+                if (item.ctx["tid"]) {
+                    message += ` ${regular}[t:${item.ctx["tid"]}]`;
                 }
                 else {
                     message += ` ${param}[t:]`;
                 }
-                if (item.ctx['cid']) {
-                    message += ` ${light}[c:${item.ctx['cid']}]`;
+                if (item.ctx["cid"]) {
+                    message += ` ${light}[c:${item.ctx["cid"]}]`;
                 }
                 else {
                     message += ` ${param}[c:]`;
@@ -181,44 +130,30 @@ export class LogCommon {
             else {
                 message += ` ${param}[${emptyWhere}]`;
             }
-            message += ` ${isBold ? bold : ''}${light}${item.message}${end}`;
-            return message + (item.paramStr ? ` ~^~ ${param}${item.paramStr}${end}` : '');
+            message += ` ${isBold ? bold : ""}${light}${item.message}${end}`;
+            return message + (item.paramStr ? ` ~^~ ${param}${item.paramStr}${end}` : "");
         };
-        /**
-         * Set current styler by environment
-         * */
-        if (process.env['NODE_ENV'] === 'local') {
+        if (process.env["NODE_ENV"] === "local") {
             this._logStyler = this._logLocalStyler;
         }
         else {
             this._logStyler = this._logDeploymentStyler;
         }
     }
-    /**
-     * Build short style of logger name
-     *
-     * @param {string} where - original logger name
-     * @param {string} - short style
-     * */
     _shortenWhere(where) {
         if (!where) {
             return undefined;
         }
-        if (!where.includes('.')) {
+        if (!where.includes(".")) {
             return where;
         }
-        const parts = where.split('.');
+        const parts = where.split(".");
         where = parts.pop();
         if (parts.length > 0) {
-            where = parts.map(w => w.slice(0, 1)).join('.') + '.' + where;
+            where = parts.map((w) => w.slice(0, 1)).join(".") + "." + where;
         }
         return where;
     }
-    /**
-     * Log consumer
-     *
-     * @param {LogItem} item
-     * */
     _consumeLog(item) {
         if (!isObj(item)) {
             return;
@@ -227,46 +162,31 @@ export class LogCommon {
         try {
             this._logFormatter(item);
         }
-        catch (e) {
+        catch (_e) {
         }
         let message;
         try {
             message = this._logStyler(item);
         }
-        catch (e) {
+        catch (_e) {
         }
-        if (typeof message !== 'string') {
-            message = `${item?.now} - ${typeof item.message === 'string' ? item.message : secureJson(item.message)}`;
+        if (typeof message !== "string") {
+            message = `${item?.now} - ${typeof item.message === "string" ? item.message : secureJson(item.message)}`;
             if (item.params) {
                 message += ` ~^~ ${secureJson(item.params)}`;
             }
         }
         console[item.level](message);
     }
-    /**
-     * Generate random logger name
-     *
-     * @return {string}
-     * */
     _randomLoggerName() {
-        return this._checkLoggerName('Logger', Math.floor(Math.random() * 1000));
+        return this._checkLoggerName("Logger", Math.floor(Math.random() * 1000));
     }
-    /**
-     * Check logger name's uniqueness, and loop till unique name
-     *
-     * @param {string} name - base name
-     * @param {number} index - try count
-     * @return {string}
-     * */
     _checkLoggerName(name, index) {
         if (this._loggers.has(name)) {
             return this._checkLoggerName(name, index + 1);
         }
-        return name + (index === 0) ? '' : `(#${index})`;
+        return name + (index === 0) ? "" : `(#${index})`;
     }
-    // endregion private
-    // region public
-    /** @inheritDoc */
     of(value) {
         let name;
         let fqn;
@@ -289,25 +209,20 @@ export class LogCommon {
         }
         const ins = new this.leyyo.loggerInstance(name);
         if (!fqn) {
-            onFqnSet(value, f => ins.$secure.$refreshName(f));
+            onFqnSet(value, (f) => ins.$secure.$refreshName(f));
         }
         this._loggers.set(name, ins);
         return ins;
     }
-    /** @inheritDoc */
     initConsume() {
-        // bind to context finder
-        this.leyyo.eventCommon.listen('context:set-finder', (v) => {
-            if (typeof v === 'function') {
+        this.leyyo.eventCommon.listen("context:set-finder", (v) => {
+            if (typeof v === "function") {
                 this._contextFinder = v;
             }
         });
-        // bind to event emitter
-        this.leyyo.eventCommon.listen('log', (v) => this._consumeLog(v));
-        this.initConsume = () => {
-        };
+        this.leyyo.eventCommon.listen("log", (v) => this._consumeLog(v));
+        this.initConsume = () => { };
     }
-    /** @inheritDoc */
     emitLog(level, where, message, params) {
         const item = {
             level,
@@ -324,25 +239,25 @@ export class LogCommon {
                 }
                 err[KEY_LOG_ALREADY] = true;
             }
-            catch (e) {
+            catch (_e) {
             }
             item.message = this.leyyo.errorCommon.text(message);
             item.params = this.leyyo.errorCommon.toJsonBasic(message, params);
         }
         else {
-            if (typeof message !== 'string') {
+            if (typeof message !== "string") {
                 if (isEmpty(message)) {
-                    message = '??';
+                    message = "??";
                 }
                 else {
-                    if (typeof message === 'object') {
+                    if (typeof message === "object") {
                         try {
                             if (message[KEY_LOG_ALREADY]) {
                                 return;
                             }
                             message[KEY_LOG_ALREADY] = true;
                         }
-                        catch (e) {
+                        catch (_e) {
                         }
                     }
                     message = secureJson(message);
@@ -353,7 +268,7 @@ export class LogCommon {
         }
         if (!item.where && params?.where) {
             try {
-                if (typeof params.where === 'string') {
+                if (typeof params.where === "string") {
                     item.where = params.where;
                     delete params.where;
                 }
@@ -363,16 +278,16 @@ export class LogCommon {
                     params.where.delete(item.where);
                 }
             }
-            catch (e) {
+            catch (_e) {
             }
         }
         if (this._contextFinder) {
             try {
                 item.ctx = this._contextFinder(item.params?.req);
             }
-            catch (e) {
+            catch (_e) {
             }
         }
-        this.leyyo.eventCommon.emit('log', item);
+        this.leyyo.eventCommon.emit("log", item);
     }
 }

package/dist/common/repo.common.d.ts

@@ -4,222 +4,34 @@ import { LeyyoLike } from "../base/index.js";
 export declare class RepoCommon implements RepoCommonLike {
     private leyyo;
     private static _created;
-    /**
-     * Internal items which stores arrays
-     * */
     private _arrayItems;
-    /**
-     * Internal array volatile repo which could be cleared after lifecycle run
-     * */
     private _arrayVolatiles;
-    /**
-     * Internal items which stores lists
-     * */
     private _listItems;
-    /**
-     * Internal list volatiles repo which could be cleared after lifecycle run
-     * */
     private _listVolatiles;
-    /**
-     * Internal items which stores maps
-     * */
     private _mapItems;
-    /**
-     * Internal map volatile repo which could be cleared after lifecycle run
-     * */
     private _mapVolatiles;
-    /**
-     * Internal items which stores sets
-     * */
     private _setItems;
-    /**
-     * Internal set volatiles repo which could be cleared after lifecycle run
-     * */
     private _setVolatiles;
     constructor(leyyo: LeyyoLike);
-    /**
-     * Create new array
-     *
-     * @param {string} name - name of collection
-     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
-     * @return {Array<any>}
-     * */
     newArray<V>(name: string, volatile?: boolean): Array<V>;
-    /**
-     * Remove array by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of removed items in collection
-     * */
     removeArray(key: symbol): number;
-    /**
-     * Clear array by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of cleared items in collection
-     * */
     clearArray(key: symbol): number;
-    /**
-     * List all array keys
-     *
-     * @return {Array<symbol>}
-     * */
     listArrays(): Array<symbol>;
-    /**
-     * Print all arrays
-     *
-     * @return {Record} - as {key: length of collection}
-     *
-     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
-     * */
     printArrays(): Record<string, number>;
-    /**
-     * Create new list
-     *
-     * @param {string} name - name of collection
-     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
-     * @return {List<any>}
-     * */
     newList<V>(name: string, volatile?: boolean): List<V>;
-    /**
-     * Remove list by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of removed items in collection
-     * */
     removeList(key: symbol): number;
-    /**
-     * Clear list by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of cleared items in collection
-     * */
     clearList(key: symbol): number;
-    /**
-     * List all list keys
-     *
-     * @return {Array<symbol>}
-     * */
     listLists(): Array<symbol>;
-    /**
-     * Print all lists
-     *
-     * @return {Record} - as {key: length of collection}
-     *
-     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
-     * */
     printLists(): Record<string, number>;
-    /**
-     * Create new map
-     *
-     * @param {string} name - name of collection
-     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
-     * @return {Map<any, any>}
-     * */
     newMap<K, V>(name: string, volatile?: boolean): Map<K, V>;
-    /**
-     * Remove map by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of removed items in collection
-     * */
     removeMap(key: symbol): number;
-    /**
-     * Clear map by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of cleared items in collection
-     * */
     clearMap(key: symbol): number;
-    /**
-     * List all map keys
-     *
-     * @return {Array<symbol>}
-     * */
     listMaps(): Array<symbol>;
-    /**
-     * Print all maps
-     *
-     * @return {Record} - as {key: length of collection}
-     *
-     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
-     * */
     printMaps(): Record<string, number>;
-    /**
-     * Create new set
-     *
-     * @param {string} name - name of collection
-     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
-     * @return {Set<any>}
-     * */
     newSet<V>(name: string, volatile?: boolean): Set<V>;
-    /**
-     * Remove set by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of removed items in collection
-     * */
     removeSet(key: symbol): number;
-    /**
-     * Clear set by given key
-     *
-     * @param {symbol} key - key of collection
-     * @return {number}
-     *
-     * Return possibilities:
-     *  - `-2`: key is not valid symbol
-     *  - `-1`: key does not exist
-     *  - `>= 0`: length of cleared items in collection
-     * */
     clearSet(key: symbol): number;
-    /**
-     * List all set keys
-     *
-     * @return {Array<symbol>}
-     * */
     listSets(): Array<symbol>;
-    /**
-     * Print all sets
-     *
-     * @return {Record} - as {key: length of collection}
-     *
-     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
-     * */
     printSets(): Record<string, number>;
     init(): void;
 }