@leyyo/common 1.3.19 → 1.3.20

package/dist/error/http.error.d.ts

@@ -1,8 +1,21 @@
 import { LeyyoError } from "./leyyo.error.js";
 import { Opt } from "../function/index.js";
+/**
+ * Http error
+ * */
 export declare class HttpError extends LeyyoError {
     status: number;
+    /**
+     * @param {string} message - error message
+     * */
     constructor(message: string);
+    /**
+     * @param {Opt} params - error parameters
+     * */
     constructor(params: Opt);
+    /**
+     * @param {string} message - error message
+     * @param {Opt} params - error parameters
+     * */
     constructor(message: string, params: Opt);
 }

package/dist/error/http.error.js

@@ -1,7 +1,14 @@
 import { LeyyoError } from "./leyyo.error.js";
 import { KEY_ERROR_DEFAULT_MESSAGE, KEY_ERROR_HTTP_STATUS } from "../const/index.js";
+/**
+ * Http error
+ * */
 export class HttpError extends LeyyoError {
     status;
+    /**
+     * @param {(string|Opt)} p1 - error message or error parameters
+     * @param {Opt?} p2 - error parameters
+     * */
     constructor(p1, p2) {
         super(p1, p2);
         const clazz = this.constructor;

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

@@ -1,46 +1,195 @@
 import { ClassLike, Obj, OneOrMore, ShiftMain, ShiftSecure } from "../base/index.js";
 import { Opt } from "../function/index.js";
 import { Logger } from "../common/index.js";
+/**
+ * {@link LeyyoError}
+ * */
 export interface LeyyoErrorCtor {
+    /**
+     * Create without any parameter
+     * */
     new (): LeyyoErrorLike;
+    /**
+     * Create with only message
+     *
+     * @param {string} message - error message
+     * */
     new (message: string): LeyyoErrorLike;
+    /**
+     * Create with only params
+     *
+     * @param {Opt} params - error parameters
+     * */
     new (params: Opt): LeyyoErrorLike;
+    /**
+     * Create with message and params
+     *
+     * @param {string} message - error message
+     * @param {Opt} params - error parameters
+     * */
     new (message: string, params: Opt): LeyyoErrorLike;
 }
+/**
+ * {@link DeveloperError}
+ * */
 export interface DeveloperErrorCtor {
+    /**
+     * Create developer error
+     *
+     * @param {string} message - error message
+     * @param {string} issue - test case
+     * @param {string} where - where
+     * */
     new (message: string, issue?: string, where?: string): DeveloperErrorLike;
 }
 export type LeyyoErrorTag = "printed" | "sent";
+/**
+ * Stack line
+ * */
 export interface ErrorStackLine {
+    /**
+     * File of error
+     * */
     file: string;
+    /**
+     * Method of error
+     * */
     method?: string;
+    /**
+     * Position of error
+     * */
     pos?: string;
 }
 export interface DeveloperErrorLike extends Error {
+    /**
+     * Formatted stack trace
+     * */
     stackTrace?: Array<ErrorStackLine>;
+    /**
+     * Log error
+     *
+     * @param {Error?} err - optional caused error
+     * */
     log(err?: Error): void;
 }
 export interface LeyyoErrorLike extends Error, ShiftSecure<LeyyoErrorSecure> {
+    /**
+     * Parameters for error
+     * */
     params?: Opt;
+    /**
+     * Formatted stack trace
+     * */
     stackTrace?: Array<ErrorStackLine>;
+    /**
+     * Caused error
+     * */
     causedBy?: OneOrMore<Error>;
+    /**
+     * Bind caused error
+     *
+     * @param {Error} err
+     * @return {LeyyoErrorLike}
+     * */
     causes(err: Error): this;
+    /**
+     * Bind holder class name
+     *
+     * @param {string} name - name of class
+     * @param {string?} fqn - fqn
+     * @return {LeyyoErrorLike}
+     * */
     where(name: string, fqn?: string): this;
+    /**
+     * Bind holder instance
+     *
+     * @param {Obj} instance - this instance
+     * @return {LeyyoErrorLike}
+     * */
     where(instance: Obj): this;
+    /**
+     * Bind holder instance
+     *
+     * @param {function} clazz - class
+     * @return {LeyyoErrorLike}
+     * */
     where(clazz: ClassLike): this;
+    /**
+     * Alias for {@link logError}
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
     log(logger?: Logger): void;
+    /**
+     * Log as `fatal`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
     logFatal(logger?: Logger): void;
+    /**
+     * Log as `error`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
     logError(logger?: Logger): void;
+    /**
+     * Log as `warn`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
     logWarn(logger?: Logger): void;
+    /**
+     * Log as `debug`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
     logDebug(logger?: Logger): void;
+    /**
+     * Log as `info`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
     logInfo(logger?: Logger): void;
+    /**
+     * Log as `trace`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
     logTrace(logger?: Logger): void;
 }
 export interface LeyyoErrorSecure extends ShiftMain<LeyyoErrorLike> {
     get $where(): string;
+    /**
+     * List flags
+     *
+     * @return {Array<string>} - flags
+     * */
     $list<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(): Array<T>;
+    /**
+     * Append a flag
+     *
+     * @param {string} key - flag key
+     * @return {boolean} - is it appended?
+     * */
     $append<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
+    /**
+     * Remove a flag
+     *
+     * @param {string} key - flag key
+     * @return {boolean} - is it removed?
+     * */
     $remove<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
+    /**
+     * Has a flag?
+     *
+     * @param {string} key - flag key
+     * @return {boolean} - has it?
+     * */
     $has<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
+    /**
+     * Copy source properties into target parameters
+     *
+     * @param {Error} source - source error
+     * */
     $copyProperties(source: Error): void;
 }

package/dist/error/invalid-value.error.d.ts

@@ -1,3 +1,6 @@
 import { LeyyoError } from "./leyyo.error.js";
+/**
+ * Invalid value error
+ * */
 export declare class InvalidValueError extends LeyyoError {
 }

package/dist/error/invalid-value.error.js

@@ -1,5 +1,8 @@
 import { LeyyoError } from "./leyyo.error.js";
 import { KEY_ERROR_DEFAULT_MESSAGE } from "../const/index.js";
+/**
+ * Invalid value error
+ * */
 export class InvalidValueError extends LeyyoError {
     static {
         this[KEY_ERROR_DEFAULT_MESSAGE] = "Invalid value";

package/dist/error/leyyo.error.d.ts

@@ -4,31 +4,64 @@ import { ClassLike, LeyyoLike, Obj, OneOrMore } from "../base/index.js";
 import { Opt } from "../function/index.js";
 import { KEY_ERROR_FLAGS, KEY_LEYYO_SECURE } from "../const/index.js";
 type T2 = LeyyoErrorTag;
+/**
+ * Leyyo base error
+ * */
 export declare class LeyyoError extends Error implements LeyyoErrorLike, LeyyoErrorSecure {
+    /**
+     * Error flags
+     * */
     private [KEY_ERROR_FLAGS];
+    /**
+     * Error parameters
+     * */
     params?: Opt;
+    /**
+     * Caused by error
+     * */
     causedBy?: OneOrMore<Error>;
+    /**
+     * Stack trace
+     * */
     stackTrace?: Array<ErrorStackLine>;
+    /**
+     * */
     constructor();
+    /**
+     * @param {string} message - error message
+     * */
     constructor(message: string);
+    /**
+     * @param {Opt} params - error parameters
+     * */
     constructor(params: Opt);
+    /**
+     * @param {string} message - error message
+     * @param {Opt} params - error parameters
+     * */
     constructor(message: string, params: Opt);
     static [KEY_LEYYO_SECURE](leyyo: LeyyoLike): void;
     causes(err: Error): this;
     where(p1: ClassLike | Obj | string, fqn?: string): this;
     private _log;
+    /** @inheritDoc */
     log(logger?: Logger): void;
     logFatal(logger?: Logger): void;
     logError(logger?: Logger): void;
+    /** @inheritDoc */
     logWarn(logger?: Logger): void;
+    /** @inheritDoc */
     logDebug(logger?: Logger): void;
+    /** @inheritDoc */
     logInfo(logger?: Logger): void;
+    /** @inheritDoc */
     logTrace(logger?: Logger): void;
     get $where(): string;
     $list<T extends T2 | string = T2 | string>(): Array<T>;
     $append<T extends T2 | string = T2 | string>(key: T): boolean;
     $remove<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
     $has<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
+    /** @inheritDoc */
     $copyProperties(source: Error): void;
     get $back(): LeyyoErrorLike;
     get $secure(): LeyyoErrorSecure;

package/dist/error/leyyo.error.js

@@ -1,13 +1,34 @@
 import { getFqn, getSymbol, isFilledObj, isObj, optAdd, optAppend, setSymbol, } from "../function/index.js";
 import { KEY_ERROR_FLAGS, KEY_ERROR_WHERE, KEY_LEYYO_SECURE, VAL_ERROR_UNKNOWN_MESSAGE, } from "../const/index.js";
 let _leyyo;
+// region property
 const _errorField = ["name", "message", "stack"];
 const _leyyoErrorFields = [..._errorField, "params", "causedBy", "stackTrace"];
+// endregion property
+/**
+ * Leyyo base error
+ * */
 export class LeyyoError extends Error {
+    /**
+     * Error flags
+     * */
     [KEY_ERROR_FLAGS];
+    /**
+     * Error parameters
+     * */
     params;
+    /**
+     * Caused by error
+     * */
     causedBy;
+    /**
+     * Stack trace
+     * */
     stackTrace;
+    /**
+     * @param {(string|Opt)?} p1 - error message or error parameters
+     * @param {Opt?} p2 - error parameters
+     * */
     constructor(p1, p2) {
         let message;
         let params;
@@ -38,6 +59,7 @@ export class LeyyoError extends Error {
             _leyyo = leyyo;
         }
     }
+    // region bind
     causes(err) {
         if (err instanceof Error) {
             if (!this.causedBy) {
@@ -74,6 +96,8 @@ export class LeyyoError extends Error {
         }
         return this;
     }
+    // endregion bind
+    // region log
     _log(level, logger) {
         if (logger) {
             logger[level](this);
@@ -82,6 +106,7 @@ export class LeyyoError extends Error {
             _leyyo.logCommon.emitLog(level, undefined, this, {});
         }
     }
+    /** @inheritDoc */
     log(logger) {
         this._log("error", logger);
     }
@@ -91,18 +116,24 @@ export class LeyyoError extends Error {
     logError(logger) {
         this._log("error", logger);
     }
+    /** @inheritDoc */
     logWarn(logger) {
         this._log("warn", logger);
     }
+    /** @inheritDoc */
     logDebug(logger) {
         this._log("debug", logger);
     }
+    /** @inheritDoc */
     logInfo(logger) {
         this._log("info", logger);
     }
+    /** @inheritDoc */
     logTrace(logger) {
         this._log("trace", logger);
     }
+    // endregion log
+    // region flags
     get $where() {
         return getSymbol(this, KEY_ERROR_WHERE);
     }
@@ -141,6 +172,9 @@ export class LeyyoError extends Error {
         }
         return this[KEY_ERROR_FLAGS].has(key);
     }
+    // endregion flags
+    // region methods
+    /** @inheritDoc */
     $copyProperties(source) {
         if (!(source instanceof Error)) {
             return;
@@ -170,6 +204,8 @@ export class LeyyoError extends Error {
             }
         }
     }
+    // endregion methods
+    // region modes
     get $back() {
         return this;
     }

package/dist/error/multiple.error.d.ts

@@ -1,7 +1,13 @@
 import { LeyyoErrorLike } from "./index.types.js";
 import { LeyyoError } from "./leyyo.error.js";
+/**
+ * Multiple error which manages multiple errors
+ * */
 export declare class MultipleError extends LeyyoError {
     causedBy: Array<LeyyoErrorLike>;
+    /**
+     * @param {...Error[]} errors
+     * */
     constructor(...errors: Array<Error>);
     push(...errors: Array<Error>): this;
 }

package/dist/error/multiple.error.js

@@ -1,6 +1,13 @@
 import { LeyyoError } from "./leyyo.error.js";
 import { CausedError } from "./caused.error.js";
+// noinspection Annotator
+/**
+ * Multiple error which manages multiple errors
+ * */
 export class MultipleError extends LeyyoError {
+    /**
+     * @param {...Error[]} errors
+     * */
     constructor(...errors) {
         const first = errors.length > 0 ? errors[0] : undefined;
         super(first?.message ?? "Multiple error", {});

package/dist/function/define-loader.d.ts

@@ -1,2 +1,8 @@
 import { LoaderItem, LoaderLike } from "./index.types.js";
+/**
+ * Set name of a loader
+ *
+ * @param {string} fqn - component name
+ * @param {...LoaderItem[]} items - items
+ * */
 export declare function defineLoader(fqn: string, ...items: Array<LoaderItem>): LoaderLike;

package/dist/function/define-loader.js

@@ -1,6 +1,12 @@
 import { isFilledArr } from "./is-filled-arr.js";
 import { isText } from "./is-text.js";
 import { KEY_LOADER_NAME } from "../const/index.js";
+/**
+ * Set name of a loader
+ *
+ * @param {string} fqn - component name
+ * @param {...LoaderItem[]} items - items
+ * */
 export function defineLoader(fqn, ...items) {
     if (!isText(fqn)) {
         fqn = `leyyo/@${Date.now()}`;

package/dist/function/delay.d.ts

@@ -1 +1,9 @@
+/**
+ * Delay or sleep n msec
+ *
+ * @param {number} waiting - waiting as milliseconds
+ * @param {any} response - response value
+ * @return {any}
+ * @async
+ * */
 export declare function delay<R = undefined>(waiting?: number, response?: R): Promise<R>;

package/dist/function/delay.js

@@ -1,3 +1,12 @@
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Delay or sleep n msec
+ *
+ * @param {number} waiting - waiting as milliseconds
+ * @param {any} response - response value
+ * @return {any}
+ * @async
+ * */
 export function delay(waiting, response) {
     if (typeof waiting !== "number" || waiting < 10) {
         waiting = Math.round(Math.random() * 1_000);

package/dist/function/delete-prop.d.ts

@@ -1,3 +1,24 @@
+/**
+ * Delete target property
+ *
+ * @param {any} target - target
+ * @param {string} key - key
+ * @return {boolean} - is deleted?
+ * */
 export declare function deleteKey(target: unknown, key: string): boolean;
+/**
+ * Delete target hidden property
+ *
+ * @param {any} target - target
+ * @param {symbol} key - hidden key
+ * @return {boolean} - is deleted?
+ * */
 export declare function deleteSymbol(target: unknown, key: symbol): boolean;
+/**
+ * Delete target property
+ *
+ * @param {any} target - target
+ * @param {(symbol|string)} key - key
+ * @return {boolean} - is deleted?
+ * */
 export declare function deleteProp(target: unknown, key: symbol | string): boolean;

package/dist/function/delete-prop.js

@@ -3,18 +3,39 @@ import { testCase } from "./test-case.js";
 import { $$get_leyyo_fn } from "./leyyo-fn.js";
 const where = `${FQN}.DeleteProp`;
 let _leyyo;
+/**
+ * Delete target property
+ *
+ * @param {any} target - target
+ * @param {string} key - key
+ * @return {boolean} - is deleted?
+ * */
 export function deleteKey(target, key) {
     if (typeof key !== "string") {
         return false;
     }
     return deleteProp(target, key);
 }
+/**
+ * Delete target hidden property
+ *
+ * @param {any} target - target
+ * @param {symbol} key - hidden key
+ * @return {boolean} - is deleted?
+ * */
 export function deleteSymbol(target, key) {
     if (typeof key !== "symbol") {
         return false;
     }
     return deleteProp(target, key);
 }
+/**
+ * Delete target property
+ *
+ * @param {any} target - target
+ * @param {(symbol|string)} key - key
+ * @return {boolean} - is deleted?
+ * */
 export function deleteProp(target, key) {
     if (!["symbol", "string"].includes(typeof key)) {
         return false;
@@ -27,6 +48,7 @@ export function deleteProp(target, key) {
         return true;
     }
     catch (e) {
+        // nothing
     }
     try {
         Object.defineProperty(target, key, {

package/dist/function/empty-fn.d.ts

@@ -1 +1,7 @@
+/**
+ * Empty function, it can be more useful sometimes
+ *
+ * @param {Arr} _args - insignificant parameters
+ * @return {any}
+ * */
 export declare function emptyFn<R = unknown>(..._args: Array<unknown>): R | void;

package/dist/function/empty-fn.js

@@ -1 +1,8 @@
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Empty function, it can be more useful sometimes
+ *
+ * @param {Arr} _args - insignificant parameters
+ * @return {any}
+ * */
 export function emptyFn(..._args) { }

package/dist/function/extended-type.d.ts

@@ -1,2 +1,8 @@
 import { ExtendedType } from "../base/index.js";
+/**
+ * Get extended type of value
+ *
+ * @param {any} value - given value
+ * @return {ExtendedType}
+ * */
 export declare function extendedType(value: unknown): ExtendedType;

package/dist/function/extended-type.js

@@ -1,6 +1,13 @@
 import { List } from "../class/list.js";
 import { KEY_ENUM_NAME, KEY_LITERAL_NAME } from "../const/index.js";
 import { isClass } from "./is-class.js";
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Get extended type of value
+ *
+ * @param {any} value - given value
+ * @return {ExtendedType}
+ * */
 export function extendedType(value) {
     let trimmed;
     switch (typeof value) {

package/dist/function/get-fqn.d.ts

@@ -1,2 +1,8 @@
 import { FqnTarget } from "./index.types.js";
+/**
+ * Get fqn name
+ *
+ * @param {FqnTarget} target - target (function, class, instance, enum, literal)
+ * @return {string} - fully qualified name
+ * */
 export declare function getFqn(target: FqnTarget): string;

package/dist/function/get-fqn.js

@@ -1,9 +1,16 @@
 import { KEY_ENUM_NAME, KEY_FQN_NAME, KEY_LITERAL_NAME } from "../const/index.js";
+/**
+ * Get fqn name
+ *
+ * @param {FqnTarget} target - target (function, class, instance, enum, literal)
+ * @return {string} - fully qualified name
+ * */
 export function getFqn(target) {
     if (!target) {
         return undefined;
     }
     if (typeof target === "function") {
+        // function, class
         return target[KEY_FQN_NAME] ?? target.name;
     }
     else if (typeof target === "object") {

package/dist/function/get-prop.d.ts

@@ -1,3 +1,24 @@
+/**
+ * Get target property
+ *
+ * @param {any} target - target
+ * @param {string} key - key
+ * @return {any}
+ * */
 export declare function getKey<T>(target: unknown, key: string): T;
+/**
+ * Get target hidden property
+ *
+ * @param {any} target - target
+ * @param {symbol} key - hidden key
+ * @return {any}
+ * */
 export declare function getSymbol<T>(target: unknown, key: symbol): T;
+/**
+ * Get target property
+ *
+ * @param {any} target - target
+ * @param {(symbol|string)} key - key
+ * @return {any}
+ * */
 export declare function getProp<T>(target: unknown, key: symbol | string): T;