@valkyriestudios/utils 12.18.0 → 12.19.0

package/README.md

@@ -851,12 +851,17 @@ Copies the keys passed in the 'keys' array from the passed object to a new objec
 pick({a: 1, b: 2, c: 3}, ['a','b']); // {a: 1, b: 2}
 ```
 
-- **merge(target:Object={},obj:Object={})**
+- **merge(target:Object={},obj:Object|Object[]={}, opts?:{union?:boolean})**
 Merges two objects together, with the preference over the second object.
 ```typescript
-merge({a: 1, b: false}, {a: 900, c: 50}); // {a: 900, b: false, c: 50}
+merge({a: 1, b: false}, {a: 900, c: 50}, {union: true}); // {a: 900, b: false, c: 50}
+merge({a: 1, b: false}, {a: 900, c: 50}, {union: false}); // {a: 900, b: false}
+merge({a: 1, c: {bar: 'foo'}}, [{b: 2}, {c: {foo: 'bar'}}], {union: true}); // {a: 1, b: 2, c: {bar: 'foo', foo: 'bar'}}
 ```
 
+Take Note: The default behavior is to not have union, this means that ONLY the keys in the target object
+are going to be available in the response of this function.
+
 - **define(props:Object, obj:Object={})**
 Creates an object with the passed accessors set on it
 ```typescript

package/array/dedupe.d.ts

@@ -1,4 +1,7 @@
 type DedupeOptions<T> = {
+    /**
+     * Pass a custom filter function which will be run in O(n) while deduping is going on
+     */
     filter_fn?: (el: T) => boolean;
 };
 /**

package/deep/freeze.js

@@ -4,8 +4,8 @@ exports.deepFreeze = deepFreeze;
 exports.default = deepFreeze;
 function deep(obj) {
     if (Array.isArray(obj)) {
-        for (const el of obj)
-            deep(el);
+        for (let i = 0; i < obj.length; i++)
+            deep(obj[i]);
     }
     else {
         for (const key in obj) {

package/deep/get.d.ts

@@ -2,16 +2,16 @@
  * Get a property's value deep inside the structure of an array/object
  *
  * Example:
- *  const myObj = {
- *      a: 2,
- *      b: [
- *          {price : 2},
- *          {price : 4},
- *      ],
- *  };
- *  deepGet(myObj, 'b[0].price');
+ * const myObj = {
+ *  a: 2,
+ *  b: [
+ *   {price : 2},
+ *   {price : 4},
+ *  ],
+ * };
+ * deepGet(myObj, 'b[0].price');
  * Output:
- *  2
+ * 2
  *
  * @param val - Object/Array to get the value from
  * @param path - Path string to deeply get the value at
@@ -20,9 +20,10 @@
  * @returns Value stored at property or undefined
  * @throws {TypeError}
  */
-declare function deepGet(obj: {
+type ObjectType = {
     [key: string]: any;
-} | {
-    [key: string]: any;
-}[] | any[], path: string, get_parent?: boolean): any | undefined;
+};
+type ArrayType = any[];
+type DeepGetResult<T extends ObjectType | ArrayType, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType | ArrayType ? DeepGetResult<T[Key], Rest> : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], Rest> : undefined : undefined : P extends `${infer Key}[${infer Index}]` ? Key extends keyof T ? T[Key] extends ArrayType ? Index extends `${number}` ? DeepGetResult<T[Key][number], ''> : undefined : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], `[${Index}]`> : undefined : undefined : P extends keyof T ? T[P] : T extends ArrayType ? number extends keyof T ? T[number] : undefined : undefined;
+declare function deepGet<T extends ObjectType | ArrayType, P extends string>(obj: T, path: P, get_parent?: boolean): DeepGetResult<T, P> | undefined;
 export { deepGet, deepGet as default };

package/deep/get.js

@@ -9,34 +9,56 @@ function deepGet(obj, path, get_parent = false) {
     if (typeof path !== 'string')
         throw new TypeError('No path was given');
     const path_s = path.trim();
-    if (!path_s.length)
+    const path_len = path_s.length;
+    if (!path_len)
         throw new TypeError('No path was given');
-    const parts = path_s
-        .replace(/\[/g, '.')
-        .replace(/(\.){2,}/g, '.')
-        .replace(/(^\.|\.$|\])/g, '')
-        .split('.');
-    if (!parts.length || (parts.length === 1 && get_parent))
+    const parts = [];
+    let cursor_part = '';
+    let in_bracket = false;
+    for (let i = 0; i < path_len; i++) {
+        const char = path_s[i];
+        if (char === '[' || char === ']') {
+            in_bracket = !in_bracket;
+            if (cursor_part) {
+                parts.push(cursor_part);
+                cursor_part = '';
+            }
+        }
+        else if (char === '.' && !in_bracket) {
+            if (cursor_part) {
+                parts.push(cursor_part);
+                cursor_part = '';
+            }
+        }
+        else {
+            cursor_part += char;
+        }
+    }
+    if (cursor_part)
+        parts.push(cursor_part);
+    let len = parts.length;
+    if (!len || (len === 1 && get_parent))
         return obj;
-    if (get_parent)
+    if (get_parent) {
         parts.pop();
+        len -= 1;
+    }
     let cursor = obj;
-    while (parts.length) {
+    for (let i = 0; i < len; i++) {
         if (Array.isArray(cursor)) {
-            const ix = parseInt(parts.shift());
-            if (!Number.isInteger(ix) || ix < 0 || ix > (cursor.length - 1))
+            const ix = parseInt(parts[i], 10);
+            if (ix < 0 || ix > cursor.length - 1)
                 return undefined;
             cursor = cursor[ix];
         }
         else if (Object.prototype.toString.call(cursor) === '[object Object]') {
-            const key = parts.shift();
-            if (cursor[key] === undefined)
+            cursor = cursor[parts[i]];
+            if (cursor === undefined)
                 return undefined;
-            cursor = cursor[key];
         }
-        if ((!Array.isArray(cursor) && Object.prototype.toString.call(cursor) !== '[object Object]') &&
-            parts.length)
+        else {
             return undefined;
+        }
     }
     return cursor;
 }

package/deep/seal.js

@@ -4,8 +4,8 @@ exports.deepSeal = deepSeal;
 exports.default = deepSeal;
 function deep(obj) {
     if (Array.isArray(obj)) {
-        for (const el of obj)
-            deep(el);
+        for (let i = 0; i < obj.length; i++)
+            deep(obj[i]);
     }
     else {
         for (const key in obj) {

package/equal.js

@@ -4,9 +4,10 @@ exports.equal = equal;
 exports.default = equal;
 const isNumericalNaN_1 = require("./number/isNumericalNaN");
 function isArrayEqual(a, b) {
-    if (a.length !== b.length)
+    const a_len = a.length;
+    if (a_len !== b.length)
         return false;
-    for (let i = a.length - 1; i >= 0; i--) {
+    for (let i = a_len - 1; i >= 0; i--) {
         if (equal(a[i], b[i]))
             continue;
         return false;
@@ -15,9 +16,10 @@ function isArrayEqual(a, b) {
 }
 function isObjectEqual(a, b) {
     const keys_a = Object.keys(a);
-    if (keys_a.length !== Object.keys(b).length)
+    const keys_a_len = keys_a.length;
+    if (keys_a_len !== Object.keys(b).length)
         return false;
-    for (let i = keys_a.length - 1; i >= 0; i--) {
+    for (let i = keys_a_len - 1; i >= 0; i--) {
         if (equal(a[keys_a[i]], b[keys_a[i]]))
             continue;
         return false;

package/index.d.ts

@@ -272,35 +272,29 @@ declare module "object/define" {
     export { define, define as default };
 }
 declare module "object/merge" {
-    function merge(target: {
-        [key: string]: any;
-    }, source?: {
-        [key: string]: any;
-    }): {
-        [key: string]: any;
+    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" {
-    function deepGet(obj: {
-        [key: string]: any;
-    } | {
+    type ObjectType = {
         [key: string]: any;
-    }[] | any[], path: string, get_parent?: boolean): any | undefined;
+    };
+    type ArrayType = any[];
+    type DeepGetResult<T extends ObjectType | ArrayType, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType | ArrayType ? DeepGetResult<T[Key], Rest> : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], Rest> : undefined : undefined : P extends `${infer Key}[${infer Index}]` ? Key extends keyof T ? T[Key] extends ArrayType ? Index extends `${number}` ? DeepGetResult<T[Key][number], ''> : undefined : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], `[${Index}]`> : undefined : undefined : P extends keyof T ? T[P] : T extends ArrayType ? number extends keyof T ? T[number] : undefined : undefined;
+    function deepGet<T extends ObjectType | ArrayType, P extends string>(obj: T, path: P, get_parent?: boolean): DeepGetResult<T, P> | undefined;
     export { deepGet, deepGet as default };
 }
-declare module "deep/set" {
-    function deepSet(obj: {
-        [key: string]: any;
-    } | {
-        [key: string]: any;
-    }[] | any[], path: string, value: any, define?: boolean): boolean;
-    export { deepSet, deepSet as default };
-}
 declare module "object/pick" {
-    function pick(obj: {
+    type ObjectType = {
         [key: string]: any;
-    }, keys: string[]): {
+    };
+    type DottedKeys<T> = (T extends ObjectType ? {
+        [K in keyof T & string]: T[K] extends ObjectType ? K | `${K}.${DottedKeys<T[K]>}` : K;
+    }[keyof T & string] : string) & string;
+    function pick<T extends Record<string, any>, K extends DottedKeys<T>>(obj: T, keys: K[]): {
         [key: string]: any;
     };
     export { pick, pick as default };
@@ -525,6 +519,14 @@ declare module "deep/seal" {
     function deepSeal<T extends deepInput>(obj: T): Sealed<T>;
     export { deepSeal, deepSeal as default };
 }
+declare module "deep/set" {
+    function deepSet(obj: {
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[] | any[], path: string, value: any, define?: boolean): boolean;
+    export { deepSet, deepSet as default };
+}
 declare module "deep/index" {
     import { deepFreeze } from "deep/freeze";
     import { deepGet } from "deep/get";

package/object/merge.d.ts

@@ -1,3 +1,10 @@
+type MergeOptions = {
+    /**
+     * Defaults to false, when passed as true it ensures all keys from both objects
+     * are available in the merged object
+     */
+    union?: boolean;
+};
 /**
  * Deep merge two objects together while ensuring nested objects also get merged,
  * take note: this does not merge onto passed objects by reference but instead
@@ -8,11 +15,5 @@
  *
  * @returns Combined target and source objects
  */
-declare function merge(target: {
-    [key: string]: any;
-}, source?: {
-    [key: string]: any;
-}): {
-    [key: string]: any;
-};
+declare function merge(target: Record<string, any>, source?: Record<string, any> | Record<string, any>[], opts?: MergeOptions): Record<string, any>;
 export { merge, merge as default };

package/object/merge.js

@@ -3,19 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.merge = merge;
 exports.default = merge;
 const PROTO_OBJ = '[object Object]';
-function merge(target, source = {}) {
-    if (Object.prototype.toString.call(target) !== PROTO_OBJ ||
-        Object.prototype.toString.call(source) !== PROTO_OBJ)
-        throw new TypeError('Please pass a target and object to merge');
-    const acc = {};
-    for (const key in target) {
-        if (Object.prototype.toString.call(target[key]) === PROTO_OBJ &&
-            Object.prototype.toString.call(source[key]) === PROTO_OBJ) {
-            acc[key] = merge(target[key], source[key]);
+function innerMerge(target, source, UNION) {
+    const origin = UNION ? source : target;
+    for (const key in origin) {
+        const t_key = target[key];
+        const s_key = source[key];
+        if (Object.prototype.toString.call(t_key) === PROTO_OBJ &&
+            Object.prototype.toString.call(s_key) === PROTO_OBJ) {
+            target[key] = innerMerge({ ...t_key }, s_key, UNION);
         }
         else {
-            acc[key] = source[key] !== undefined ? source[key] : target[key];
+            target[key] = s_key !== undefined ? s_key : t_key;
         }
     }
+    return target;
+}
+function merge(target, source = {}, opts = {}) {
+    if (Object.prototype.toString.call(target) !== PROTO_OBJ)
+        throw new Error('object/merge: Please ensure valid target/source is passed');
+    const union = opts?.union === true;
+    const sources = Array.isArray(source) ? source : [source];
+    let acc = { ...target };
+    for (let i = 0; i < sources.length; i++) {
+        const el = sources[i];
+        if (Object.prototype.toString.call(el) !== PROTO_OBJ) {
+            throw new Error('object/merge: Please ensure valid target/source is passed');
+        }
+        acc = innerMerge(acc, el, union);
+    }
     return acc;
 }

package/object/pick.d.ts

@@ -1,3 +1,9 @@
+type ObjectType = {
+    [key: string]: any;
+};
+type DottedKeys<T> = (T extends ObjectType ? {
+    [K in keyof T & string]: T[K] extends ObjectType ? K | `${K}.${DottedKeys<T[K]>}` : K;
+}[keyof T & string] : string) & string;
 /**
  * Returns a new object with the keys picked from the passed object
  *
@@ -6,9 +12,7 @@
  *
  * @returns Object containing the picked keys from source object
  */
-declare function pick(obj: {
-    [key: string]: any;
-}, keys: string[]): {
+declare function pick<T extends Record<string, any>, K extends DottedKeys<T>>(obj: T, keys: K[]): {
     [key: string]: any;
 };
 export { pick, pick as default };

package/object/pick.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pick = pick;
 exports.default = pick;
 const get_1 = require("../deep/get");
-const set_1 = require("../deep/set");
-const RGX_DEEP = /(\.|\[)/;
 function pick(obj, keys) {
     if (Object.prototype.toString.call(obj) !== '[object Object]' ||
         !Array.isArray(keys) ||
@@ -20,11 +18,21 @@ function pick(obj, keys) {
         sanitized = key.trim();
         if (!sanitized.length)
             continue;
-        if (RGX_DEEP.test(sanitized)) {
+        if (sanitized.includes('.')) {
             val = (0, get_1.deepGet)(obj, sanitized);
             if (val === undefined)
                 continue;
-            (0, set_1.deepSet)(map, sanitized, val);
+            const parts = key.split('.');
+            const parts_len = parts.length;
+            let cursor = map;
+            for (let y = 0; y < parts_len - 1; y++) {
+                const part = parts[y].trim();
+                if (!cursor[part]) {
+                    cursor[part] = {};
+                }
+                cursor = cursor[part];
+            }
+            cursor[parts[parts_len - 1].trim()] = val;
         }
         else if (obj[sanitized] !== undefined) {
             map[sanitized] = obj[sanitized];

package/package.json

@@ -1 +1 @@
-{ "name": "@valkyriestudios/utils", "version": "12.18.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.19.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" }