Merge branch 'main' into feat/flip

benchmarks/performance/defer.bench.ts

@@ -0,0 +1,15 @@
+import { bench, describe } from 'vitest';
+import { defer as deferToolkit } from 'es-toolkit/compat';
+import { defer as deferLodash } from 'lodash';
+
+describe('defer', () => {
+  bench('es-toolkit/defer', () => {
+    const id = deferToolkit(() => {});
+    clearTimeout(id);
+  });
+
+  bench('lodash/defer', () => {
+    const id = deferLodash(() => {});
+    clearTimeout(id);
+  });
+});

benchmarks/performance/isFinite.bench.ts

@@ -0,0 +1,25 @@
+import { isFinite as isFiniteToolkit } from 'es-toolkit/compat';
+import { isFinite as isFiniteLodash } from 'lodash';
+import { bench, describe } from 'vitest';
+
+describe('isFinite', () => {
+  bench('es-toolkit/isFinite', () => {
+    isFiniteToolkit(1);
+    isFiniteToolkit(1.12);
+    isFiniteToolkit(Infinity);
+    isFiniteToolkit(-Infinity);
+    isFiniteToolkit([]);
+    isFiniteToolkit({});
+    isFiniteToolkit('1');
+  });
+
+  bench('lodash/isFinite', () => {
+    isFiniteLodash(1);
+    isFiniteLodash(1.12);
+    isFiniteLodash(Infinity);
+    isFiniteLodash(-Infinity);
+    isFiniteLodash([]);
+    isFiniteLodash({});
+    isFiniteLodash('1');
+  });
+});

benchmarks/performance/pad.bench.ts

@@ -1,15 +1,21 @@
 import { bench, describe } from 'vitest';
-import { pad as padStartToolkit } from 'es-toolkit';
-import { pad as padStartLodash } from 'lodash';
+import { pad as padToolkit } from 'es-toolkit';
+import { pad as padToolkitCompat } from 'es-toolkit/compat';
+import { pad as padLodash } from 'lodash';
 
 describe('pad', () => {
   bench('es-toolkit/pad', () => {
     const str = 'abc';
-    padStartToolkit(str, 6, '_-');
+    padToolkit(str, 6, '_-');
+  });
+
+  bench('es-toolkit/compat/pad', () => {
+    const str = 'abc';
+    padToolkitCompat(str, 6, '_-');
   });
 
   bench('lodash/pad', () => {
     const str = 'abc';
-    padStartLodash(str, 6, '_-');
+    padLodash(str, 6, '_-');
   });
 });

benchmarks/performance/padEnd.bench.ts

@@ -1,15 +1,15 @@
 import { bench, describe } from 'vitest';
-import { padEnd as padStartToolkit } from 'es-toolkit/compat';
-import { padEnd as padStartLodash } from 'lodash';
+import { padEnd as padEndToolkit } from 'es-toolkit/compat';
+import { padEnd as padEndLodash } from 'lodash';
 
 describe('padEnd', () => {
   bench('es-toolkit/padEnd', () => {
     const str = 'abc';
-    padStartToolkit(str, 6, '_-');
+    padEndToolkit(str, 6, '_-');
   });
 
   bench('lodash/padEnd', () => {
     const str = 'abc';
-    padStartLodash(str, 6, '_-');
+    padEndLodash(str, 6, '_-');
   });
 });

benchmarks/performance/toFinite.bench.ts

@@ -0,0 +1,25 @@
+import { bench, describe } from 'vitest';
+import { toFinite as toFiniteToolkitCompat } from 'es-toolkit/compat';
+import { toFinite as toFiniteLodash } from 'lodash';
+
+describe('toFinite', () => {
+  bench('es-toolkit/compat/toFinite', () => {
+    toFiniteToolkitCompat({ valueOf: () => 1 });
+    toFiniteToolkitCompat({ valueOf: () => 2 });
+    toFiniteToolkitCompat({ toString: () => '3' });
+    toFiniteToolkitCompat('0b101010');
+    toFiniteToolkitCompat('0o12345');
+    toFiniteToolkitCompat('0x1a2b3c');
+    toFiniteToolkitCompat('1.1');
+  });
+
+  bench('lodash/toFinite', () => {
+    toFiniteLodash({ valueof: () => 1 });
+    toFiniteLodash({ valueof: () => 2 });
+    toFiniteLodash({ toString: () => '3' });
+    toFiniteLodash('0b101010');
+    toFiniteLodash('0o12345');
+    toFiniteLodash('0x1a2b3c');
+    toFiniteLodash('1.1');
+  });
+});

benchmarks/performance/toInteger.bench.ts

@@ -0,0 +1,25 @@
+import { bench, describe } from 'vitest';
+import { toInteger as toIntegerToolkitCompat } from 'es-toolkit/compat';
+import { toInteger as toIntegerLodash } from 'lodash';
+
+describe('toInteger', () => {
+  bench('es-toolkit/compat/toInteger', () => {
+    toIntegerToolkitCompat({ valueOf: () => 1 });
+    toIntegerToolkitCompat({ valueOf: () => 2 });
+    toIntegerToolkitCompat({ toString: () => '3' });
+    toIntegerToolkitCompat('0b101010');
+    toIntegerToolkitCompat('0o12345');
+    toIntegerToolkitCompat('0x1a2b3c');
+    toIntegerToolkitCompat('1.1');
+  });
+
+  bench('lodash/toInteger', () => {
+    toIntegerLodash({ valueof: () => 1 });
+    toIntegerLodash({ valueof: () => 2 });
+    toIntegerLodash({ toString: () => '3' });
+    toIntegerLodash('0b101010');
+    toIntegerLodash('0o12345');
+    toIntegerLodash('0x1a2b3c');
+    toIntegerLodash('1.1');
+  });
+});

benchmarks/performance/toNumber.bench.ts

@@ -0,0 +1,25 @@
+import { bench, describe } from 'vitest';
+import { toNumber as toNumberToolkitCompat } from 'es-toolkit/compat';
+import { toNumber as toNumberLodash } from 'lodash';
+
+describe('toNumber', () => {
+  bench('es-toolkit/compat/toNumber', () => {
+    toNumberToolkitCompat({ valueOf: () => 1 });
+    toNumberToolkitCompat({ valueOf: () => 2 });
+    toNumberToolkitCompat({ toString: () => '3' });
+    toNumberToolkitCompat('0b101010');
+    toNumberToolkitCompat('0o12345');
+    toNumberToolkitCompat('0x1a2b3c');
+    toNumberToolkitCompat('1.1');
+  });
+
+  bench('lodash/toNumber', () => {
+    toNumberLodash({ valueof: () => 1 });
+    toNumberLodash({ valueof: () => 2 });
+    toNumberLodash({ toString: () => '3' });
+    toNumberLodash('0b101010');
+    toNumberLodash('0o12345');
+    toNumberLodash('0x1a2b3c');
+    toNumberLodash('1.1');
+  });
+});

docs/ja/reference/array/compact.md

@@ -1,11 +1,11 @@
 # compact
 
-偽と評価される値である `false`、`null`、`0`、`''`、`undefined`、`NaN` を除去した新しい配列を返します。
+偽と評価される値である `false`、 `null`、 `0`、 `0n`, `''`、 `undefined`、 `NaN` を除去した新しい配列を返します。
 
 ## インターフェース
 
 ```typescript
-function compact<T>(arr: T[]): Array<Exclude<T, false | null | 0 | '' | undefined>>;
+function compact<T>(arr: T[]): Array<Exclude<T, false | null | 0 | 0n | '' | undefined>>;
 ```
 
 ### パラメータ
@@ -14,11 +14,11 @@ function compact<T>(arr: T[]): Array<Exclude<T, false | null | 0 | '' | undefine
 
 ### 戻り値
 
-(`Array<Exclude<T, false | null | 0 | '' | undefined>>`): 偽と評価される値をすべて除去した新しい配列。
+(`Array<Exclude<T, false | null | 0 | 0n | '' | undefined>>`): 偽と評価される値をすべて除去した新しい配列。
 
 ## 例
 
 ```typescript
-compact([0, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+compact([0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
 // 戻り値: [1, 2, 3, 4, 5]
 ```

docs/ja/reference/array/maxBy.md

@@ -24,4 +24,12 @@ function maxBy<T>(items: T[], getValue: (element: T) => number): T;
 ```typescript
 maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // 戻り値: { a: 3 }
 maxBy([], x => x.a); // 戻り値: undefined
+maxBy(
+  [
+    { name: 'john', age: 30 },
+    { name: 'jane', age: 28 },
+    { name: 'joe', age: 26 },
+  ],
+  x => x.age
+); // 戻り値: { name: 'john', age: 30 }
 ```

docs/ja/reference/array/minBy.md

@@ -22,4 +22,12 @@ function minBy<T>(items: T[], getValue: (element: T) => number): T;
 ```typescript
 minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // 戻り値: { a: 1 }
 minBy([], x => x.a); // 戻り値: undefined
+minBy(
+  [
+    { name: 'john', age: 30 },
+    { name: 'jane', age: 28 },
+    { name: 'joe', age: 26 },
+  ],
+  x => x.age
+); // 戻り値: { name: 'joe', age: 26 }
 ```

docs/ja/reference/compat/predicate/isFinite.md

@@ -0,0 +1,37 @@
+# isFinite
+
+::: info
+この関数は互換性のために `es-toolkit/compat` からのみインポートできます。代替となるネイティブ JavaScript API が存在するか、まだ十分に最適化されていないためです。
+
+`es-toolkit/compat` からこの関数をインポートすると、[lodash と完全に同じように動作](../../../compatibility.md)します。
+:::
+
+与えられた値が有限の数値かどうかを確認します。
+
+この関数は、TypeScriptにおいて型を判別するための述語関数としても使用でき、引数の型を `number` に絞り込むことができます。
+
+## インターフェース
+
+```typescript
+function isFinite(value: unknown): value is number;
+```
+
+### パラメータ
+
+- `value` (`unknown`): 有限の数値かどうかを確認する値。
+
+### 戻り値
+
+(`value is number`): 値が有限の数値であれば `true`、そうでなければ `false` を返します。
+
+## 例
+
+```typescript
+const value1 = 100;
+const value2 = Infinity;
+const value3 = '100';
+
+console.log(isFinite(value1)); // true
+console.log(isFinite(value2)); // false
+console.log(isFinite(value3)); // false
+```

docs/ja/reference/function/curry.md

@@ -17,7 +17,6 @@ function curry<P1, P2, P3, P4, P5, R>(
   func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R
 ): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R;
 function curry(func: (...args: any[]) => any): (...args: any[]) => any;
-function curry(func: (...args: any[]) => any): (...args: any[]) => any;
 ```
 
 ### パラメータ

docs/ja/reference/string/startCase.md

@@ -25,8 +25,8 @@ import { startCase } from 'es-toolkit/string';
 
 startCase('--foo-bar--'); // 'Foo Bar' を返します
 startCase('fooBar'); // 'Foo Bar' を返します
-startCase('__FOO_BAR__'); // 'FOO BAR' を返します
-startCase('XMLHttpRequest'); // 'XML Http Request' を返します
+startCase('__FOO_BAR__'); // 'Foo Bar' を返します
+startCase('XMLHttpRequest'); // 'Xml Http Request' を返します
 startCase('_abc_123_def'); // 'Abc 123 Def' を返します
 startCase('__abc__123__def__'); // 'Abc 123 Def' を返します
 startCase('_-_-_-_'); // '' を返します

docs/ko/reference/array/compact.md

@@ -1,11 +1,11 @@
 # compact
 
-거짓으로 평가될 수 있는 값인 `false`, `null`, `0`, `''`, `undefined`, `NaN`을 제거한 새로운 배열을 반환해요.
+거짓으로 평가될 수 있는 값인 `false`, `null`, `0`, `0n`, `''`, `undefined`, `NaN`을 제거한 새로운 배열을 반환해요.
 
 ## 인터페이스
 
 ```typescript
-function compact<T>(arr: T[]): Array<Exclude<T, false | null | 0 | '' | undefined>>;
+function compact<T>(arr: T[]): Array<Exclude<T, false | null | 0 | 0n | '' | undefined>>;
 ```
 
 ### 파라미터
@@ -14,11 +14,11 @@ function compact<T>(arr: T[]): Array<Exclude<T, false | null | 0 | '' | undefine
 
 ### 반환 값
 
-(`Array<Exclude<T, false | null | 0 | '' | undefined>>`): 거짓으로 평가될 수 있는 값을 모두 제거한 새로운 배열.
+(`Array<Exclude<T, false | null | 0 | 0n | '' | undefined>>`): 거짓으로 평가될 수 있는 값을 모두 제거한 새로운 배열.
 
 ## 예시
 
 ```typescript
-compact([0, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+compact([0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
 // 반환 값: [1, 2, 3, 4, 5]
 ```

docs/ko/reference/array/maxBy.md

@@ -25,4 +25,12 @@ function maxBy<T>(items: T[], getValue: (element: T) => number): T | undefined;
 ```typescript
 maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
 maxBy([], x => x.a); // Returns: undefined
+maxBy(
+  [
+    { name: 'john', age: 30 },
+    { name: 'jane', age: 28 },
+    { name: 'joe', age: 26 },
+  ],
+  x => x.age
+); // Returns: { name: 'john', age: 30 }
 ```

docs/ko/reference/array/minBy.md

@@ -23,4 +23,12 @@ function minBy<T>(items: T[], getValue: (element: T) => number): T | undefined;
 ```typescript
 minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
 minBy([], x => x.a); // Returns: undefined
+minBy(
+  [
+    { name: 'john', age: 30 },
+    { name: 'jane', age: 28 },
+    { name: 'joe', age: 26 },
+  ],
+  x => x.age
+); // Returns: { name: 'joe', age: 26 }
 ```