@leyyo/common 1.3.18 → 1.3.19

package/dist/base/index.d.ts

@@ -1,3 +1,3 @@
-export * from './index.types.js';
-export * from './leyyo.types.js';
-export * from './leyyo.js';
+export * from "./index.types.js";
+export * from "./leyyo.types.js";
+export * from "./leyyo.js";

package/dist/base/index.js

@@ -1,3 +1,3 @@
-export * from './index.types.js';
-export * from './leyyo.types.js';
-export * from './leyyo.js';
+export * from "./index.types.js";
+export * from "./leyyo.types.js";
+export * from "./leyyo.js";

package/dist/base/index.types.d.ts

@@ -1,9 +1,9 @@
 export type HttpStatus = number;
-export type BasicType = 'undefined' | 'string' | 'object' | 'number' | 'boolean' | 'function' | 'symbol' | 'bigint';
-export type ExtendedType = BasicType | 'array' | 'null' | 'enum-map' | 'literal-items' | 'class' | 'empty' | 'text' | 'nan' | 'integer' | 'date' | 'map' | 'set' | 'list';
+export type BasicType = "undefined" | "string" | "object" | "number" | "boolean" | "function" | "symbol" | "bigint";
+export type ExtendedType = BasicType | "array" | "null" | "enum-map" | "literal-items" | "class" | "empty" | "text" | "nan" | "integer" | "date" | "map" | "set" | "list";
 export type KeyValue = string | number;
 export type AnyKey = string | number | symbol;
-export type Obj = Object & {};
+export type Obj = object & {};
 export type Dict<T = unknown> = Record<KeyValue, T>;
 export type Arr<T = unknown> = Array<T>;
 export type LangLike = string;
@@ -65,22 +65,10 @@ export type TypeOfMethod<T, M extends keyof T> = T[M] extends Function ? T[M] :
 export type TypeOfFnc<F extends Fnc> = F extends (...args: Arr) => infer R ? R : never;
 export type TypeOfAsync<F extends Async> = TypeOfPromise<TypeOfFnc<F>>;
 export type TypeOfPromise<P> = P extends Promise<infer R> ? R : P;
-/**
- * String keys of an interface
- * - Note: keyof keywords returns string|number|symbol, but it's ignore number and symbol keys
- * */
 export type StrKey<T> = Extract<keyof T, string>;
-/**
- * Serialized version of another type
- */
 export type Serialized<T> = {
     [P in keyof T]: T[P];
 };
-/**
- * Makes mutable an interface
- *
- * @see Readonly
- * */
 export type Mutable<A> = {
     -readonly [K in keyof A]: A[K];
 };
@@ -90,44 +78,16 @@ export type ValueOf<T> = T[KeyOf<T>];
 export type Values<T> = Array<T[KeyOf<T>]>;
 export type OneOrMore<T> = T | Array<T>;
 export type SetOrMore<T> = T | Set<T>;
-/**
- * An interface which contains secure mode members and provides to shift to main mode
- * */
 export interface ShiftSecure<S extends ShiftMain<any>> {
-    /**
-     * Shifts to secure mode
-     * */
     get $secure(): S;
 }
-/**
- * An interface which contains main mode members and provides to shift to secure mode
- *
- * IT's so useful to hide some public members
- * - to see clean auto-completed members in IDE
- * - to indicated that secure mode members should be used in special cases
- * */
 export interface ShiftMain<M extends ShiftSecure<any>> {
-    /**
-     * Shifts to main mode
-     * */
     get $back(): M;
 }
-/**
- * An interface which provides to flat generic interfaces/classes to prevent verbose casting commands
- * */
 export interface ShiftFlat<D> {
-    /**
-     * Flats current classes, or eliminate generic parameters
-     * */
     get $flat(): D;
 }
-/**
- * Useful interface which provides initialization state for instances
- * */
 export interface InitLike {
-    /**
-     * Initializes the instance
-     * */
     $init(...args: Arr): void;
 }
 export type IgnoreFieldsByType<T, I> = {
@@ -178,37 +138,10 @@ export type IsoDatetime = string;
 export type IsoDate = string;
 export type IsoTime = string;
 export type JsonText<T = unknown> = string;
-/**
- * JSON Object, record of `JsonValue`
- *
- * @see #JsonValue
- */
 export type JsonObject = {
     [K in string]?: JsonValue;
 };
-/**
- * JSON Array, array of `JsonValue`
- *
- * @see #JsonValue
- */
 export type JsonArray = Array<JsonValue>;
-/**
- * JSON Primitive
- *
- * `OneOf`
- * @see `string`
- * @see `number`
- * @see `boolean`
- * @see `null`
- */
 export type JsonPrimitive = string | number | boolean | null;
-/**
- * JSON Value
- *
- * `OneOf`
- * @see #JsonPrimitive
- * @see #JsonObject
- * @see #JsonArray
- */
 export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 export {};

package/dist/base/index.types.js

@@ -1,33 +1 @@
 export {};
-// endregion json
-/*
-
-// export type StrObject<T> = {
-//     [K in keyof T ]: K extends string ? K : never;
-// };
-// export type StrKey<T> = keyof StrObject<T>;
-
-interface _BaseFunc {
-    readonly name?: string;
-    readonly length?: number;
-    bind(thisArg: unknown, ...args: Array<unknown>): unknown;
-
-    apply(thisArg: unknown, args: Array<unknown>): unknown;
-
-    call(thisArg: unknown, ...args: Array<unknown>): unknown;
-}
-
-interface _SyncFnc<R> extends _BaseFunc {
-    (...args: Array<unknown>): R;
-}
-interface _AsyncFnc<R> extends _BaseFunc {
-    (...args: Array<unknown>): Promise<R>;
-}
-
-// export type ClassOrName = ClassLike | string;
-// export type FuncOrName = Function | string;
-// export type ClassOrFuncOrName = ClassLike | Function | string;
-// export type ClassLike<T = {}> = (_BaseFunc & _Type<T>) | _SyncFnc<T>;
-// export type AnyFnc<R = unknown> = Fnc<R> | Async<R>;
-
-*/

package/dist/base/leyyo.d.ts

@@ -1,5 +1,2 @@
 import { LeyyoLike } from "./leyyo.types.js";
-/**
- * Leyyo common instance
- * */
 export declare const leyyo: LeyyoLike;

package/dist/base/leyyo.js

@@ -1,4 +1,4 @@
-import { DeployCommon, EnumPool, ErrorCommon, ErrorPool, EventCommon, LifecycleCommon, LiteralPool, LogCommon, RepoCommon } from "../common/index.js";
+import { DeployCommon, EnumPool, ErrorCommon, ErrorPool, EventCommon, LifecycleCommon, LiteralPool, LogCommon, RepoCommon, } from "../common/index.js";
 import { DeveloperError, LeyyoError } from "../error/index.js";
 import { LoggerInstance } from "../class/logger.instance.js";
 import { KEY_LEYYO_SECURE } from "../const/index.js";
@@ -18,7 +18,6 @@ class Leyyo {
     _logCommon;
     _logger;
     constructor() {
-        // region binding
         $$set_leyyo_fn(this);
         this._developerError = DeveloperError;
         this._developerError[KEY_LEYYO_SECURE](this);
@@ -26,24 +25,17 @@ class Leyyo {
         this._leyyoError[KEY_LEYYO_SECURE](this);
         this._loggerInstance = LoggerInstance;
         this._loggerInstance[KEY_LEYYO_SECURE](this);
-        // endregion binding
-        // region instances
-        this._repoCommon = new RepoCommon(this); // none
-        this._errorCommon = new ErrorCommon(this); // none
-        this._logCommon = new LogCommon(this); // repo
-        this._eventCommon = new EventCommon(this); // repo
-        this._deployCommon = new DeployCommon(this); // repo
-        this._lifecycleCommon = new LifecycleCommon(this); // repo
-        this._enumPool = new EnumPool(this); // complex
+        this._repoCommon = new RepoCommon(this);
+        this._errorCommon = new ErrorCommon(this);
+        this._logCommon = new LogCommon(this);
+        this._eventCommon = new EventCommon(this);
+        this._deployCommon = new DeployCommon(this);
+        this._lifecycleCommon = new LifecycleCommon(this);
+        this._enumPool = new EnumPool(this);
         this._errorPool = new ErrorPool(this);
         this._literalPool = new LiteralPool(this);
-        // endregion instances
-        // region instance-ops
         this._logger = this._logCommon.of(Leyyo);
-        // endregion instance-ops
-        // region final
         this._startToConsume();
-        // endregion final
     }
     _startToConsume() {
         this.logCommon.initConsume();
@@ -88,7 +80,4 @@ class Leyyo {
         return this._logger;
     }
 }
-/**
- * Leyyo common instance
- * */
 export const leyyo = new Leyyo();

package/dist/class/index.d.ts

@@ -1,2 +1,2 @@
-export * from './index.types.js';
-export * from './list.js';
+export * from "./index.types.js";
+export * from "./list.js";

package/dist/class/index.js

@@ -1,2 +1,2 @@
-export * from './index.types.js';
-export * from './list.js';
+export * from "./index.types.js";
+export * from "./list.js";

package/dist/class/index.types.d.ts

@@ -2,29 +2,9 @@ import { Logger } from "../common/index.js";
 export interface LoggerInstanceCtor {
     new (name: string): Logger;
 }
-/**
- * Extended array interface, ie: Clearable arrays
- * */
 export interface ListLike<T = unknown> extends Array<T> {
-    /**
-     * Clears array items, to align all iteration repositories, like Set, Map etc
-     *
-     * @return {number} - returns deleted count
-     * */
     clear(): number;
-    /**
-     * Deletes given item
-     *
-     * @param {any} value - will be deleted record
-     * @return {boolean} - is deleted?
-     * */
     delete(value: T): boolean;
-    /**
-     * Deletes by given predicate
-     *
-     * @param {function} predicate - lambda expression
-     * @return {boolean} - is deleted?
-     * */
     deleteByLambda(predicate: ListPredicate<T>): boolean;
 }
 export type ListPredicate<T = unknown> = (value: T, index?: number, arr?: Array<T>) => T;

package/dist/class/list.d.ts

@@ -1,13 +1,7 @@
 import { ListLike, ListPredicate } from "./index.types.js";
-/**
- * Extended array class, ie: Clearable arrays
- * */
 export declare class List<T = unknown> extends Array<T> implements ListLike<T> {
     constructor(...items: Array<T>);
-    /** @inheritDoc */
     clear(): number;
-    /** @inheritDoc */
     delete(value: T): boolean;
-    /** @inheritDoc */
     deleteByLambda(predicate: ListPredicate<T>): boolean;
 }

package/dist/class/list.js

@@ -1,17 +1,12 @@
-/**
- * Extended array class, ie: Clearable arrays
- * */
 export class List extends Array {
     constructor(...items) {
         super(...items);
     }
-    /** @inheritDoc */
     clear() {
         const size = this.length;
         this.splice(0, this.length);
         return size;
     }
-    /** @inheritDoc */
     delete(value) {
         const index = this.indexOf(value);
         if (index >= 0) {
@@ -20,7 +15,6 @@ export class List extends Array {
         }
         return false;
     }
-    /** @inheritDoc */
     deleteByLambda(predicate) {
         const index = this.findIndex(predicate);
         if (index >= 0) {

package/dist/class/logger.instance.d.ts

@@ -7,20 +7,15 @@ export declare class LoggerInstance implements Logger, LoggerSecure {
     private _name;
     constructor(name: string);
     static [KEY_LEYYO_SECURE](leyyo: LeyyoLike): void;
-    debug(message: any, params?: any | Opt): void;
-    trace(message: any, params?: any | Opt): void;
-    info(message: any, params?: any | Opt): void;
-    warn(message: any, params?: any | Opt): void;
-    error(message: any, params?: any | Opt): void;
-    fatal(message: any, params?: any | Opt): void;
-    /** @inheritDoc */
+    debug(message: unknown, params?: unknown | Opt): void;
+    trace(message: unknown, params?: unknown | Opt): void;
+    info(message: unknown, params?: unknown | Opt): void;
+    warn(message: unknown, params?: unknown | Opt): void;
+    error(message: unknown, params?: unknown | Opt): void;
+    fatal(message: unknown, params?: unknown | Opt): void;
     get $back(): Logger;
-    /** @inheritDoc */
     get $secure(): LoggerSecure;
-    /** @inheritDoc */
     get $name(): string;
-    /** @inheritDoc */
     $refreshName(name: string): void;
-    /** @inheritDoc */
     $refreshLevels(level: LogLevel): void;
 }

package/dist/class/logger.instance.js

@@ -1,9 +1,6 @@
 import { isText } from "../function/index.js";
 import { KEY_LEYYO_SECURE } from "../const/index.js";
-// region property
 let _leyyo;
-// endregion property
-// noinspection JSUnusedLocalSymbols
 export class LoggerInstance {
     _name;
     constructor(name) {
@@ -12,54 +9,44 @@ export class LoggerInstance {
         }
         this._name = name;
     }
-    // region static
     static [KEY_LEYYO_SECURE](leyyo) {
         if (!_leyyo) {
             _leyyo = leyyo;
         }
     }
-    // endregion static
-    // region levels
     debug(message, params) {
-        _leyyo.logCommon.emitLog('debug', this._name, message, params);
+        _leyyo.logCommon.emitLog("debug", this._name, message, params);
     }
     trace(message, params) {
-        _leyyo.logCommon.emitLog('trace', this._name, message, params);
+        _leyyo.logCommon.emitLog("trace", this._name, message, params);
     }
     info(message, params) {
-        _leyyo.logCommon.emitLog('info', this._name, message, params);
+        _leyyo.logCommon.emitLog("info", this._name, message, params);
     }
     warn(message, params) {
-        _leyyo.logCommon.emitLog('warn', this._name, message, params);
+        _leyyo.logCommon.emitLog("warn", this._name, message, params);
     }
     error(message, params) {
-        _leyyo.logCommon.emitLog('error', this._name, message, params);
+        _leyyo.logCommon.emitLog("error", this._name, message, params);
     }
     fatal(message, params) {
-        _leyyo.logCommon.emitLog('fatal', this._name, message, params);
+        _leyyo.logCommon.emitLog("fatal", this._name, message, params);
     }
-    // endregion levels
-    // region secure
-    /** @inheritDoc */
     get $back() {
         return this;
     }
-    /** @inheritDoc */
     get $secure() {
         return this;
     }
-    /** @inheritDoc */
     get $name() {
         return this._name;
     }
-    /** @inheritDoc */
     $refreshName(name) {
         if (!isText(name)) {
             return;
         }
         this._name = name;
     }
-    /** @inheritDoc */
     $refreshLevels(level) {
         if (!isText(level)) {
             return;
@@ -73,22 +60,22 @@ export class LoggerInstance {
             fatal: true,
         };
         switch (level) {
-            case 'debug':
+            case "debug":
                 rec.debug = true;
                 rec.trace = true;
                 rec.info = true;
                 rec.warn = true;
                 break;
-            case 'trace':
+            case "trace":
                 rec.trace = true;
                 rec.info = true;
                 rec.warn = true;
                 break;
-            case 'info':
+            case "info":
                 rec.info = true;
                 rec.warn = true;
                 break;
-            case 'warn':
+            case "warn":
                 rec.warn = true;
                 break;
             default:
@@ -99,8 +86,7 @@ export class LoggerInstance {
                 this[k] = (message, params) => _leyyo.logCommon.emitLog(k, this._name, message, params);
             }
             else {
-                this[k] = (_message, _params) => {
-                };
+                this[k] = (_message, _params) => { };
             }
         }
     }

package/dist/common/deploy.common.d.ts

@@ -1,26 +1,10 @@
 import { Fnc, LeyyoLike } from "../base/index.js";
 import { DeployCommonLike } from "./index.types.js";
-/**
- * Deploy common interface
- * */
 export declare class DeployCommon implements DeployCommonLike {
     private leyyo;
     private _waitingCallbacks;
     private _alreadyDeployed;
     constructor(leyyo: LeyyoLike);
-    /**
-     * Wait deploy of a component
-     *
-     * @param {string} name - name of component
-     * @param {function} callback - callback for creator of component, if it completes it, this callback will be called
-     * */
     wait(name: string, callback: Fnc): void;
-    /**
-     * Complete deploy of a component
-     * - It should be called by owner of component
-     *
-     * @param {string} name - name of component
-     * @param {...Array} values - They will be sent to callback of waiting component, {@link #wait}
-     * */
     complete(name: string, ...values: Array<unknown>): void;
 }

package/dist/common/deploy.common.js

@@ -1,10 +1,6 @@
 import { FQN } from "../internal.js";
 import { isText, testCase } from "../function/index.js";
 const where = `${FQN}.DeployCommon`;
-// noinspection JSUnusedGlobalSymbols
-/**
- * Deploy common interface
- * */
 export class DeployCommon {
     leyyo;
     _waitingCallbacks;
@@ -14,17 +10,11 @@ export class DeployCommon {
         this._waitingCallbacks = this.leyyo.repoCommon.newMap(`${where}.waitingCallbacks`);
         this._alreadyDeployed = this.leyyo.repoCommon.newMap(`${where}.alreadyDeployed`);
     }
-    /**
-     * Wait deploy of a component
-     *
-     * @param {string} name - name of component
-     * @param {function} callback - callback for creator of component, if it completes it, this callback will be called
-     * */
     wait(name, callback) {
         if (!isText(name)) {
-            throw new this.leyyo.developerError('Invalid component name', testCase(FQN, 120), where);
+            throw new this.leyyo.developerError("Invalid component name", testCase(FQN, 120), where);
         }
-        if (typeof callback !== 'function') {
+        if (typeof callback !== "function") {
             throw new this.leyyo.developerError(`Invalid caller callback [${name}]`, testCase(FQN, 121), where);
         }
         if (this._alreadyDeployed.has(name)) {
@@ -41,16 +31,9 @@ export class DeployCommon {
         }
         this._waitingCallbacks.get(name).push(callback);
     }
-    /**
-     * Complete deploy of a component
-     * - It should be called by owner of component
-     *
-     * @param {string} name - name of component
-     * @param {...Array} values - They will be sent to callback of waiting component, {@link #wait}
-     * */
     complete(name, ...values) {
         if (!isText(name)) {
-            throw new this.leyyo.developerError('Invalid component name', testCase(FQN, 123), where);
+            throw new this.leyyo.developerError("Invalid component name", testCase(FQN, 123), where);
         }
         const isNew = !this._alreadyDeployed.has(name);
         this._alreadyDeployed.set(name, values);
@@ -58,7 +41,7 @@ export class DeployCommon {
             if (this._waitingCallbacks.has(name)) {
                 const callbacks = this._waitingCallbacks.get(name);
                 this._waitingCallbacks.delete(name);
-                callbacks.forEach(callback => {
+                callbacks.forEach((callback) => {
                     try {
                         callback(...values);
                     }

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

@@ -1,25 +1,17 @@
 import { Inert } from "./inert.js";
-import { Enum, EnumItemConfig, EnumPoolItem, EnumPoolLike, EnumPoolOpt } from "./index.types.js";
-import { LeyyoLike } from "../base/index.js";
-/**
- * Enum pool for call with name and lazy loading
- * */
+import { Enum, EnumItemConfig, EnumNonFunctional, EnumPoolItem, EnumPoolLike, EnumPoolOpt } from "./index.types.js";
+import { KeyValue, LeyyoLike } from "../base/index.js";
 export declare class EnumPool extends Inert<EnumPoolItem, Enum, EnumPoolOpt> implements EnumPoolLike {
     protected leyyo: LeyyoLike;
     constructor(leyyo: LeyyoLike);
-    /** @inheritDoc */
     protected _getName(enm: Enum): string;
-    /** @inheritDoc */
     protected _nextLoad(item: EnumPoolItem): Promise<void>;
-    /** @inheritDoc */
     protected _setName(enm: Enum, name: string): string;
-    /** @inheritDoc */
     protected _afterTargetFound(item: EnumPoolItem): void;
-    /** @inheritDoc */
     protected _validate(enm: Enum): boolean;
-    /** @inheritDoc */
     setConfigItem(enm: Enum, conf: EnumItemConfig): void;
     getConfigItem(enm: Enum): EnumItemConfig;
-    /** @inheritDoc */
-    define(fqn: string, name: string, target: Enum, opt?: Omit<EnumPoolOpt, 'name' | 'target' | 'lazyTarget' | 'fqn'>): void;
+    define(fqn: string, name: string, target: Enum, opt?: Omit<EnumPoolOpt, "name" | "target" | "lazyTarget" | "fqn">): void;
+    toLiteral<E extends KeyValue = KeyValue>(enm: Enum<E>): ReadonlyArray<EnumNonFunctional<E>>;
+    merge<N>(...maps: Enum[]): N;
 }

package/dist/common/enum.pool.js

@@ -1,24 +1,17 @@
 import { Inert } from "./inert.js";
-import { getSymbol, isEmpty, isFilledObj, isObj, isText, setSymbol, testCase } from "../function/index.js";
+import { getSymbol, isEmpty, isFilledObj, isObj, isText, setSymbol, testCase, } from "../function/index.js";
 import { FQN } from "../internal.js";
 import { KEY_ENUM_ALT, KEY_ENUM_I18N, KEY_ENUM_NAME } from "../const/index.js";
 const where = `${FQN}.EnumPool`;
-// noinspection JSUnusedGlobalSymbols
-/**
- * Enum pool for call with name and lazy loading
- * */
 export class EnumPool extends Inert {
     leyyo;
     constructor(leyyo) {
-        super(leyyo, 'enum', {});
+        super(leyyo, "enum", {});
         this.leyyo = leyyo;
     }
-    // region protected
-    /** @inheritDoc */
     _getName(enm) {
         return this.getConfigItem(enm)?.name;
     }
-    /** @inheritDoc */
     async _nextLoad(item) {
         if (item.target && item.lazyAlt) {
             try {
@@ -27,12 +20,11 @@ export class EnumPool extends Inert {
                 this.setConfigItem(item.target, item);
             }
             catch (e) {
-                new this.leyyo.developerError('Callback error during loading enum alternate data', testCase(FQN, 186), where).log(e);
+                new this.leyyo.developerError("Callback error during loading enum alternate data", testCase(FQN, 186), where).log(e);
             }
         }
         delete item.lazyAlt;
     }
-    /** @inheritDoc */
     _setName(enm, name) {
         if (isText(name)) {
             setSymbol(enm, KEY_ENUM_NAME, name);
@@ -40,7 +32,6 @@ export class EnumPool extends Inert {
         }
         return undefined;
     }
-    /** @inheritDoc */
     _afterTargetFound(item) {
         if (item.lazyTarget) {
             delete item.lazyTarget;
@@ -50,13 +41,9 @@ export class EnumPool extends Inert {
         }
         this.setConfigItem(item.target, item);
     }
-    /** @inheritDoc */
     _validate(enm) {
         return isFilledObj(enm);
     }
-    // endregion protected
-    // region public
-    /** @inheritDoc */
     setConfigItem(enm, conf) {
         if (!isObj(conf)) {
             return;
@@ -81,8 +68,20 @@ export class EnumPool extends Inert {
             alt: getSymbol(enm, KEY_ENUM_ALT),
         };
     }
-    /** @inheritDoc */
     define(fqn, name, target, opt) {
         this.register({ ...(opt ?? {}), fqn, name, target });
     }
+    toLiteral(enm) {
+        return Object.keys(enm)
+            .filter((key) => isNaN(Number(key)))
+            .map((key) => enm[key])
+            .filter((val) => ["number", "string"].includes(typeof val));
+    }
+    merge(...maps) {
+        let result = {};
+        maps.forEach((item) => {
+            result = { ...result, ...item };
+        });
+        return result;
+    }
 }