es-toolkit 1.49.0-dev.1970 → 1.49.0-dev.1974

package/dist/array/partition.d.mts

@@ -33,11 +33,12 @@ declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value
  * @template T - The type of elements in the array.
  * @param arr - The array to partition.
  * @param isInTruthy - A predicate function that determines
- * whether an element should be placed in the truthy array. The function is called with each
+ * whether an element should be placed in the truthy array. An element is placed in the truthy
+ * array when the function returns a truthy value. The function is called with each
  * element of the array and its index.
  * @returns A tuple containing two arrays: the first array contains elements for
- * which the predicate returned true, and the second array contains elements for which the
- * predicate returned false.
+ * which the predicate returned a truthy value, and the second array contains elements for which the
+ * predicate returned a falsy value.
  *
  * @example
  * const array = [1, 2, 3, 4, 5];
@@ -45,6 +46,6 @@ declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value
  * const [even, odd] = partition(array, isEven);
  * // even will be [2, 4], and odd will be [1, 3, 5]
  */
-declare function partition<T>(arr: readonly T[], isInTruthy: (value: T, index: number, array: readonly T[]) => boolean): [truthy: T[], falsy: T[]];
+declare function partition<T>(arr: readonly T[], isInTruthy: (value: T, index: number, array: readonly T[]) => unknown): [truthy: T[], falsy: T[]];
 //#endregion
 export { partition };

package/dist/array/partition.d.ts

@@ -33,11 +33,12 @@ declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value
  * @template T - The type of elements in the array.
  * @param arr - The array to partition.
  * @param isInTruthy - A predicate function that determines
- * whether an element should be placed in the truthy array. The function is called with each
+ * whether an element should be placed in the truthy array. An element is placed in the truthy
+ * array when the function returns a truthy value. The function is called with each
  * element of the array and its index.
  * @returns A tuple containing two arrays: the first array contains elements for
- * which the predicate returned true, and the second array contains elements for which the
- * predicate returned false.
+ * which the predicate returned a truthy value, and the second array contains elements for which the
+ * predicate returned a falsy value.
  *
  * @example
  * const array = [1, 2, 3, 4, 5];
@@ -45,6 +46,6 @@ declare function partition<T, U extends T>(arr: readonly T[], isInTruthy: (value
  * const [even, odd] = partition(array, isEven);
  * // even will be [2, 4], and odd will be [1, 3, 5]
  */
-declare function partition<T>(arr: readonly T[], isInTruthy: (value: T, index: number, array: readonly T[]) => boolean): [truthy: T[], falsy: T[]];
+declare function partition<T>(arr: readonly T[], isInTruthy: (value: T, index: number, array: readonly T[]) => unknown): [truthy: T[], falsy: T[]];
 //#endregion
 export { partition };

package/dist/types/DeepPartial.d.mts

@@ -0,0 +1,21 @@
+//#region src/types/DeepPartial.d.ts
+/**
+ * Makes all properties of `T` optional recursively, unlike the built-in
+ * `Partial` which only affects the first level.
+ *
+ * Recurses into plain objects, arrays/tuples (elements do not become sparse),
+ * and `Map`/`Set` contents. Functions, `Date`, and `RegExp` pass through
+ * unchanged.
+ *
+ * @template T - The type to make deeply optional.
+ *
+ * @example
+ * type Config = { server: { host: string; port: number }; debug: boolean };
+ * type ConfigPatch = DeepPartial<Config>;
+ * // => { server?: { host?: string; port?: number }; debug?: boolean }
+ *
+ * const patch: ConfigPatch = { server: { port: 8080 } }; // ok, host omitted
+ */
+type DeepPartial<T> = T extends ((...args: any[]) => unknown) | Date | RegExp ? T : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer U> ? Set<DeepPartial<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPartial<U>> : T extends readonly unknown[] ? { [K in keyof T]: DeepPartial<T[K]> } : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+//#endregion
+export { DeepPartial };

package/dist/types/DeepPartial.d.ts

@@ -0,0 +1,21 @@
+//#region src/types/DeepPartial.d.ts
+/**
+ * Makes all properties of `T` optional recursively, unlike the built-in
+ * `Partial` which only affects the first level.
+ *
+ * Recurses into plain objects, arrays/tuples (elements do not become sparse),
+ * and `Map`/`Set` contents. Functions, `Date`, and `RegExp` pass through
+ * unchanged.
+ *
+ * @template T - The type to make deeply optional.
+ *
+ * @example
+ * type Config = { server: { host: string; port: number }; debug: boolean };
+ * type ConfigPatch = DeepPartial<Config>;
+ * // => { server?: { host?: string; port?: number }; debug?: boolean }
+ *
+ * const patch: ConfigPatch = { server: { port: 8080 } }; // ok, host omitted
+ */
+type DeepPartial<T> = T extends ((...args: any[]) => unknown) | Date | RegExp ? T : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer U> ? Set<DeepPartial<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPartial<U>> : T extends readonly unknown[] ? { [K in keyof T]: DeepPartial<T[K]> } : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+//#endregion
+export { DeepPartial };

package/dist/types/DeepReadonly.d.mts

@@ -0,0 +1,22 @@
+//#region src/types/DeepReadonly.d.ts
+/**
+ * Makes all properties of `T` readonly recursively, unlike the built-in
+ * `Readonly` which only affects the first level.
+ *
+ * Arrays and tuples become readonly, and `Map`/`Set` become
+ * `ReadonlyMap`/`ReadonlySet`. Functions, `Date`, and `RegExp` pass through
+ * unchanged.
+ *
+ * @template T - The type to make deeply readonly.
+ *
+ * @example
+ * type State = { user: { name: string; tags: string[] } };
+ * type FrozenState = DeepReadonly<State>;
+ * // => { readonly user: { readonly name: string; readonly tags: readonly string[] } }
+ *
+ * declare const state: FrozenState;
+ * state.user.name = 'x'; // error: name is readonly
+ */
+type DeepReadonly<T> = T extends ((...args: any[]) => unknown) | Date | RegExp ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
+//#endregion
+export { DeepReadonly };

package/dist/types/DeepReadonly.d.ts

@@ -0,0 +1,22 @@
+//#region src/types/DeepReadonly.d.ts
+/**
+ * Makes all properties of `T` readonly recursively, unlike the built-in
+ * `Readonly` which only affects the first level.
+ *
+ * Arrays and tuples become readonly, and `Map`/`Set` become
+ * `ReadonlyMap`/`ReadonlySet`. Functions, `Date`, and `RegExp` pass through
+ * unchanged.
+ *
+ * @template T - The type to make deeply readonly.
+ *
+ * @example
+ * type State = { user: { name: string; tags: string[] } };
+ * type FrozenState = DeepReadonly<State>;
+ * // => { readonly user: { readonly name: string; readonly tags: readonly string[] } }
+ *
+ * declare const state: FrozenState;
+ * state.user.name = 'x'; // error: name is readonly
+ */
+type DeepReadonly<T> = T extends ((...args: any[]) => unknown) | Date | RegExp ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
+//#endregion
+export { DeepReadonly };

package/dist/types/NonEmptyArray.d.mts

@@ -0,0 +1,14 @@
+//#region src/types/NonEmptyArray.d.ts
+/**
+ * An array guaranteed to have at least one element.
+ * The first element resolves to `T` instead of `T | undefined`.
+ *
+ * @template T - The type of the elements.
+ *
+ * @example
+ * const a: NonEmptyArray<number> = [1, 2, 3]; // ok
+ * const b: NonEmptyArray<number> = [];        // error: empty array not allowed
+ */
+type NonEmptyArray<T> = [T, ...T[]];
+//#endregion
+export { NonEmptyArray };

package/dist/types/NonEmptyArray.d.ts

@@ -0,0 +1,14 @@
+//#region src/types/NonEmptyArray.d.ts
+/**
+ * An array guaranteed to have at least one element.
+ * The first element resolves to `T` instead of `T | undefined`.
+ *
+ * @template T - The type of the elements.
+ *
+ * @example
+ * const a: NonEmptyArray<number> = [1, 2, 3]; // ok
+ * const b: NonEmptyArray<number> = [];        // error: empty array not allowed
+ */
+type NonEmptyArray<T> = [T, ...T[]];
+//#endregion
+export { NonEmptyArray };

package/dist/types/Simplify.d.mts

@@ -0,0 +1,18 @@
+//#region src/types/Simplify.d.ts
+/**
+ * Flattens an intersection or mapped type into a single, readable object type.
+ *
+ * The result is equivalent for plain object types, but editors show the
+ * resolved shape (`{ a: 1; b: 2 }`) instead of `A & B`.
+ *
+ * @template T - The type to flatten.
+ *
+ * @example
+ * type A = { name: string };
+ * type B = { age: number };
+ * type User = Simplify<A & B>;
+ * // hover => { name: string; age: number }   (instead of A & B)
+ */
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+//#endregion
+export { Simplify };

package/dist/types/Simplify.d.ts

@@ -0,0 +1,18 @@
+//#region src/types/Simplify.d.ts
+/**
+ * Flattens an intersection or mapped type into a single, readable object type.
+ *
+ * The result is equivalent for plain object types, but editors show the
+ * resolved shape (`{ a: 1; b: 2 }`) instead of `A & B`.
+ *
+ * @template T - The type to flatten.
+ *
+ * @example
+ * type A = { name: string };
+ * type B = { age: number };
+ * type User = Simplify<A & B>;
+ * // hover => { name: string; age: number }   (instead of A & B)
+ */
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+//#endregion
+export { Simplify };

package/dist/types/ValueOf.d.mts

@@ -0,0 +1,14 @@
+//#region src/types/ValueOf.d.ts
+/**
+ * Creates a union of all value types in `T`. The value-side counterpart to `keyof`.
+ *
+ * @template T - The object type to read values from.
+ *
+ * @example
+ * const STATUS = { IDLE: 'idle', ERROR: 'error' } as const;
+ * type Status = ValueOf<typeof STATUS>;
+ * // => 'idle' | 'error'
+ */
+type ValueOf<T> = T[keyof T];
+//#endregion
+export { ValueOf };

package/dist/types/ValueOf.d.ts

@@ -0,0 +1,14 @@
+//#region src/types/ValueOf.d.ts
+/**
+ * Creates a union of all value types in `T`. The value-side counterpart to `keyof`.
+ *
+ * @template T - The object type to read values from.
+ *
+ * @example
+ * const STATUS = { IDLE: 'idle', ERROR: 'error' } as const;
+ * type Status = ValueOf<typeof STATUS>;
+ * // => 'idle' | 'error'
+ */
+type ValueOf<T> = T[keyof T];
+//#endregion
+export { ValueOf };

package/dist/types/Writable.d.mts

@@ -0,0 +1,15 @@
+//#region src/types/Writable.d.ts
+/**
+ * Removes the `readonly` modifier from all properties of `T`.
+ * The inverse of the built-in `Readonly`.
+ *
+ * @template T - The object type to make writable.
+ *
+ * @example
+ * type Config = { readonly host: string; readonly port: number };
+ * type MutableConfig = Writable<Config>;
+ * // => { host: string; port: number }
+ */
+type Writable<T> = { -readonly [K in keyof T]: T[K] };
+//#endregion
+export { Writable };

package/dist/types/Writable.d.ts

@@ -0,0 +1,15 @@
+//#region src/types/Writable.d.ts
+/**
+ * Removes the `readonly` modifier from all properties of `T`.
+ * The inverse of the built-in `Readonly`.
+ *
+ * @template T - The object type to make writable.
+ *
+ * @example
+ * type Config = { readonly host: string; readonly port: number };
+ * type MutableConfig = Writable<Config>;
+ * // => { host: string; port: number }
+ */
+type Writable<T> = { -readonly [K in keyof T]: T[K] };
+//#endregion
+export { Writable };

package/dist/types/index.d.mts

@@ -0,0 +1,7 @@
+import { DeepPartial } from "./DeepPartial.mjs";
+import { DeepReadonly } from "./DeepReadonly.mjs";
+import { NonEmptyArray } from "./NonEmptyArray.mjs";
+import { Simplify } from "./Simplify.mjs";
+import { ValueOf } from "./ValueOf.mjs";
+import { Writable } from "./Writable.mjs";
+export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ValueOf, type Writable };

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+import { DeepPartial } from "./DeepPartial.js";
+import { DeepReadonly } from "./DeepReadonly.js";
+import { NonEmptyArray } from "./NonEmptyArray.js";
+import { Simplify } from "./Simplify.js";
+import { ValueOf } from "./ValueOf.js";
+import { Writable } from "./Writable.js";
+export { type DeepPartial, type DeepReadonly, type NonEmptyArray, type Simplify, type ValueOf, type Writable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-toolkit",
-  "version": "1.49.0-dev.1970+953920b2",
+  "version": "1.49.0-dev.1974+9232c573",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
   "homepage": "https://es-toolkit.dev",
   "bugs": "https://github.com/toss/es-toolkit/issues",
@@ -164,6 +164,14 @@
         "default": "./dist/string/index.js"
       }
     },
+    "./types": {
+      "import": {
+        "types": "./dist/types/index.d.mts"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts"
+      }
+    },
     "./util": {
       "import": {
         "types": "./dist/util/index.d.mts",
@@ -405,6 +413,14 @@
           "default": "./dist/string/index.js"
         }
       },
+      "./types": {
+        "import": {
+          "types": "./dist/types/index.d.mts"
+        },
+        "require": {
+          "types": "./dist/types/index.d.ts"
+        }
+      },
       "./util": {
         "import": {
           "types": "./dist/util/index.d.mts",

package/types.d.ts

@@ -0,0 +1 @@
+export * from './dist/types';