@valkyriestudios/utils 12.24.0 → 12.25.1

package/README.md

@@ -30,7 +30,7 @@ isNotEmptyArray([]); // FALSE
 isNotEmptyArray([0, 1, 2]); // TRUE
 ```
 
-### array/mapKey(val:Record[], key:string, opts:object={})
+### array/mapKey(val:Record[], key:string, opts?:{merge?:boolean;filter_fn?:(el:T) => boolean})
 Map a non-primitive object array into an object map by key
 ```typescript
 import mapKey from '@valkyriestudios/utils/array/mapKey';
@@ -39,9 +39,7 @@ mapKey([
     {uid: 15, name: 'Jonas'},
     {uid: 87, name: 'Josh'},
 ], 'uid');
-
-output:
-
+/* Expected output: */
 {
     12: {uid: 12, name: 'Peter'},
     15: {uid: 15, name: 'Jonas'},
@@ -64,9 +62,7 @@ mapKey([
     new Date(),
     {uid: 87, name: 'Josh'},
 ], 'uid');
-
-output:
-
+/* Expected output: */
 {
     12: {uid: 12, name: 'Peter'},
     15: {uid: 15, name: 'Jonas'},
@@ -92,9 +88,7 @@ mapKey([
     {uid: 87, name: 'Josh'},
     {uid: 12, name: 'Farah'},
 ], 'uid', {merge: true})
-
-output:
-
+/* Expected output: */
 {
     12: {uid: 12, name: 'Farah'},
     15: {uid: 15, name: 'Bob', dob: '2022-02-07'},
@@ -102,6 +96,24 @@ output:
 }
 ```
 
+allows filtering out objects with a custom filter_fn:
+```typescript
+import mapKey from '@valkyriestudios/utils/array/mapKey';
+mapKey([
+    {uid: 12, name: 'Peter', isActive: true},
+    {uid: 15, name: 'Jonas', dob: '2022-02-07', isActive: true},
+    {uid: 15, name: 'Bob', isActive: false},
+    {name: 'Alana', isActive: true},
+    {uid: 87, name: 'Josh', isActive: false},
+    {uid: 12, name: 'Farah', isActive: false},
+], 'uid', {merge: true})
+/* Expected output: */
+{
+    12: {uid: 12, name: 'Peter', isActive: true},
+    15: {uid: 15, name: 'Jonas', dob: '2022-02-07'},
+}
+```
+
 ### array/mapFn(val:Record[], key:Function, opts:object={})
 Same behavior as mapKey but instead of a key, a function is passed to generate your own key. Eg:
 
@@ -112,9 +124,7 @@ mapFn([
     {uid: 15, name: 'Jonas'},
     {uid: 87, name: 'Josh'},
 ], el => el.uid)
-
-output:
-
+/* Expected output: */
 {
     12: {uid: 12, name: 'Peter'},
     15: {uid: 15, name: 'Jonas'},
@@ -124,7 +134,7 @@ output:
 
 options are the same as the mapKey function
 
-### array/mapPrimitive(val:any[], opts:object={valtrim:false,keyround:false,valround:false})
+### array/mapPrimitive(val:any[], opts?:{valtrim:false;keyround:false;valround:false;filter_fn:(el)=>boolean})
 Map an array of primitives (number/string)
 ```typescript
 import mapPrimitive from '@valkyriestudios/utils/array/mapPrimitive';
@@ -133,6 +143,12 @@ mapPrimitive(['hello', 'hello', 'foo', 'bar']); // {hello: 'hello', foo: 'foo',
 mapPrimitive(['hello', ' hello', 'foo', '  foo'], {valtrim: true}); // {hello: 'hello', foo: 'foo'}
 ```
 
+Allows filtering out unwanted values:
+```typescript
+import mapPrimitive from '@valkyriestudios/utils/array/mapPrimitive';
+mapPrimitive([1,2,'bla', 3, false], {filter_fn: isNumber}); // {1: 1, 2: 2, 3: 3}
+```
+
 ### array/groupBy(val:Record[], handler:Function|string)
 Return a grouped object from an array. This function **will automatically filter out any non/empty objects**.
 
@@ -428,7 +444,15 @@ Available tokens for usage in spec:
 | `Z` | Zone, does not allow full zone names, only Z or offsets | `Z` `+02:00` |
 | `ISO` | Check for full iso date format, take note this enforces milliseconds as a requirement | 2024-02-03T10:28:30.000Z |
 
-Note: The `ISO` token is a shorthand for `YYYY-MM-DDTHH:mm:ss.SSSZ`
+Allows for marking certain portions as optional by wrapping in `{...}`:
+```typescript
+import isFormat from '@valkyriestudios/utils/date/isFormat';
+isFormat('2024-02-07', 'YYYY-MM-DD{THH:mm:ss}'); // true
+isFormat('2024-02-07T14:50', 'YYYY-MM-DD{THH:mm:ss}'); // false, optional part passed but invalid
+isFormat('2024-02-07T14:50:30', 'YYYY-MM-DD{THH:mm:ss}'); // true
+```
+
+Note: The `ISO` token is a shorthand for `YYYY-MM-DDTHH:mm:ss{.SSS}Z`
 Note: You can escape characters by surrounding them with `[...]` in your spec, eg: `YYYY-[Q]Q` would check for example `2024-Q1`
 
 ### date/diff(val_a:Date, val_b:Date, key:string)
@@ -787,7 +811,7 @@ isFormData(new FormData()); // TRUE
 isFormData({hi: 'there'}); // FALSE
 ```
 
-### formdata/toObject(val:FormData, {raw?:string[]|true;single?:string[]} = {})
+### formdata/toObject(val:FormData, {raw?:string[]|true;single?:string[];normalize_bool?:boolean;normalize_date?:bool;normalize_number?:bool} = {})
 Converts an instance of FormData to an object
 ```typescript
 import toObject from '@valkyriestudios/utils/formdata/toObject';
@@ -800,7 +824,7 @@ form.append('emptyField', '');
 toObject(form); // {name: 'Alice', hobbies: ['reading', 'writing'], emptyField: ''}
 ```
 
-Automatically converts strings to numbers and booleans, and nests objects/arrays based on key structures:
+Automatically converts strings to numbers, dates, booleans and nests objects/arrays based on key structures:
 ```typescript
 const form = new FormData();
 form.append('user[0].name', 'Alice');
@@ -853,6 +877,24 @@ formData.append('action', 'reset');
 toObject(formData, { single: ['status', 'action'] }) /* {status: 'inactive', action: 'reset'} */
 ```
 
+Allows configuring what types of data to normalize:
+```typescript
+const form = new FormData();
+form.append('pincode', '0123');
+form.append('enabled', 'false');
+form.append('config.isGood', 'true');
+form.append('config.amount', ' 50 ');
+
+toObject(form, {raw: ['pincode'], normalize_bool: false}); /* {
+    pincode: '0123',
+    enabled: 'false',
+    config: {
+        isGood: 'true',
+        amount: 50,
+    },
+} */
+```
+
 ### hash/guid()
 Generate a unique identifier (guid) according to RFC4122
 ```typescript

package/array/mapFn.d.ts

@@ -1,4 +1,4 @@
-interface mapOptions {
+type MapOptions = {
     /**
      * Allow merging existing keys or not, if not keys will be overriden if they exist
      * (default=false)
@@ -11,8 +11,8 @@ interface mapOptions {
      *  {12: {uid: 12, b: 'ho'}}
      */
     merge?: boolean;
-}
-type mapFn<T extends Record<string, any>> = (entry: T) => (string | number | boolean);
+};
+type MapFn<T extends Record<string, any>> = (entry: T) => (string | number | boolean);
 /**
  * Map an object array into a kv-object through a function that generates a key. Returning a non-string,
  * non-numeric value from the function (eg: false) will filter out the object.
@@ -23,10 +23,10 @@ type mapFn<T extends Record<string, any>> = (entry: T) => (string | number | boo
  *  {12: {uid: 12, name: 'Peter'}, 15: {uid: 15, name: 'Jonas'}}
  *
  * @param {Record<string, any>[]} val - Array to map
- * @param {mapFn} fn - Handler function which is run for each of the objects and should return a string or number
- * @param {mapOptions?} opts - Options object to override built-in defaults
+ * @param {MapFn} fn - Handler function which is run for each of the objects and should return a string or number
+ * @param {MapOptions?} opts - Options object to override built-in defaults
  *
  * @returns {Record<string, T>} KV-Map object
  */
-declare function mapFn<T extends Record<string, any>>(arr: T[], fn: mapFn<T>, opts?: mapOptions): Record<string, T>;
+declare function mapFn<T extends Record<string, any>>(arr: T[], fn: MapFn<T>, opts?: MapOptions): Record<string, T>;
 export { mapFn, mapFn as default };

package/array/mapFn.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapFn = mapFn;
 exports.default = mapFn;
+const merge_1 = require("../object/merge");
 function mapFn(arr, fn, opts) {
     if ((!Array.isArray(arr) || !arr.length) ||
         typeof fn !== 'function')
@@ -17,7 +18,7 @@ function mapFn(arr, fn, opts) {
         if (!Number.isFinite(hash) && !(typeof hash === 'string' && hash.trim().length))
             continue;
         hash = hash + '';
-        map[hash] = MERGE && map[hash] !== undefined ? { ...map[hash], ...el } : el;
+        map[hash] = (MERGE && hash in map ? (0, merge_1.merge)(map[hash], el, { union: true }) : el);
     }
     return map;
 }

package/array/mapKey.d.ts

@@ -1,4 +1,4 @@
-interface mapOptions {
+type MapOptions<T> = {
     /**
      * Allow merging existing keys or not, if not keys will be overriden if they exist
      * (default=false)
@@ -11,7 +11,11 @@ interface mapOptions {
      *  {12: {uid: 12, b: 'ho'}}
      */
     merge?: boolean;
-}
+    /**
+     * Pass a custom filter function which will be run in O(n) while iterating
+     */
+    filter_fn?: (el: T) => boolean;
+};
 /**
  * Map an object array into a kv-object by passing a common key that exists on the objects. Objects for
  * which the key doesn't exist will be filtered out automatically
@@ -23,9 +27,9 @@ interface mapOptions {
  *
  * @param {Record<string,any>[]} val - Array to map
  * @param {string} key - Key to map by
- * @param {mapOptions?} opts - Options object to override built-in defaults
+ * @param {MapOptions?} opts - Options object to override built-in defaults
  *
  * @returns {Record<string, T>} KV-Map object
  */
-declare function mapKey<T extends Record<string, any>>(arr: T[], key: string, opts?: mapOptions): Record<string, T>;
+declare function mapKey<T extends Record<string, any>>(arr: T[], key: string, opts?: MapOptions<T>): Record<string, T>;
 export { mapKey, mapKey as default };

package/array/mapKey.js

@@ -2,15 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapKey = mapKey;
 exports.default = mapKey;
+const merge_1 = require("../object/merge");
 function mapKey(arr, key, opts) {
     if (!Array.isArray(arr) || typeof key !== 'string')
         return {};
-    const key_s = key.trim();
-    if (!key_s.length)
-        return {};
     const len = arr.length;
     if (!len)
         return {};
+    const key_s = key.trim();
+    if (!key_s.length)
+        return {};
+    const FILTER_FN = opts?.filter_fn;
     const MERGE = opts?.merge === true;
     const map = {};
     for (let i = 0; i < len; i++) {
@@ -18,7 +20,9 @@ function mapKey(arr, key, opts) {
         const el_key = el?.[key_s];
         if (el_key === undefined)
             continue;
-        map[el_key] = MERGE && el_key in map ? { ...map[el_key], ...el } : el;
+        if (FILTER_FN && !FILTER_FN(el))
+            continue;
+        map[el_key] = (MERGE && el_key in map ? (0, merge_1.merge)(map[el_key], el, { union: true }) : el);
     }
     return map;
 }

package/array/mapPrimitive.d.ts

@@ -1,4 +1,4 @@
-interface mapOptions {
+type MapOptions = {
     /**
      * Automatically trim all string values
      * (default=false)
@@ -18,7 +18,11 @@ interface mapOptions {
      * eg: mapPrimitive([5.432, 5.4, 5.43, 4.2, 4.1], {keyround: true}) -> {5: 5.43, 4: 4.1}
      */
     keyround?: boolean;
-}
+    /**
+     * Pass a custom filter function which will be run in O(n) while iterating
+     */
+    filter_fn?: (el: unknown) => boolean;
+};
 type mapReturn = Record<string, string | number>;
 /**
  * Map an array of primitive values (numbers/strings) into a kv-object
@@ -30,7 +34,7 @@ type mapReturn = Record<string, string | number>;
  *  {hello: 'hello', foo: 'foo', bar: 'bar'}
  *
  * @param {unknown[]} val - Array to map
- * @param {mapOptions?} opts - Options object to override built-in defaults
+ * @param {MapOptions?} opts - Options object to override built-in defaults
  */
-declare function mapPrimitive(arr: unknown[], opts?: mapOptions): mapReturn;
+declare function mapPrimitive(arr: unknown[], opts?: MapOptions): mapReturn;
 export { mapPrimitive, mapPrimitive as default };

package/array/mapPrimitive.js

@@ -10,11 +10,16 @@ function mapPrimitive(arr, opts = {}) {
     const VALTRIM = opts?.valtrim === true;
     const VALROUND = (0, isIntegerAboveOrEqual_1.isIntegerAboveOrEqual)(opts?.valround, 0)
         ? opts?.valround
-        : opts?.valround === true;
+        : opts?.valround === true
+            ? 0
+            : null;
     const KEYROUND = opts?.keyround === true;
+    const FILTER_FN = opts?.filter_fn;
     const map = {};
     for (let i = 0; i < arr.length; i++) {
         const el = arr[i];
+        if (FILTER_FN && !FILTER_FN(el))
+            continue;
         if (typeof el === 'string') {
             const trimmed = el.trim();
             if (!trimmed)
@@ -22,11 +27,9 @@ function mapPrimitive(arr, opts = {}) {
             map[trimmed] = VALTRIM ? trimmed : el;
         }
         else if (Number.isFinite(el)) {
-            map[`${KEYROUND ? Math.round(el) : el}`] = VALROUND === false
+            map[`${KEYROUND ? Math.round(el) : el}`] = VALROUND === null
                 ? el
-                : VALROUND === true
-                    ? Math.round(el)
-                    : (0, round_1.round)(el, VALROUND);
+                : (0, round_1.round)(el, VALROUND);
         }
     }
     return map;

package/date/format.js

@@ -59,7 +59,7 @@ function toZone(d, zone) {
         return new Date(time + zone_offset_cache[ckey]);
     let zone_time = null;
     try {
-        zone_time = new Date(d.toLocaleString(DEFAULT_LOCALE, { timeZone: zone })).getTime();
+        zone_time = new Date(d.toLocaleString(DEFAULT_LOCALE, { timeZone: zone })).getTime() + d.getMilliseconds();
     }
     catch {
         throw new Error(`format: Invalid zone passed - ${zone}`);
@@ -149,7 +149,7 @@ function getSpecChain(spec) {
     let repl_len = 0;
     if (base.indexOf('[') >= 0) {
         base = base.replace(ESCAPE_RGX, match => {
-            const escape_token = '$R' + repl_len++ + '$';
+            const escape_token = '$' + repl_len++ + '$';
             repl.push([escape_token, match.slice(1, -1)]);
             return escape_token;
         });
@@ -171,7 +171,7 @@ function getSpecChain(spec) {
         }
     }
     const chain_len = chain.length;
-    const result = chain_len ? { base, chain, chain_len, repl, repl_len } : null;
+    const result = chain_len ? { base, chain, chain_len, repl } : null;
     spec_cache[spec] = result;
     return result;
 }
@@ -190,15 +190,17 @@ function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ, sow = DEF
         return n_val.toISOString();
     const d = toZone(n_val, zone);
     let base = n_spec.base;
-    const { chain_len, chain, repl_len, repl } = n_spec;
-    for (let i = 0; i < chain_len; i++) {
-        let pos = base.indexOf(chain[i][0]);
-        const formatted_val = chain[i][1](d, locale, sow);
+    const repl = [...n_spec.repl];
+    let repl_len = n_spec.repl.length;
+    for (let i = 0; i < n_spec.chain_len; i++) {
+        const el = n_spec.chain[i];
+        let pos = base.indexOf(el[0]);
+        const token_val = el[1](d, locale, sow);
         while (pos !== -1) {
-            base = base.slice(0, pos) +
-                formatted_val +
-                base.slice(pos + chain[i][2]);
-            pos = base.indexOf(chain[i][0], pos + chain[i][2]);
+            const key = '$' + repl_len++ + '$';
+            repl.push([key, token_val]);
+            base = base.slice(0, pos) + key + base.slice(pos + el[2]);
+            pos = base.indexOf(el[0], pos + el[2]);
         }
     }
     for (let i = 0; i < repl_len; i++) {

package/date/isFormat.js

@@ -45,10 +45,10 @@ const TOKENS = [
         }],
 ];
 const SPEC_ALIASES = {
-    ISO: 'YYYY-MM-DDTHH:mm:ss.SSSZ',
+    ISO: 'YYYY-MM-DDTHH:mm:ss{.SSS}Z',
 };
 const spec_pat_cache = {};
-function compileSpec(spec) {
+function compileSpec(spec, is_chunk = false) {
     if (spec in spec_pat_cache)
         return spec_pat_cache[spec];
     const tokens = [];
@@ -62,6 +62,15 @@ function compileSpec(spec) {
             pat += spec.slice(cursor + 1, end_idx).replace(SPECIAL_CHARS, '\\$&');
             cursor = end_idx + 1;
         }
+        else if (spec[cursor] === '{') {
+            const end_idx = spec.indexOf('}', cursor);
+            if (end_idx === -1)
+                throw new Error('isDateFormat: Unmatched { in format string');
+            const compiled = compileSpec(spec.slice(cursor + 1, end_idx), true);
+            pat += '(?:' + compiled.rgx.source + ')?';
+            tokens.push(...compiled.tokens);
+            cursor = end_idx + 1;
+        }
         else {
             const token_idx = TOKENS.findIndex(([token_key]) => spec.startsWith(token_key, cursor));
             if (token_idx >= 0) {
@@ -76,7 +85,7 @@ function compileSpec(spec) {
             }
         }
     }
-    spec_pat_cache[spec] = { rgx: RegExp('^' + pat + '$'), tokens };
+    spec_pat_cache[spec] = { rgx: is_chunk ? RegExp(pat) : RegExp('^' + pat + '$'), tokens };
     return spec_pat_cache[spec];
 }
 function isDateFormat(input, spec) {
@@ -95,7 +104,8 @@ function isDateFormat(input, spec) {
     const matches = patMatch.slice(1);
     const context = {};
     for (let i = 0; i < matches.length; i++) {
-        if (!TOKENS[tokens[i]][2](matches[i], context))
+        const match = matches[i];
+        if (match !== undefined && !TOKENS[tokens[i]][2](match, context))
             return false;
     }
     const { is12, day, month, year } = context;

package/deep/set.js

@@ -21,8 +21,6 @@ function deepSet(obj, path, value, define = false) {
         .split('.');
     const last_part_ix = parts.length - 1;
     for (let i = 0; i < last_part_ix; i++) {
-        if (parts[i] === '')
-            continue;
         if (Array.isArray(obj)) {
             const idx = parseInt(parts[i]);
             if (!Number.isInteger(idx) || idx < 0)

package/equal.js

@@ -2,41 +2,69 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.equal = equal;
 exports.default = equal;
-const isNumericalNaN_1 = require("./number/isNumericalNaN");
 function isArrayEqual(a, b) {
     const a_len = a.length;
     if (a_len !== b.length)
         return false;
     for (let i = a_len - 1; i >= 0; i--) {
-        if (equal(a[i], b[i]))
-            continue;
-        return false;
+        if (!equal(a[i], b[i]))
+            return false;
     }
     return true;
 }
 function isObjectEqual(a, b) {
-    const keys_a = Object.keys(a);
-    const keys_a_len = keys_a.length;
-    if (keys_a_len !== Object.keys(b).length)
+    const a_keys = Object.keys(a);
+    const b_keys = Object.keys(b);
+    const a_len = a_keys.length;
+    if (a_len !== b_keys.length)
         return false;
-    for (let i = keys_a_len - 1; i >= 0; i--) {
-        if (equal(a[keys_a[i]], b[keys_a[i]]))
-            continue;
+    for (let i = a_len - 1; i >= 0; i--) {
+        const key = a_keys[i];
+        if (!equal(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+function isMapEqual(a, b) {
+    if (a.size !== b.size)
         return false;
+    for (const [key, value] of a) {
+        if (!b.has(key) || !equal(value, b.get(key)))
+            return false;
     }
     return true;
 }
 function equal(a, b) {
-    if (a instanceof Date)
-        return b instanceof Date && a.valueOf() === b.valueOf();
-    if (a instanceof RegExp)
-        return b instanceof RegExp && String(a) === String(b);
-    if (Array.isArray(a))
-        return Array.isArray(b) && isArrayEqual(a, b);
-    if (Object.prototype.toString.call(a) === '[object Object]') {
-        return Object.prototype.toString.call(b) === '[object Object]' && isObjectEqual(a, b);
+    if (a === b)
+        return true;
+    switch (typeof a) {
+        case 'number':
+            return Number.isNaN(b) && Number.isNaN(a);
+        case 'object': {
+            if (a === null || b === null)
+                return false;
+            if (Array.isArray(a))
+                return Array.isArray(b) && isArrayEqual(a, b);
+            const proto_a = Object.prototype.toString.call(a);
+            const proto_b = Object.prototype.toString.call(b);
+            if (proto_a !== proto_b)
+                return false;
+            switch (proto_a) {
+                case '[object Date]':
+                    return a.valueOf() === b.valueOf();
+                case '[object Object]':
+                    return isObjectEqual(a, b);
+                case '[object Error]':
+                    return a.name === b.name && a.message === b.message;
+                case '[object RegExp]':
+                    return String(a) === String(b);
+                case '[object Map]':
+                    return isMapEqual(a, b);
+                default:
+                    return false;
+            }
+        }
+        default:
+            return false;
     }
-    if ((0, isNumericalNaN_1.isNumericalNaN)(a))
-        return (0, isNumericalNaN_1.isNumericalNaN)(b);
-    return a === b;
 }

package/formdata/toObject.d.ts

@@ -1,4 +1,4 @@
-type toObjectConfig = {
+type ToObjectConfig = {
     /**
      * Pass array of keys that should not be normalized into number/bool when seen
      */
@@ -7,6 +7,18 @@ type toObjectConfig = {
      * Pass array of keys that should only have a single value (e.g., 'action')
      */
     single?: string[];
+    /**
+     * Whether or not we should normalize booleans, defaults to true if not set
+     */
+    normalize_bool?: boolean;
+    /**
+     * Whether or not we should normalize dates, defaults to true if not set
+     */
+    normalize_date?: boolean;
+    /**
+     * Whether or not we should normalize numbers, defaults to true if not set
+     */
+    normalize_number?: boolean;
 };
 /**
  * Converts a FormData instance to a json object
@@ -21,7 +33,7 @@ type toObjectConfig = {
  *  {name: 'Alice', hobbies: ['reading', 'writing'], emptyField: ''}
  *
  * @param {FormData} val - FormData instance to convert to an object
- * @param {}
+ * @param {ToObjectConfig?} config - Config for conversion
  */
-declare function toObject<T extends Record<string, unknown>>(form: FormData, config?: toObjectConfig): T;
+declare function toObject<T extends Record<string, unknown>>(form: FormData, config?: ToObjectConfig): T;
 export { toObject, toObject as default };

package/formdata/toObject.js

@@ -2,36 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toObject = toObject;
 exports.default = toObject;
+const isFormat_1 = require("../date/isFormat");
 const RGX_CLOSE = /\]/g;
 function assignValue(acc, rawkey, value, single) {
     let cursor = acc;
     const keys = rawkey.replace(RGX_CLOSE, '').split(/\[|\./);
-    for (let i = 0; i < keys.length; i++) {
+    const keys_len = keys.length;
+    for (let i = 0; i < keys_len; i++) {
         const key = keys[i];
-        if (i === keys.length - 1) {
-            if (cursor[key] !== undefined && (!single || !single.has(key))) {
-                if (Array.isArray(cursor[key])) {
+        if (i === keys_len - 1) {
+            const cursor_val = cursor[key];
+            if (cursor_val !== undefined && (!single || !single.has(key))) {
+                if (Array.isArray(cursor_val)) {
                     cursor[key].push(value);
                 }
                 else {
-                    cursor[key] = [cursor[key], value];
+                    cursor[key] = [cursor_val, value];
                 }
             }
             else {
                 cursor[key] = value;
             }
-            return;
-        }
-        if (Array.isArray(cursor)) {
-            const index = Number(key);
-            if (!cursor[index])
-                cursor[index] = isNaN(Number(keys[i + 1])) ? {} : [];
-            cursor = cursor[index];
         }
         else {
-            if (!cursor[key])
-                cursor[key] = isNaN(Number(keys[i + 1])) ? {} : [];
-            cursor = cursor[key];
+            const n_key = Array.isArray(cursor) ? Number(key) : key;
+            if (!cursor[n_key])
+                cursor[n_key] = isNaN(Number(keys[i + 1])) ? {} : [];
+            cursor = cursor[n_key];
         }
     }
 }
@@ -40,20 +37,36 @@ function toObject(form, config) {
         throw new Error('formdata/toObject: Value is not an instance of FormData');
     const set = config?.raw === true ? true : new Set(Array.isArray(config?.raw) ? config?.raw : []);
     const single = Array.isArray(config?.single) && config?.single.length ? new Set(config.single) : null;
+    const nBool = config?.normalize_bool !== false;
+    const nDate = config?.normalize_date !== false;
+    const nNumber = config?.normalize_number !== false;
     const acc = {};
     form.forEach((value, key) => {
-        let normalizedValue = value;
         if (set !== true && typeof value === 'string' && !set.has(key)) {
-            const lower = value.toLowerCase();
-            normalizedValue = (lower === 'true'
-                ? true
-                : lower === 'false'
-                    ? false
-                    : !isNaN(Number(value)) && value.trim() !== ''
-                        ? Number(value)
-                        : value);
+            if (nBool) {
+                const lower = value.toLowerCase();
+                if (lower === 'true') {
+                    assignValue(acc, key, true, single);
+                    return;
+                }
+                else if (lower === 'false') {
+                    assignValue(acc, key, false, single);
+                    return;
+                }
+            }
+            const trimmed = value.trim();
+            if (trimmed.length) {
+                if (nNumber && !isNaN(Number(value))) {
+                    assignValue(acc, key, Number(value), single);
+                    return;
+                }
+                if (nDate && (0, isFormat_1.isDateFormat)(value, 'ISO')) {
+                    assignValue(acc, key, new Date(value), single);
+                    return;
+                }
+            }
         }
-        assignValue(acc, key, normalizedValue, single);
+        assignValue(acc, key, value, single);
     });
     return acc;
 }

package/index.d.ts

@@ -1,7 +1,3 @@
-declare module "number/isNumericalNaN" {
-    function isNumericalNaN(val: unknown): boolean;
-    export { isNumericalNaN, isNumericalNaN as default };
-}
 declare module "equal" {
     function equal(a: any, b: any): boolean;
     export { equal, equal as default };
@@ -40,29 +36,38 @@ declare module "array/join" {
     function join(val: unknown[], opts?: joinOptions): string;
     export { join, join as default };
 }
+declare module "object/merge" {
+    type MergeOptions = {
+        union?: boolean;
+    };
+    function merge(target: Record<string, any>, source?: Record<string, any> | Record<string, any>[], opts?: MergeOptions): Record<string, any>;
+    export { merge, merge as default };
+}
 declare module "array/mapFn" {
-    interface mapOptions {
+    type MapOptions = {
         merge?: boolean;
-    }
-    type mapFn<T extends Record<string, any>> = (entry: T) => (string | number | boolean);
-    function mapFn<T extends Record<string, any>>(arr: T[], fn: mapFn<T>, opts?: mapOptions): Record<string, T>;
+    };
+    type MapFn<T extends Record<string, any>> = (entry: T) => (string | number | boolean);
+    function mapFn<T extends Record<string, any>>(arr: T[], fn: MapFn<T>, opts?: MapOptions): Record<string, T>;
     export { mapFn, mapFn as default };
 }
 declare module "array/mapKey" {
-    interface mapOptions {
+    type MapOptions<T> = {
         merge?: boolean;
-    }
-    function mapKey<T extends Record<string, any>>(arr: T[], key: string, opts?: mapOptions): Record<string, T>;
+        filter_fn?: (el: T) => boolean;
+    };
+    function mapKey<T extends Record<string, any>>(arr: T[], key: string, opts?: MapOptions<T>): Record<string, T>;
     export { mapKey, mapKey as default };
 }
 declare module "array/mapPrimitive" {
-    interface mapOptions {
+    type MapOptions = {
         valtrim?: boolean;
         valround?: boolean | number;
         keyround?: boolean;
-    }
+        filter_fn?: (el: unknown) => boolean;
+    };
     type mapReturn = Record<string, string | number>;
-    function mapPrimitive(arr: unknown[], opts?: mapOptions): mapReturn;
+    function mapPrimitive(arr: unknown[], opts?: MapOptions): mapReturn;
     export { mapPrimitive, mapPrimitive as default };
 }
 declare module "object/isNotEmpty" {
@@ -229,11 +234,14 @@ declare module "formdata/is" {
     export { isFormData, isFormData as default };
 }
 declare module "formdata/toObject" {
-    type toObjectConfig = {
+    type ToObjectConfig = {
         raw?: string[] | true;
         single?: string[];
+        normalize_bool?: boolean;
+        normalize_date?: boolean;
+        normalize_number?: boolean;
     };
-    function toObject<T extends Record<string, unknown>>(form: FormData, config?: toObjectConfig): T;
+    function toObject<T extends Record<string, unknown>>(form: FormData, config?: ToObjectConfig): T;
     export { toObject, toObject as default };
 }
 declare module "formdata/index" {
@@ -309,13 +317,6 @@ declare module "object/define" {
     };
     export { define, define as default };
 }
-declare module "object/merge" {
-    type MergeOptions = {
-        union?: boolean;
-    };
-    function merge(target: Record<string, any>, source?: Record<string, any> | Record<string, any>[], opts?: MergeOptions): Record<string, any>;
-    export { merge, merge as default };
-}
 declare module "deep/get" {
     type ObjectType = {
         [key: string]: any;
@@ -385,6 +386,10 @@ declare module "number/isIntegerBelowOrEqual" {
     function isIntegerBelowOrEqual(val: unknown, ref: number): val is number;
     export { isIntegerBelowOrEqual, isIntegerBelowOrEqual as default };
 }
+declare module "number/isNumericalNaN" {
+    function isNumericalNaN(val: unknown): boolean;
+    export { isNumericalNaN, isNumericalNaN as default };
+}
 declare module "number/randomBetween" {
     function randomBetween(min?: number, max?: number): number;
     export { randomBetween, randomBetween as default };

package/package.json

@@ -1 +1 @@
-{ "name": "@valkyriestudios/utils", "version": "12.24.0", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "url": "https://www.linkedin.com/in/petervermeulen1/" }, "keywords": [ "utility", "library", "javascript", "js", "node", "bun" ], "license": "MIT", "repository": { "type": "git", "url": "git+https://github.com/ValkyrieStudios/utils.git" }, "bugs": { "url": "https://github.com/ValkyrieStudios/utils/issues" }, "homepage": "https://github.com/ValkyrieStudios/utils#readme", "types": "index.d.ts" }
+{ "name": "@valkyriestudios/utils", "version": "12.25.1", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "url": "https://www.linkedin.com/in/petervermeulen1/" }, "keywords": [ "utility", "library", "javascript", "js", "node", "bun" ], "license": "MIT", "repository": { "type": "git", "url": "git+https://github.com/ValkyrieStudios/utils.git" }, "bugs": { "url": "https://github.com/ValkyrieStudios/utils/issues" }, "homepage": "https://github.com/ValkyrieStudios/utils#readme", "types": "index.d.ts" }