@leyyo/common 1.3.19 → 1.3.21

package/dist/common/inert.js

@@ -1,12 +1,20 @@
 import { FQN } from "../internal.js";
 import { getFqn, isFilledArr, isFilledObj, isObj, isText, onFqnSet, setAnonymousName, setFqn, testCase, } from "../function/index.js";
 const where = `${FQN}.Inert`;
+// noinspection JSUnusedGlobalSymbols
 export class Inert {
     leyyo;
     cluster;
     options;
     _repo;
     static _pool;
+    /**
+     * Constructor
+     *
+     * @param {LeyyoLike} leyyo
+     * @param {string} cluster
+     * @param {InertBuildOpt} options
+     * */
     constructor(leyyo, cluster, options) {
         this.leyyo = leyyo;
         this.cluster = cluster;
@@ -37,6 +45,7 @@ export class Inert {
         };
         Inert._pool.set(this.cluster, this._repo);
     }
+    // region private
     _inFqnStage(item) {
         item.full = getFqn(item.target);
         if (!item.full || !item.full.includes(".")) {
@@ -113,15 +122,19 @@ export class Inert {
             });
         }
     }
+    // endregion private
+    /** @inheritDoc */
     register(options) {
         const { uniqueLoaded } = this._repo;
         if (!isFilledObj(options)) {
             throw new this.leyyo.developerError("Invalid inert options", testCase(FQN, "XXX"), where);
         }
+        // target
         if (this._validate(options.target)) {
             if (options.lazyTarget) {
                 delete options.lazyTarget;
             }
+            // already defined
             if (uniqueLoaded.has(options.target)) {
                 return;
             }
@@ -146,10 +159,12 @@ export class Inert {
             this._onFqnCompleted(item);
             this._afterTargetFound(item);
         }
+        // lazy target
         else if (options.lazyTarget instanceof Promise) {
             if (!isText(options.name)) {
                 throw new this.leyyo.developerError("Invalid inert name", testCase(FQN, "XXX"), where);
             }
+            // it's already pending to be loaded
             const { pendingLazy } = this._repo;
             if (pendingLazy.has(options.name)) {
                 return;
@@ -161,27 +176,35 @@ export class Inert {
             throw new this.leyyo.developerError(`Invalid target or lazy target [${options.name}]`, testCase(FQN, 224), where);
         }
     }
+    /** @inheritDoc */
     lazy(fqn, name, lazyTarget, opt) {
         this.register({ ...(opt ?? {}), fqn, name, lazyTarget });
     }
+    /** @inheritDoc */
     isLazy(name) {
         return this.get(name)?.mode === "lazy";
     }
+    /** @inheritDoc */
     isInvalid(name) {
         return ["failed", "conflicted"].includes(this.get(name)?.mode);
     }
+    /** @inheritDoc */
     isFailed(name) {
         return this.get(name)?.mode === "failed";
     }
+    /** @inheritDoc */
     isConflicted(name) {
         return this.get(name)?.mode === "conflicted";
     }
+    /** @inheritDoc */
     isEager(name) {
         return this.get(name)?.mode === "eager";
     }
+    /** @inheritDoc */
     has(name) {
         return !!this.get(name);
     }
+    /** @inheritDoc */
     get(name) {
         if (!isText(name)) {
             return undefined;
@@ -193,6 +216,7 @@ export class Inert {
             }
             return this.get(name.split(".").pop());
         }
+        // no dot
         if (pendingFqn.has(name)) {
             return pendingFqn.get(name);
         }
@@ -204,6 +228,7 @@ export class Inert {
         }
         return basicNames.get(name);
     }
+    /** @inheritDoc */
     async load(name) {
         if (!isText(name)) {
             throw new this.leyyo.developerError(`Invalid lazy name`, testCase(FQN, "ZZZ"), where);
@@ -213,6 +238,7 @@ export class Inert {
         if (!item) {
             throw new this.leyyo.developerError(`Lazy was not defined [${name}]`, testCase(FQN, "ZZZ"), where);
         }
+        // It was already loaded
         if (item.mode === "eager") {
             return item;
         }
@@ -221,10 +247,12 @@ export class Inert {
             if (this._validate(item.target)) {
                 item.mode = "eager";
                 delete item.lazyTarget;
+                // remove from pending
                 if (pendingLazy.has(name)) {
                     pendingLazy.delete(name);
                 }
                 await this._nextLoad(item);
+                // already loaded
                 if (uniqueLoaded.has(item.target)) {
                     return item;
                 }
@@ -237,6 +265,7 @@ export class Inert {
             item.mode = "failed";
             new this.leyyo.developerError(`Callback inert during loading lazy class [${name}]`, testCase(FQN, 227), where).log(e);
         }
+        // file could not be loaded
         if (!item.target) {
             return undefined;
         }

package/dist/common/lifecycle.common.d.ts

@@ -1,12 +1,26 @@
 import { LifecycleCommonLike, LifecycleSortLambda, LifecycleStage } from "./index.types.js";
 import { Fnc, LeyyoLike } from "../base/index.js";
+/**
+ * Lifecycle common interface
+ * */
 export declare class LifecycleCommon implements LifecycleCommonLike {
     private leyyo;
     private _stages;
     private _sortLambda;
+    /**
+     * Constructor
+     * */
     constructor(leyyo: LeyyoLike);
+    /**
+     * Init lifecycle by stage
+     *
+     * @param {LifecycleStage} stage - stage
+     * */
     private _init;
+    /** @inheritDoc */
     addStage(stage: LifecycleStage, name: string, callback: Fnc): void;
+    /** @inheritDoc */
     runStage(stage: LifecycleStage, ...params: Array<unknown>): Promise<number>;
+    /** @inheritDoc */
     setOrderLambda(stage: LifecycleStage, lambda: LifecycleSortLambda): void;
 }

package/dist/common/lifecycle.common.js

@@ -1,13 +1,21 @@
 import { FQN } from "../internal.js";
 import { isText, testCase } from "../function/index.js";
 const where = `${FQN}.LifecycleFn`;
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Lifecycle common interface
+ * */
 export class LifecycleCommon {
     leyyo;
     _stages;
     _sortLambda;
+    /**
+     * Constructor
+     * */
     constructor(leyyo) {
         this.leyyo = leyyo;
         this._stages = this.leyyo.repoCommon.newMap(`${where}.stages`);
+        // initialize stages
         this._init("initialize");
         this._init("print");
         this._init("validate");
@@ -17,10 +25,16 @@ export class LifecycleCommon {
         this._init("ota-after");
         this._init("kill");
     }
+    /**
+     * Init lifecycle by stage
+     *
+     * @param {LifecycleStage} stage - stage
+     * */
     _init(stage) {
         const newMap = this.leyyo.repoCommon.newMap(`${where}.${stage}`);
         this._stages.set(stage, newMap);
     }
+    /** @inheritDoc */
     addStage(stage, name, callback) {
         if (!isText(stage)) {
             throw new this.leyyo.developerError("Invalid lifecycle stage", testCase(FQN, 100), where);
@@ -40,6 +54,7 @@ export class LifecycleCommon {
         }
         item.get(name).push(callback);
     }
+    /** @inheritDoc */
     async runStage(stage, ...params) {
         if (!isText(stage)) {
             throw new this.leyyo.developerError("Invalid lifecycle stage", testCase(FQN, 104), where);
@@ -80,6 +95,7 @@ export class LifecycleCommon {
         }
         return count;
     }
+    /** @inheritDoc */
     setOrderLambda(stage, lambda) {
         if (!isText(stage)) {
             throw new this.leyyo.developerError("Invalid lifecycle stage", testCase(FQN, 108), where);

package/dist/common/literal.pool.d.ts

@@ -1,15 +1,26 @@
 import { Inert } from "./inert.js";
 import { Literal, LiteralItemConfig, LiteralPoolItem, LiteralPoolLike, LiteralPoolOpt } from "./index.types.js";
 import { LeyyoLike } from "../base/index.js";
+/**
+ * Literal pool for call with name and lazy loading
+ * */
 export declare class LiteralPool extends Inert<LiteralPoolItem, Literal, LiteralPoolOpt> implements LiteralPoolLike {
     protected leyyo: LeyyoLike;
     constructor(leyyo: LeyyoLike);
+    /** @inheritDoc */
     protected _getName(lit: Literal): string;
+    /** @inheritDoc */
     protected _nextLoad(item: LiteralPoolItem): Promise<void>;
+    /** @inheritDoc */
     protected _setName(lit: Literal, name: string): string;
+    /** @inheritDoc */
     protected _afterTargetFound(item: LiteralPoolItem): void;
+    /** @inheritDoc */
     protected _validate(lit: Literal): boolean;
+    /** @inheritDoc */
     setConfigItem(lit: Literal, conf: LiteralItemConfig): void;
+    /** @inheritDoc */
     getConfigItem(lit: Literal): LiteralItemConfig;
+    /** @inheritDoc */
     define(fqn: string, name: string, target: Literal, opt?: Omit<LiteralPoolOpt, "name" | "target" | "lazyTarget" | "fqn">): void;
 }

package/dist/common/literal.pool.js

@@ -3,15 +3,22 @@ import { getSymbol, isEmpty, isFilledArr, isFilledObj, isObj, isText, setSymbol,
 import { FQN } from "../internal.js";
 import { KEY_LITERAL_ALT, KEY_LITERAL_I18N, KEY_LITERAL_NAME } from "../const/index.js";
 const where = `${FQN}.LiteralPool`;
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Literal pool for call with name and lazy loading
+ * */
 export class LiteralPool extends Inert {
     leyyo;
     constructor(leyyo) {
         super(leyyo, "literal", {});
         this.leyyo = leyyo;
     }
+    // region protected
+    /** @inheritDoc */
     _getName(lit) {
         return this.getConfigItem(lit)?.name;
     }
+    /** @inheritDoc */
     async _nextLoad(item) {
         if (item.target && item.lazyAlt) {
             try {
@@ -25,6 +32,7 @@ export class LiteralPool extends Inert {
         }
         delete item.lazyAlt;
     }
+    /** @inheritDoc */
     _setName(lit, name) {
         if (isText(name)) {
             setSymbol(lit, KEY_LITERAL_NAME, name);
@@ -32,6 +40,7 @@ export class LiteralPool extends Inert {
         }
         return undefined;
     }
+    /** @inheritDoc */
     _afterTargetFound(item) {
         if (item.lazyTarget) {
             delete item.lazyTarget;
@@ -41,9 +50,13 @@ export class LiteralPool extends Inert {
         }
         this.setConfigItem(item.target, item);
     }
+    /** @inheritDoc */
     _validate(lit) {
         return isFilledArr(lit);
     }
+    // endregion protected
+    // region public
+    /** @inheritDoc */
     setConfigItem(lit, conf) {
         if (!isObj(conf)) {
             return;
@@ -58,6 +71,7 @@ export class LiteralPool extends Inert {
             setSymbol(lit, KEY_LITERAL_ALT, conf.alt);
         }
     }
+    /** @inheritDoc */
     getConfigItem(lit) {
         if (!this._validate(lit)) {
             return undefined;
@@ -68,6 +82,7 @@ export class LiteralPool extends Inert {
             alt: getSymbol(lit, KEY_LITERAL_ALT),
         };
     }
+    /** @inheritDoc */
     define(fqn, name, target, opt) {
         this.register({ ...(opt ?? {}), fqn, name, target });
     }

package/dist/common/log.common.d.ts

@@ -4,7 +4,15 @@ import { Opt } from "../function/index.js";
 import { ContextFinderLambda, LogCommonLike, LogFormatterLambda, Logger, LogStylerLambda } from "./index.types.js";
 export declare class LogCommon implements LogCommonLike {
     private leyyo;
+    /**
+     * Loggers
+     * */
     private _loggers;
+    /**
+     * Local console colors
+     *
+     * @type {LocalColorLike}
+     * */
     private _localColor;
     private _logFormatter;
     private _logDeploymentStyler;
@@ -12,16 +20,62 @@ export declare class LogCommon implements LogCommonLike {
     private _logStyler;
     private _contextFinder;
     constructor(leyyo: LeyyoLike);
+    /**
+     * Set formatter
+     *
+     * @param {function} fn - lambda for formatter
+     * */
     setLogFormatter(fn: LogFormatterLambda): void;
+    /**
+     * Set deployment styler
+     *
+     * @param {function} fn - lambda for styler
+     * */
     setLogDeploymentStyler(fn: LogStylerLambda): void;
+    /**
+     * Set local style
+     *
+     * @param {function} fn - lambda for styler
+     * */
     setLogLocalStyler(fn: LogStylerLambda): void;
+    /**
+     * Set local style
+     *
+     * @param {function} fn - lambda for styler
+     * */
     setContextFinder(fn: ContextFinderLambda): void;
     private _defaults;
+    /**
+     * Build short style of logger name
+     *
+     * @param {string} where - original logger name
+     * @param {string} - short style
+     * */
     private _shortenWhere;
+    /**
+     * Log consumer
+     *
+     * @param {LogItem} item
+     * */
     private _consumeLog;
+    /**
+     * Generate random logger name
+     *
+     * @return {string}
+     * */
     private _randomLoggerName;
+    /**
+     * Check logger name's uniqueness, and loop till unique name
+     *
+     * @param {string} name - base name
+     * @param {number} index - try count
+     * @return {string}
+     * */
     private _checkLoggerName;
+    /** @inheritDoc */
     of(value: ClassLike | Fnc | Obj | string): Logger;
+    /** @inheritDoc */
     initConsume(): void;
+    /** @inheritDoc */
     emitLog(level: LogLevel, where: string, message: any, params?: any | Opt): void;
 }

package/dist/common/log.common.js

@@ -3,21 +3,31 @@ import { getFqn, hasFqn, isEmpty, isFilledObj, isObj, onFqnSet, secureJson, test
 import { KEY_LOG_ALREADY } from "../const/index.js";
 const where = `${FQN}.LogCommon`;
 const emptyWhere = "".padStart(20);
+// noinspection JSUnusedGlobalSymbols
 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",
         levels: {
-            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"],
+            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
         },
     };
     _logFormatter;
@@ -25,17 +35,29 @@ export class LogCommon {
     _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);
         }
         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);
@@ -45,6 +67,11 @@ export class LogCommon {
             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);
@@ -54,13 +81,25 @@ export class LogCommon {
             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);
         }
         this._contextFinder = fn;
     }
+    // endregion setters
+    // region private
     _defaults() {
+        /**
+         * Default log formatter
+         *
+         * @param {LogItem} item
+         * */
         this._logFormatter = (item) => {
             if (item?.ctx) {
                 const ctx = item.ctx;
@@ -75,6 +114,12 @@ export class LogCommon {
                 delete item.paramStr;
             }
         };
+        /**
+         * Default log deployment styler (on server)
+         *
+         * @param {LogItem} item
+         * @return {string}
+         * */
         this._logDeploymentStyler = (item) => {
             let message = item.now;
             if (item?.ctx) {
@@ -106,6 +151,12 @@ export class LogCommon {
             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;
@@ -133,6 +184,9 @@ export class LogCommon {
             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") {
             this._logStyler = this._logLocalStyler;
         }
@@ -140,6 +194,12 @@ export class LogCommon {
             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;
@@ -154,6 +214,11 @@ export class LogCommon {
         }
         return where;
     }
+    /**
+     * Log consumer
+     *
+     * @param {LogItem} item
+     * */
     _consumeLog(item) {
         if (!isObj(item)) {
             return;
@@ -163,12 +228,14 @@ export class LogCommon {
             this._logFormatter(item);
         }
         catch (_e) {
+            // nothing
         }
         let message;
         try {
             message = this._logStyler(item);
         }
         catch (_e) {
+            // nothing
         }
         if (typeof message !== "string") {
             message = `${item?.now} - ${typeof item.message === "string" ? item.message : secureJson(item.message)}`;
@@ -178,15 +245,30 @@ export class LogCommon {
         }
         console[item.level](message);
     }
+    /**
+     * Generate random logger name
+     *
+     * @return {string}
+     * */
     _randomLoggerName() {
         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})`;
     }
+    // endregion private
+    // region public
+    /** @inheritDoc */
     of(value) {
         let name;
         let fqn;
@@ -214,15 +296,19 @@ export class LogCommon {
         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._contextFinder = v;
             }
         });
+        // bind to event emitter
         this.leyyo.eventCommon.listen("log", (v) => this._consumeLog(v));
         this.initConsume = () => { };
     }
+    /** @inheritDoc */
     emitLog(level, where, message, params) {
         const item = {
             level,
@@ -240,6 +326,7 @@ export class LogCommon {
                 err[KEY_LOG_ALREADY] = true;
             }
             catch (_e) {
+                // nothing
             }
             item.message = this.leyyo.errorCommon.text(message);
             item.params = this.leyyo.errorCommon.toJsonBasic(message, params);
@@ -258,6 +345,7 @@ export class LogCommon {
                             message[KEY_LOG_ALREADY] = true;
                         }
                         catch (_e) {
+                            // nothing
                         }
                     }
                     message = secureJson(message);
@@ -279,6 +367,7 @@ export class LogCommon {
                 }
             }
             catch (_e) {
+                // nothing
             }
         }
         if (this._contextFinder) {
@@ -286,6 +375,7 @@ export class LogCommon {
                 item.ctx = this._contextFinder(item.params?.req);
             }
             catch (_e) {
+                // nothing
             }
         }
         this.leyyo.eventCommon.emit("log", item);