@leyyo/common 1.3.19 → 1.3.20

package/dist/common/repo.common.d.ts

@@ -4,34 +4,222 @@ import { LeyyoLike } from "../base/index.js";
 export declare class RepoCommon implements RepoCommonLike {
     private leyyo;
     private static _created;
+    /**
+     * Internal items which stores arrays
+     * */
     private _arrayItems;
+    /**
+     * Internal array volatile repo which could be cleared after lifecycle run
+     * */
     private _arrayVolatiles;
+    /**
+     * Internal items which stores lists
+     * */
     private _listItems;
+    /**
+     * Internal list volatiles repo which could be cleared after lifecycle run
+     * */
     private _listVolatiles;
+    /**
+     * Internal items which stores maps
+     * */
     private _mapItems;
+    /**
+     * Internal map volatile repo which could be cleared after lifecycle run
+     * */
     private _mapVolatiles;
+    /**
+     * Internal items which stores sets
+     * */
     private _setItems;
+    /**
+     * Internal set volatiles repo which could be cleared after lifecycle run
+     * */
     private _setVolatiles;
     constructor(leyyo: LeyyoLike);
+    /**
+     * Create new array
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {Array<any>}
+     * */
     newArray<V>(name: string, volatile?: boolean): Array<V>;
+    /**
+     * Remove array by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeArray(key: symbol): number;
+    /**
+     * Clear array by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearArray(key: symbol): number;
+    /**
+     * List all array keys
+     *
+     * @return {Array<symbol>}
+     * */
     listArrays(): Array<symbol>;
+    /**
+     * Print all arrays
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printArrays(): Record<string, number>;
+    /**
+     * Create new list
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {List<any>}
+     * */
     newList<V>(name: string, volatile?: boolean): List<V>;
+    /**
+     * Remove list by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeList(key: symbol): number;
+    /**
+     * Clear list by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearList(key: symbol): number;
+    /**
+     * List all list keys
+     *
+     * @return {Array<symbol>}
+     * */
     listLists(): Array<symbol>;
+    /**
+     * Print all lists
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printLists(): Record<string, number>;
+    /**
+     * Create new map
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {Map<any, any>}
+     * */
     newMap<K, V>(name: string, volatile?: boolean): Map<K, V>;
+    /**
+     * Remove map by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeMap(key: symbol): number;
+    /**
+     * Clear map by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearMap(key: symbol): number;
+    /**
+     * List all map keys
+     *
+     * @return {Array<symbol>}
+     * */
     listMaps(): Array<symbol>;
+    /**
+     * Print all maps
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printMaps(): Record<string, number>;
+    /**
+     * Create new set
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {Set<any>}
+     * */
     newSet<V>(name: string, volatile?: boolean): Set<V>;
+    /**
+     * Remove set by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeSet(key: symbol): number;
+    /**
+     * Clear set by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearSet(key: symbol): number;
+    /**
+     * List all set keys
+     *
+     * @return {Array<symbol>}
+     * */
     listSets(): Array<symbol>;
+    /**
+     * Print all sets
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printSets(): Record<string, number>;
     init(): void;
 }

package/dist/common/repo.common.js

@@ -3,19 +3,49 @@ import { isText, testCase } from "../function/index.js";
 import { DeveloperError } from "../error/index.js";
 import { List } from "../class/index.js";
 import { getRootStorage } from "../sys/index.js";
+/**
+ * Identifier of file
+ * */
 const where = `${FQN}.Repo`;
 const _NAME = "$$leyyo.repo";
+// noinspection JSUnusedGlobalSymbols
 export class RepoCommon {
     leyyo;
+    // region property
     static _created;
+    /**
+     * Internal items which stores arrays
+     * */
     _arrayItems = getRootStorage(_NAME, new Map());
+    /**
+     * Internal array volatile repo which could be cleared after lifecycle run
+     * */
     _arrayVolatiles = getRootStorage(_NAME, new Set());
+    /**
+     * Internal items which stores lists
+     * */
     _listItems = getRootStorage(_NAME, new Map());
+    /**
+     * Internal list volatiles repo which could be cleared after lifecycle run
+     * */
     _listVolatiles = getRootStorage(_NAME, new Set());
+    /**
+     * Internal items which stores maps
+     * */
     _mapItems = getRootStorage(_NAME, new Map());
+    /**
+     * Internal map volatile repo which could be cleared after lifecycle run
+     * */
     _mapVolatiles = getRootStorage(_NAME, new Set());
+    /**
+     * Internal items which stores sets
+     * */
     _setItems = getRootStorage(_NAME, new Map());
+    /**
+     * Internal set volatiles repo which could be cleared after lifecycle run
+     * */
     _setVolatiles = getRootStorage(_NAME, new Set());
+    // endregion property
     constructor(leyyo) {
         this.leyyo = leyyo;
         if (RepoCommon._created) {
@@ -23,6 +53,14 @@ export class RepoCommon {
         }
         RepoCommon._created = true;
     }
+    // region array
+    /**
+     * Create new array
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {Array<any>}
+     * */
     newArray(name, volatile) {
         if (!isText(name)) {
             throw new DeveloperError("Invalid repository array name", testCase(FQN, 140), where);
@@ -35,6 +73,17 @@ export class RepoCommon {
         }
         return item;
     }
+    /**
+     * Remove array by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeArray(key) {
         const cleared = this.clearArray(key);
         if (cleared >= 0) {
@@ -45,6 +94,17 @@ export class RepoCommon {
         }
         return cleared;
     }
+    /**
+     * Clear array by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearArray(key) {
         if (typeof key !== "symbol") {
             return -2;
@@ -57,9 +117,21 @@ export class RepoCommon {
         item.splice(0, length);
         return length;
     }
+    /**
+     * List all array keys
+     *
+     * @return {Array<symbol>}
+     * */
     listArrays() {
         return Array.from(this._arrayItems.keys());
     }
+    /**
+     * Print all arrays
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printArrays() {
         const result = {};
         let index = 0;
@@ -76,6 +148,15 @@ export class RepoCommon {
         }
         return result;
     }
+    // endregion array
+    // region list
+    /**
+     * Create new list
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {List<any>}
+     * */
     newList(name, volatile) {
         if (!isText(name)) {
             throw new DeveloperError("Invalid repository list name", testCase(FQN, 141), where);
@@ -88,6 +169,17 @@ export class RepoCommon {
         }
         return item;
     }
+    /**
+     * Remove list by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeList(key) {
         const cleared = this.clearList(key);
         if (cleared >= 0) {
@@ -98,6 +190,17 @@ export class RepoCommon {
         }
         return cleared;
     }
+    /**
+     * Clear list by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearList(key) {
         if (typeof key !== "symbol") {
             return -2;
@@ -110,9 +213,21 @@ export class RepoCommon {
         item.clear();
         return length;
     }
+    /**
+     * List all list keys
+     *
+     * @return {Array<symbol>}
+     * */
     listLists() {
         return Array.from(this._listItems.keys());
     }
+    /**
+     * Print all lists
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printLists() {
         const result = {};
         let index = 0;
@@ -129,6 +244,15 @@ export class RepoCommon {
         }
         return result;
     }
+    // endregion list
+    // region map
+    /**
+     * Create new map
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {Map<any, any>}
+     * */
     newMap(name, volatile) {
         if (!isText(name)) {
             throw new DeveloperError("Invalid repository map name", testCase(FQN, 142), where);
@@ -141,6 +265,17 @@ export class RepoCommon {
         }
         return item;
     }
+    /**
+     * Remove map by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeMap(key) {
         const cleared = this.clearMap(key);
         if (cleared >= 0) {
@@ -151,6 +286,17 @@ export class RepoCommon {
         }
         return cleared;
     }
+    /**
+     * Clear map by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearMap(key) {
         if (typeof key !== "symbol") {
             return -2;
@@ -163,9 +309,22 @@ export class RepoCommon {
         item.clear();
         return length;
     }
+    /**
+     * List all map keys
+     *
+     * @return {Array<symbol>}
+     * */
     listMaps() {
         return Array.from(this._mapItems.keys());
     }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Print all maps
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printMaps() {
         const result = {};
         let index = 0;
@@ -182,6 +341,15 @@ export class RepoCommon {
         }
         return result;
     }
+    // endregion map
+    // region set
+    /**
+     * Create new set
+     *
+     * @param {string} name - name of collection
+     * @param {boolean} volatile - if yes: it will be removed after lifecycle run
+     * @return {Set<any>}
+     * */
     newSet(name, volatile) {
         if (!isText(name)) {
             throw new DeveloperError("Invalid repository set name", testCase(FQN, 143), where);
@@ -194,6 +362,18 @@ export class RepoCommon {
         }
         return item;
     }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Remove set by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of removed items in collection
+     * */
     removeSet(key) {
         const cleared = this.clearSet(key);
         if (cleared >= 0) {
@@ -204,6 +384,17 @@ export class RepoCommon {
         }
         return cleared;
     }
+    /**
+     * Clear set by given key
+     *
+     * @param {symbol} key - key of collection
+     * @return {number}
+     *
+     * Return possibilities:
+     *  - `-2`: key is not valid symbol
+     *  - `-1`: key does not exist
+     *  - `>= 0`: length of cleared items in collection
+     * */
     clearSet(key) {
         if (typeof key !== "symbol") {
             return -2;
@@ -216,9 +407,23 @@ export class RepoCommon {
         item.clear();
         return length;
     }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * List all set keys
+     *
+     * @return {Array<symbol>}
+     * */
     listSets() {
         return Array.from(this._setItems.keys());
     }
+    // noinspection JSUnusedGlobalSymbols
+    /**
+     * Print all sets
+     *
+     * @return {Record} - as {key: length of collection}
+     *
+     * Note: if stringified symbol is duplicated, add index postfix with `#` symbol
+     * */
     printSets() {
         const result = {};
         let index = 0;
@@ -235,20 +440,26 @@ export class RepoCommon {
         }
         return result;
     }
+    // endregion set
+    // region secure
     init() {
         const lifecycle = this.leyyo.lifecycleCommon;
+        // clear volatile arrays
         lifecycle.addStage("clear", "repo.array", () => {
             Array.from(this._arrayVolatiles.values()).forEach((key) => this._arrayItems.delete(key));
             this._arrayVolatiles.clear();
         });
+        // clear volatile lists
         lifecycle.addStage("clear", "repo.list", () => {
             Array.from(this._listVolatiles.values()).forEach((key) => this._listItems.delete(key));
             this._listVolatiles.clear();
         });
+        // clear volatile maps
         lifecycle.addStage("clear", "repo.map", () => {
             Array.from(this._mapVolatiles.values()).forEach((key) => this._mapItems.delete(key));
             this._mapVolatiles.clear();
         });
+        // clear volatile sets
         lifecycle.addStage("clear", "repo.set", () => {
             Array.from(this._setVolatiles.values()).forEach((key) => this._setItems.delete(key));
             this._setVolatiles.clear();

package/dist/const/index.d.ts

@@ -1,5 +1,11 @@
 export declare const VAL_FQN_ANONYMOUS = "#Fqn";
+/**
+ * Normal empty values
+ * */
 export declare const EMPTY_VALUES: any[];
+/**
+ * Empty values with empty string
+ * */
 export declare const EMPTY_VALUES_STR: Array<unknown>;
 export declare const VAL_NAME_ANONYMOUS: string;
 export declare const VAL_ERROR_UNKNOWN_NAME: string;

package/dist/const/index.js

@@ -1,5 +1,12 @@
 export const VAL_FQN_ANONYMOUS = "#Fqn";
+/**
+ * Normal empty values
+ * */
 export const EMPTY_VALUES = [null, undefined];
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Empty values with empty string
+ * */
 export const EMPTY_VALUES_STR = [null, undefined, ""];
 export const VAL_NAME_ANONYMOUS = "~";
 export const VAL_ERROR_UNKNOWN_NAME = "UnknownError";

package/dist/enum/log-level.d.ts

@@ -1,4 +1,7 @@
 declare const literals: readonly ["debug", "trace", "info", "warn", "error", "fatal"];
+/**
+ * Log Level
+ * */
 export type LogLevel = (typeof literals)[number];
 export declare const LogLevelItems: ReadonlyArray<LogLevel>;
 export {};

package/dist/error/caused.error.d.ts

@@ -1,5 +1,15 @@
 import { LeyyoError } from "./leyyo.error.js";
 import { Opt } from "../function/index.js";
+/**
+ * Caused error
+ * */
 export declare class CausedError extends LeyyoError {
+    /**
+     * Cast a native error to caused error
+     *
+     * @param {Error} e - native error instance
+     * @param {Opt?} params - params for error
+     * @return {CausedError} - new caused error instance
+     * */
     static of(e: Error, params?: Opt): CausedError;
 }

package/dist/error/caused.error.js

@@ -1,5 +1,15 @@
 import { LeyyoError } from "./leyyo.error.js";
+/**
+ * Caused error
+ * */
 export class CausedError extends LeyyoError {
+    /**
+     * Cast a native error to caused error
+     *
+     * @param {Error} e - native error instance
+     * @param {Opt?} params - params for error
+     * @return {CausedError} - new caused error instance
+     * */
     static of(e, params) {
         const err = new CausedError(e.message, params);
         err.causedBy = e;

package/dist/error/developer.error.d.ts

@@ -1,11 +1,19 @@
 import { KEY_DEVELOPER_CASE, KEY_DEVELOPER_WHERE, KEY_LEYYO_SECURE } from "../const/index.js";
 import { LeyyoLike } from "../base/index.js";
 import { DeveloperErrorLike, ErrorStackLine } from "./index.types.js";
+/** Developer error */
 export declare class DeveloperError extends Error implements DeveloperErrorLike {
     protected [KEY_DEVELOPER_CASE]: string;
     protected [KEY_DEVELOPER_WHERE]: string;
+    /** @inheritDoc */
     stackTrace?: Array<ErrorStackLine>;
+    /**
+     * @param {string} message - error message
+     * @param {string} issue - test case
+     * @param {string} where - where
+     * */
     constructor(message: string, issue?: string, where?: string);
     static [KEY_LEYYO_SECURE](leyyo: LeyyoLike): void;
+    /** @inheritDoc */
     log(err?: Error): void;
 }

package/dist/error/developer.error.js

@@ -1,9 +1,18 @@
 import { KEY_DEVELOPER_CASE, KEY_DEVELOPER_WHERE, KEY_LEYYO_SECURE } from "../const/index.js";
+// region properties
 let _leyyo;
+// endregion properties
+/** Developer error */
 export class DeveloperError extends Error {
     [KEY_DEVELOPER_CASE];
     [KEY_DEVELOPER_WHERE];
+    /** @inheritDoc */
     stackTrace;
+    /**
+     * @param {string} message - error message
+     * @param {string} issue - test case
+     * @param {string} where - where
+     * */
     constructor(message, issue, where) {
         message = message ?? "Developer error";
         super(message);
@@ -20,6 +29,7 @@ export class DeveloperError extends Error {
             _leyyo = leyyo;
         }
     }
+    /** @inheritDoc */
     log(err) {
         if (err instanceof Error) {
             this["causedBy"] = err;