merge-anything 6.0.5 → 6.0.7

package/README.md

@@ -194,7 +194,7 @@ const merged = copy(merge(original, extraInfo))
 merged.airport.status = 'lan. 🛬'(merged.airport.status === 'lan. 🛬')(
   // true
   // `original` won't be modified!
-  original.airport.status === 'dep. 🛫'
+  original.airport.status === 'dep. 🛫',
 ) // true
 ```
 

package/dist/typeUtils/Assign.d.ts

@@ -2,49 +2,54 @@ import type { Iteration, IterationOf, Next, Pos } from './Iteration.js';
 import type { Length, List } from './List.js';
 import type { MergeDeep } from './MergeDeep.js';
 /**
- * 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`
+ * 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.
+ *
  * @example
- * ```ts
- * type test0 = Cast<'42', string> // '42'
- * type test1 = Cast<'42', number> // number
- * ```
+ *   ;```ts
+ *   type test0 = Cast<'42', string> // '42'
+ *   type test1 = Cast<'42', number> // number
+ *   ```
+ *
+ * @param A1 To check against
+ * @param A2 To cast to
+ * @returns `A1 | A2`
  */
 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]]
+ * Check whether `A1` is part of `A2` or not. The difference with `extends` is that it forces a
+ * [[Boolean]] return.
+ *
  * @example
- * ```ts
- * type test0 = Extends<'a' | 'b', 'b'> // Boolean
- * type test1 = Extends<'a', 'a' | 'b'> // True
+ *   ```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 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`
+ *   ```
  *
- * type test4 = Extends<never, never> // False
- * /// Nothing cannot extend nothing, use `Equals`
- * ```
+ * @param A1
+ * @param A2
+ * @returns {undefined | undefined} Boolean
  */
 type Extends<A1, A2> = [A1] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
 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>>;
 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;
 /**
- * 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]]
+ * 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).
+ *
  * @example
- * ```ts
- * ```
+ *   ;```ts
+ *   ```
+ *
+ * @param O To assign to
+ * @param Os To assign
+ * @returns {undefined | undefined} Object
  */
 export 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;
 export {};

package/dist/typeUtils/Iteration.d.ts

@@ -1,6 +1,4 @@
-/**
- * An entry of `IterationMap`
- */
+/** An entry of `IterationMap` */
 export type Iteration = [
     value: number,
     sign: '-' | '0' | '+',
@@ -213,45 +211,50 @@ export type IterationMap = {
     '100': [100, '+', '99', '__', '-100'];
 };
 /**
- * Transform a number into an [[Iteration]]
- * (to use [[Prev]], [[Next]], & [[Pos]])
- * @param N to transform
- * @returns [[Iteration]]
+ * Transform a number into an [[Iteration]] (to use [[Prev]], [[Next]], & [[Pos]])
+ *
  * @example
- * ```ts
- * type i = IterationOf<0> // ["-1", "1", "0", 0, "0"]
+ *   ;```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 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
- * ```
+ *   type nnext = Pos<next>    // +1
+ *   type nprev = Pos<prev>    // -1
+ *   ```
+ *
+ * @param N To transform
+ * @returns {undefined | undefined} Iteration
  */
 export 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'>
+ *   ;```ts
+ *   type i = IterationOf<'20'>
+ *
+ *   type test0 = Pos<i>         // 20
+ *   type test1 = Pos<Next<i>> // 21
+ *   ```
  *
- * type test0 = Pos<i>         // 20
- * type test1 = Pos<Next<i>> // 21
- * ```
+ * @param I To query
+ * @returns `number`
  */
 export type Pos<I extends Iteration> = I[0];
 /**
  * Move `I`'s position forward
- * @param I to move
- * @returns [[Iteration]]
+ *
  * @example
- * ```ts
- * type i = IterationOf<'20'>
+ *   ;```ts
+ *   type i = IterationOf<'20'>
+ *
+ *   type test0 = Pos<i>         // 20
+ *   type test1 = Pos<Next<i>> // 21
+ *   ```
  *
- * type test0 = Pos<i>         // 20
- * type test1 = Pos<Next<i>> // 21
- * ```
+ * @param I To move
+ * @returns {undefined | undefined} Iteration
  */
 export type Next<I extends Iteration> = IterationMap[I[3]];

package/dist/typeUtils/List.d.ts

@@ -1,29 +1,35 @@
 /**
  * A [[List]]
- * @param T its type
- * @returns [[List]]
+ *
  * @example
- * ```ts
- * type list0 = [1, 2, 3]
- * type list1 = number[]
- * ```
+ *   ;```ts
+ *   type list0 = [1, 2, 3]
+ *   type list1 = number[]
+ *   ```
+ *
+ * @param T Its type
+ * @returns {undefined | undefined} List
  */
 export type List<T = unknown> = readonly T[];
 /**
  * Get the length of `L`
- * @param L to get length
- * @returns [[String]] or `number`
+ *
  * @example
- * ```ts
- * ```
+ *   ;```ts
+ *   ```
+ *
+ * @param L To get length
+ * @returns {undefined | undefined} String or `number`
  */
 export type Length<L extends List> = L['length'];
 /**
  * Return the last item out of a [[List]]
- * @param L
- * @returns [[List]]
+ *
  * @example
- * ```ts
- * ```
+ *   ;```ts
+ *   ```
+ *
+ * @param L
+ * @returns {undefined | undefined} List
  */
 export type Pop<L extends List> = L extends readonly [] ? never : L extends [...unknown[], infer Last] ? Last : L extends (infer T)[] ? T : never;

package/dist/typeUtils/MergeDeep.d.ts

@@ -1,21 +1,25 @@
 /**
  * Get the keys of `O` that are optional
- * @param O
- * @returns [[Key]]
+ *
  * @example
- * ```ts
- * ```
+ *   ;```ts
+ *   ```
+ *
+ * @param O
+ * @returns {undefined | undefined} Key
  */
 type OptionalKeys<O extends object> = O extends unknown ? {
     [K in keyof O]-?: {} extends Pick<O, K> ? K : never;
 }[keyof O] : never;
 /**
  * Get the keys of `O` that are required
- * @param O
- * @returns [[Key]]
+ *
  * @example
- * ```ts
- * ```
+ *   ;```ts
+ *   ```
+ *
+ * @param O
+ * @returns {undefined | undefined} Key
  */
 type RequiredKeys<O extends object> = O extends unknown ? {
     [K in keyof O]-?: {} extends Pick<O, K> ? never : K;
@@ -25,33 +29,34 @@ type MergeObjectDeeply<O extends Record<string | number | symbol, unknown>, O1 e
 };
 type MergeObjectsOrReturnFallback<O, O1, Fallback> = O extends Record<string | number | symbol, unknown> ? O1 extends Record<string | number | symbol, unknown> ? MergeObjectDeeply<O, O1> : Fallback : Fallback;
 /**
- * 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.
+ * 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
- * import { PrettyPrint } from './PrettyPrint'
- *
- * type A1 = { a: number; b?: number;            d?: number; e?: number; x: string;             y?: number; z: string;  } // prettier-ignore
- * type A2 = { a?: number;           c?: number; d?: number; e: number;  x: number | undefined; y?: string; z?: number; } // prettier-ignore
- *
- * type Result = PrettyPrint<MergeDeep<A1, A2>>
- * {
- *    a: number;
- *    b?: number | undefined;
- *    c?: number | undefined;
- *    d?: number | undefined;
- *    e: number;
- *    x: number | undefined;
- *    y?: string | number | undefined;
- *    z: string | number;
- * }
- * ```
+ *   ;```ts
+ *   import { PrettyPrint } from './PrettyPrint'
+ *
+ *   type A1 = { a: number; b?: number;            d?: number; e?: number; x: string;             y?: number; z: string;  } // prettier-ignore
+ *   type A2 = { a?: number;           c?: number; d?: number; e: number;  x: number | undefined; y?: string; z?: number; } // prettier-ignore
+ *
+ *   type Result = PrettyPrint<MergeDeep<A1, A2>>
+ *   {
+ *      a: number;
+ *      b?: number | undefined;
+ *      c?: number | undefined;
+ *      d?: number | undefined;
+ *      e: number;
+ *      x: number | undefined;
+ *      y?: string | number | undefined;
+ *      z: string | number;
+ *   }
+ *   ```
+ *
+ * @param O To complete
+ * @param O1 To copy from
+ * @returns {undefined | undefined} Object
  */
 export 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;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-anything",
-  "version": "6.0.5",
+  "version": "6.0.7",
   "description": "Merge objects & other types recursively. A simple & small integration.",
   "type": "module",
   "sideEffects": false,
@@ -10,21 +10,17 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "lint": "tsc --noEmit && eslint ./src",
-    "test": "vitest run",
-    "build": "del-cli dist && tsc",
-    "release": "npm run lint && npm run build && np"
-  },
   "dependencies": {
-    "is-what": "^5.2.0"
+    "is-what": "^5.5.2"
   },
   "devDependencies": {
-    "@cycraft/eslint": "^0.4.3",
+    "@cycraft/eslint": "^0.4.11",
     "@cycraft/tsconfig": "^0.1.2",
-    "del-cli": "^6.0.0",
-    "np": "^10.2.0",
-    "vitest": "^3.0.6"
+    "bumpp": "^12.3.0",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.20.1",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.2"
   },
   "files": [
     "dist"
@@ -59,5 +55,11 @@
     "url": "https://github.com/mesqueeb/merge-anything.git"
   },
   "homepage": "https://github.com/mesqueeb/merge-anything#readme",
-  "bugs": "https://github.com/mesqueeb/merge-anything/issues"
-}
+  "bugs": "https://github.com/mesqueeb/merge-anything/issues",
+  "scripts": {
+    "lint": "tsc --noEmit && eslint ./src",
+    "test": "vitest run",
+    "build": "del-cli dist && tsc",
+    "release": "pnpm run lint && pnpm run build && pnpm test && bumpp --no-push --all && pnpm publish --no-git-checks && npx jsr publish && git push --follow-tags && gh release create $(git describe --tags --abbrev=0) --generate-notes --notes \"$(git log --pretty='- %s  %h' $(git describe --tags --abbrev=0 HEAD~1 2>/dev/null || git rev-list --max-parents=0 HEAD)..HEAD~1)\""
+  }
+}