@leyyo/common 1.3.17 → 1.3.19

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

@@ -1,10 +1,2 @@
 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,31 +1,22 @@
 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
+    if (typeof target === "function") {
         return _item(target, target.name);
     }
-    else if (typeof target === 'object') {
+    else if (typeof target === "object") {
         if (Array.isArray(target)) {
             if (target[KEY_LITERAL_NAME]) {
                 return _item(target, target[KEY_LITERAL_NAME]);
             }
-            return false; // normal array
+            return false;
         }
         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,7 +1,2 @@
 import { ExporterData } from "./index.types.js";
-/**
- * Run exporter
- *
- * @return {Promise<ExporterData>}
- * */
 export declare function runExporter(): Promise<ExporterData>;

package/dist/function/run-exporter.js

@@ -1,34 +1,20 @@
 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 = {
         add(name, value) {
             append(data, name, value, 0);
-        }
+        },
     };
     if (!_leyyo) {
         _leyyo = $$get_leyyo_fn();
     }
-    await _leyyo.lifecycleCommon.runStage('print', depot);
+    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;
+    const postfix = duplicated === 0 ? "" : "#" + duplicated;
     if (data[name + postfix] !== undefined) {
         data[name + postfix] = value;
     }

package/dist/function/secure-clone.js

@@ -2,7 +2,7 @@ export function _secureClone(value, weakSet) {
     if (value === undefined || value === null) {
         return value;
     }
-    if (typeof value !== 'object') {
+    if (typeof value !== "object") {
         return value;
     }
     if (weakSet.has(weakSet)) {
@@ -10,10 +10,10 @@ export function _secureClone(value, weakSet) {
     }
     weakSet.add(value);
     if (Array.isArray(value)) {
-        return value.map(item => secureClone(item));
+        return value.map((item) => secureClone(item));
     }
     if (value instanceof Set) {
-        return new Set(Array.from(value.values()).map(item => secureClone(item)));
+        return new Set(Array.from(value.values()).map((item) => secureClone(item)));
     }
     if (value instanceof Map) {
         const newMap = new Map();

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

@@ -1,37 +1,2 @@
-/**
- * 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,16 +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;
     }
+    let obj;
     switch (typeof value) {
-        case 'object':
+        case "object":
             if (set.has(value)) {
                 return `#circular <${value?.constructor?.name}>`;
             }
@@ -19,22 +13,22 @@ function _secureObject(value, depth, set) {
             }
             set.add(value);
             if (Array.isArray(value)) {
-                return value.map(item => _secureObject(item, depth + 1, set));
+                return value.map((item) => _secureObject(item, depth + 1, set));
             }
             if (value instanceof Set) {
-                return Array.from(value).map(item => _secureObject(item, depth + 1, set));
+                return Array.from(value).map((item) => _secureObject(item, depth + 1, set));
             }
-            const obj = {};
+            obj = {};
             if (value instanceof Map) {
                 for (const [k, v] of value.entries()) {
-                    if (typeof k === 'string') {
+                    if (typeof k === "string") {
                         obj[k] = _secureObject(v, depth + 1, set);
                     }
                 }
             }
             else if (value?.constructor === Object) {
                 for (const [k, v] of Object.entries(value)) {
-                    if (typeof k === 'string') {
+                    if (typeof k === "string") {
                         obj[k] = _secureObject(v, depth + 1, set);
                     }
                 }
@@ -42,7 +36,8 @@ function _secureObject(value, depth, set) {
             else {
                 let exists;
                 for (const [k, v] of Object.entries(value)) {
-                    if (typeof k === 'string' && !['function', 'symbol', 'undefined'].includes(typeof value)) {
+                    if (typeof k === "string" &&
+                        !["function", "symbol", "undefined"].includes(typeof value)) {
                         exists = true;
                         obj[k] = _secureObject(v, depth + 1, set);
                     }
@@ -57,30 +52,13 @@ function _secureObject(value, depth, set) {
                 }
             }
             return obj;
-        case 'function':
+        case "function":
             return `#function <${value.name}> (length: ${value.length})`;
-        case 'symbol':
+        case "symbol":
             return `#symbol <${value.description}>`;
     }
     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());
@@ -89,30 +67,10 @@ 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());
-        return (typeof json === 'string') ? json : JSON.stringify(json);
+        return typeof json === "string" ? json : JSON.stringify(json);
     }
     catch (e) {
         return `#error <${e.name}> (message: ${e.message})`;

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

@@ -1,4 +1,4 @@
-import { KEY_ENUM_NAME, KEY_FQN_NAME, KEY_LITERAL_NAME, VAL_FQN_ANONYMOUS } from "../const/index.js";
+import { KEY_ENUM_NAME, KEY_FQN_NAME, KEY_LITERAL_NAME, VAL_FQN_ANONYMOUS, } from "../const/index.js";
 import { triggerFqn } from "./trigger-fqn.js";
 import { setAnonymousName } from "./set-anonymous-name.js";
 import { isClass } from "./is-class.js";
@@ -7,13 +7,13 @@ export function setAnonymousFqn(target) {
     if (!target) {
         return undefined;
     }
-    if (typeof target === 'function') { // function, class
+    if (typeof target === "function") {
         if (!target.name) {
-            setAnonymousName(target, isClass(target) ? 'Class' : 'function');
+            setAnonymousName(target, isClass(target) ? "Class" : "function");
         }
         return _item(target, target.name);
     }
-    else if (typeof target === 'object') {
+    else if (typeof target === "object") {
         if (Array.isArray(target)) {
             if (target[KEY_LITERAL_NAME]) {
                 return _item(target, target[KEY_LITERAL_NAME]);
@@ -23,7 +23,6 @@ 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-anonymous-name.js

@@ -9,25 +9,25 @@ let _counter = 0;
 const where = `${FQN}.nameFn`;
 let _leyyo;
 export function setAnonymousName(target, prefix) {
-    if (typeof target !== 'function') {
+    if (typeof target !== "function") {
         if (!_leyyo) {
             _leyyo = $$get_leyyo_fn();
         }
-        throw new _leyyo.developerError(`Invalid target`, testCase(FQN, 'ZZZ'), where);
+        throw new _leyyo.developerError(`Invalid target`, testCase(FQN, "ZZZ"), where);
     }
     if (isText(prefix)) {
         if (!_pattern.test(prefix)) {
             if (!_leyyo) {
                 _leyyo = $$get_leyyo_fn();
             }
-            throw new _leyyo.developerError(`Invalid anonymous name part [${prefix}]`, testCase(FQN, 'ZZZ'), where);
+            throw new _leyyo.developerError(`Invalid anonymous name part [${prefix}]`, testCase(FQN, "ZZZ"), where);
         }
     }
     else {
-        prefix = isClass(target) ? 'Class' : 'function';
+        prefix = isClass(target) ? "Class" : "function";
     }
     _counter++;
-    const name = VAL_NAME_ANONYMOUS + [prefix, _counter].join('$');
+    const name = VAL_NAME_ANONYMOUS + [prefix, _counter].join("$");
     _setName(target, name, false);
     return name;
 }
@@ -36,27 +36,27 @@ function _setName(target, name, checkAnonymous) {
         _leyyo = $$get_leyyo_fn();
     }
     if (!isText(name)) {
-        throw new _leyyo.developerError(`Invalid name`, testCase(FQN, 'ZZZ'), where);
+        throw new _leyyo.developerError(`Invalid name`, testCase(FQN, "ZZZ"), where);
     }
-    if (name.includes('.')) {
-        throw new _leyyo.developerError(`Invalid name with dot`, testCase(FQN, 'ZZZ'), where);
+    if (name.includes(".")) {
+        throw new _leyyo.developerError(`Invalid name with dot`, testCase(FQN, "ZZZ"), where);
     }
     if (checkAnonymous && name.startsWith(VAL_NAME_ANONYMOUS)) {
-        throw new _leyyo.developerError(`Invalid name with anonymous`, testCase(FQN, 'ZZZ'), where);
+        throw new _leyyo.developerError(`Invalid name with anonymous`, testCase(FQN, "ZZZ"), where);
     }
-    if (typeof target !== 'function') {
-        throw new _leyyo.developerError(`Invalid name [${name}]`, testCase(FQN, 'ZZZ'), where);
+    if (typeof target !== "function") {
+        throw new _leyyo.developerError(`Invalid name [${name}]`, testCase(FQN, "ZZZ"), where);
     }
     try {
-        Object.defineProperty(target, 'name', {
+        Object.defineProperty(target, "name", {
             value: name,
             configurable: true,
             writable: true,
-            enumerable: true
+            enumerable: true,
         });
     }
     catch (e) {
-        new _leyyo.developerError(`Unexpected error during set name [${name}]`, testCase(FQN, 'ZZZ'), where).log(e);
+        new _leyyo.developerError(`Unexpected error during set name [${name}]`, testCase(FQN, "ZZZ"), where).log(e);
         return false;
     }
     return true;

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

@@ -1,9 +1,2 @@
 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

@@ -3,46 +3,39 @@ import { $$get_leyyo_fn } from "./leyyo-fn.js";
 import { isClass } from "./is-class.js";
 import { isText } from "./is-text.js";
 import { testCase } from "./test-case.js";
-import { KEY_ENUM_NAME, KEY_FQN_NAME, KEY_LITERAL_NAME, VAL_FQN_ANONYMOUS } from "../const/index.js";
+import { KEY_ENUM_NAME, KEY_FQN_NAME, KEY_LITERAL_NAME, VAL_FQN_ANONYMOUS, } from "../const/index.js";
 import { triggerFqn } from "./trigger-fqn.js";
 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();
     }
     if (!isText(fqn)) {
-        new _leyyo.developerError('Invalid fqn name', testCase(FQN, 150), where).log();
+        new _leyyo.developerError("Invalid fqn name", testCase(FQN, 150), where).log();
         return undefined;
     }
-    if (fqn.startsWith('.') || fqn.endsWith('.')) {
-        new _leyyo.developerError('Invalid fqn name with dots', testCase(FQN, 'ZZZ'), where).log();
+    if (fqn.startsWith(".") || fqn.endsWith(".")) {
+        new _leyyo.developerError("Invalid fqn name with dots", testCase(FQN, "ZZZ"), where).log();
         return undefined;
     }
     if (fqn.startsWith(VAL_FQN_ANONYMOUS)) {
-        new _leyyo.developerError('Anonymous fqn is used', testCase(FQN, 'ZZZ'), where).log();
+        new _leyyo.developerError("Anonymous fqn is used", testCase(FQN, "ZZZ"), where).log();
         return undefined;
     }
     if (!target) {
         new _leyyo.developerError(`Empty fqn target [${fqn}]`, testCase(FQN, 151), where).log();
         return undefined;
     }
-    if (typeof target === 'function') { // function, class
+    if (typeof target === "function") {
         if (!target.name) {
-            setAnonymousName(target, isClass(target) ? 'Class' : 'function');
+            setAnonymousName(target, isClass(target) ? "Class" : "function");
         }
         return _item(target, target.name, fqn);
     }
-    else if (typeof target === 'object') {
+    else if (typeof target === "object") {
         if (Array.isArray(target)) {
             if (target[KEY_LITERAL_NAME]) {
                 return _item(target, target[KEY_LITERAL_NAME], fqn);

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

@@ -1,27 +1,3 @@
-/**
- * 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,47 +3,23 @@ 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') {
+    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') {
+    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)) {
+    if (!["symbol", "string"].includes(typeof key)) {
         return false;
     }
-    if (!target || !['object', 'function'].includes(typeof target)) {
+    if (!target || !["object", "function"].includes(typeof target)) {
         return false;
     }
     try {
@@ -51,7 +27,7 @@ export function setProp(target, key, value) {
             value,
             configurable: false,
             writable: false,
-            enumerable: typeof key === 'string'
+            enumerable: typeof key === "string",
         });
         return true;
     }
@@ -59,7 +35,7 @@ export function setProp(target, key, value) {
         if (!_leyyo) {
             _leyyo = $$get_leyyo_fn();
         }
-        new _leyyo.developerError(`Unexpected error during set name [${key.toString()}]`, testCase(FQN, 'ZZZ'), where).log(e);
+        new _leyyo.developerError(`Unexpected error during set name [${key.toString()}]`, testCase(FQN, "ZZZ"), where).log(e);
         return false;
     }
 }

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

@@ -1,8 +1,2 @@
 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,12 +1,6 @@
 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') {
+    if (typeof fn === "function") {
         fn[KEY_LOADER_STAMP] = true;
         return fn;
     }

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

@@ -1,8 +1 @@
-/**
- * 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,19 +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;
+    pck = typeof pck === "string" ? pck : FQN;
     let caseStr;
-    if (typeof caseNo === 'string') {
+    if (typeof caseNo === "string") {
         caseStr = caseNo;
     }
-    else if (typeof caseNo === 'number') {
+    else if (typeof caseNo === "number") {
         caseStr = caseNo.toString(10);
     }
     else {

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

@@ -1,8 +1 @@
-/**
- * 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,14 +1,7 @@
 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 : '???';
+    testCase = typeof testCase === "string" ? testCase : `${FQN}@${randomTestNo()}`;
+    title = typeof title === "string" ? title : "???";
     return `[test:${testCase}] >> ${title}`;
 }

package/dist/function/trigger-fqn.js

@@ -4,13 +4,12 @@ export function triggerFqn(target, full) {
         const arr = target[KEY_FQN_ON_SET];
         delete target[KEY_FQN_ON_SET];
         if (Array.isArray(arr)) {
-            arr.forEach(callback => {
-                if (typeof callback === 'function') {
+            arr.forEach((callback) => {
+                if (typeof callback === "function") {
                     try {
                         callback(full);
                     }
                     catch (_e) {
-                        // nothing
                     }
                 }
             });