@tstdl/base 0.91.1 → 0.91.3

package/enumerable/async-enumerable.d.ts

@@ -1,9 +1,9 @@
 import type { CancellationSignal } from '../cancellation/token.js';
-import type { AnyIterable } from '../utils/any-iterable-iterator.js';
+import { type AnyIterable } from '../utils/any-iterable-iterator.js';
 import type { AsyncComparator } from '../utils/sort.js';
 import type { Observable } from 'rxjs';
 import type { AsyncGroupSelectors, AsyncIteratorFunction, AsyncPredicate, AsyncReducer, AsyncRetryPredicate, ParallelizableIteratorFunction, ParallelizablePredicate, ThrottleFunction } from '../utils/async-iterable-helpers/index.js';
-import type { IterableItemMetadata, TypePredicate } from '../utils/iterable-helpers/index.js';
+import { type IterableItemMetadata, type TypePredicate } from '../utils/iterable-helpers/index.js';
 import type { EnumerableMethods } from './enumerable-methods.js';
 import { Enumerable } from './enumerable.js';
 export declare class AsyncEnumerable<T> implements EnumerableMethods, AsyncIterable<T> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.1",
+  "version": "0.91.3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -115,13 +115,13 @@
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "2.3",
+    "@stylistic/eslint-plugin": "2.6",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
     "@types/minio": "7.1",
     "@types/mjml": "4.7",
-    "@types/node": "20",
+    "@types/node": "22",
     "@types/nodemailer": "6.4",
     "@typescript-eslint/eslint-plugin": "7.17",
     "concurrently": "8.2",
@@ -136,12 +136,12 @@
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.14",
     "@koa/router": "^12.0",
-    "@tstdl/angular": "^0.90",
+    "@tstdl/angular": "^0.91",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
-    "chroma-js": "^2.4",
+    "chroma-js": "^2.6",
     "drizzle-orm": "^0.32",
     "handlebars": "^4.7",
     "koa": "^2.15",

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];
+    });
+}