@leyyo/common 1.3.19 → 1.3.20

package/dist/function/opt-field.js

@@ -1,4 +1,12 @@
 import { isObj } from "./is-obj.js";
+/**
+ * Add field into options
+ * Note: field could not be multiple in option
+ *
+ * @param {Opt} options - source options
+ * @param {KeyValue} field - value
+ * @return {Opt} - added options
+ * */
 export function optField(options, field) {
     const o = (isObj(options) ? options : {});
     const t = typeof field;

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

@@ -1,2 +1,8 @@
 import { Opt } from "./index.types.js";
+/**
+ * It's used to easy arrow function usage for lazy evaluation of options
+ *
+ * @param {Opt} options - options
+ * @return {Opt} - options
+ * */
 export declare function optFn<O extends Opt = Opt>(options: O | Opt): O;

package/dist/function/opt-fn.js

@@ -1,4 +1,11 @@
 import { isObj } from "./is-obj.js";
+// noinspection JSUnusedGlobalSymbols
+/**
+ * It's used to easy arrow function usage for lazy evaluation of options
+ *
+ * @param {Opt} options - options
+ * @return {Opt} - options
+ * */
 export function optFn(options) {
     return (isObj(options) ? options : {});
 }

package/dist/function/random-test-no.d.ts

@@ -1 +1,6 @@
+/**
+ * Generate random test no
+ *
+ * @return {string}
+ * */
 export declare function randomTestNo(): string;

package/dist/function/random-test-no.js

@@ -1,3 +1,8 @@
+/**
+ * Generate random test no
+ *
+ * @return {string}
+ * */
 export function randomTestNo() {
     return (Math.floor(Math.random() * 999) + 100).toString(10);
 }

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

@@ -1,2 +1,10 @@
 import { FqnTarget } from "./index.types.js";
+/**
+ * Remove fqn name
+ *
+ * @param {FqnTarget} target - target (function, class, instance, enum, literal)
+ * @return {boolean?} - is removed
+ *
+ * Note: if it returns `undefined`, means that it could not find valid target
+ * */
 export declare function removeFqn(target: FqnTarget): boolean;

package/dist/function/remove-fqn.js

@@ -1,10 +1,19 @@
 import { KEY_ENUM_NAME, KEY_FQN_NAME, KEY_LITERAL_NAME } from "../const/index.js";
 import { triggerFqn } from "./trigger-fqn.js";
+/**
+ * Remove fqn name
+ *
+ * @param {FqnTarget} target - target (function, class, instance, enum, literal)
+ * @return {boolean?} - is removed
+ *
+ * Note: if it returns `undefined`, means that it could not find valid target
+ * */
 export function removeFqn(target) {
     if (!target) {
         return false;
     }
     if (typeof target === "function") {
+        // function, class
         return _item(target, target.name);
     }
     else if (typeof target === "object") {
@@ -12,11 +21,12 @@ export function removeFqn(target) {
             if (target[KEY_LITERAL_NAME]) {
                 return _item(target, target[KEY_LITERAL_NAME]);
             }
-            return false;
+            return false; // normal array
         }
         if (target[KEY_ENUM_NAME]) {
             return _item(target, target[KEY_ENUM_NAME]);
         }
+        // instance
         return false;
     }
     return false;

package/dist/function/run-exporter.d.ts

@@ -1,2 +1,7 @@
 import { ExporterData } from "./index.types.js";
+/**
+ * Run exporter
+ *
+ * @return {Promise<ExporterData>}
+ * */
 export declare function runExporter(): Promise<ExporterData>;

package/dist/function/run-exporter.js

@@ -1,5 +1,11 @@
 import { $$get_leyyo_fn } from "./leyyo-fn.js";
 let _leyyo;
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Run exporter
+ *
+ * @return {Promise<ExporterData>}
+ * */
 export async function runExporter() {
     const data = {};
     const depot = {
@@ -13,6 +19,14 @@ export async function runExporter() {
     await _leyyo.lifecycleCommon.runStage("print", depot);
     return data;
 }
+/**
+ * Append to exporter with preventing overridden keys
+ *
+ * @param {ExporterData} data
+ * @param {string} name
+ * @param {ExporterValue} value
+ * @param {number} duplicated
+ * */
 const append = (data, name, value, duplicated) => {
     const postfix = duplicated === 0 ? "" : "#" + duplicated;
     if (data[name + postfix] !== undefined) {

package/dist/function/secure-json.d.ts

@@ -1,2 +1,37 @@
+/**
+ * Converts an object to secure object
+ *
+ * - `secure` means:
+ * - removes `circular` relations
+ * - cuts after max depths, default: `10`
+ * - converts `Set` to `array`
+ * - converts `Map` to `object`
+ * - cuts `methods` of an object
+ * - cuts `symbol` properties of an object
+ * - cuts `non-string keys` of an object
+ * - cuts `undefined` properties of an object
+ *
+ * @param {any} value
+ * @return {any}
+ * */
 export declare function secureObject<E>(value: E): E;
+/**
+ * Converts an object to secure string
+ *
+ * - `secure` means:
+ * - removes `circular` relations
+ * - cuts after max depths, default: `10`
+ * - converts `Set` to `array`
+ * - converts `Map` to `object`
+ * - cuts `methods` of an object
+ * - cuts `symbol` properties of an object
+ * - cuts `non-string keys` of an object
+ * - cuts `undefined` properties of an object
+ *
+ * Note:
+ * `JSON.stringify` can fail if there is a `dependency
+ *
+ * @param {any} value
+ * @return {string}
+ * */
 export declare function secureJson(value: unknown): string;

package/dist/function/secure-json.js

@@ -1,3 +1,10 @@
+/**
+ * Inner secure json function, it will be used after creating weak set
+ *
+ * @param {any} value
+ * @param {number} depth
+ * @param {WeakSet} set
+ * */
 function _secureObject(value, depth, set) {
     if ([null, undefined].includes(value)) {
         return value;
@@ -59,6 +66,23 @@ function _secureObject(value, depth, set) {
     }
     return value;
 }
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Converts an object to secure object
+ *
+ * - `secure` means:
+ * - removes `circular` relations
+ * - cuts after max depths, default: `10`
+ * - converts `Set` to `array`
+ * - converts `Map` to `object`
+ * - cuts `methods` of an object
+ * - cuts `symbol` properties of an object
+ * - cuts `non-string keys` of an object
+ * - cuts `undefined` properties of an object
+ *
+ * @param {any} value
+ * @return {any}
+ * */
 export function secureObject(value) {
     try {
         return _secureObject(value, 0, new WeakSet());
@@ -67,6 +91,26 @@ export function secureObject(value) {
         return `#error <${e.name}> (message: ${e.message})`;
     }
 }
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Converts an object to secure string
+ *
+ * - `secure` means:
+ * - removes `circular` relations
+ * - cuts after max depths, default: `10`
+ * - converts `Set` to `array`
+ * - converts `Map` to `object`
+ * - cuts `methods` of an object
+ * - cuts `symbol` properties of an object
+ * - cuts `non-string keys` of an object
+ * - cuts `undefined` properties of an object
+ *
+ * Note:
+ * `JSON.stringify` can fail if there is a `dependency
+ *
+ * @param {any} value
+ * @return {string}
+ * */
 export function secureJson(value) {
     try {
         const json = _secureObject(value, 0, new WeakSet());

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

@@ -8,6 +8,7 @@ export function setAnonymousFqn(target) {
         return undefined;
     }
     if (typeof target === "function") {
+        // function, class
         if (!target.name) {
             setAnonymousName(target, isClass(target) ? "Class" : "function");
         }
@@ -23,6 +24,7 @@ export function setAnonymousFqn(target) {
         if (target[KEY_ENUM_NAME]) {
             return _item(target, target[KEY_ENUM_NAME]);
         }
+        // instance
         return undefined;
     }
     return undefined;

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

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

package/dist/function/set-fqn.js

@@ -9,6 +9,13 @@ import { setAnonymousName } from "./set-anonymous-name.js";
 import { getFqn } from "./get-fqn.js";
 const where = `${FQN}.FqnFn`;
 let _leyyo;
+/**
+ * Set fqn name
+ *
+ * @param {FqnTarget} target - target (function, class, instance, enum, literal)
+ * @param {string} fqn - fully qualified name
+ * @return {string} - full name
+ * */
 export function setFqn(target, fqn) {
     if (!_leyyo) {
         _leyyo = $$get_leyyo_fn();
@@ -30,6 +37,7 @@ export function setFqn(target, fqn) {
         return undefined;
     }
     if (typeof target === "function") {
+        // function, class
         if (!target.name) {
             setAnonymousName(target, isClass(target) ? "Class" : "function");
         }

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

@@ -1,3 +1,27 @@
+/**
+ * Set target property
+ *
+ * @param {any} target - target
+ * @param {string} key - key
+ * @param {any} value
+ * @return {boolean} - is set?
+ * */
 export declare function setKey(target: unknown, key: string, value: unknown): boolean;
+/**
+ * Set target hidden property
+ *
+ * @param {any} target - target
+ * @param {symbol} key - hidden key
+ * @param {any} value
+ * @return {boolean} - is set?
+ * */
 export declare function setSymbol(target: unknown, key: symbol, value: unknown): boolean;
+/**
+ * Set target property
+ *
+ * @param {any} target - target
+ * @param {(symbol|string)} key - key
+ * @param {any} value
+ * @return {boolean} - is set?
+ * */
 export declare function setProp(target: unknown, key: symbol | string, value: unknown): boolean;

package/dist/function/set-prop.js

@@ -3,18 +3,42 @@ import { testCase } from "./test-case.js";
 import { $$get_leyyo_fn } from "./leyyo-fn.js";
 const where = `${FQN}.DeleteProp`;
 let _leyyo;
+/**
+ * Set target property
+ *
+ * @param {any} target - target
+ * @param {string} key - key
+ * @param {any} value
+ * @return {boolean} - is set?
+ * */
 export function setKey(target, key, value) {
     if (typeof key !== "string") {
         return false;
     }
     return setProp(target, key, value);
 }
+/**
+ * Set target hidden property
+ *
+ * @param {any} target - target
+ * @param {symbol} key - hidden key
+ * @param {any} value
+ * @return {boolean} - is set?
+ * */
 export function setSymbol(target, key, value) {
     if (typeof key !== "symbol") {
         return false;
     }
     return setProp(target, key, value);
 }
+/**
+ * Set target property
+ *
+ * @param {any} target - target
+ * @param {(symbol|string)} key - key
+ * @param {any} value
+ * @return {boolean} - is set?
+ * */
 export function setProp(target, key, value) {
     if (!["symbol", "string"].includes(typeof key)) {
         return false;

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

@@ -1,2 +1,8 @@
 import { LeyyoStampEmpty, LeyyoStampLambda } from "./index.types.js";
+/**
+ * Stamp an instance for loader
+ *
+ * @param {function} fn - callback function to save
+ * @return {(LeyyoStampLambda | LeyyoStampEmpty)} - stamped function
+ * */
 export declare function stampLoader(fn: LeyyoStampLambda): LeyyoStampLambda | LeyyoStampEmpty;

package/dist/function/stamp-loader.js

@@ -1,4 +1,10 @@
 import { KEY_LOADER_EMPTY, KEY_LOADER_STAMP } from "../const/index.js";
+/**
+ * Stamp an instance for loader
+ *
+ * @param {function} fn - callback function to save
+ * @return {(LeyyoStampLambda | LeyyoStampEmpty)} - stamped function
+ * */
 export function stampLoader(fn) {
     if (typeof fn === "function") {
         fn[KEY_LOADER_STAMP] = true;

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

@@ -1 +1,8 @@
+/**
+ * Build test case
+ *
+ * @param {string} pck - Package or FQN name
+ * @param {(string|number)} caseNo
+ * @return {string}
+ * */
 export declare function testCase(pck: string, caseNo: string | number): string;

package/dist/function/test-case.js

@@ -1,5 +1,12 @@
 import { randomTestNo } from "./random-test-no.js";
 import { FQN } from "../internal.js";
+/**
+ * Build test case
+ *
+ * @param {string} pck - Package or FQN name
+ * @param {(string|number)} caseNo
+ * @return {string}
+ * */
 export function testCase(pck, caseNo) {
     pck = typeof pck === "string" ? pck : FQN;
     let caseStr;

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

@@ -1 +1,8 @@
+/**
+ * Build test name
+ *
+ * @param {string} testCase - it would be built via {@link testCase}
+ * @param {string} title - test title
+ * @return {string}
+ * */
 export declare function testName(testCase: string, title: string): string;

package/dist/function/test-name.js

@@ -1,5 +1,12 @@
 import { randomTestNo } from "./random-test-no.js";
 import { FQN } from "../internal.js";
+/**
+ * Build test name
+ *
+ * @param {string} testCase - it would be built via {@link testCase}
+ * @param {string} title - test title
+ * @return {string}
+ * */
 export function testName(testCase, title) {
     testCase = typeof testCase === "string" ? testCase : `${FQN}@${randomTestNo()}`;
     title = typeof title === "string" ? title : "???";

package/dist/function/trigger-fqn.js

@@ -10,6 +10,7 @@ export function triggerFqn(target, full) {
                         callback(full);
                     }
                     catch (_e) {
+                        // nothing
                     }
                 }
             });

package/dist/index.foretell.js

@@ -1,11 +1,14 @@
 import { leyyo } from "./base/index.js";
 import { FQN } from "./internal.js";
+// noinspection JSUnusedGlobalSymbols
 export const foretell_leyyoCommon = [
+    // errors
     () => leyyo.errorPool.lazy(FQN, "CausedError", import("./error/caused.error.js").then((m) => m.CausedError), { i18n: true, emit: true }),
     () => leyyo.errorPool.lazy(FQN, "DeveloperError", import("./error/developer.error.js").then((m) => m.DeveloperError), { i18n: true, emit: true }),
     () => leyyo.errorPool.lazy(FQN, "HttpError", import("./error/http.error.js").then((m) => m.HttpError), { i18n: true, emit: true }),
     () => leyyo.errorPool.lazy(FQN, "InvalidValueError", import("./error/invalid-value.error.js").then((m) => m.InvalidValueError), { i18n: true, emit: true }),
     () => leyyo.errorPool.lazy(FQN, "LeyyoError", import("./error/leyyo.error.js").then((m) => m.LeyyoError), { i18n: true, emit: false }),
     () => leyyo.errorPool.lazy(FQN, "MultipleError", import("./error/multiple.error.js").then((m) => m.MultipleError), { i18n: true, emit: true }),
+    // enums
     () => leyyo.literalPool.lazy(FQN, "LogLevel", import("./enum/log-level.js").then((m) => m.LogLevelItems), { i18n: true }),
 ];

package/dist/index.js

@@ -1,3 +1,4 @@
+// noinspection JSUnusedGlobalSymbols
 import { init } from "./init/index.js";
 import { leyyo } from "./base/index.js";
 import { setFqn } from "./function/index.js";

package/dist/index.loader.js

@@ -1,3 +1,10 @@
 import { defineLoader } from "./function/index.js";
 import { FQN } from "./internal.js";
-export const loader_leyyoCommon = defineLoader(FQN, () => import("./error/caused.error.js").then((m) => m.CausedError), () => import("./error/developer.error.js").then((m) => m.DeveloperError), () => import("./error/http.error.js").then((m) => m.HttpError), () => import("./error/invalid-value.error.js").then((m) => m.InvalidValueError), () => import("./error/leyyo.error.js").then((m) => m.LeyyoError), () => import("./error/multiple.error.js").then((m) => m.MultipleError), () => import("./enum/log-level.js").then((m) => m.LogLevelItems), () => import("./class/list.js").then((m) => m.List), () => import("./class/logger.instance.js").then((m) => m.LoggerInstance));
+// noinspection JSUnusedGlobalSymbols
+export const loader_leyyoCommon = defineLoader(FQN, 
+// errors
+() => import("./error/caused.error.js").then((m) => m.CausedError), () => import("./error/developer.error.js").then((m) => m.DeveloperError), () => import("./error/http.error.js").then((m) => m.HttpError), () => import("./error/invalid-value.error.js").then((m) => m.InvalidValueError), () => import("./error/leyyo.error.js").then((m) => m.LeyyoError), () => import("./error/multiple.error.js").then((m) => m.MultipleError), 
+// enums
+() => import("./enum/log-level.js").then((m) => m.LogLevelItems), 
+// classes
+() => import("./class/list.js").then((m) => m.List), () => import("./class/logger.instance.js").then((m) => m.LoggerInstance));

package/dist/sys/leyyo-storage.d.ts

@@ -1,4 +1,11 @@
 type LeyyoStorage = Map<string, unknown>;
+/**
+ * Local storage for leyyo platform
+ * */
 export declare const leyyoStorage: LeyyoStorage;
+/**
+ * @param {string} name - name of storage
+ * @param {any} def - initial value
+ * */
 export declare function getRootStorage<T>(name: string, def: T): T;
 export {};

package/dist/sys/leyyo-storage.js

@@ -1,7 +1,18 @@
 const _NAME = "$$leyyo.packages";
+/**
+ * Create a standalone storage
+ *
+ * @return {LeyyoStorage}
+ * */
 function _new() {
     return new Map();
 }
+/**
+ * Get a global storage
+ *
+ * @param {any} source - `global` or `globalThis`
+ * @return {LeyyoStorage}
+ * */
 function _get(source) {
     if (!source) {
         return undefined;
@@ -12,6 +23,11 @@ function _get(source) {
     source[_NAME] = _new();
     return source[_NAME];
 }
+/**
+ * Build storage
+ *
+ * @return {LeyyoStorage}
+ * */
 function _build() {
     try {
         return _get(globalThis) ?? _get(global) ?? _new();
@@ -20,7 +36,14 @@ function _build() {
         return _new();
     }
 }
+/**
+ * Local storage for leyyo platform
+ * */
 export const leyyoStorage = _build();
+/**
+ * @param {string} name - name of storage
+ * @param {any} def - initial value
+ * */
 export function getRootStorage(name, def) {
     if (typeof name !== "string") {
         throw new Error("Invalid storage name", name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/common",
-  "version": "1.3.19",
+  "version": "1.3.20",
   "description": "Leyyo common library",
   "keywords": [
     "common"