@leyyo/common 1.3.19 → 1.3.21

package/dist/function/get-prop.js

@@ -3,18 +3,39 @@ import { testCase } from "./test-case.js";
 import { $$get_leyyo_fn } from "./leyyo-fn.js";
 const where = `${FQN}.GetProp`;
 let _leyyo;
+/**
+ * Get target property
+ *
+ * @param {any} target - target
+ * @param {string} key - key
+ * @return {any}
+ * */
 export function getKey(target, key) {
     if (typeof key !== "string") {
         return undefined;
     }
     return getProp(target, key);
 }
+/**
+ * Get target hidden property
+ *
+ * @param {any} target - target
+ * @param {symbol} key - hidden key
+ * @return {any}
+ * */
 export function getSymbol(target, key) {
     if (typeof key !== "symbol") {
         return undefined;
     }
     return getProp(target, key);
 }
+/**
+ * Get target property
+ *
+ * @param {any} target - target
+ * @param {(symbol|string)} key - key
+ * @return {any}
+ * */
 export function getProp(target, key) {
     if (!["symbol", "string"].includes(typeof key)) {
         return undefined;

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

@@ -39,20 +39,40 @@ export interface StatisticsOs {
     cpu: Array<StatisticsCpuInfo>;
 }
 export interface StatisticsMemory {
+    /**
+     * Resident Set Size, is the amount of space occupied in the main memory device (that is a subset of the total allocated memory) for the
+     * process, including all C++ and JavaScript objects and code.
+     */
     rss: number;
+    /**
+     * Refers to V8's memory usage.
+     */
     heapTotal: number;
+    /**
+     * Refers to V8's memory usage.
+     */
     heapUsed: number;
     external: number;
+    /**
+     * Refers to memory allocated for `ArrayBuffer`s and `SharedArrayBuffer`s, including all Node.js Buffers. This is also included
+     * in the external value. When Node.js is used as an embedded library, this value may be `0` because allocations for `ArrayBuffer`s
+     * may not be tracked in that case.
+     */
     arrayBuffers: number;
 }
 export interface StatisticsCpuInfo {
     model: string;
     speed: number;
     times: {
+        /** The number of milliseconds the CPU has spent in user mode. */
         user: number;
+        /** The number of milliseconds the CPU has spent in nice mode. */
         nice: number;
+        /** The number of milliseconds the CPU has spent in sys mode. */
         sys: number;
+        /** The number of milliseconds the CPU has spent in idle mode. */
         idle: number;
+        /** The number of milliseconds the CPU has spent in irq mode. */
         irq: number;
     };
 }

package/dist/function/has-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 hasFqn(target: FqnTarget): boolean;

package/dist/function/has-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 hasFqn(target) {
     if (!target) {
         return false;
     }
     if (typeof target === "function") {
+        // function, class
         return !!target[KEY_FQN_NAME];
     }
     else if (typeof target === "object") {

package/dist/function/index.d.ts

@@ -38,3 +38,4 @@ export * from "./test-case.js";
 export * from "./test-name.js";
 export * from "./random-test-no.js";
 export * from "./is-test.js";
+export * from "./times.js";

package/dist/function/index.js

@@ -38,3 +38,4 @@ export * from "./test-case.js";
 export * from "./test-name.js";
 export * from "./random-test-no.js";
 export * from "./is-test.js";
+export * from "./times.js";

package/dist/function/is-class.d.ts

@@ -1 +1,7 @@
+/**
+ * Is class?
+ *
+ * @param {any} fn - given value
+ * @return {boolean} - is class?
+ * */
 export declare function isClass(fn: unknown): boolean;

package/dist/function/is-class.js

@@ -1,3 +1,9 @@
+/**
+ * Is class?
+ *
+ * @param {any} fn - given value
+ * @return {boolean} - is class?
+ * */
 export function isClass(fn) {
     if (typeof fn !== "function") {
         return false;
@@ -8,4 +14,16 @@ export function isClass(fn) {
     catch (e) {
         return false;
     }
+    // // Class constructor is also a function
+    // if ( !(fn && fn.constructor === Function) || (fn as Fnc).prototype === undefined) {
+    //     return false;
+    // }
+    //
+    // // This is a class that extends other class
+    // if (Function.prototype !== Object.getPrototypeOf(fn)) {
+    //     return true;
+    // }
+    //
+    // // Usually a function will only have 'constructor' in the prototype
+    // return Object.getOwnPropertyNames((fn as Fnc).prototype).length > 1;
 }

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

@@ -1 +1,12 @@
+/**
+ * Is empty?
+ * Means:
+ * - `not null`
+ * - `not undefined`
+ * - `not empty string`
+ *
+ * @param {any} value - given value
+ * @param {boolean?} notSpace - yes: ignore empty string
+ * @return {boolean} - is empty?
+ * */
 export declare function isEmpty(value: unknown, notSpace?: boolean): boolean;

package/dist/function/is-empty.js

@@ -1,4 +1,15 @@
 import { EMPTY_VALUES } from "../const/index.js";
+/**
+ * Is empty?
+ * Means:
+ * - `not null`
+ * - `not undefined`
+ * - `not empty string`
+ *
+ * @param {any} value - given value
+ * @param {boolean?} notSpace - yes: ignore empty string
+ * @return {boolean} - is empty?
+ * */
 export function isEmpty(value, notSpace) {
     if (notSpace) {
         return EMPTY_VALUES.includes(value);

package/dist/function/is-filled-arr.d.ts

@@ -1 +1,10 @@
+/**
+ * Is filled array?
+ * Means
+ * - `constructor === "Array"`
+ * - `arr.length > 0`
+ *
+ * @param {any} arr - given value
+ * @return {boolean} - is filled array?
+ * */
 export declare function isFilledArr(arr: unknown): boolean;

package/dist/function/is-filled-arr.js

@@ -1,3 +1,12 @@
+/**
+ * Is filled array?
+ * Means
+ * - `constructor === "Array"`
+ * - `arr.length > 0`
+ *
+ * @param {any} arr - given value
+ * @return {boolean} - is filled array?
+ * */
 export function isFilledArr(arr) {
     return Array.isArray(arr) && arr.length > 0;
 }

package/dist/function/is-filled-obj.d.ts

@@ -1 +1,10 @@
+/**
+ * Is filled object?
+ * Means:
+ * - `constructor === "Object"`
+ * - `obj.keys.length > 0`
+ *
+ * @param {any} obj - given value
+ * @return {boolean} - is filled object?
+ * */
 export declare function isFilledObj(obj: unknown): boolean;

package/dist/function/is-filled-obj.js

@@ -1,4 +1,13 @@
 import { isObj } from "./is-obj.js";
+/**
+ * Is filled object?
+ * Means:
+ * - `constructor === "Object"`
+ * - `obj.keys.length > 0`
+ *
+ * @param {any} obj - given value
+ * @return {boolean} - is filled object?
+ * */
 export function isFilledObj(obj) {
     return isObj(obj) && Object.keys(obj).length > 0;
 }

package/dist/function/is-obj.d.ts

@@ -1 +1,9 @@
+/**
+ * Is bare object?
+ * Means:
+ * - `constructor === "Object"`
+ *
+ * @param {any} obj - given value
+ * @return {boolean} - is bare object?
+ * */
 export declare function isObj(obj: unknown): boolean;

package/dist/function/is-obj.js

@@ -1,3 +1,11 @@
+/**
+ * Is bare object?
+ * Means:
+ * - `constructor === "Object"`
+ *
+ * @param {any} obj - given value
+ * @return {boolean} - is bare object?
+ * */
 export function isObj(obj) {
     return obj && typeof obj === "object" && !Array.isArray(obj);
 }

package/dist/function/is-test.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Initialize test
+ * */
 export declare function initTest(): void;
+/**
+ * Is test?
+ *
+ * @return {boolean}
+ * */
 export declare function isTest(): boolean;

package/dist/function/is-test.js

@@ -1,4 +1,13 @@
+// noinspection JSUnusedGlobalSymbols
+// region properties
+/**
+ * Is test?
+ * */
 let _isTest;
+// endregion properties
+/**
+ * Initialize test
+ * */
 export function initTest() {
     _isTest = true;
     if (global) {
@@ -11,6 +20,11 @@ export function initTest() {
         }
     }
 }
+/**
+ * Is test?
+ *
+ * @return {boolean}
+ * */
 export function isTest() {
     return _isTest;
 }

package/dist/function/is-text.d.ts

@@ -1 +1,11 @@
+/**
+ * Is text?
+ * Means:
+ * - `typeof === "string"`
+ * - `not empty string`
+ * - `not starts/ends with space`
+ *
+ * @param {any} str - given value
+ * @return {boolean} - is text?
+ * */
 export declare function isText(str: unknown): boolean;

package/dist/function/is-text.js

@@ -1,3 +1,13 @@
+/**
+ * Is text?
+ * Means:
+ * - `typeof === "string"`
+ * - `not empty string`
+ * - `not starts/ends with space`
+ *
+ * @param {any} str - given value
+ * @return {boolean} - is text?
+ * */
 export function isText(str) {
     if (typeof str !== "string") {
         return false;

package/dist/function/jitter-interval.d.ts

@@ -1 +1,10 @@
+/**
+ * Generate next delay time with exponential & randomized manner
+ *
+ * @param {number} tryCount - try count
+ * @param {number} baseDelay - starting delay interval
+ * @param {number} maxDelay - maximum delay interval
+ * @param {number} maxTryCount - max try count, if `tryCount` excess it, it returns undefined
+ * @return {number} - next interval time if (maxTryCount && `tryCount` >= `maxTryCount`)
+ * */
 export declare function jitterInterval(tryCount: number, baseDelay: number, maxDelay: number, maxTryCount?: number): number;

package/dist/function/jitter-interval.js

@@ -1,3 +1,13 @@
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Generate next delay time with exponential & randomized manner
+ *
+ * @param {number} tryCount - try count
+ * @param {number} baseDelay - starting delay interval
+ * @param {number} maxDelay - maximum delay interval
+ * @param {number} maxTryCount - max try count, if `tryCount` excess it, it returns undefined
+ * @return {number} - next interval time if (maxTryCount && `tryCount` >= `maxTryCount`)
+ * */
 export function jitterInterval(tryCount, baseDelay, maxDelay, maxTryCount) {
     if ([tryCount, baseDelay, maxDelay].some((v) => !isValid(v))) {
         return undefined;
@@ -9,6 +19,12 @@ export function jitterInterval(tryCount, baseDelay, maxDelay, maxTryCount) {
     const result = Math.floor(exp / 2 + Math.random() * (exp / 2));
     return Number.isSafeInteger(result) ? result : undefined;
 }
+/**
+ * Check value is expected interval value
+ *
+ * @param {any} value - given value, possible number
+ * @return {boolean} - is it expected?
+ * */
 function isValid(value) {
     return (typeof value === "number" && value > 0 && Number.isInteger(value) && Number.isSafeInteger(value));
 }

package/dist/function/load-config.d.ts

@@ -1,3 +1,22 @@
 import { LeyyoConfig } from "./index.types.js";
 export declare const leyyoConfig: LeyyoConfig;
+/**
+ * Load config from `.leyyo.yaml` file
+ *
+ * `OBJECT` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * `ARRAY` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * Generics:
+ * - `C`- config model
+ *
+ * @param {string} url
+ * @return {LeyyoConfig}
+ * */
 export declare function loadConfig(url: string): LeyyoConfig;

package/dist/function/load-config.js

@@ -10,6 +10,25 @@ import { isEmpty } from "./is-empty.js";
 import { secureJson, secureObject } from "./secure-json.js";
 const _NAME = "$$leyyo.config";
 export const leyyoConfig = getRootStorage(_NAME, {});
+/**
+ * Load config from `.leyyo.yaml` file
+ *
+ * `OBJECT` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * `ARRAY` postfixes:
+ * - !: only override (`don't merge`)
+ * - ?: only merge (`don't override`)
+ * - <empty>: only set if key is absent
+ *
+ * Generics:
+ * - `C`- config model
+ *
+ * @param {string} url
+ * @return {LeyyoConfig}
+ * */
 export function loadConfig(url) {
     try {
         const __dirname = dirname(dirname(fileURLToPath(url)));
@@ -30,6 +49,11 @@ export function loadConfig(url) {
         return undefined;
     }
 }
+/**
+ * Get key behaviour
+ * @param {string} keyFull - key
+ * @return {Array} - tuple as `[behaviour, key]`
+ * */
 function _behaviour(keyFull) {
     if (!isText(keyFull)) {
         return [undefined, undefined];
@@ -50,6 +74,13 @@ function _behaviour(keyFull) {
     }
     return [undefined, keyFull];
 }
+/**
+ * Merge array
+ *
+ * @param {Array} source
+ * @param {string} key
+ * @param {Array} value
+ * */
 function _array(source, key, value) {
     value.forEach((item, index) => {
         if (isEmpty(item)) {
@@ -79,6 +110,13 @@ function _array(source, key, value) {
         }
     });
 }
+/**
+ * Merge object
+ *
+ * @param {object} source
+ * @param {string} keyFull - key
+ * @param {any} value
+ * */
 function _object(source, keyFull, value) {
     if (isEmpty(value)) {
         return;
@@ -91,6 +129,7 @@ function _object(source, keyFull, value) {
     if (!source) {
         source = {};
     }
+    // old is empty
     if (isEmpty(source[key])) {
         switch (typeof value) {
             case "string":
@@ -118,7 +157,7 @@ function _object(source, keyFull, value) {
                 case "override":
                     source[key] = value;
                     break;
-                default:
+                default: // merge
                     if (isEmpty(source[key])) {
                         source[key] = value;
                     }
@@ -126,7 +165,9 @@ function _object(source, keyFull, value) {
             }
             break;
         case "object":
+            // new is an array
             if (Array.isArray(value)) {
+                // old is an array (BOTH)
                 if (Array.isArray(source[key])) {
                     switch (behaviour) {
                         case "override":
@@ -136,35 +177,44 @@ function _object(source, keyFull, value) {
                             _array(source[key], key, value);
                             break;
                         default:
+                            // old exists, ignore
                             break;
                     }
                 }
+                // CONFLICT: old is not array
                 else {
                     switch (behaviour) {
                         case "override":
                             source[key] = secureObject(value);
                             break;
                         case "merge":
+                            // old is different, conflict
                             console.warn(`[leyyoConfig] type is conflicted at (${key})`);
                             break;
                         default:
+                            // old exists, ignore
                             break;
                     }
                 }
             }
+            // new is an object
             else {
+                // CONFLICT: old is not object
                 if (Array.isArray(source[key])) {
                     switch (behaviour) {
                         case "override":
                             source[key] = value;
                             break;
                         case "merge":
+                            // old is different, conflict
                             console.warn(`[leyyoConfig] type is conflicted at (${key})`);
                             break;
                         default:
+                            // old exists, ignore
                             break;
                     }
                 }
+                // old is an object (BOTH)
                 else {
                     switch (behaviour) {
                         case "override":
@@ -176,6 +226,7 @@ function _object(source, keyFull, value) {
                             }
                             break;
                         default:
+                            // old exists, ignore
                             break;
                     }
                 }

package/dist/function/on-fqn-set.js

@@ -7,6 +7,7 @@ export function onFqnSet(target, callback) {
         return false;
     }
     if (typeof target === "function") {
+        // function, class
         return _item(target, callback);
     }
     else if (typeof target === "object") {

package/dist/function/one-or-more.d.ts

@@ -1,2 +1,8 @@
 import { OneOrMore } from "../base/index.js";
+/**
+ * Return array value from one or more type
+ *
+ * @param {OneOrMore} value - it can be one value or array value
+ * @return {Array}
+ * */
 export declare function oneOrMore<T = unknown>(value: OneOrMore<T>): Array<T> | undefined;

package/dist/function/one-or-more.js

@@ -1,3 +1,10 @@
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Return array value from one or more type
+ *
+ * @param {OneOrMore} value - it can be one value or array value
+ * @return {Array}
+ * */
 export function oneOrMore(value) {
     if (Array.isArray(value)) {
         return value;

package/dist/function/opt-add.d.ts

@@ -1,2 +1,10 @@
 import { Opt } from "./index.types.js";
+/**
+ * Add key=value into options
+ *
+ * @param {Opt} options - source options
+ * @param {string} key - key
+ * @param {any} value - value
+ * @return {Opt} - added options
+ * */
 export declare function optAdd<O extends Opt = Opt>(options: O | Opt, key: keyof O | string, value: unknown): O;

package/dist/function/opt-add.js

@@ -1,5 +1,13 @@
 import { optField } from "./opt-field.js";
 import { isObj } from "./is-obj.js";
+/**
+ * Add key=value into options
+ *
+ * @param {Opt} options - source options
+ * @param {string} key - key
+ * @param {any} value - value
+ * @return {Opt} - added options
+ * */
 export function optAdd(options, key, value) {
     const o = (isObj(options) ? options : {});
     if (value === undefined || typeof key !== "string") {

package/dist/function/opt-append.d.ts

@@ -1,2 +1,9 @@
 import { Opt } from "./index.types.js";
+/**
+ * Merge two options
+ *
+ * @param {Opt} options - source options
+ * @param {Opt} appended - appended options
+ * @return {Opt} - merged options
+ * */
 export declare function optAppend<O extends Opt = Opt>(options: O | Opt, appended: O | Opt): O;

package/dist/function/opt-append.js

@@ -1,5 +1,12 @@
 import { isObj } from "./is-obj.js";
 import { optAdd } from "./opt-add.js";
+/**
+ * Merge two options
+ *
+ * @param {Opt} options - source options
+ * @param {Opt} appended - appended options
+ * @return {Opt} - merged options
+ * */
 export function optAppend(options, appended) {
     const o = (isObj(options) ? options : {});
     if (!isObj(appended)) {

package/dist/function/opt-check.d.ts

@@ -1,2 +1,8 @@
 import { Opt, OptFn } from "./index.types.js";
+/**
+ * Check option, if it's invalid, create empty options
+ *
+ * @param {(Opt|OptFn)} options - options or options callback
+ * @return {Opt} - checked options
+ * */
 export declare function optCheck<O extends Opt = Opt>(options: O | OptFn<O> | Opt): O;

package/dist/function/opt-check.js

@@ -1,8 +1,15 @@
+// noinspection JSUnusedGlobalSymbols
 import { $$get_leyyo_fn } from "./leyyo-fn.js";
 import { isObj } from "./is-obj.js";
 import { FQN } from "../internal.js";
 let _leyyo;
 const where = `${FQN}.optCheck`;
+/**
+ * Check option, if it's invalid, create empty options
+ *
+ * @param {(Opt|OptFn)} options - options or options callback
+ * @return {Opt} - checked options
+ * */
 export function optCheck(options) {
     let o = options;
     if (typeof options === "function") {

package/dist/function/opt-clone.d.ts

@@ -1,2 +1,8 @@
 import { Opt } from "./index.types.js";
+/**
+ * Clone existing option
+ *
+ * @param {Opt} options - source options
+ * @return {Opt} - cloned options
+ * */
 export declare function optClone<O extends Opt = Opt>(options: O | Opt): O;

package/dist/function/opt-clone.js

@@ -1,5 +1,12 @@
+// noinspection JSUnusedGlobalSymbols
 import { isObj } from "./is-obj.js";
 import { secureClone } from "./secure-clone.js";
+/**
+ * Clone existing option
+ *
+ * @param {Opt} options - source options
+ * @return {Opt} - cloned options
+ * */
 export function optClone(options) {
     return (isObj(options) ? secureClone(options) : {});
 }