@augment-vir/common 21.0.1 → 21.2.0

package/dist/cjs/augments/object/merge-deep.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeDeep = void 0;
 const runtime_type_of_1 = require("../runtime-type-of");
 const tuple_1 = require("../tuple");
+const object_1 = require("./object");
 /**
  * Accepts multiple objects and merges their key-value pairs recursively.
  *
@@ -10,28 +11,40 @@ const tuple_1 = require("../tuple");
  */
 function mergeDeep(...inputs) {
     if (!(0, tuple_1.isLengthAtLeast)(inputs, 1)) {
+        // nothing to merge if no inputs
         return {};
     }
     if (inputs.length === 1) {
+        // nothing to merge if only one input
         return inputs[0];
     }
-    let result = {};
+    let result = undefined;
     const mergeProps = {};
     inputs.forEach((individualInput) => {
         try {
+            if (!(0, object_1.isObject)(individualInput)) {
+                /** If not an object, we can't merge. So overwrite instead. */
+                result = individualInput;
+                return;
+            }
             Object.entries(individualInput).forEach(([key, value,]) => {
-                if ((0, runtime_type_of_1.isRuntimeTypeOf)(value, 'object')) {
-                    const mergePropsArray = mergeProps[key] || [];
-                    if (!mergeProps[key]) {
-                        mergeProps[key] = mergePropsArray;
-                    }
-                    mergePropsArray.push(value);
+                const mergePropsArray = mergeProps[key] || [];
+                if (!mergeProps[key]) {
+                    mergeProps[key] = mergePropsArray;
                 }
+                mergePropsArray.push(value);
             });
-            result = {
-                ...result,
-                ...individualInput,
-            };
+            if (result) {
+                if ((0, runtime_type_of_1.isRuntimeTypeOf)(result, 'object')) {
+                    result = {
+                        ...result,
+                        ...individualInput,
+                    };
+                }
+            }
+            else {
+                result = individualInput;
+            }
         }
         catch (error) {
             /** Ignore errors, such as individualInput not actually being an object. */

package/dist/cjs/augments/object/nested-keys.js

@@ -1,15 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getValueFromNestedKeys = exports.setValueWithNestedKeys = void 0;
+const runtime_type_of_1 = require("../runtime-type-of");
 const object_1 = require("./object");
 const typed_has_property_1 = require("./typed-has-property");
-function setValueWithNestedKeys(inputObject, nestedKeys, value) {
+function setValueWithNestedKeys(originalObject, nestedKeys, value) {
     /**
      * Lots of as any casts in here because these types are, under the hood, pretty complex. Since
      * the inputs and outputs of this function are well typed, these internal as any casts do not
      * affect the external API of this function.
      */
-    const nextKey = nestedKeys[0];
+    const nestedKeysInput = nestedKeys;
+    const inputObject = originalObject;
+    if ((0, runtime_type_of_1.isRuntimeTypeOf)(inputObject, 'array')) {
+        inputObject.forEach((entry) => {
+            if ((0, object_1.isObject)(entry)) {
+                setValueWithNestedKeys(entry, nestedKeysInput, value);
+            }
+        });
+        return;
+    }
+    const nextKey = nestedKeysInput[0];
     if (!(nextKey in inputObject)) {
         inputObject[nextKey] = {};
     }
@@ -17,27 +28,32 @@ function setValueWithNestedKeys(inputObject, nestedKeys, value) {
         throw new Error(`Cannot set value at key '${String(nextKey)}' as its not an object.`);
     }
     const nextParent = inputObject[nextKey];
-    if (nestedKeys.length > 2) {
-        setValueWithNestedKeys(nextParent, nestedKeys.slice(1), value);
+    if (nestedKeysInput.length > 2) {
+        setValueWithNestedKeys(nextParent, nestedKeysInput.slice(1), value);
     }
     else {
-        nextParent[nestedKeys[1]] = value;
+        nextParent[nestedKeysInput[1]] = value;
     }
 }
 exports.setValueWithNestedKeys = setValueWithNestedKeys;
-function getValueFromNestedKeys(inputObject, nestedKeys) {
+function getValueFromNestedKeys(originalObject, nestedKeys) {
     /**
      * Lots of as any casts in here because these types are, under the hood, pretty complex. Since
      * the inputs and outputs of this function are well typed, these internal as any casts do not
      * affect the external API of this function.
      */
-    const keyToAccess = nestedKeys[0];
+    const nestedKeysInput = nestedKeys;
+    const inputObject = originalObject;
+    if ((0, runtime_type_of_1.isRuntimeTypeOf)(inputObject, 'array')) {
+        return inputObject.map((entry) => getValueFromNestedKeys(entry, nestedKeys));
+    }
+    const keyToAccess = nestedKeysInput[0];
     if (!(0, typed_has_property_1.typedHasProperty)(inputObject, keyToAccess)) {
         return undefined;
     }
     const currentValue = inputObject[keyToAccess];
-    if (nestedKeys.length > 1) {
-        return getValueFromNestedKeys(currentValue, nestedKeys.slice(1));
+    if (nestedKeysInput.length > 1) {
+        return getValueFromNestedKeys(currentValue, nestedKeysInput.slice(1));
     }
     else {
         return currentValue;

package/dist/cjs/augments/object/object.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.copyThroughJson = exports.isObject = void 0;
+/** Checks if the input is non-null and an object. Includes arrays. */
 function isObject(input) {
     return !!input && typeof input === 'object';
 }

package/dist/esm/augments/object/merge-deep.js

@@ -1,5 +1,6 @@
 import { isRuntimeTypeOf } from '../runtime-type-of';
 import { isLengthAtLeast } from '../tuple';
+import { isObject } from './object';
 /**
  * Accepts multiple objects and merges their key-value pairs recursively.
  *
@@ -7,28 +8,40 @@ import { isLengthAtLeast } from '../tuple';
  */
 export function mergeDeep(...inputs) {
     if (!isLengthAtLeast(inputs, 1)) {
+        // nothing to merge if no inputs
         return {};
     }
     if (inputs.length === 1) {
+        // nothing to merge if only one input
         return inputs[0];
     }
-    let result = {};
+    let result = undefined;
     const mergeProps = {};
     inputs.forEach((individualInput) => {
         try {
+            if (!isObject(individualInput)) {
+                /** If not an object, we can't merge. So overwrite instead. */
+                result = individualInput;
+                return;
+            }
             Object.entries(individualInput).forEach(([key, value,]) => {
-                if (isRuntimeTypeOf(value, 'object')) {
-                    const mergePropsArray = mergeProps[key] || [];
-                    if (!mergeProps[key]) {
-                        mergeProps[key] = mergePropsArray;
-                    }
-                    mergePropsArray.push(value);
+                const mergePropsArray = mergeProps[key] || [];
+                if (!mergeProps[key]) {
+                    mergeProps[key] = mergePropsArray;
                 }
+                mergePropsArray.push(value);
             });
-            result = {
-                ...result,
-                ...individualInput,
-            };
+            if (result) {
+                if (isRuntimeTypeOf(result, 'object')) {
+                    result = {
+                        ...result,
+                        ...individualInput,
+                    };
+                }
+            }
+            else {
+                result = individualInput;
+            }
         }
         catch (error) {
             /** Ignore errors, such as individualInput not actually being an object. */

package/dist/esm/augments/object/nested-keys.js

@@ -1,12 +1,23 @@
+import { isRuntimeTypeOf } from '../runtime-type-of';
 import { isObject } from './object';
 import { typedHasProperty } from './typed-has-property';
-export function setValueWithNestedKeys(inputObject, nestedKeys, value) {
+export function setValueWithNestedKeys(originalObject, nestedKeys, value) {
     /**
      * Lots of as any casts in here because these types are, under the hood, pretty complex. Since
      * the inputs and outputs of this function are well typed, these internal as any casts do not
      * affect the external API of this function.
      */
-    const nextKey = nestedKeys[0];
+    const nestedKeysInput = nestedKeys;
+    const inputObject = originalObject;
+    if (isRuntimeTypeOf(inputObject, 'array')) {
+        inputObject.forEach((entry) => {
+            if (isObject(entry)) {
+                setValueWithNestedKeys(entry, nestedKeysInput, value);
+            }
+        });
+        return;
+    }
+    const nextKey = nestedKeysInput[0];
     if (!(nextKey in inputObject)) {
         inputObject[nextKey] = {};
     }
@@ -14,26 +25,31 @@ export function setValueWithNestedKeys(inputObject, nestedKeys, value) {
         throw new Error(`Cannot set value at key '${String(nextKey)}' as its not an object.`);
     }
     const nextParent = inputObject[nextKey];
-    if (nestedKeys.length > 2) {
-        setValueWithNestedKeys(nextParent, nestedKeys.slice(1), value);
+    if (nestedKeysInput.length > 2) {
+        setValueWithNestedKeys(nextParent, nestedKeysInput.slice(1), value);
     }
     else {
-        nextParent[nestedKeys[1]] = value;
+        nextParent[nestedKeysInput[1]] = value;
     }
 }
-export function getValueFromNestedKeys(inputObject, nestedKeys) {
+export function getValueFromNestedKeys(originalObject, nestedKeys) {
     /**
      * Lots of as any casts in here because these types are, under the hood, pretty complex. Since
      * the inputs and outputs of this function are well typed, these internal as any casts do not
      * affect the external API of this function.
      */
-    const keyToAccess = nestedKeys[0];
+    const nestedKeysInput = nestedKeys;
+    const inputObject = originalObject;
+    if (isRuntimeTypeOf(inputObject, 'array')) {
+        return inputObject.map((entry) => getValueFromNestedKeys(entry, nestedKeys));
+    }
+    const keyToAccess = nestedKeysInput[0];
     if (!typedHasProperty(inputObject, keyToAccess)) {
         return undefined;
     }
     const currentValue = inputObject[keyToAccess];
-    if (nestedKeys.length > 1) {
-        return getValueFromNestedKeys(currentValue, nestedKeys.slice(1));
+    if (nestedKeysInput.length > 1) {
+        return getValueFromNestedKeys(currentValue, nestedKeysInput.slice(1));
     }
     else {
         return currentValue;

package/dist/esm/augments/object/object.js

@@ -1,3 +1,4 @@
+/** Checks if the input is non-null and an object. Includes arrays. */
 export function isObject(input) {
     return !!input && typeof input === 'object';
 }

package/dist/types/augments/object/nested-keys.d.ts

@@ -1,12 +1,16 @@
+import { ArrayElement } from '../type';
 import { PropertyValueType } from './object';
 import { UnionToIntersection } from './old-union-to-intersection';
-export type NestedSequentialKeys<ObjectGeneric extends object> = PropertyValueType<{
-    [Prop in keyof ObjectGeneric]: NonNullable<ObjectGeneric[Prop]> extends object ? Readonly<[Prop, ...(NestedSequentialKeys<NonNullable<ObjectGeneric[Prop]>> | [])]> : Readonly<[Prop]>;
+export type NestedSequentialKeys<ObjectGeneric extends object> = NonNullable<ObjectGeneric> extends ReadonlyArray<any> ? NestedSequentialKeys<Extract<NonNullable<ObjectGeneric>[number], object>> : PropertyValueType<{
+    [Prop in keyof ObjectGeneric]: NonNullable<ObjectGeneric[Prop]> extends object ? Readonly<[
+        Prop,
+        ...(NestedSequentialKeys<NonNullable<ObjectGeneric[Prop]>> | [])
+    ]> : Readonly<[Prop]>;
 }>;
-export type NestedKeys<ObjectGeneric extends object> = UnionToIntersection<Extract<PropertyValueType<ObjectGeneric>, object>> extends object ? [
+export type NestedKeys<ObjectGeneric extends object> = ObjectGeneric extends ReadonlyArray<any> ? NestedKeys<ArrayElement<ObjectGeneric>> : UnionToIntersection<Extract<PropertyValueType<ObjectGeneric>, object>> extends object ? [
     keyof ObjectGeneric,
     ...(NestedKeys<UnionToIntersection<Extract<PropertyValueType<ObjectGeneric>, object>>> | [])
 ] : [keyof ObjectGeneric];
-export type NestedValue<ObjectGeneric extends object, NestedKeysGeneric extends NestedSequentialKeys<ObjectGeneric>> = NestedKeysGeneric extends readonly [infer FirstEntry, ...infer FollowingEntries] ? FirstEntry extends keyof ObjectGeneric ? FollowingEntries extends never[] ? ObjectGeneric[FirstEntry] : ObjectGeneric[FirstEntry] extends object ? FollowingEntries extends NestedSequentialKeys<ObjectGeneric[FirstEntry]> ? NestedValue<ObjectGeneric[FirstEntry], FollowingEntries> : never : never : never : never;
-export declare function setValueWithNestedKeys<const ObjectGeneric extends object, const KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(inputObject: ObjectGeneric, nestedKeys: KeysGeneric, value: NestedValue<ObjectGeneric, KeysGeneric>): void;
-export declare function getValueFromNestedKeys<const ObjectGeneric extends object, const KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(inputObject: ObjectGeneric, nestedKeys: KeysGeneric): NestedValue<ObjectGeneric, KeysGeneric> | undefined;
+export type NestedValue<ObjectGeneric extends object, NestedKeysGeneric extends NestedSequentialKeys<ObjectGeneric>> = ObjectGeneric extends ReadonlyArray<any> ? NestedValue<Extract<ObjectGeneric[number], object>, NestedKeysGeneric>[] : NestedKeysGeneric extends readonly [infer FirstEntry, ...infer FollowingEntries] ? FirstEntry extends keyof ObjectGeneric ? FollowingEntries extends never[] ? ObjectGeneric[FirstEntry] : ObjectGeneric[FirstEntry] extends object ? FollowingEntries extends NestedSequentialKeys<ObjectGeneric[FirstEntry]> ? NestedValue<ObjectGeneric[FirstEntry], FollowingEntries> : never : never : never : never;
+export declare function setValueWithNestedKeys<const ObjectGeneric extends object, const KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(originalObject: ObjectGeneric, nestedKeys: KeysGeneric, value: NestedValue<ObjectGeneric, KeysGeneric>): void;
+export declare function getValueFromNestedKeys<const ObjectGeneric extends object, const KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(originalObject: ObjectGeneric, nestedKeys: KeysGeneric): NestedValue<ObjectGeneric, KeysGeneric>;

package/dist/types/augments/object/object.d.ts

@@ -4,6 +4,7 @@ export type PartialAndNullable<T extends object> = {
 export type PartialAndUndefined<T extends object> = {
     [Prop in keyof T]?: T[Prop] | undefined;
 };
+/** Checks if the input is non-null and an object. Includes arrays. */
 export declare function isObject(input: any): input is NonNullable<object>;
 /** The input here must be serializable otherwise JSON parsing errors will be thrown */
 export declare function copyThroughJson<T>(input: T): T;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "21.0.1",
+    "version": "21.2.0",
     "homepage": "https://github.com/electrovir/augment-vir/tree/main/packages/common",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"