@leyyo/common 1.3.18 → 1.3.19

package/dist/common/inert.js

@@ -1,39 +1,31 @@
 import { FQN } from "../internal.js";
-import { getFqn, isFilledArr, isFilledObj, isObj, isText, onFqnSet, setAnonymousName, setFqn, testCase } from "../function/index.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;
         this.options = options;
         if (!isText(this.cluster)) {
-            throw new this.leyyo.developerError('Invalid cluster name', testCase(FQN, 'XXX'), where);
+            throw new this.leyyo.developerError("Invalid cluster name", testCase(FQN, "XXX"), where);
         }
         if (isObj(this.options)) {
             this.options = {};
         }
         if (this.options.anonymousName && !isText(this.options.anonymousName)) {
-            throw new this.leyyo.developerError('Invalid anonymous name', testCase(FQN, 'XXX'), where);
+            throw new this.leyyo.developerError("Invalid anonymous name", testCase(FQN, "XXX"), where);
         }
         const repo = this.leyyo.repoCommon;
         if (!Inert._pool) {
             Inert._pool = repo.newMap(`${where}.pool`);
         }
         if (Inert._pool.has(this.cluster)) {
-            throw new this.leyyo.developerError(`Duplicated cluster [${this.cluster}]`, testCase(FQN, 'XXX'), where);
+            throw new this.leyyo.developerError(`Duplicated cluster [${this.cluster}]`, testCase(FQN, "XXX"), where);
         }
         this._repo = {
             uniqueLoaded: repo.newSet(`${where}.${this.cluster}.uniqueLoaded`),
@@ -45,18 +37,17 @@ 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('.')) {
+        if (!item.full || !item.full.includes(".")) {
             if (isText(item.fqn)) {
                 item.full = setFqn(item.target, item.fqn);
             }
             else {
                 const { pendingFqn } = this._repo;
                 pendingFqn.set(item.name, item);
-                item.stage = 'fqn-waiting';
-                onFqnSet(item.target, f => this._afterFqnSet(f));
+                item.stage = "fqn-waiting";
+                onFqnSet(item.target, (f) => this._afterFqnSet(f));
                 this._afterTargetFound(item);
                 return true;
             }
@@ -68,15 +59,15 @@ export class Inert {
             return;
         }
         const { pendingFqn } = this._repo;
-        const item = pendingFqn.get(full.split('.').pop());
+        const item = pendingFqn.get(full.split(".").pop());
         if (item) {
             pendingFqn.delete(item.name);
             item.full = full;
-            item.stage = 'persistent';
+            item.stage = "persistent";
             this._onFqnCompleted(item);
         }
         else {
-            new this.leyyo.developerError(`Inert could not be found after come back, [${full}]`, testCase(FQN, 'ZZZ'), where).log();
+            new this.leyyo.developerError(`Inert could not be found after come back, [${full}]`, testCase(FQN, "ZZZ"), where).log();
         }
     }
     _onFqnCompleted(item) {
@@ -88,7 +79,7 @@ export class Inert {
                 const anotherItem = fullNames.get(item.full);
                 if (anotherItem.target !== item.target) {
                     ignore = true;
-                    new this.leyyo.developerError(`Duplicated full name [${item.full}]`, testCase(FQN, 'ZZZ'), where).log();
+                    new this.leyyo.developerError(`Duplicated full name [${item.full}]`, testCase(FQN, "ZZZ"), where).log();
                 }
             }
             if (!ignore) {
@@ -100,20 +91,20 @@ export class Inert {
             const anotherItem = basicNames.get(item.name);
             if (anotherItem.target !== item.target) {
                 ignore = true;
-                new this.leyyo.developerError(`Duplicated basic name [${item.name}]`, testCase(FQN, 'ZZZ'), where).log();
+                new this.leyyo.developerError(`Duplicated basic name [${item.name}]`, testCase(FQN, "ZZZ"), where).log();
             }
         }
         if (!ignore) {
             basicNames.set(item.name, item);
         }
         if (isFilledArr(item.aliases)) {
-            item.aliases.forEach(alias => {
+            item.aliases.forEach((alias) => {
                 ignore = false;
                 if (aliases.has(alias)) {
                     const anotherName = aliases.get(alias);
                     if (![item.name, item.full].includes(anotherName)) {
                         ignore = true;
-                        new this.leyyo.developerError(`Duplicated alias [${item.name}]`, testCase(FQN, 'ZZZ'), where).log();
+                        new this.leyyo.developerError(`Duplicated alias [${item.name}]`, testCase(FQN, "ZZZ"), where).log();
                     }
                 }
                 if (!ignore) {
@@ -122,19 +113,15 @@ 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);
+            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;
             }
@@ -149,74 +136,63 @@ export class Inert {
                 }
             }
             if (!basicName) {
-                throw new this.leyyo.developerError('Empty name', testCase(FQN, 220), where);
+                throw new this.leyyo.developerError("Empty name", testCase(FQN, 220), where);
             }
-            const item = { ...options, name: basicName, stage: undefined, mode: 'eager' };
+            const item = { ...options, name: basicName, stage: undefined, mode: "eager" };
             if (this._inFqnStage(item)) {
                 return;
             }
-            item.stage = 'persistent';
+            item.stage = "persistent";
             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);
+                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;
             }
-            const item = { ...options, stage: 'loading-waiting', mode: 'lazy' };
+            const item = { ...options, stage: "loading-waiting", mode: "lazy" };
             pendingLazy.set(options.name, item);
         }
         else {
             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';
+        return this.get(name)?.mode === "lazy";
     }
-    /** @inheritDoc */
     isInvalid(name) {
-        return ['failed', 'conflicted'].includes(this.get(name)?.mode);
+        return ["failed", "conflicted"].includes(this.get(name)?.mode);
     }
-    /** @inheritDoc */
     isFailed(name) {
-        return this.get(name)?.mode === 'failed';
+        return this.get(name)?.mode === "failed";
     }
-    /** @inheritDoc */
     isConflicted(name) {
-        return this.get(name)?.mode === 'conflicted';
+        return this.get(name)?.mode === "conflicted";
     }
-    /** @inheritDoc */
     isEager(name) {
-        return this.get(name)?.mode === 'eager';
+        return this.get(name)?.mode === "eager";
     }
-    /** @inheritDoc */
     has(name) {
         return !!this.get(name);
     }
-    /** @inheritDoc */
     get(name) {
         if (!isText(name)) {
             return undefined;
         }
         const { fullNames, basicNames, pendingFqn, pendingLazy, aliases } = this._repo;
-        if (name.includes('.')) {
+        if (name.includes(".")) {
             if (fullNames.has(name)) {
                 return fullNames.get(name);
             }
-            return this.get(name.split('.').pop());
+            return this.get(name.split(".").pop());
         }
-        // no dot
         if (pendingFqn.has(name)) {
             return pendingFqn.get(name);
         }
@@ -228,44 +204,39 @@ 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);
+            throw new this.leyyo.developerError(`Invalid lazy name`, testCase(FQN, "ZZZ"), where);
         }
         const { pendingLazy, uniqueLoaded } = this._repo;
         const item = this.get(name);
         if (!item) {
-            throw new this.leyyo.developerError(`Lazy was not defined [${name}]`, testCase(FQN, 'ZZZ'), where);
+            throw new this.leyyo.developerError(`Lazy was not defined [${name}]`, testCase(FQN, "ZZZ"), where);
         }
-        // It was already loaded
-        if (item.mode === 'eager') {
+        if (item.mode === "eager") {
             return item;
         }
         try {
             item.target = await item.lazyTarget;
             if (this._validate(item.target)) {
-                item.mode = 'eager';
+                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;
                 }
             }
             else {
-                item.mode = 'conflicted';
+                item.mode = "conflicted";
             }
         }
         catch (e) {
-            item.mode = 'failed';
+            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;
         }
@@ -275,13 +246,13 @@ export class Inert {
                 realName = this._setName(item.target, item.name);
             }
             if (!realName) {
-                new this.leyyo.developerError(`Conflict in names [${item.name} vs ${realName}]`, testCase(FQN, 'ZZZ'), where).log();
+                new this.leyyo.developerError(`Conflict in names [${item.name} vs ${realName}]`, testCase(FQN, "ZZZ"), where).log();
             }
         }
         if (this._inFqnStage(item)) {
             return;
         }
-        item.stage = 'persistent';
+        item.stage = "persistent";
         this._onFqnCompleted(item);
         this._afterTargetFound(item);
         return item;

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

@@ -1,26 +1,12 @@
 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,43 +1,29 @@
 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');
-        this._init('process');
-        this._init('clear');
-        this._init('ota-before');
-        this._init('ota-after');
-        this._init('kill');
+        this._init("initialize");
+        this._init("print");
+        this._init("validate");
+        this._init("process");
+        this._init("clear");
+        this._init("ota-before");
+        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);
+            throw new this.leyyo.developerError("Invalid lifecycle stage", testCase(FQN, 100), where);
         }
         if (!this._stages.has(stage)) {
             throw new this.leyyo.developerError(`Lifecycle stage could not be found [${stage}]`, testCase(FQN, 101), where);
@@ -45,7 +31,7 @@ export class LifecycleCommon {
         if (!isText(name)) {
             throw new this.leyyo.developerError(`Invalid lifecycle name [${stage}]`, testCase(FQN, 102), where);
         }
-        if (typeof callback !== 'function') {
+        if (typeof callback !== "function") {
             throw new this.leyyo.developerError(`Invalid lifecycle callback [${stage}/${name}]`, testCase(FQN, 103), where);
         }
         const item = this._stages.get(stage);
@@ -54,10 +40,9 @@ 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);
+            throw new this.leyyo.developerError("Invalid lifecycle stage", testCase(FQN, 104), where);
         }
         if (!this._stages.has(stage)) {
             throw new this.leyyo.developerError(`Lifecycle stage could not be found [${stage}]`, testCase(FQN, 105), where);
@@ -95,15 +80,14 @@ export class LifecycleCommon {
         }
         return count;
     }
-    /** @inheritDoc */
     setOrderLambda(stage, lambda) {
         if (!isText(stage)) {
-            throw new this.leyyo.developerError('Invalid lifecycle stage', testCase(FQN, 108), where);
+            throw new this.leyyo.developerError("Invalid lifecycle stage", testCase(FQN, 108), where);
         }
         if (!this._stages.has(stage)) {
             throw new this.leyyo.developerError(`Lifecycle stage could not be found [${stage}]`, testCase(FQN, 109), where);
         }
-        if (typeof lambda !== 'function') {
+        if (typeof lambda !== "function") {
             throw new this.leyyo.developerError(`Invalid lifecycle callback [${stage}]`, testCase(FQN, 110), where);
         }
         this._sortLambda = lambda;

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

@@ -1,26 +1,15 @@
 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;
+    define(fqn: string, name: string, target: Literal, opt?: Omit<LiteralPoolOpt, "name" | "target" | "lazyTarget" | "fqn">): void;
 }

package/dist/common/literal.pool.js

@@ -1,24 +1,17 @@
 import { Inert } from "./inert.js";
-import { getSymbol, isEmpty, isFilledArr, isFilledObj, isObj, isText, setSymbol, testCase } from "../function/index.js";
+import { getSymbol, isEmpty, isFilledArr, isFilledObj, isObj, isText, setSymbol, testCase, } from "../function/index.js";
 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', {});
+        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 {
@@ -27,12 +20,11 @@ export class LiteralPool extends Inert {
                 this.setConfigItem(item.target, item);
             }
             catch (e) {
-                new this.leyyo.developerError('Callback error during loading literal alternate data', testCase(FQN, 186), where).log(e);
+                new this.leyyo.developerError("Callback error during loading literal alternate data", testCase(FQN, 186), where).log(e);
             }
         }
         delete item.lazyAlt;
     }
-    /** @inheritDoc */
     _setName(lit, name) {
         if (isText(name)) {
             setSymbol(lit, KEY_LITERAL_NAME, name);
@@ -40,7 +32,6 @@ export class LiteralPool extends Inert {
         }
         return undefined;
     }
-    /** @inheritDoc */
     _afterTargetFound(item) {
         if (item.lazyTarget) {
             delete item.lazyTarget;
@@ -50,13 +41,9 @@ 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;
@@ -71,7 +58,6 @@ export class LiteralPool extends Inert {
             setSymbol(lit, KEY_LITERAL_ALT, conf.alt);
         }
     }
-    /** @inheritDoc */
     getConfigItem(lit) {
         if (!this._validate(lit)) {
             return undefined;
@@ -82,7 +68,6 @@ 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,15 +4,7 @@ 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;
@@ -20,62 +12,16 @@ 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;
 }