merge-anything 5.1.0 → 5.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/index.cjs +25 -3
  2. package/dist/index.es.js +25 -3
  3. package/dist/types/merge.d.ts +5 -5
  4. package/dist/types/typeUtils/Assign.d.ts +3 -3
  5. package/dist/types/typeUtils/List.d.ts +9 -0
  6. package/dist/types/typeUtils/MergeDeep.d.ts +32 -42
  7. package/package.json +1 -1
package/dist/index.cjs CHANGED
@@ -80,14 +80,36 @@ function mergeAndConcat(object, ...otherObjects) {
80
80
  return mergeRecursively(result, newComer, concatArrays);
81
81
  }, object);
82
82
  }
83
- // import { Timestamp } from 'firebase/firestore'
83
+ // import { Timestamp } from '../test/Timestamp'
84
84
  // type T1 = { date: Timestamp }
85
85
  // type T2 = [{ b: string[] }, { b: number[] }, { date: Timestamp }]
86
- // type Test = Merge<T1, T2>
86
+ // type TestT = Merge<T1, T2>
87
87
  // type A1 = { arr: string[] }
88
88
  // type A2 = { arr: number[] }
89
89
  // type A3 = { arr: boolean[] }
90
- // type Test = Merge<A1, [A2, A3]>
90
+ // type TestA = Merge<A1, [A2, A3]>
91
+ // interface I1 {
92
+ // date: Timestamp
93
+ // }
94
+ // interface I2 {
95
+ // date: Timestamp
96
+ // }
97
+ // const _a: I2 = { date: '' } as unknown as I2
98
+ // type TestI = Merge<I1, [I2]>
99
+ // // ReturnType<(typeof merge)<I1, I2>>
100
+ // const a = merge(_a, [_a])
101
+ // interface Arguments extends Record<string | number | symbol, unknown> {
102
+ // key: string;
103
+ // }
104
+ // const aa1: Arguments = { key: "value1" }
105
+ // const aa2: Arguments = { key: "value2" }
106
+ // const aa = merge(a1, a2);
107
+ // interface Barguments {
108
+ // key: string
109
+ // }
110
+ // const ba1: Barguments = { key: 'value1' }
111
+ // const ba2: Barguments = { key: 'value2' }
112
+ // const ba = merge(ba1, ba2)
91
113
 
92
114
  exports.concatArrays = concatArrays;
93
115
  exports.merge = merge;
package/dist/index.es.js CHANGED
@@ -78,13 +78,35 @@ function mergeAndConcat(object, ...otherObjects) {
78
78
  return mergeRecursively(result, newComer, concatArrays);
79
79
  }, object);
80
80
  }
81
- // import { Timestamp } from 'firebase/firestore'
81
+ // import { Timestamp } from '../test/Timestamp'
82
82
  // type T1 = { date: Timestamp }
83
83
  // type T2 = [{ b: string[] }, { b: number[] }, { date: Timestamp }]
84
- // type Test = Merge<T1, T2>
84
+ // type TestT = Merge<T1, T2>
85
85
  // type A1 = { arr: string[] }
86
86
  // type A2 = { arr: number[] }
87
87
  // type A3 = { arr: boolean[] }
88
- // type Test = Merge<A1, [A2, A3]>
88
+ // type TestA = Merge<A1, [A2, A3]>
89
+ // interface I1 {
90
+ // date: Timestamp
91
+ // }
92
+ // interface I2 {
93
+ // date: Timestamp
94
+ // }
95
+ // const _a: I2 = { date: '' } as unknown as I2
96
+ // type TestI = Merge<I1, [I2]>
97
+ // // ReturnType<(typeof merge)<I1, I2>>
98
+ // const a = merge(_a, [_a])
99
+ // interface Arguments extends Record<string | number | symbol, unknown> {
100
+ // key: string;
101
+ // }
102
+ // const aa1: Arguments = { key: "value1" }
103
+ // const aa2: Arguments = { key: "value2" }
104
+ // const aa = merge(a1, a2);
105
+ // interface Barguments {
106
+ // key: string
107
+ // }
108
+ // const ba1: Barguments = { key: 'value1' }
109
+ // const ba2: Barguments = { key: 'value2' }
110
+ // const ba = merge(ba1, ba2)
89
111
 
90
112
  export { concatArrays, merge, mergeAndCompare, mergeAndConcat };
package/dist/types/merge.d.ts CHANGED
@@ -1,17 +1,17 @@
1
1
  import type { Assign } from './typeUtils/Assign';
2
- import type { List } from './typeUtils/List';
2
+ import type { Pop } from './typeUtils/List';
3
3
  import type { PrettyPrint } from './typeUtils/PrettyPrint';
4
4
  /**
5
5
  * The return type of `merge()`. It reflects the type that is returned by JavaScript.
6
6
  *
7
7
  * This TS Utility can be used as standalone as well
8
8
  */
9
- export declare type Merge<T extends object, Ts extends List<object>> = PrettyPrint<Assign<T, Ts>>;
9
+ export declare type Merge<T, Ts extends unknown[]> = T extends Record<string | number | symbol, unknown> ? Ts extends Record<string | number | symbol, unknown>[] ? PrettyPrint<Assign<T, Ts>> : Pop<Ts> : Pop<Ts>;
10
10
  /**
11
11
  * Merge anything recursively.
12
12
  * Objects get merged, special objects (classes etc.) are re-assigned "as is".
13
13
  * Basic types overwrite objects or other basic types.
14
14
  */
15
- export declare function merge<T extends Record<string | number | symbol, unknown>, Tn extends Record<string | number | symbol, unknown>[]>(object: T, ...otherObjects: Tn): Merge<T, Tn>;
16
- export declare function mergeAndCompare<T extends Record<string | number | symbol, unknown>, Tn extends Record<string | number | symbol, unknown>[]>(compareFn: (prop1: any, prop2: any, propName: string | symbol) => any, object: T, ...otherObjects: Tn): Merge<T, Tn>;
17
- export declare function mergeAndConcat<T extends Record<string | number | symbol, unknown>, Tn extends Record<string | number | symbol, unknown>[]>(object: T, ...otherObjects: Tn): Merge<T, Tn>;
15
+ export declare function merge<T, Tn extends unknown[]>(object: T, ...otherObjects: Tn): Merge<T, Tn>;
16
+ export declare function mergeAndCompare<T, Tn extends unknown[]>(compareFn: (prop1: any, prop2: any, propName: string | symbol) => any, object: T, ...otherObjects: Tn): Merge<T, Tn>;
17
+ export declare function mergeAndConcat<T, Tn extends unknown[]>(object: T, ...otherObjects: Tn): Merge<T, Tn>;
package/dist/types/typeUtils/Assign.d.ts CHANGED
@@ -34,8 +34,8 @@ declare type Cast<A1, A2> = A1 extends A2 ? A1 : A2;
34
34
  * ```
35
35
  */
36
36
  declare type Extends<A1, A2> = [A1] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
37
- declare type __Assign<O extends object, Os extends List<object>, I extends Iteration = IterationOf<0>> = Extends<Pos<I>, Length<Os>> extends 1 ? O : __Assign<MergeDeep<O, Os[Pos<I>]>, Os, Next<I>>;
38
- declare type _Assign<O extends object, Os extends List<object>> = __Assign<O, Os> extends infer X ? Cast<X, object> : never;
37
+ declare type __Assign<O extends Record<string | number | symbol, unknown>, Os extends List<Record<string | number | symbol, unknown>>, I extends Iteration = IterationOf<0>> = Extends<Pos<I>, Length<Os>> extends 1 ? O : __Assign<MergeDeep<O, Os[Pos<I>]>, Os, Next<I>>;
38
+ declare type _Assign<O extends Record<string | number | symbol, unknown>, Os extends List<Record<string | number | symbol, unknown>>> = __Assign<O, Os> extends infer X ? Cast<X, Record<string | number | symbol, unknown>> : never;
39
39
  /**
40
40
  * Assign a list of [[Object]] into `O` with [[MergeDeep]]. Merges from right to
41
41
  * left, first items get overridden by the next ones (last-in overrides).
@@ -46,5 +46,5 @@ declare type _Assign<O extends object, Os extends List<object>> = __Assign<O, Os
46
46
  * ```ts
47
47
  * ```
48
48
  */
49
- export declare type Assign<O extends object, Os extends List<object>> = O extends unknown ? Os extends unknown ? _Assign<O, Os> : never : never;
49
+ export declare type Assign<O extends Record<string | number | symbol, unknown>, Os extends List<Record<string | number | symbol, unknown>>> = O extends unknown ? (Os extends unknown ? _Assign<O, Os> : never) : never;
50
50
  export {};
package/dist/types/typeUtils/List.d.ts CHANGED
@@ -18,3 +18,12 @@ export declare type List<T = any> = readonly T[];
18
18
  * ```
19
19
  */
20
20
  export declare type Length<L extends List> = L['length'];
21
+ /**
22
+ * Return the last item out of a [[List]]
23
+ * @param L
24
+ * @returns [[List]]
25
+ * @example
26
+ * ```ts
27
+ * ```
28
+ */
29
+ export declare type Pop<L extends List> = L extends readonly [] ? L : L extends readonly [...any, infer Last] ? Last : L;
package/dist/types/typeUtils/MergeDeep.d.ts CHANGED
@@ -1,30 +1,29 @@
1
1
  /**
2
- * Make an object properties (all) `never`. We use this to intersect `object`s and
3
- * preserve the combine modifiers like `+readonly` and `?optional`.
2
+ * Get the keys of `O` that are optional
3
+ * @param O
4
+ * @returns [[Key]]
5
+ * @example
6
+ * ```ts
7
+ * ```
4
8
  */
5
- declare type Anyfy<O extends object> = {
6
- [K in keyof O]: any;
7
- };
9
+ declare type OptionalKeys<O extends object> = O extends unknown ? {
10
+ [K in keyof O]-?: {} extends Pick<O, K> ? K : never;
11
+ }[keyof O] : never;
8
12
  /**
9
- * Get in `O` the type of a field of key `K`
10
- * @param O to extract from
11
- * @param K to extract at
12
- * @returns [[Any]]
13
+ * Get the keys of `O` that are required
14
+ * @param O
15
+ * @returns [[Key]]
13
16
  * @example
14
17
  * ```ts
15
- * type User = {
16
- * info: { name: string; age: number; payment: {} }
17
- * id: number
18
- * }
19
- *
20
- * type test0 = At<User, 'id'> // number
21
18
  * ```
22
19
  */
23
- declare type At<A, K extends string | number | symbol> = unknown extends A ? unknown : K extends keyof A ? A[K] : undefined;
20
+ declare type RequiredKeys<O extends object> = O extends unknown ? {
21
+ [K in keyof O]-?: {} extends Pick<O, K> ? never : K;
22
+ }[keyof O] : never;
24
23
  declare type MergeObjectDeeply<O extends Record<string | number | symbol, unknown>, O1 extends Record<string | number | symbol, unknown>> = {
25
- [K in keyof (Anyfy<O> & O1)]: K extends keyof O1 ? MergeObjectOrReturnValue<At<O, K>, At<O1, K>> : O[K];
24
+ [K in keyof (O & O1)]: K extends RequiredKeys<O1> ? MergeObjectsOrReturnFallback<O[K], O1[K], O1[K]> : K extends OptionalKeys<O1> ? K extends OptionalKeys<O> ? MergeObjectsOrReturnFallback<Exclude<O[K], undefined>, Exclude<O1[K], undefined>, Exclude<O[K], undefined> | Exclude<O1[K], undefined>> : K extends RequiredKeys<O> ? Exclude<O1[K], undefined> extends O[K] ? O[K] : MergeObjectsOrReturnFallback<O[K], Exclude<O1[K], undefined>, O[K] | Exclude<O1[K], undefined>> : O1[K] : O[K];
26
25
  };
27
- declare type MergeObjectOrReturnValue<OK, O1K> = [O1K] extends [never] ? OK : OK extends Record<string | number | symbol, unknown> ? O1K extends Record<string | number | symbol, unknown> ? MergeObjectDeeply<OK, O1K> : O1K : O1K;
26
+ declare type MergeObjectsOrReturnFallback<O, O1, Fallback> = O extends Record<string | number | symbol, unknown> ? O1 extends Record<string | number | symbol, unknown> ? MergeObjectDeeply<O, O1> : Fallback : Fallback;
28
27
  /**
29
28
  * Accurately merge the fields of `O` with the ones of `O1`. It is
30
29
  * equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
@@ -36,32 +35,23 @@ declare type MergeObjectOrReturnValue<OK, O1K> = [O1K] extends [never] ? OK : OK
36
35
  * @returns [[Object]]
37
36
  * @example
38
37
  * ```ts
39
- * type O = {
40
- * name?: string
41
- * age?: number
42
- * zip?: string
43
- * pay: { cvv?: number }
44
- * }
38
+ * import { PrettyPrint } from './PrettyPrint'
45
39
  *
46
- * type O1 = {
47
- * age: number
48
- * zip?: number
49
- * pay: { cvv : number; ccn?: string }
50
- * city: string
51
- * }
40
+ * type A1 = { a: number; b?: number; d?: number; e?: number; x: string; y?: number; z: string; } // prettier-ignore
41
+ * type A2 = { a?: number; c?: number; d?: number; e: number; x: number | undefined; y?: string; z?: number; } // prettier-ignore
52
42
  *
53
- * type test = MergeDeep<O, O1>
54
- * // {
55
- * // name?: string;
56
- * // age: number;
57
- * // zip: number | undefined;
58
- * // pay: {
59
- * // cvv: number;
60
- * // ccn?: string;
61
- * // };
62
- * // city: string;
63
- * // }
43
+ * type Result = PrettyPrint<MergeDeep<A1, A2>>
44
+ * {
45
+ * a: number;
46
+ * b?: number | undefined;
47
+ * c?: number | undefined;
48
+ * d?: number | undefined;
49
+ * e: number;
50
+ * x: number | undefined;
51
+ * y?: string | number | undefined;
52
+ * z: string | number;
53
+ * }
64
54
  * ```
65
55
  */
66
- export declare type MergeDeep<O extends object, O1 extends object> = O extends unknown ? O1 extends unknown ? MergeObjectOrReturnValue<O, O1> : never : never;
56
+ export declare type MergeDeep<O extends Record<string | number | symbol, unknown>, O1 extends Record<string | number | symbol, unknown>> = O extends unknown ? (O1 extends unknown ? MergeObjectDeeply<O, O1> : never) : never;
67
57
  export {};
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "merge-anything",
3
- "version": "5.1.0",
3
+ "version": "5.1.2",
4
4
  "sideEffects": false,
5
5
  "type": "module",
6
6
  "description": "Merge objects & other types recursively. A simple & small integration.",