@leyyo/common 1.3.19 → 1.3.21

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

@@ -65,10 +65,22 @@ 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];
 };
@@ -78,16 +90,44 @@ 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> = {
@@ -138,10 +178,37 @@ 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 +1,33 @@
 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,2 +1,5 @@
 import { LeyyoLike } from "./leyyo.types.js";
+/**
+ * Leyyo common instance
+ * */
 export declare const leyyo: LeyyoLike;

package/dist/base/leyyo.js

@@ -18,6 +18,7 @@ class Leyyo {
     _logCommon;
     _logger;
     constructor() {
+        // region binding
         $$set_leyyo_fn(this);
         this._developerError = DeveloperError;
         this._developerError[KEY_LEYYO_SECURE](this);
@@ -25,17 +26,24 @@ class Leyyo {
         this._leyyoError[KEY_LEYYO_SECURE](this);
         this._loggerInstance = LoggerInstance;
         this._loggerInstance[KEY_LEYYO_SECURE](this);
-        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);
+        // 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._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();
@@ -80,4 +88,7 @@ class Leyyo {
         return this._logger;
     }
 }
+/**
+ * Leyyo common instance
+ * */
 export const leyyo = new Leyyo();

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

@@ -2,9 +2,29 @@ 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,7 +1,13 @@
 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,12 +1,17 @@
+/**
+ * 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) {
@@ -15,6 +20,7 @@ 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

@@ -13,9 +13,14 @@ export declare class LoggerInstance implements Logger, LoggerSecure {
     warn(message: unknown, params?: unknown | Opt): void;
     error(message: unknown, params?: unknown | Opt): void;
     fatal(message: unknown, params?: unknown | Opt): void;
+    /** @inheritDoc */
     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,6 +1,9 @@
 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) {
@@ -9,11 +12,14 @@ 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);
     }
@@ -32,21 +38,28 @@ export class LoggerInstance {
     fatal(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;

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

@@ -1,10 +1,26 @@
 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,6 +1,10 @@
 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;
@@ -10,6 +14,12 @@ 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);
@@ -31,6 +41,13 @@ 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);

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

@@ -1,16 +1,26 @@
 import { Inert } from "./inert.js";
 import { Enum, EnumItemConfig, EnumNonFunctional, EnumPoolItem, EnumPoolLike, EnumPoolOpt } from "./index.types.js";
 import { KeyValue, LeyyoLike } from "../base/index.js";
+/**
+ * Enum pool for call with name and lazy loading
+ * */
 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;
     toLiteral<E extends KeyValue = KeyValue>(enm: Enum<E>): ReadonlyArray<EnumNonFunctional<E>>;
     merge<N>(...maps: Enum[]): N;

package/dist/common/enum.pool.js

@@ -3,15 +3,22 @@ import { getSymbol, isEmpty, isFilledObj, isObj, isText, setSymbol, testCase, }
 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", {});
         this.leyyo = leyyo;
     }
+    // region protected
+    /** @inheritDoc */
     _getName(enm) {
         return this.getConfigItem(enm)?.name;
     }
+    /** @inheritDoc */
     async _nextLoad(item) {
         if (item.target && item.lazyAlt) {
             try {
@@ -25,6 +32,7 @@ export class EnumPool extends Inert {
         }
         delete item.lazyAlt;
     }
+    /** @inheritDoc */
     _setName(enm, name) {
         if (isText(name)) {
             setSymbol(enm, KEY_ENUM_NAME, name);
@@ -32,6 +40,7 @@ export class EnumPool extends Inert {
         }
         return undefined;
     }
+    /** @inheritDoc */
     _afterTargetFound(item) {
         if (item.lazyTarget) {
             delete item.lazyTarget;
@@ -41,9 +50,13 @@ 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;
@@ -68,6 +81,7 @@ export class EnumPool extends Inert {
             alt: getSymbol(enm, KEY_ENUM_ALT),
         };
     }
+    /** @inheritDoc */
     define(fqn, name, target, opt) {
         this.register({ ...(opt ?? {}), fqn, name, target });
     }

package/dist/common/error.common.d.ts

@@ -8,21 +8,51 @@ export declare class ErrorCommon implements ErrorCommonLike {
     private _stats;
     readonly started: Date;
     constructor(leyyo: LeyyoLike);
+    /**
+     * Transform error as a bare object
+     *
+     * @param {Error} err - error instance
+     * @param {Opt} existing - existing parameters
+     * @param {boolean} ignoreNameMessage - ignore name & message?
+     * @param {WeakSet} weakSet - weak set to prevent duplicates
+     * @return {Opt?} - bare error object
+     * */
     private _toErrorJson;
+    /**
+     * Build error info part as `<part1/part2>`
+     *
+     * @param {Array<string|number>} parts - parts for info
+     * @return {string}
+     * */
     private _buildTextParts;
+    /** @inheritDoc */
     setConfigItem(clazz: ClassLike, conf: ErrorItemConfig): void;
+    /** @inheritDoc */
     getConfigItem(clazz: ClassLike): ErrorItemConfig;
+    /** @inheritDoc */
     emit(err: Error): void;
+    /** @inheritDoc */
     buildStack(source: Error, force?: boolean): void;
+    /** @inheritDoc */
     toJsonBasic(err: Error, existing?: Opt): Opt;
+    /** @inheritDoc */
     toJsonFull(err: Error, existing: Opt): Opt;
+    /** @inheritDoc */
     cast<E extends LeyyoErrorLike>(e: Error, params?: Opt): E;
+    /** @inheritDoc */
     forcedCast<E extends LeyyoErrorLike>(clazz: ClassLike, e: Error, params?: Opt): E;
+    /** @inheritDoc */
     addKnownPackage(packageName: string, shortName: string): void;
+    /** @inheritDoc */
     bareObj(err: Error): ErrorObject;
+    /** @inheritDoc */
     text(err: Error, ...parts: Array<string | number>): string;
+    /** @inheritDoc */
     addStat(p1: Error | ErrorCtor): number;
+    /** @inheritDoc */
     getStat(p1: Error | ErrorCtor): number;
+    /** @inheritDoc */
     clearStats(): void;
+    /** @inheritDoc */
     listStats(): Record<string, number>;
 }