fix(some): fix lodash compatibility

docs/ja/reference/compat/array/some.md

@@ -6,7 +6,7 @@
 `es-toolkit/compat` からこの関数をインポートすると、[lodash と完全に同じように動作](../../../compatibility.md)します。
 :::
 
-配列内に指定された条件と一致する要素があるかどうかを確認します。
+配列またはオブジェクト内の要素が指定された条件を満たすかどうかを確認します。
 
 条件は複数の方法で指定できます。
 
@@ -15,42 +15,110 @@
 - **プロパティ-値ペア**: 該当プロパティに対して値が一致する最初の要素が選択されます。
 - **プロパティ名**: 該当プロパティに対して真と評価される値を持つ最初の要素が選択されます。
 
-条件が提供されていない場合、関数は配列内に真と評価される要素があるかどうかを確認します。
+条件が指定されていない場合、配列またはオブジェクトに真と評価される要素があるか確認します。
 
 ## インターフェース
 
 ```typescript
+function some<T>(arr: T[]): boolean;
 function some<T>(arr: T[], predicate: (item: T, index: number, arr: any) => unknown): boolean;
 function some<T>(arr: T[], predicate: [keyof T, unknown]): boolean;
 function some<T>(arr: T[], predicate: string): boolean;
 function some<T>(arr: T[], predicate: Partial<T>): boolean;
+
+function some<T extends Record<string, unknown>>(object: T): boolean;
+function some<T extends Record<string, unknown>>(
+  object: T,
+  predicate: (value: T[keyof T], key: keyof T, object: T) => unknown
+): boolean;
+function some<T extends Record<string, unknown>>(object: T, predicate: Partial<T[keyof T]>): boolean;
+function some<T extends Record<string, unknown>>(object: T, predicate: [keyof T[keyof T], unknown]): boolean;
+function some<T extends Record<string, unknown>>(object: T, predicate: string): boolean;
 ```
 
 ### パラメータ
 
-- `arr` (`T[]`): 反復する配列です。
-- `predicate` (`((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string`):
-  - **検査関数** (`(item: T, index: number, arr: T[]) => unknown`): 探している要素かどうかを返す関数。
-  - **部分オブジェクト** (`Partial<T>`): 一致させるプロパティと値を指定した部分オブジェクト。
-  - **プロパティ-値ペア** (`[keyof T, unknown]`): 最初が一致させるプロパティ、2番目が一致させる値を表すタプル。
-  - **プロパティ名** (`string`): 真と評価される値を持っているか確認するプロパティ名。
+- `arr` (`T[]`) または `object` (`T`): 反復する配列です。
+
+- `predicate`:
+
+  - 配列の場合:
+
+    - **検査関数** (`(item: T, index: number, arr: T[]) => unknown`): 各要素に対して検査する関数。
+    - **部分オブジェクト** (`Partial<T>`): 部分的に一致するプロパティを持つ最初の要素を返す。
+    - **プロパティ-値ペア** (`[keyof T, unknown]`): 最初が一致させるプロパティ、2番目が一致させる値を表すタプル。
+    - **プロパティ名** (`string`): 真と評価される値を持っているか確認するプロパティ名。
+
+  - オブジェクトの場合:
+
+    - **検査関数** (`(value: T[keyof T], key: keyof T, object: T) => unknown`): 条件を満たすかどうかを確認する関数。
+    - **部分オブジェクト** (`Partial<T[keyof T]>`): 部分的に一致するプロパティを持つ最初の要素を返す。
+    - **プロパティ-値ペア** (`[keyof T[keyof T], unknown]`): 最初が一致させるプロパティ、2番目が一致させる値を表すタプル。
+    - **プロパティ名** (`string`): 真と評価される値を持っているか確認するプロパティ名。
 
 ### 戻り値
 
 (`boolean`): 述語チェックを通過する要素があれば`true`、それ以外の場合は`false`。
 
 ## 例
 
-```typescript
-some([1, 2, 3, 4], n => n % 2 === 0);
-// => true
+### 配列の場合
 
-some([{ a: 1 }, { a: 2 }, { a: 3 }], { a: 2 });
-// => true
+```typescript
+import { some } from 'es-toolkit/compat';
+
+// 検査関数を使う場合
+let items = [1, 2, 3, 4, 5];
+let result = some(items, item => item > 3);
+console.log(result); // true
+
+// 部分オブジェクトを使う場合
+items = [
+  { id: 1, name: 'Alice' },
+  { id: 2, name: 'Bob' },
+];
+result = some(items, { name: 'Bob' });
+console.log(result); // true
+
+// プロパティ-値ペアを使う場合
+items = [
+  { id: 1, name: 'Alice' },
+  { id: 2, name: 'Bob' },
+];
+result = some(items, ['name', 'Bob']);
+console.log(result); // true
+
+// プロパティ名を使う場合
+items = [
+  { id: 1, name: 'Alice' },
+  { id: 2, name: 'Bob' },
+];
+result = some(items, 'name');
+console.log(result); // true
+```
 
-some([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
-// => true
+### オブジェクトの場合
 
-some([{ a: 1 }, { a: 2 }, { a: 3 }], 'a');
-// => true
+```typescript
+import { some } from 'es-toolkit/compat';
+
+// 検査関数を使う場合
+let obj = { a: 1, b: 2, c: 3 };
+let result = some(object, value => value > 2);
+console.log(result); // true
+
+// 部分オブジェクトを使う場合
+obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+result = some(obj, { name: 'Bob' });
+console.log(result); // true
+
+// プロパティ-値ペアを使う場合
+obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+result = some(obj, ['name', 'Bob']);
+console.log(result); // true
+
+// プロパティ名を使う場合
+obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+result = some(obj, 'name');
+console.log(result); // true
 ```

docs/ko/reference/compat/array/some.md

@@ -6,7 +6,7 @@
 `es-toolkit/compat`에서 이 함수를 가져오면, [lodash와 완전히 똑같이 동작](../../../compatibility.md)해요.
 :::
 
-주어진 조건을 만족하는 요소가 배열에 있는지 확인해요.
+배열이나 객체의 요소 중 주어진 조건을 만족하는 요소가 있는지 확인해요.
 
 조건은 여러 방법들로 명시할 수 있어요.
 
@@ -15,42 +15,127 @@
 - **프로퍼티-값 쌍**: 해당 프로퍼티에 대해서 값이 일치하는 첫 번째 요소가 선택돼요.
 - **프로퍼티 이름**: 해당 프로퍼티에 대해서 참으로 평가되는 값을 가지는 첫 번째 요소가 선택돼요.
 
-조건이 주어지지 않았다면, 배열에 참으로 평가받는 요소가 있는지 확인해요.
+조건이 제공되지 않으면, 배열이나 객체에 참으로 평가되는 요소가 있는지 확인해요.
 
 ## 인터페이스
 
 ```typescript
+function some<T>(arr: T[]): boolean;
 function some<T>(arr: T[], predicate: (item: T, index: number, arr: any) => unknown): boolean;
 function some<T>(arr: T[], predicate: [keyof T, unknown]): boolean;
 function some<T>(arr: T[], predicate: string): boolean;
 function some<T>(arr: T[], predicate: Partial<T>): boolean;
+
+function some<T extends Record<string, unknown>>(object: T): boolean;
+function some<T extends Record<string, unknown>>(
+  object: T,
+  predicate: (value: T[keyof T], key: keyof T, object: T) => unknown
+): boolean;
+function some<T extends Record<string, unknown>>(object: T, predicate: Partial<T[keyof T]>): boolean;
+function some<T extends Record<string, unknown>>(object: T, predicate: [keyof T[keyof T], unknown]): boolean;
+function some<T extends Record<string, unknown>>(object: T, predicate: string): boolean;
 ```
 
 ### 파라미터
 
-- `arr` (`T[]`): 반복할 배열.
-- `predicate` (`((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string`):
-  - **검사 함수** (`(item: T, index: number, arr: T[]) => unknown`): 찾는 요소인지 여부를 반환하는 함수.
-  - **부분 객체** (`Partial<T>`): 일치시킬 프로퍼티와 값들을 명시한 부분 객체.
-  - **프로퍼티-값 쌍** (`[keyof T, unknown]`): 첫 번째가 일치시킬 프로퍼티, 두 번째가 일치시킬 값을 나타내는 튜플.
-  - **프로퍼티 이름** (`string`): 참으로 평가되는 값을 가지고 있는지 확인할 프로퍼티 이름.
+- `arr` (`T[]`) 또는 `object` (`T`): 반복할 배열.
+
+::: info `arr`는 `ArrayLike<T>`일 수도 있고, `null` 또는 `undefined`일 수도 있어요
+
+lodash와 완벽하게 호환되도록 `every` 함수는 `arr`을 다음과 같이 처리해요:
+
+- `arr`가 `ArrayLike<T>`인 경우 `Array.from(...)`을 사용하여 배열로 변환해요.
+- `arr`가 `null` 또는 `undefined`인 경우 빈 배열로 간주돼요.
+
+:::
+
+::: info `object`는 `null` 또는 `undefined`일 수도 있어요
+
+lodash와 완벽하게 호환되도록 `every` 함수는 `object`를 다음과 같이 처리해요:
+
+- `object`가 `null` 또는 `undefined`인 경우 빈 객체로 변환돼요.
+
+:::
+
+- `predicate`:
+
+  - 배열의 경우:
+
+    - **검사 함수** (`(item: T, index: number, arr: any) => unknown`): 요소, 인덱스, 배열을 받아 조건을 만족하면 `true`를 반환하는 함수.
+    - **부분 객체** (`Partial<T>`): 일치시킬 프로퍼티와 값들을 명시한 부분 객체.
+    - **프로퍼티-값 쌍** (`[keyof T, unknown]`): 첫 번째가 일치시킬 프로퍼티, 두 번째가 일치시킬 값을 나타내는 튜플.
+    - **프로퍼티 이름** (`string`): 참으로 평가되는 값을 가지고 있는지 확인할 프로퍼티 이름.
+
+  - 객체의 경우:
+
+    - **검사 함수** (`(value: T[keyof T], key: keyof T, object: T) => unknown`): 값, 키, 객체를 받아 조건을 만족하면 `true`를 반환하는 함수.
+    - **부분 값** (`Partial<T[keyof T]>`): 값과 일치시킬 부분 값을 명시한 부분 객체.
+    - **프로퍼티-값 쌍** (`[keyof T[keyof T], unknown]`): 첫 번째가 일치시킬 프로퍼티, 두 번째가 일치시킬 값을 나타내는 튜플.
+    - **프로퍼티 이름** (`string`): 참으로 평가되는 값을 가지고 있는지 확인할 프로퍼티 이름.
 
 ### 반환 값
 
 (`boolean`): 조건을 만족하는 요소가 있는지 여부.
 
 ## 예시
 
-```typescript
-some([1, 2, 3, 4], n => n % 2 === 0);
-// => true
+### 배열의 경우
 
-some([{ a: 1 }, { a: 2 }, { a: 3 }], { a: 2 });
-// => true
+```typescript
+import { every } from 'es-toolkit/compat';
+
+// 검사 함수를 쓰는 경우
+const items = [1, 2, 3, 4, 5];
+const result = every(items, item => item > 0);
+console.log(result); // true
+
+// 부분 객체를 쓰는 경우
+const items = [
+  { id: 1, name: 'Alice' },
+  { id: 2, name: 'Bob' },
+];
+const result = every(items, { name: 'Bob' });
+console.log(result); // false
+
+// 프로퍼티-값 쌍을 쓰는 경우
+const items = [
+  { id: 1, name: 'Alice' },
+  { id: 2, name: 'Bob' },
+];
+const result = every(items, ['name', 'Alice']);
+console.log(result); // false
+
+// 프로퍼티 이름을 쓰는 경우
+const items = [
+  { id: 1, name: 'Alice' },
+  { id: 2, name: 'Bob' },
+];
+const result = every(items, 'name');
+console.log(result); // true
+```
 
-some([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
-// => true
+### 객체의 경우
 
-some([{ a: 1 }, { a: 2 }, { a: 3 }], 'a');
-// => true
+```typescript
+import { every } from 'es-toolkit/compat';
+
+// 검사 함수를 쓰는 경우
+const obj = { a: 1, b: 2, c: 3 };
+const result = every(obj, value => value > 0);
+console.log(result); // true
+
+// 부분 객체를 쓰는 경우
+const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+const result = every(obj, { name: 'Bob' });
+console.log(result); // false
+
+// 프로퍼티-값 쌍을 쓰는 경우
+const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+const result = every(obj, ['name', 'Alice']);
+console.log(result); // false
+
+// 프로퍼티 이름을 쓰는 경우
+const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+const result = every(obj, 'name');
+console.log(result); // true
 ```