@tstdl/base 0.91.2 → 0.91.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.2",
+  "version": "0.91.3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/tsconfig.json

@@ -4,7 +4,7 @@
     "module": "nodenext",
     "moduleResolution": "nodenext",
     "lib": ["esnext", "dom"],
-    "target": "es2022",
+    "target": "es2023",
     "baseUrl": "source/",
     "rootDir": "source/",
     "outDir": "dist/",

package/tsconfig.server.json

@@ -1,6 +1,6 @@
 {
   "extends": "./tsconfig.json", // in dist tsconfig.base.json is renamed to tsconfig.json
   "compilerOptions": {
-    "target": "es2022"
+    "target": "es2023"
   }
 }

package/utils/merge.d.ts

@@ -1,4 +1,19 @@
-import type { Merge, Record } from '../types.js';
+import type { IsEqual, MergeDeep, MergeDeepOptions as TypeFestMergeDeepOptions } from 'type-fest';
+import type { If, Merge, Record, TypedOmit } from '../types.js';
 type BaseType = Record | any[] | Map<any, any> | Set<any>;
 export declare function merge<A extends BaseType, B extends BaseType>(a: A | undefined, b: B | undefined): A extends (infer T)[] ? B extends (infer U)[] ? (T | U)[] : never : A extends Map<infer K, infer V> ? B extends Map<infer K2, infer V2> ? Map<K | K2, V | V2> : never : A extends Set<infer T> ? B extends Set<infer U> ? Set<T | U> : never : A extends Record ? B extends Record ? Merge<A, B> : never : never;
+export type MergeDeepOptions = TypedOmit<TypeFestMergeDeepOptions, 'arrayMergeMode'> & {
+    arrayMergeMode?: TypeFestMergeDeepOptions['arrayMergeMode'] | 'mergeItems';
+};
+export declare function mergeDeep<A extends Record, B extends Record, Options extends MergeDeepOptions = {
+    arrayMergeMode: 'spread';
+    recurseIntoArrays: true;
+}>(a: A, b: B, options?: Options): MergeDeep<A, B, {
+    arrayMergeMode: If<IsEqual<Options['arrayMergeMode'], 'mergeItems'>, 'spread', Exclude<Options['arrayMergeMode'], 'mergeItems'>>;
+    recurseIntoArrays: Options['recurseIntoArrays'];
+}>;
+export declare function mergeArray<A extends readonly any[], B extends readonly any[], Mode extends NonNullable<MergeDeepOptions['arrayMergeMode']>>(a: A, b: B, mode: Mode): MergeDeep<A, B, {
+    recurseIntoArrays: true;
+    arrayMergeMode: If<IsEqual<Mode, 'mergeItems'>, 'spread', Exclude<Mode, 'mergeItems'>>;
+}>;
 export {};

package/utils/merge.js

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
+import { createArray } from './array/array.js';
+import { objectEntries } from './object/object.js';
 import { assertArray, assertLiteralObject, assertMap, assertSet, isArray, isLiteralObject, isMap, isSet, isUndefined } from './type-guards.js';
 export function merge(a, b) {
     if (isUndefined(a)) {
@@ -25,3 +27,37 @@ export function merge(a, b) {
     }
     throw new Error('Merging of data can only be done with objects, arrays, maps and sets.');
 }
+export function mergeDeep(a, b, options) {
+    const { arrayMergeMode = 'spread', recurseIntoArrays = true } = options ?? {};
+    const result = { ...a };
+    for (const [key, value] of objectEntries(b)) {
+        if (isLiteralObject(a[key]) && isLiteralObject(value)) {
+            result[key] = mergeDeep(a[key], value);
+        }
+        else if (recurseIntoArrays && isArray(a[key]) && isArray(value)) {
+            result[key] = mergeArray(a[key], value, arrayMergeMode);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function mergeArray(a, b, mode) {
+    if (mode == 'spread') {
+        return [...a, ...b];
+    }
+    const length = Math.max(a.length, b.length);
+    if (mode == 'replace') {
+        return createArray(length, (index) => b[index] ?? a[index]);
+    }
+    return createArray(length, (index) => {
+        if (isLiteralObject(a[index]) && isLiteralObject(b[index])) {
+            return mergeDeep(a[index], b[index], { arrayMergeMode: mode, recurseIntoArrays: true });
+        }
+        else if (isArray(a[index]) && isArray(b[index])) {
+            return mergeArray(a[index], b[index], mode);
+        }
+        return b[index] ?? a[index];
+    });
+}