merge-anything 5.0.4 → 5.1.0

package/README.md

@@ -26,15 +26,20 @@ This last one is crucial! In JavaScript almost everything is _an object_, sure,
 
 merge-anything will merge objects and nested properties, but only as long as they're "plain objects". As soon as a sub-prop is not a "plain object" and has a special prototype, it will copy that instance over "as is". ♻️
 
-## Meet the family
+## Meet the family (more tiny utils with TS support)
 
+- [is-what 🙉](https://github.com/mesqueeb/is-what)
+- [is-where 🙈](https://github.com/mesqueeb/is-where)
 - [merge-anything 🥡](https://github.com/mesqueeb/merge-anything)
+- [check-anything 👁](https://github.com/mesqueeb/check-anything)
+- [remove-anything ✂️](https://github.com/mesqueeb/remove-anything)
+- [getorset-anything 🐊](https://github.com/mesqueeb/getorset-anything)
+- [map-anything 🗺](https://github.com/mesqueeb/map-anything)
 - [filter-anything ⚔️](https://github.com/mesqueeb/filter-anything)
-- [find-and-replace-anything 🎣](https://github.com/mesqueeb/find-and-replace-anything)
-- [compare-anything 🛰](https://github.com/mesqueeb/compare-anything)
 - [copy-anything 🎭](https://github.com/mesqueeb/copy-anything)
+- [case-anything 🐫](https://github.com/mesqueeb/case-anything)
 - [flatten-anything 🏏](https://github.com/mesqueeb/flatten-anything)
-- [is-what 🙉](https://github.com/mesqueeb/is-what)
+- [nestify-anything 🧅](https://github.com/mesqueeb/nestify-anything)
 
 ## Usage
 
@@ -63,6 +68,18 @@ In the example above, if you are using TypeScript, and you hover over `evolution
 
 ![typescript support](https://raw.githubusercontent.com/mesqueeb/merge-anything/master/.github/typescript-support.png)
 
+The return type of the `merge()` function is usable as a TypeScript utility as well:
+
+```ts
+import type { Merge } from 'merge-anything'
+
+type A1 = { name: string }
+type A2 = { types: { water: boolean } }
+type A3 = { types: { fighting: boolean } }
+
+type Result = Merge<A1, [A2, A3]>
+```
+
 ## Rules
 
 This package will recursively go through plain objects and merge the values onto a new object.
@@ -124,7 +141,7 @@ For this case we use `mergeAndCompare`. Here is an example with a compare functi
 ```js
 import { mergeAndCompare } from 'merge-anything'
 
-function concatStrings (originVal, newVal, key) {
+function concatStrings(originVal, newVal, key) {
   if (typeof originVal === 'string' && typeof newVal === 'string') {
     // concat logic
     return `${originVal}${newVal}`
@@ -192,7 +209,7 @@ It is literally just going through an object recursively and assigning the value
 ```js
 import { isPlainObject } from 'is-what'
 
-function mergeRecursively (origin, newComer) {
+function mergeRecursively(origin, newComer) {
   if (!isPlainObject(newComer)) return newComer
   // define newObject to merge all values upon
   const newObject = isPlainObject(origin)

package/dist/index.cjs

@@ -1,10 +1,7 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var isWhat = require('is-what');
 
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 function concatArrays(originVal, newVal) {
     if (isWhat.isArray(originVal) && isWhat.isArray(newVal)) {
         // concat logic
@@ -67,8 +64,6 @@ function mergeRecursively(origin, newComer, compareFn) {
  * Merge anything recursively.
  * Objects get merged, special objects (classes etc.) are re-assigned "as is".
  * Basic types overwrite objects or other basic types.
- * @param object
- * @param otherObjects
  */
 function merge(object, ...otherObjects) {
     return otherObjects.reduce((result, newComer) => {
@@ -84,7 +79,15 @@ function mergeAndConcat(object, ...otherObjects) {
     return otherObjects.reduce((result, newComer) => {
         return mergeRecursively(result, newComer, concatArrays);
     }, object);
-}
+}
+// import { Timestamp } from 'firebase/firestore'
+// type T1 = { date: Timestamp }
+// type T2 = [{ b: string[] }, { b: number[] }, { date: Timestamp }]
+// type Test = Merge<T1, T2>
+// type A1 = { arr: string[] }
+// type A2 = { arr: number[] }
+// type A3 = { arr: boolean[] }
+// type Test = Merge<A1, [A2, A3]>
 
 exports.concatArrays = concatArrays;
 exports.merge = merge;

package/dist/index.es.js

@@ -1,6 +1,5 @@
 import { isArray, isPlainObject, isSymbol } from 'is-what';
 
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 function concatArrays(originVal, newVal) {
     if (isArray(originVal) && isArray(newVal)) {
         // concat logic
@@ -63,8 +62,6 @@ function mergeRecursively(origin, newComer, compareFn) {
  * Merge anything recursively.
  * Objects get merged, special objects (classes etc.) are re-assigned "as is".
  * Basic types overwrite objects or other basic types.
- * @param object
- * @param otherObjects
  */
 function merge(object, ...otherObjects) {
     return otherObjects.reduce((result, newComer) => {
@@ -80,6 +77,14 @@ function mergeAndConcat(object, ...otherObjects) {
     return otherObjects.reduce((result, newComer) => {
         return mergeRecursively(result, newComer, concatArrays);
     }, object);
-}
+}
+// import { Timestamp } from 'firebase/firestore'
+// type T1 = { date: Timestamp }
+// type T2 = [{ b: string[] }, { b: number[] }, { date: Timestamp }]
+// type Test = Merge<T1, T2>
+// type A1 = { arr: string[] }
+// type A2 = { arr: number[] }
+// type A3 = { arr: boolean[] }
+// type Test = Merge<A1, [A2, A3]>
 
 export { concatArrays, merge, mergeAndCompare, mergeAndConcat };

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
-export { merge, mergeAndCompare, mergeAndConcat } from './merge';
-export { concatArrays } from './extensions';
+export * from './merge';
+export * from './extensions';

package/dist/types/merge.d.ts

@@ -1,15 +1,17 @@
-import { O } from 'ts-toolbelt';
-declare type ExpandDeep<T> = T extends Record<string | number | symbol, unknown> ? {
-    [K in keyof T]: ExpandDeep<T[K]>;
-} : T extends Array<infer E> ? Array<ExpandDeep<E>> : T;
+import type { Assign } from './typeUtils/Assign';
+import type { List } from './typeUtils/List';
+import type { PrettyPrint } from './typeUtils/PrettyPrint';
+/**
+ * The return type of `merge()`. It reflects the type that is returned by JavaScript.
+ *
+ * This TS Utility can be used as standalone as well
+ */
+export declare type Merge<T extends object, Ts extends List<object>> = PrettyPrint<Assign<T, Ts>>;
 /**
  * Merge anything recursively.
  * Objects get merged, special objects (classes etc.) are re-assigned "as is".
  * Basic types overwrite objects or other basic types.
- * @param object
- * @param otherObjects
  */
-export declare function merge<T extends Record<string, any>, Tn extends Record<string, any>[]>(object: T, ...otherObjects: Tn): ExpandDeep<O.Assign<T, Tn, 'deep'>>;
-export declare function mergeAndCompare<T extends Record<string, any>, Tn extends Record<string, any>[]>(compareFn: (prop1: any, prop2: any, propName: string | symbol) => any, object: T, ...otherObjects: Tn): ExpandDeep<O.Assign<T, Tn, 'deep'>>;
-export declare function mergeAndConcat<T extends Record<string, any>, Tn extends Record<string, any>[]>(object: T, ...otherObjects: Tn): ExpandDeep<O.Assign<T, Tn, 'deep'>>;
-export {};
+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>;
+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>;
+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>;

package/dist/types/typeUtils/Assign.d.ts

@@ -0,0 +1,50 @@
+import { MergeDeep } from './MergeDeep';
+import { Iteration, IterationOf, Pos, Next } from './Iteration';
+import { Length, List } from './List';
+/**
+ * Ask TS to re-check that `A1` extends `A2`.
+ * And if it fails, `A2` will be enforced anyway.
+ * Can also be used to add constraints on parameters.
+ * @param A1 to check against
+ * @param A2 to cast to
+ * @returns `A1 | A2`
+ * @example
+ * ```ts
+ * type test0 = Cast<'42', string> // '42'
+ * type test1 = Cast<'42', number> // number
+ * ```
+ */
+declare type Cast<A1, A2> = A1 extends A2 ? A1 : A2;
+/**
+ * Check whether `A1` is part of `A2` or not. The difference with
+ * `extends` is that it forces a [[Boolean]] return.
+ * @param A1
+ * @param A2
+ * @returns [[Boolean]]
+ * @example
+ * ```ts
+ * type test0 = Extends<'a' | 'b', 'b'> // Boolean
+ * type test1 = Extends<'a', 'a' | 'b'> // True
+ *
+ * type test2 = Extends<{a: string}, {a: any}>      // True
+ * type test3 = Extends<{a: any}, {a: any, b: any}> // False
+ *
+ * type test4 = Extends<never, never> // False
+ * /// Nothing cannot extend nothing, use `Equals`
+ * ```
+ */
+declare type Extends<A1, A2> = [A1] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
+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>>;
+declare type _Assign<O extends object, Os extends List<object>> = __Assign<O, Os> extends infer X ? Cast<X, object> : never;
+/**
+ * Assign a list of [[Object]] into `O` with [[MergeDeep]]. Merges from right to
+ * left, first items get overridden by the next ones (last-in overrides).
+ * @param O to assign to
+ * @param Os to assign
+ * @returns [[Object]]
+ * @example
+ * ```ts
+ * ```
+ */
+export declare type Assign<O extends object, Os extends List<object>> = O extends unknown ? Os extends unknown ? _Assign<O, Os> : never : never;
+export {};

package/dist/types/typeUtils/Iteration.d.ts

@@ -0,0 +1,257 @@
+/**
+ * An entry of `IterationMap`
+ */
+export declare type Iteration = [
+    value: number,
+    sign: '-' | '0' | '+',
+    prev: keyof IterationMap,
+    next: keyof IterationMap,
+    oppo: keyof IterationMap
+];
+export declare type IterationMap = {
+    '__': [number, '-' | '0' | '+', '__', '__', '__'];
+    '-100': [-100, '-', '__', '-99', '100'];
+    '-99': [-99, '-', '-100', '-98', '99'];
+    '-98': [-98, '-', '-99', '-97', '98'];
+    '-97': [-97, '-', '-98', '-96', '97'];
+    '-96': [-96, '-', '-97', '-95', '96'];
+    '-95': [-95, '-', '-96', '-94', '95'];
+    '-94': [-94, '-', '-95', '-93', '94'];
+    '-93': [-93, '-', '-94', '-92', '93'];
+    '-92': [-92, '-', '-93', '-91', '92'];
+    '-91': [-91, '-', '-92', '-90', '91'];
+    '-90': [-90, '-', '-91', '-89', '90'];
+    '-89': [-89, '-', '-90', '-88', '89'];
+    '-88': [-88, '-', '-89', '-87', '88'];
+    '-87': [-87, '-', '-88', '-86', '87'];
+    '-86': [-86, '-', '-87', '-85', '86'];
+    '-85': [-85, '-', '-86', '-84', '85'];
+    '-84': [-84, '-', '-85', '-83', '84'];
+    '-83': [-83, '-', '-84', '-82', '83'];
+    '-82': [-82, '-', '-83', '-81', '82'];
+    '-81': [-81, '-', '-82', '-80', '81'];
+    '-80': [-80, '-', '-81', '-79', '80'];
+    '-79': [-79, '-', '-80', '-78', '79'];
+    '-78': [-78, '-', '-79', '-77', '78'];
+    '-77': [-77, '-', '-78', '-76', '77'];
+    '-76': [-76, '-', '-77', '-75', '76'];
+    '-75': [-75, '-', '-76', '-74', '75'];
+    '-74': [-74, '-', '-75', '-73', '74'];
+    '-73': [-73, '-', '-74', '-72', '73'];
+    '-72': [-72, '-', '-73', '-71', '72'];
+    '-71': [-71, '-', '-72', '-70', '71'];
+    '-70': [-70, '-', '-71', '-69', '70'];
+    '-69': [-69, '-', '-70', '-68', '69'];
+    '-68': [-68, '-', '-69', '-67', '68'];
+    '-67': [-67, '-', '-68', '-66', '67'];
+    '-66': [-66, '-', '-67', '-65', '66'];
+    '-65': [-65, '-', '-66', '-64', '65'];
+    '-64': [-64, '-', '-65', '-63', '64'];
+    '-63': [-63, '-', '-64', '-62', '63'];
+    '-62': [-62, '-', '-63', '-61', '62'];
+    '-61': [-61, '-', '-62', '-60', '61'];
+    '-60': [-60, '-', '-61', '-59', '60'];
+    '-59': [-59, '-', '-60', '-58', '59'];
+    '-58': [-58, '-', '-59', '-57', '58'];
+    '-57': [-57, '-', '-58', '-56', '57'];
+    '-56': [-56, '-', '-57', '-55', '56'];
+    '-55': [-55, '-', '-56', '-54', '55'];
+    '-54': [-54, '-', '-55', '-53', '54'];
+    '-53': [-53, '-', '-54', '-52', '53'];
+    '-52': [-52, '-', '-53', '-51', '52'];
+    '-51': [-51, '-', '-52', '-50', '51'];
+    '-50': [-50, '-', '-51', '-49', '50'];
+    '-49': [-49, '-', '-50', '-48', '49'];
+    '-48': [-48, '-', '-49', '-47', '48'];
+    '-47': [-47, '-', '-48', '-46', '47'];
+    '-46': [-46, '-', '-47', '-45', '46'];
+    '-45': [-45, '-', '-46', '-44', '45'];
+    '-44': [-44, '-', '-45', '-43', '44'];
+    '-43': [-43, '-', '-44', '-42', '43'];
+    '-42': [-42, '-', '-43', '-41', '42'];
+    '-41': [-41, '-', '-42', '-40', '41'];
+    '-40': [-40, '-', '-41', '-39', '40'];
+    '-39': [-39, '-', '-40', '-38', '39'];
+    '-38': [-38, '-', '-39', '-37', '38'];
+    '-37': [-37, '-', '-38', '-36', '37'];
+    '-36': [-36, '-', '-37', '-35', '36'];
+    '-35': [-35, '-', '-36', '-34', '35'];
+    '-34': [-34, '-', '-35', '-33', '34'];
+    '-33': [-33, '-', '-34', '-32', '33'];
+    '-32': [-32, '-', '-33', '-31', '32'];
+    '-31': [-31, '-', '-32', '-30', '31'];
+    '-30': [-30, '-', '-31', '-29', '30'];
+    '-29': [-29, '-', '-30', '-28', '29'];
+    '-28': [-28, '-', '-29', '-27', '28'];
+    '-27': [-27, '-', '-28', '-26', '27'];
+    '-26': [-26, '-', '-27', '-25', '26'];
+    '-25': [-25, '-', '-26', '-24', '25'];
+    '-24': [-24, '-', '-25', '-23', '24'];
+    '-23': [-23, '-', '-24', '-22', '23'];
+    '-22': [-22, '-', '-23', '-21', '22'];
+    '-21': [-21, '-', '-22', '-20', '21'];
+    '-20': [-20, '-', '-21', '-19', '20'];
+    '-19': [-19, '-', '-20', '-18', '19'];
+    '-18': [-18, '-', '-19', '-17', '18'];
+    '-17': [-17, '-', '-18', '-16', '17'];
+    '-16': [-16, '-', '-17', '-15', '16'];
+    '-15': [-15, '-', '-16', '-14', '15'];
+    '-14': [-14, '-', '-15', '-13', '14'];
+    '-13': [-13, '-', '-14', '-12', '13'];
+    '-12': [-12, '-', '-13', '-11', '12'];
+    '-11': [-11, '-', '-12', '-10', '11'];
+    '-10': [-10, '-', '-11', '-9', '10'];
+    '-9': [-9, '-', '-10', '-8', '9'];
+    '-8': [-8, '-', '-9', '-7', '8'];
+    '-7': [-7, '-', '-8', '-6', '7'];
+    '-6': [-6, '-', '-7', '-5', '6'];
+    '-5': [-5, '-', '-6', '-4', '5'];
+    '-4': [-4, '-', '-5', '-3', '4'];
+    '-3': [-3, '-', '-4', '-2', '3'];
+    '-2': [-2, '-', '-3', '-1', '2'];
+    '-1': [-1, '-', '-2', '0', '1'];
+    '0': [0, '0', '-1', '1', '0'];
+    '1': [1, '+', '0', '2', '-1'];
+    '2': [2, '+', '1', '3', '-2'];
+    '3': [3, '+', '2', '4', '-3'];
+    '4': [4, '+', '3', '5', '-4'];
+    '5': [5, '+', '4', '6', '-5'];
+    '6': [6, '+', '5', '7', '-6'];
+    '7': [7, '+', '6', '8', '-7'];
+    '8': [8, '+', '7', '9', '-8'];
+    '9': [9, '+', '8', '10', '-9'];
+    '10': [10, '+', '9', '11', '-10'];
+    '11': [11, '+', '10', '12', '-11'];
+    '12': [12, '+', '11', '13', '-12'];
+    '13': [13, '+', '12', '14', '-13'];
+    '14': [14, '+', '13', '15', '-14'];
+    '15': [15, '+', '14', '16', '-15'];
+    '16': [16, '+', '15', '17', '-16'];
+    '17': [17, '+', '16', '18', '-17'];
+    '18': [18, '+', '17', '19', '-18'];
+    '19': [19, '+', '18', '20', '-19'];
+    '20': [20, '+', '19', '21', '-20'];
+    '21': [21, '+', '20', '22', '-21'];
+    '22': [22, '+', '21', '23', '-22'];
+    '23': [23, '+', '22', '24', '-23'];
+    '24': [24, '+', '23', '25', '-24'];
+    '25': [25, '+', '24', '26', '-25'];
+    '26': [26, '+', '25', '27', '-26'];
+    '27': [27, '+', '26', '28', '-27'];
+    '28': [28, '+', '27', '29', '-28'];
+    '29': [29, '+', '28', '30', '-29'];
+    '30': [30, '+', '29', '31', '-30'];
+    '31': [31, '+', '30', '32', '-31'];
+    '32': [32, '+', '31', '33', '-32'];
+    '33': [33, '+', '32', '34', '-33'];
+    '34': [34, '+', '33', '35', '-34'];
+    '35': [35, '+', '34', '36', '-35'];
+    '36': [36, '+', '35', '37', '-36'];
+    '37': [37, '+', '36', '38', '-37'];
+    '38': [38, '+', '37', '39', '-38'];
+    '39': [39, '+', '38', '40', '-39'];
+    '40': [40, '+', '39', '41', '-40'];
+    '41': [41, '+', '40', '42', '-41'];
+    '42': [42, '+', '41', '43', '-42'];
+    '43': [43, '+', '42', '44', '-43'];
+    '44': [44, '+', '43', '45', '-44'];
+    '45': [45, '+', '44', '46', '-45'];
+    '46': [46, '+', '45', '47', '-46'];
+    '47': [47, '+', '46', '48', '-47'];
+    '48': [48, '+', '47', '49', '-48'];
+    '49': [49, '+', '48', '50', '-49'];
+    '50': [50, '+', '49', '51', '-50'];
+    '51': [51, '+', '50', '52', '-51'];
+    '52': [52, '+', '51', '53', '-52'];
+    '53': [53, '+', '52', '54', '-53'];
+    '54': [54, '+', '53', '55', '-54'];
+    '55': [55, '+', '54', '56', '-55'];
+    '56': [56, '+', '55', '57', '-56'];
+    '57': [57, '+', '56', '58', '-57'];
+    '58': [58, '+', '57', '59', '-58'];
+    '59': [59, '+', '58', '60', '-59'];
+    '60': [60, '+', '59', '61', '-60'];
+    '61': [61, '+', '60', '62', '-61'];
+    '62': [62, '+', '61', '63', '-62'];
+    '63': [63, '+', '62', '64', '-63'];
+    '64': [64, '+', '63', '65', '-64'];
+    '65': [65, '+', '64', '66', '-65'];
+    '66': [66, '+', '65', '67', '-66'];
+    '67': [67, '+', '66', '68', '-67'];
+    '68': [68, '+', '67', '69', '-68'];
+    '69': [69, '+', '68', '70', '-69'];
+    '70': [70, '+', '69', '71', '-70'];
+    '71': [71, '+', '70', '72', '-71'];
+    '72': [72, '+', '71', '73', '-72'];
+    '73': [73, '+', '72', '74', '-73'];
+    '74': [74, '+', '73', '75', '-74'];
+    '75': [75, '+', '74', '76', '-75'];
+    '76': [76, '+', '75', '77', '-76'];
+    '77': [77, '+', '76', '78', '-77'];
+    '78': [78, '+', '77', '79', '-78'];
+    '79': [79, '+', '78', '80', '-79'];
+    '80': [80, '+', '79', '81', '-80'];
+    '81': [81, '+', '80', '82', '-81'];
+    '82': [82, '+', '81', '83', '-82'];
+    '83': [83, '+', '82', '84', '-83'];
+    '84': [84, '+', '83', '85', '-84'];
+    '85': [85, '+', '84', '86', '-85'];
+    '86': [86, '+', '85', '87', '-86'];
+    '87': [87, '+', '86', '88', '-87'];
+    '88': [88, '+', '87', '89', '-88'];
+    '89': [89, '+', '88', '90', '-89'];
+    '90': [90, '+', '89', '91', '-90'];
+    '91': [91, '+', '90', '92', '-91'];
+    '92': [92, '+', '91', '93', '-92'];
+    '93': [93, '+', '92', '94', '-93'];
+    '94': [94, '+', '93', '95', '-94'];
+    '95': [95, '+', '94', '96', '-95'];
+    '96': [96, '+', '95', '97', '-96'];
+    '97': [97, '+', '96', '98', '-97'];
+    '98': [98, '+', '97', '99', '-98'];
+    '99': [99, '+', '98', '100', '-99'];
+    '100': [100, '+', '99', '__', '-100'];
+};
+/**
+ * Transform a number into an [[Iteration]]
+ * (to use [[Prev]], [[Next]], & [[Pos]])
+ * @param N to transform
+ * @returns [[Iteration]]
+ * @example
+ * ```ts
+ * type i = IterationOf<0> // ["-1", "1", "0", 0, "0"]
+ *
+ * type next = Next<i>       // ["0", "2", "1", 1, "+"]
+ * type prev = Prev<i>       // ["-2", "0", "-1", -1, "-"]
+ *
+ * type nnext = Pos<next>    // +1
+ * type nprev = Pos<prev>    // -1
+ * ```
+ */
+export declare type IterationOf<N extends number> = `${N}` extends keyof IterationMap ? IterationMap[`${N}`] : IterationMap['__'];
+/**
+ * Get the position of `I` (**number**)
+ * @param I to query
+ * @returns `number`
+ * @example
+ * ```ts
+ * type i = IterationOf<'20'>
+ *
+ * type test0 = Pos<i>         // 20
+ * type test1 = Pos<Next<i>> // 21
+ * ```
+ */
+export declare type Pos<I extends Iteration> = I[0];
+/**
+ * Move `I`'s position forward
+ * @param I to move
+ * @returns [[Iteration]]
+ * @example
+ * ```ts
+ * type i = IterationOf<'20'>
+ *
+ * type test0 = Pos<i>         // 20
+ * type test1 = Pos<Next<i>> // 21
+ * ```
+ */
+export declare type Next<I extends Iteration> = IterationMap[I[3]];

package/dist/types/typeUtils/List.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A [[List]]
+ * @param T its type
+ * @returns [[List]]
+ * @example
+ * ```ts
+ * type list0 = [1, 2, 3]
+ * type list1 = number[]
+ * ```
+ */
+export declare type List<T = any> = readonly T[];
+/**
+ * Get the length of `L`
+ * @param L to get length
+ * @returns [[String]] or `number`
+ * @example
+ * ```ts
+ * ```
+ */
+export declare type Length<L extends List> = L['length'];

package/dist/types/typeUtils/MergeDeep.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Make an object properties (all) `never`. We use this to intersect `object`s and
+ * preserve the combine modifiers like `+readonly` and `?optional`.
+ */
+declare type Anyfy<O extends object> = {
+    [K in keyof O]: any;
+};
+/**
+ * Get in `O` the type of a field of key `K`
+ * @param O to extract from
+ * @param K to extract at
+ * @returns [[Any]]
+ * @example
+ * ```ts
+ * type User = {
+ *  info: { name: string; age: number; payment: {} }
+ *  id: number
+ * }
+ *
+ * type test0 = At<User, 'id'> // number
+ * ```
+ */
+declare type At<A, K extends string | number | symbol> = unknown extends A ? unknown : K extends keyof A ? A[K] : undefined;
+declare type MergeObjectDeeply<O extends Record<string | number | symbol, unknown>, O1 extends Record<string | number | symbol, unknown>> = {
+    [K in keyof (Anyfy<O> & O1)]: K extends keyof O1 ? MergeObjectOrReturnValue<At<O, K>, At<O1, K>> : O[K];
+};
+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;
+/**
+ * Accurately merge the fields of `O` with the ones of `O1`. It is
+ * equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
+ * fields will be handled gracefully.
+ *
+ * (⚠️ needs `--strictNullChecks` enabled)
+ * @param O to complete
+ * @param O1 to copy from
+ * @returns [[Object]]
+ * @example
+ * ```ts
+ * type O = {
+ *   name?: string
+ *   age?: number
+ *   zip?: string
+ *   pay: { cvv?: number }
+ * }
+ *
+ * type O1 = {
+ *   age: number
+ *   zip?: number
+ *   pay: { cvv : number; ccn?: string }
+ *   city: string
+ * }
+ *
+ * type test = MergeDeep<O, O1>
+ * // {
+ * //     name?: string;
+ * //     age: number;
+ * //     zip: number | undefined;
+ * //     pay: {
+ * //         cvv: number;
+ * //         ccn?: string;
+ * //     };
+ * //     city: string;
+ * // }
+ * ```
+ */
+export declare type MergeDeep<O extends object, O1 extends object> = O extends unknown ? O1 extends unknown ? MergeObjectOrReturnValue<O, O1> : never : never;
+export {};

package/dist/types/typeUtils/PrettyPrint.d.ts

@@ -0,0 +1,6 @@
+declare type Has<U, U1> = [U1] extends [U] ? 1 : 0;
+declare type If<B extends 0 | 1, Then, Else = never> = B extends 1 ? Then : Else;
+export declare type PrettyPrint<A, Seen = never> = If<Has<Seen, A>, A, A extends Record<string | number | symbol, unknown> ? {
+    [K in keyof A]: PrettyPrint<A[K], A | Seen>;
+} & unknown : A>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-anything",
-  "version": "5.0.4",
+  "version": "5.1.0",
   "sideEffects": false,
   "type": "module",
   "description": "Merge objects & other types recursively. A simple & small integration.",
@@ -23,7 +23,7 @@
   "scripts": {
     "lint": "tsc --noEmit && eslint ./src --ext .ts",
     "test": "vitest run",
-    "build": "rollup -c ./scripts/build.js",
+    "build": "rollup --bundleConfigAsCjs -c ./scripts/build.js",
     "release": "npm run lint && del dist && npm run build && np"
   },
   "repository": {
@@ -60,22 +60,21 @@
   },
   "homepage": "https://github.com/mesqueeb/merge-anything#readme",
   "dependencies": {
-    "is-what": "^4.1.7",
-    "ts-toolbelt": "^9.6.0"
+    "is-what": "^4.1.7"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.34.0",
-    "@typescript-eslint/parser": "^5.34.0",
+    "@typescript-eslint/eslint-plugin": "^5.42.1",
+    "@typescript-eslint/parser": "^5.42.1",
     "del-cli": "^5.0.0",
-    "eslint": "^8.22.0",
+    "eslint": "^8.27.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-tree-shaking": "^1.10.0",
     "np": "^7.6.2",
     "prettier": "^2.7.1",
-    "rollup": "^2.78.1",
-    "rollup-plugin-typescript2": "^0.33.0",
-    "typescript": "^4.7.4",
-    "vitest": "^0.22.1"
+    "rollup": "^3.3.0",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "typescript": "^4.8.4",
+    "vitest": "^0.25.1"
   },
   "np": {
     "yarn": false,