[#2] size 함수 추가

Author: yceffort-naver

.github/workflows/detect-changed-packages.yml

@@ -35,7 +35,7 @@ jobs:
               uses: NaverPayDev/changeset-actions/detect-add@main
               with:
                   github_token: ${{ secrets.ACTION_TOKEN }}
-                  packages_dir: packages,share
+                  packages_dir: .
                   skip_label: skip-detect-change
                   skip_branches: main
                   formatting_script: pnpm run markdownlint:fix

src/isEmpty.ts

@@ -1,6 +1,6 @@
 import {isArrayLike} from './internal'
 
-export default function isEmpty(value: unknown): boolean {
+export function isEmpty(value: unknown): boolean {
     if (value == null) {
         return true
     }
@@ -26,3 +26,5 @@ export default function isEmpty(value: unknown): boolean {
 
     return false
 }
+
+export default isEmpty

src/size.bench.ts

@@ -0,0 +1,49 @@
+import _size from 'lodash/size'
+import {bench, describe} from 'vitest'
+
+import size from './size'
+
+const testCases = [
+    null,
+    undefined,
+    '',
+    'hello',
+    [],
+    [1, 2, 3],
+    {},
+    {key: 'value'},
+    new Map(),
+    new Set(),
+    new Map([
+        ['a', 1],
+        ['b', 2],
+    ]),
+    new Set([1, 2, 3]),
+    {a: 1, b: 2, c: 3},
+    Array(1000).fill(0),
+    'a'.repeat(1000),
+    new Array(1000)
+        .fill(0)
+        .map((_, i) => [`key${i}`, i])
+        .reduce((acc, [k, v]) => ({...acc, [k]: v}), {}),
+]
+
+const ITERATIONS = 10000
+
+describe('size', () => {
+    bench('hidash', () => {
+        for (let i = 0; i < ITERATIONS; i++) {
+            testCases.forEach((testCase) => {
+                size(testCase)
+            })
+        }
+    })
+
+    bench('lodash', () => {
+        for (let i = 0; i < ITERATIONS; i++) {
+            testCases.forEach((testCase) => {
+                size(testCase)
+            })
+        }
+    })
+})

src/size.test.ts

@@ -0,0 +1,108 @@
+import {describe, test, expect} from 'vitest'
+
+import size from './size'
+
+describe('size function', () => {
+    test('returns 0 for null and undefined', () => {
+        expect(size(null)).toBe(0)
+        expect(size(undefined)).toBe(0)
+    })
+
+    test('returns correct length for strings', () => {
+        expect(size('')).toBe(0)
+        expect(size('hello')).toBe(5)
+        expect(size('한글')).toBe(2)
+    })
+
+    test('returns correct length for arrays', () => {
+        expect(size([])).toBe(0)
+        expect(size([1, 2, 3])).toBe(3)
+        expect(size(new Array(5))).toBe(5)
+    })
+
+    test('returns correct size for objects', () => {
+        expect(size({})).toBe(0)
+        expect(size({a: 1, b: 2})).toBe(2)
+        expect(size(Object.create(null))).toBe(0)
+    })
+
+    test('returns correct size for Map', () => {
+        expect(size(new Map())).toBe(0)
+        const map = new Map([
+            ['a', 1],
+            ['b', 2],
+        ])
+        expect(size(map)).toBe(2)
+    })
+
+    test('returns correct size for Set', () => {
+        expect(size(new Set())).toBe(0)
+        const set = new Set([1, 2, 3])
+        expect(size(set)).toBe(3)
+    })
+
+    test('returns 0 for non-collection primitives', () => {
+        expect(size(0)).toBe(0)
+        expect(size(42)).toBe(0)
+        expect(size(true)).toBe(0)
+        expect(size(false)).toBe(0)
+        expect(size(Symbol('TEST'))).toBe(0)
+    })
+
+    test('returns correct length for array-like objects', () => {
+        const arrayLike = {length: 3, 0: 'a', 1: 'b', 2: 'c'}
+        expect(size(arrayLike)).toBe(3)
+    })
+
+    test('returns 0 for functions', () => {
+        expect(size(() => {})).toBe(0)
+        expect(size(function () {})).toBe(0)
+    })
+
+    test('handles objects with inherited properties', () => {
+        const proto = {inherited: true}
+        const obj = Object.create(proto)
+        obj.own = true
+        expect(size(obj)).toBe(1)
+    })
+
+    test('returns correct size for large collections', () => {
+        const largeArray = Array(1000000).fill(0)
+        expect(size(largeArray)).toBe(1000000)
+
+        const largeString = 'a'.repeat(1000000)
+        expect(size(largeString)).toBe(1000000)
+
+        const largeObject: Record<string, number> = {}
+        for (let i = 0; i < 10000; i++) {
+            largeObject[`key${i}`] = i
+        }
+        expect(size(largeObject)).toBe(10000)
+    })
+
+    // WeakMap, WeakSet은 사이즈를 알 방법이 없으므로 항상 0을 반환한다.
+    test('returns 0 for WeakMap', () => {
+        const weakMap = new WeakMap()
+        const key1 = {}
+        const key2 = {}
+        weakMap.set(key1, 'value1')
+        weakMap.set(key2, 'value2')
+        expect(size(weakMap)).toBe(0)
+    })
+
+    test('returns 0 for WeakSet', () => {
+        const weakSet = new WeakSet()
+        const obj1 = {}
+        const obj2 = {}
+        weakSet.add(obj1)
+        weakSet.add(obj2)
+        expect(size(weakSet)).toBe(0)
+    })
+
+    test('returns 0 for WeakMap and WeakSet even with elements', () => {
+        const weakMap = new WeakMap([[{}, 'value']])
+        const weakSet = new WeakSet([{}])
+        expect(size(weakMap)).toBe(0)
+        expect(size(weakSet)).toBe(0)
+    })
+})

src/size.ts

@@ -0,0 +1,22 @@
+import {isArrayLike} from './internal'
+
+export function size(collection: unknown): number {
+    if (collection == null) {
+        return 0
+    }
+    if (isArrayLike(collection)) {
+        return collection.length
+    }
+
+    const type = Object.prototype.toString.call(collection)
+    if (type === '[object Map]' || type === '[object Set]') {
+        return (collection as Map<unknown, unknown> | Set<unknown>).size
+    }
+
+    if (typeof collection === 'object') {
+        return Object.keys(collection as object).length
+    }
+    return 0
+}
+
+export default size