@leyyo/common 1.3.18 → 1.3.20

package/dist/common/inert.d.ts

@@ -20,7 +20,7 @@ export declare abstract class Inert<L extends InertItem<T>, T, O extends InertOp
     /** @inheritDoc */
     register(options: InertOpt<T>): void;
     /** @inheritDoc */
-    lazy(fqn: string, name: string, lazyTarget: Promise<T>, opt?: Omit<O, 'name' | 'target' | 'lazyTarget' | 'fqn'>): void;
+    lazy(fqn: string, name: string, lazyTarget: Promise<T>, opt?: Omit<O, "name" | "target" | "lazyTarget" | "fqn">): void;
     /** @inheritDoc */
     isLazy(name: string): boolean;
     /** @inheritDoc */

package/dist/common/inert.js

@@ -1,5 +1,5 @@
 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 {
@@ -20,20 +20,20 @@ export class Inert {
         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`),
@@ -48,15 +48,15 @@ export class Inert {
     // 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 +68,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 +88,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 +100,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) {
@@ -127,7 +127,7 @@ export class Inert {
     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)) {
@@ -149,27 +149,27 @@ 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 {
@@ -182,23 +182,23 @@ export class Inert {
     }
     /** @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) {
@@ -210,11 +210,11 @@ export class Inert {
             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)) {
@@ -231,21 +231,21 @@ export class Inert {
     /** @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)) {
@@ -258,11 +258,11 @@ export class Inert {
                 }
             }
             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
@@ -275,13 +275,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.js

@@ -16,14 +16,14 @@ export class LifecycleCommon {
         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
@@ -37,7 +37,7 @@ export class LifecycleCommon {
     /** @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 +45,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);
@@ -57,7 +57,7 @@ export class LifecycleCommon {
     /** @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);
@@ -98,12 +98,12 @@ export class LifecycleCommon {
     /** @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

@@ -22,5 +22,5 @@ export declare class LiteralPool extends Inert<LiteralPoolItem, Literal, Literal
     /** @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,5 +1,5 @@
 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`;
@@ -10,7 +10,7 @@ const where = `${FQN}.LiteralPool`;
 export class LiteralPool extends Inert {
     leyyo;
     constructor(leyyo) {
-        super(leyyo, 'literal', {});
+        super(leyyo, "literal", {});
         this.leyyo = leyyo;
     }
     // region protected
@@ -27,7 +27,7 @@ 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;