@leyyo/type 1.3.6 → 1.3.7

package/dist/to/to-enum-value.js

@@ -13,15 +13,15 @@ import { isBareObject } from "../is/index.js";
 export function toEnumValue(value, opt) {
     let o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidEnumValueError, 'enum-map');
+        return _toEmpty(value, o, InvalidEnumValueError, "enum-map");
     }
     let err;
     if (!isBareObject(o.enum) || Object.keys(o.enum).length < 1) {
         o = optAppend(o, {
-            issue: 'not:allowed',
+            issue: "not:allowed",
             mapType: typeof o.enum,
         });
-        err = new InvalidEnumMapError('Invalid enum map', o);
+        err = new InvalidEnumMapError("Invalid enum map", o);
         if (!o.silent) {
             throw err;
         }
@@ -29,11 +29,12 @@ export function toEnumValue(value, opt) {
         return undefined;
     }
     let v;
+    let num;
     switch (typeof value) {
-        case 'string':
+        case "string":
             value = value.trim();
-            if (value === '') {
-                return _toEmpty(value, o, InvalidEnumValueError, 'enum-map');
+            if (!value) {
+                return _toEmpty(value, o, InvalidEnumValueError, "enum-map");
             }
             v = _inEnumMap(value, o.enum);
             if (v !== undefined) {
@@ -46,12 +47,12 @@ export function toEnumValue(value, opt) {
                 }
             }
             o = optAppend(o, {
-                issue: 'invalid',
-                expected: 'enum',
-                type: 'string',
+                issue: "invalid",
+                expected: "enum",
+                type: "string",
                 value,
             });
-            err = new InvalidEnumValueError('Invalid enum for text', o);
+            err = new InvalidEnumValueError("Invalid enum for text", o);
             if (!o.silent) {
                 throw err;
             }
@@ -59,10 +60,10 @@ export function toEnumValue(value, opt) {
                 err.logWarn();
             }
             return undefined;
-        case 'number':
-            const num = _realNumber(value, o);
+        case "number":
+            num = _realNumber(value, o);
             if (num === undefined) {
-                return undefined;
+                return _toEmpty(value, o, InvalidEnumValueError, "enum-map");
             }
             v = _inEnumMap(num, o.enum);
             if (v !== undefined) {
@@ -75,12 +76,12 @@ export function toEnumValue(value, opt) {
                 }
             }
             o = optAppend(o, {
-                issue: 'invalid',
-                expected: 'enum',
-                type: 'number',
+                issue: "invalid",
+                expected: "enum",
+                type: "number",
                 value,
             });
-            err = new InvalidEnumValueError('Invalid enum for number', o);
+            err = new InvalidEnumValueError("Invalid enum for number", o);
             if (!o.silent) {
                 throw err;
             }
@@ -88,7 +89,7 @@ export function toEnumValue(value, opt) {
                 err.logWarn();
             }
             return undefined;
-        case 'object':
+        case "object":
             if (Array.isArray(value) && value.length === 1) {
                 return toEnumValue(value[0], o);
             }
@@ -96,8 +97,8 @@ export function toEnumValue(value, opt) {
                 return toEnumValue(value.id, o);
             }
             break;
-        case 'function':
-            return toEnumValue(_toRun(value, o, 'function'), o);
+        case "function":
+            return toEnumValue(_toRun(value, o, "function"), o);
     }
-    return _toElse(value, o, InvalidEnumValueError, 'enum-map');
+    return _toElse(value, o, InvalidEnumValueError, "enum-map");
 }

package/dist/to/to-integer-value.js

@@ -10,15 +10,16 @@ import { InvalidIntegerError } from "../error/index.js";
  * @return {number}
  * */
 export function toIntegerValue(value, opt) {
-    let o = optCheck(opt);
+    const o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidIntegerError, 'integer');
+        return _toEmpty(value, o, InvalidIntegerError, "integer");
     }
+    let num;
     switch (typeof value) {
-        case 'string':
-            return toIntegerValue(_toRun(() => parseInt(value), o, 'from-string'), o);
-        case 'number':
-            let num = _realNumber(value, o);
+        case "string":
+            return toIntegerValue(_toRun(() => parseInt(value), o, "from-string"), o);
+        case "number":
+            num = _realNumber(value, o);
             if (num !== undefined) {
                 num = _safeInteger(value, o);
             }
@@ -26,11 +27,11 @@ export function toIntegerValue(value, opt) {
                 num = Math.floor(num);
             }
             return num;
-        case 'bigint':
-            return toIntegerValue(_toRun(() => Number(value), o, 'from-bigint'), o);
-        case 'boolean':
+        case "bigint":
+            return toIntegerValue(_toRun(() => Number(value), o, "from-bigint"), o);
+        case "boolean":
             return value ? 1 : 0;
-        case 'object':
+        case "object":
             if (Array.isArray(value)) {
                 if (value.length === 1) {
                     return toIntegerValue(value[0], o);
@@ -40,8 +41,8 @@ export function toIntegerValue(value, opt) {
                 return toIntegerValue(value.id, o);
             }
             break;
-        case 'function':
-            return toIntegerValue(_toRun(value, o, 'function'), o);
+        case "function":
+            return toIntegerValue(_toRun(value, o, "function"), o);
     }
-    return _toElse(value, o, InvalidIntegerError, 'integer');
+    return _toElse(value, o, InvalidIntegerError, "integer");
 }

package/dist/to/to-list-value.js

@@ -11,17 +11,18 @@ import { InvalidListError } from "../error/index.js";
  * @return {Array}
  * */
 export function toListValue(value, opt) {
-    let o = optCheck(opt);
+    const o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidListError, 'array');
+        return _toEmpty(value, o, InvalidListError, "array");
     }
+    let clonedArr;
     switch (typeof value) {
         case "string":
         case "boolean":
         case "number":
         case "bigint":
             return toListValue([value], o);
-        case 'object':
+        case "object":
             if (value instanceof Set) {
                 return toListValue(new List(...Array.from(value.values())), o);
             }
@@ -30,12 +31,12 @@ export function toListValue(value, opt) {
                     if (o.zeroLength) {
                         return value;
                     }
-                    return _toEmpty(value, o, InvalidListError, 'array');
+                    return _toEmpty(value, o, InvalidListError, "array");
                 }
                 if (typeof o.itemFn !== "function" || value.length < 1) {
                     return value;
                 }
-                const clonedArr = [...value];
+                clonedArr = [...value];
                 value.clear();
                 const producedArr = toArrayValue(clonedArr, o);
                 if (Array.isArray(producedArr)) {
@@ -47,8 +48,8 @@ export function toListValue(value, opt) {
                 return toListValue(new List(...value), o);
             }
             break;
-        case 'function':
-            return toListValue(_toRun(value, o, 'function'), o);
+        case "function":
+            return toListValue(_toRun(value, o, "function"), o);
     }
-    return _toElse(value, o, InvalidListError, 'array');
+    return _toElse(value, o, InvalidListError, "array");
 }

package/dist/to/to-literal-value.js

@@ -1,5 +1,5 @@
 import { isEmpty, optAppend, optCheck } from "@leyyo/common";
-import { _inEnumAlteration, _inEnumLiteral, _realNumber, _toElse, _toEmpty, _toRun } from "./util.js";
+import { _inEnumAlteration, _inEnumLiteral, _realNumber, _toElse, _toEmpty, _toRun, } from "./util.js";
 import { InvalidLiteralItemsError, InvalidLiteralValueError } from "../error/index.js";
 import { isBareObject } from "../is/index.js";
 // noinspection JSUnusedGlobalSymbols
@@ -13,15 +13,15 @@ import { isBareObject } from "../is/index.js";
 export function toLiteralValue(value, opt) {
     let o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidLiteralValueError, 'literal-items');
+        return _toEmpty(value, o, InvalidLiteralValueError, "literal-items");
     }
     let err;
     if (!Array.isArray(o.literal) || o.literal.length < 1) {
         o = optAppend(o, {
-            issue: 'not:allowed',
+            issue: "not:allowed",
             itemsType: typeof o.literal,
         });
-        err = new InvalidLiteralItemsError('Invalid enum literals', o);
+        err = new InvalidLiteralItemsError("Invalid enum literals", o);
         if (!o.silent) {
             throw err;
         }
@@ -29,11 +29,12 @@ export function toLiteralValue(value, opt) {
         return undefined;
     }
     let v;
+    let num;
     switch (typeof value) {
-        case 'string':
+        case "string":
             value = value.trim();
-            if (value === '') {
-                return undefined;
+            if (!value) {
+                return _toEmpty(undefined, o, InvalidLiteralValueError, "literal-items");
             }
             v = _inEnumLiteral(value, o.literal);
             if (v !== undefined) {
@@ -46,12 +47,12 @@ export function toLiteralValue(value, opt) {
                 }
             }
             o = optAppend(o, {
-                issue: 'invalid',
-                expected: 'enum',
-                type: 'string',
+                issue: "invalid",
+                expected: "enum",
+                type: "string",
                 value,
             });
-            err = new InvalidLiteralValueError('Invalid literal for text', o);
+            err = new InvalidLiteralValueError("Invalid literal for text", o);
             if (!o.silent) {
                 throw err;
             }
@@ -59,10 +60,10 @@ export function toLiteralValue(value, opt) {
                 err.logWarn();
             }
             return undefined;
-        case 'number':
-            const num = _realNumber(value, o);
+        case "number":
+            num = _realNumber(value, o);
             if (num === undefined) {
-                return undefined;
+                return _toEmpty(undefined, o, InvalidLiteralValueError, "literal-items");
             }
             v = _inEnumLiteral(value, o.literal);
             if (v !== undefined) {
@@ -75,12 +76,12 @@ export function toLiteralValue(value, opt) {
                 }
             }
             o = optAppend(o, {
-                issue: 'invalid',
-                expected: 'enum',
-                type: 'number',
+                issue: "invalid",
+                expected: "enum",
+                type: "number",
                 value,
             });
-            err = new InvalidLiteralValueError('Invalid enum for number', o);
+            err = new InvalidLiteralValueError("Invalid enum for number", o);
             if (!o.silent) {
                 throw err;
             }
@@ -88,7 +89,7 @@ export function toLiteralValue(value, opt) {
                 err.logWarn();
             }
             return undefined;
-        case 'object':
+        case "object":
             if (Array.isArray(value) && value.length === 1) {
                 return toLiteralValue(value[0], o);
             }
@@ -96,8 +97,8 @@ export function toLiteralValue(value, opt) {
                 return toLiteralValue(value.id, o);
             }
             break;
-        case 'function':
-            return toLiteralValue(_toRun(value, o, 'function'), o);
+        case "function":
+            return toLiteralValue(_toRun(value, o, "function"), o);
     }
-    return _toElse(value, o, InvalidLiteralValueError, 'literal-items');
+    return _toElse(value, o, InvalidLiteralValueError, "literal-items");
 }

package/dist/to/to-map-value.js

@@ -11,51 +11,54 @@ import { InvalidMapError } from "../error/index.js";
  * @return {Map}
  * */
 export function toMapValue(value, opt) {
-    let o = optCheck(opt);
+    const o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidMapError, 'object');
+        return _toEmpty(value, o, InvalidMapError, "object");
     }
     switch (typeof value) {
-        case 'object':
-            if (value instanceof Set) {
-                if (value.size === 1) {
-                    return toMapValue(Array.from(value.values())[0], o);
-                }
-            }
-            else if (value instanceof List) {
-                if (value.length === 1) {
-                    return toMapValue(value[0], o);
-                }
-            }
-            else if (value instanceof Map) {
-                const cloned = Object.fromEntries(value.entries());
-                value.clear();
-                const produced = toObjectValue(cloned, o);
-                if (produced) {
-                    for (const [k, v] of Object.entries(produced)) {
-                        value.set(k, v);
-                    }
-                }
-                return value;
-            }
-            else if (Array.isArray(value)) {
-                if (value.length === 1) {
-                    return toMapValue(value[0], o);
-                }
+        case "object":
+            return _toMapValue(value, o);
+        case "function":
+            return _toMapValue(_toRun(value, o, "function"), o);
+    }
+    return _toElse(value, o, InvalidMapError, "object");
+}
+function _toMapValue(value, options) {
+    if (value instanceof Set) {
+        if (value.size === 1) {
+            return toMapValue(Array.from(value.values())[0], options);
+        }
+    }
+    else if (value instanceof List) {
+        if (value.length === 1) {
+            return toMapValue(value[0], options);
+        }
+    }
+    else if (value instanceof Map) {
+        const cloned = Object.fromEntries(value.entries());
+        value.clear();
+        const produced = toObjectValue(cloned, options);
+        if (produced) {
+            for (const [k, v] of Object.entries(produced)) {
+                value.set(k, v);
             }
-            else if (this.lyy.is.bareObject(value)) {
-                const map = new Map();
-                const produced = toObjectValue(value, o);
-                if (produced) {
-                    for (const [k, v] of Object.entries(produced)) {
-                        map.set(k, v);
-                    }
-                }
-                return map;
+        }
+        return value;
+    }
+    else if (Array.isArray(value)) {
+        if (value.length === 1) {
+            return toMapValue(value[0], options);
+        }
+    }
+    else if (this.lyy.is.bareObject(value)) {
+        const map = new Map();
+        const produced = toObjectValue(value, options);
+        if (produced) {
+            for (const [k, v] of Object.entries(produced)) {
+                map.set(k, v);
             }
-            break;
-        case 'function':
-            return toMapValue(_toRun(value, o, 'function'), o);
+        }
+        return map;
     }
-    return _toElse(value, o, InvalidMapError, 'object');
+    return _toElse(value, options, InvalidMapError, "object");
 }

package/dist/to/to-number-value.js

@@ -10,28 +10,28 @@ import { InvalidNumberError } from "../error/index.js";
  * @return {number}
  * */
 export function toNumberValue(value, opt) {
-    let o = optCheck(opt);
+    const o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidNumberError, 'number');
+        return _toEmpty(value, o, InvalidNumberError, "number");
     }
     switch (typeof value) {
-        case 'string':
-            return toNumberValue(_toRun(() => parseFloat(value), o, 'from-string'), o);
-        case 'number':
+        case "string":
+            return toNumberValue(_toRun(() => parseFloat(value), o, "from-string"), o);
+        case "number":
             return _realNumber(value, o);
-        case 'bigint':
-            return toNumberValue(_toRun(() => Number(value), o, 'from-bigint'), o);
-        case 'boolean':
+        case "bigint":
+            return toNumberValue(_toRun(() => Number(value), o, "from-bigint"), o);
+        case "boolean":
             return value ? 1 : 0;
-        case 'object':
+        case "object":
             if (Array.isArray(value)) {
                 if (value.length === 1) {
                     return toNumberValue(value[0], o);
                 }
             }
             break;
-        case 'function':
-            return toNumberValue(_toRun(value, o, 'function'), o);
+        case "function":
+            return toNumberValue(_toRun(value, o, "function"), o);
     }
-    return _toElse(value, o, InvalidNumberError, 'number');
+    return _toElse(value, o, InvalidNumberError, "number");
 }

package/dist/to/to-object-value.js

@@ -1,4 +1,4 @@
-import { InvalidValueError, isEmpty, List, optAppend, optCheck, optField } from "@leyyo/common";
+import { InvalidValueError, isEmpty, List, optAppend, optCheck, optField, } from "@leyyo/common";
 import { _toElse, _toEmpty, _toRun } from "./util.js";
 import { isBareObject } from "../is/index.js";
 import { InvalidObjectError } from "../error/index.js";
@@ -11,13 +11,13 @@ import { InvalidObjectError } from "../error/index.js";
  * @return {Record}
  * */
 export function toObjectValue(value, opt) {
-    let o = optCheck(opt);
+    const o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidObjectError, 'object');
+        return _toEmpty(value, o, InvalidObjectError, "object");
     }
     let err;
     switch (typeof value) {
-        case 'object':
+        case "object":
             if (value instanceof Set) {
                 if (value.size === 1) {
                     return toObjectValue(Array.from(value.values())[0], o);
@@ -39,7 +39,7 @@ export function toObjectValue(value, opt) {
             else if (isBareObject(value)) {
                 const keys = [];
                 for (const [k, v] of Object.entries(value)) {
-                    if (typeof k !== 'symbol' && typeof v !== 'function') {
+                    if (typeof k !== "symbol" && typeof v !== "function") {
                         keys.push(k);
                     }
                 }
@@ -47,13 +47,13 @@ export function toObjectValue(value, opt) {
                     if (o.zeroLength) {
                         return {};
                     }
-                    return _toEmpty(value, o, InvalidObjectError, 'object');
+                    return _toEmpty(value, o, InvalidObjectError, "object");
                 }
                 if (typeof o.keyFn !== "function" && typeof o.itemFn !== "function") {
                     return value;
                 }
                 // value item
-                let o2 = { ...o };
+                const o2 = { ...o };
                 delete o2.nullable;
                 o2.nullable = o2.itemNullable;
                 const o2Field = o2.field;
@@ -65,32 +65,32 @@ export function toObjectValue(value, opt) {
                 delete o3.field;
                 const cloned = { ...value };
                 // clear existing object
-                keys
-                    .forEach(k => {
+                keys.forEach((k) => {
                     try {
                         delete value[k];
                     }
-                    catch (e) {
+                    catch (_e) {
+                        // nothing
                     }
                 });
                 let index = -1;
-                keys.forEach(k => {
+                keys.forEach((k) => {
                     index++;
                     let newKey;
                     let next = true;
-                    if (typeof o.keyFn === 'function') {
+                    if (typeof o.keyFn === "function") {
                         o3.field = o3Field;
                         optField(o3, `(k:${index})`);
-                        newKey = _toRun(() => o.keyFn(k, o3), o3, 'key');
+                        newKey = _toRun(() => o.keyFn(k, o3), o3, "key");
                         if (isEmpty(newKey)) {
                             next = false;
                             o3 = optAppend(o3, {
-                                issue: 'invalid',
-                                expected: 'boolean',
-                                type: 'string',
+                                issue: "invalid",
+                                expected: "boolean",
+                                type: "string",
                                 value,
                             });
-                            err = new InvalidValueError('Invalid boolean like for text', o);
+                            err = new InvalidValueError("Invalid boolean like for text", o);
                             if (!o.silent) {
                                 throw err;
                             }
@@ -104,15 +104,16 @@ export function toObjectValue(value, opt) {
                     }
                     if (next) {
                         let newValue = cloned[k];
-                        if (typeof o.valueFn === 'function') {
+                        if (typeof o.valueFn === "function") {
                             o2.field = o2Field;
                             optField(o2, newKey);
-                            newValue = _toRun(() => o.itemFn(k, o2), o2, 'item');
+                            newValue = _toRun(() => o.itemFn(k, o2), o2, "item");
                             if (!o.ignoreEmptyItems || !isEmpty(newValue)) {
                                 try {
                                     value[newKey] = newValue;
                                 }
-                                catch (e) {
+                                catch (_e) {
+                                    // nothing
                                 }
                             }
                         }
@@ -120,7 +121,8 @@ export function toObjectValue(value, opt) {
                             try {
                                 value[newKey] = newValue;
                             }
-                            catch (e) {
+                            catch (_e) {
+                                // nothing
                             }
                         }
                     }
@@ -129,8 +131,8 @@ export function toObjectValue(value, opt) {
             }
             // other objects, don't toch
             return value;
-        case 'function':
-            return toObjectValue(_toRun(value, o, 'function'), o);
+        case "function":
+            return toObjectValue(_toRun(value, o, "function"), o);
     }
-    return _toElse(value, o, InvalidObjectError, 'object');
+    return _toElse(value, o, InvalidObjectError, "object");
 }

package/dist/to/to-set-value.js

@@ -11,9 +11,9 @@ import { InvalidSetError } from "../error/index.js";
  * @return {Set}
  * */
 export function toSetValue(value, opt) {
-    let o = optCheck(opt);
+    const o = optCheck(opt);
     if (isEmpty(value)) {
-        return _toEmpty(value, o, InvalidSetError, 'array');
+        return _toEmpty(value, o, InvalidSetError, "array");
     }
     switch (typeof value) {
         case "string":
@@ -21,13 +21,13 @@ export function toSetValue(value, opt) {
         case "number":
         case "bigint":
             return toSetValue([value], o);
-        case 'object':
+        case "object":
             if (value instanceof Set) {
                 if (value.size < 1) {
                     if (o.zeroLength) {
                         return value;
                     }
-                    return _toEmpty(value, o, InvalidSetError, 'array');
+                    return _toEmpty(value, o, InvalidSetError, "array");
                 }
                 if (typeof o.itemFn !== "function" || value.size < 1) {
                     return value;
@@ -36,7 +36,7 @@ export function toSetValue(value, opt) {
                 value.clear();
                 const producedArr = toArrayValue(clonedArr, o);
                 if (Array.isArray(producedArr)) {
-                    producedArr.forEach(item => value.add(item));
+                    producedArr.forEach((item) => value.add(item));
                 }
                 return value;
             }
@@ -47,8 +47,8 @@ export function toSetValue(value, opt) {
                 return new Set([...value]);
             }
             break;
-        case 'function':
-            return toSetValue(_toRun(value, o, 'function'), o);
+        case "function":
+            return toSetValue(_toRun(value, o, "function"), o);
     }
-    return _toElse(value, o, InvalidSetError, 'array');
+    return _toElse(value, o, InvalidSetError, "array");
 }