{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/hooks/useArrayState/index.ts"],"sourcesContent":["import { Dispatch, SetStateAction, useMemo, useState } from 'react';\n\ninterface ArrayStateSetters<T> extends Dispatch<SetStateAction<T[]>> {\n  push: (...items: T[]) => void;\n  unshift: (...items: T[]) => void;\n  shift: () => void;\n  pop: () => void;\n  splice: (start: number, deleteCount: number, ...items: T[]) => void;\n  remove: (...indexes: number[]) => void;\n  removeAt: (index: number) => void;\n  removeBy: (predicate: (item: T, index: number) => boolean) => void;\n  updateAt: (index: number, item: T) => void;\n  updateBy: (iteratee: (item: T, index: number) => T) => void;\n  insertAt: (index: number, item: T) => void;\n  clear: () => void;\n}\n\n/**\n * @description 불변성을 유지하면서 배열 상태를 편리하게 관리하기 위한 커스텀 훅입니다.\n *\n * @template T - 배열 요소의 타입\n * @param {T[] | (() => T[])} initialValue - 초기 배열 값 또는 초기값을 반환하는 함수\n * @returns {UseArrayStateReturn<T>} 배열 상태와 업데이트 메서드들을 포함한 객체\n * @returns {T[]} array - 현재 배열 상태\n * @returns {ArrayStateSetters<T>} setArray - 배열 상태를 업데이트하는 함수이며, 배열 상태를 업데이트하는 메서드를 함께 제공합니다.\n * @returns {(...items: T[]) => void} setArray.push - 배열의 끝에 항목들을 추가하는 함수\n * @returns {(...items: T[]) => void} setArray.unshift - 배열의 시작에 항목들을 추가하는 함수\n * @returns {() => void} setArray.shift - 배열의 첫 번째 항목을 제거하는 함수\n * @returns {() => void} setArray.pop - 배열의 마지막 항목을 제거하는 함수\n * @returns {(start: number, deleteCount: number, ...items: T[]) => void} setArray.splice - 배열의 특정 위치에서 항목을 제거하고 새 항목을 추가하는 함수\n * @returns {(indexes: number[]) => void} setArray.remove - 주어진 인덱스들의 항목을 제거하는 함수\n * @returns {(index: number) => void} setArray.removeAt - 주어진 인덱스의 항목을 제거하는 함수\n * @returns {(predicate: (item: T, index: number) => boolean) => void} setArray.removeBy - predicate 함수 반환값이 true인 항목들을 제거하는 함수\n * @returns {(index: number, item: T) => void} setArray.updateAt - 주어진 인덱스의 항목을 업데이트하는 함수\n * @returns {(iteratee: (item: T, index: number) => T) => void} setArray.updateBy - iteratee 함수를 통해 배열의 각 항목을 업데이트하는 함수\n * @returns {(index: number, item: T) => void} setArray.insertAt - 주어진 인덱스에 항목을 삽입하는 함수\n * @returns {() => void} setArray.clear - 배열을 비우는 함수\n *\n * @example\n * // setArray 직접 호출을 통해 배열을 직접 설정할 수 있습니다.\n * const { array, setArray } = useArrayState([1, 2, 3]);\n * setArray([1, 4, 2, 3]);\n * console.log(array); // [1, 4, 2, 3]\n *\n * @example\n * // setArray 메서드를 통해 배열을 업데이트할 수 있습니다. 이때, 불변성을 유지합니다.\n * const { array, setArray } = useArrayState([1, 2, 3]);\n * setArray.insertAt(1, 4);\n * console.log(array); // [1, 4, 2, 3]\n */\nexport const useArrayState = <T>(\n  initialValue: T[] | (() => T[])\n): [T[], ArrayStateSetters<T>] => {\n  const [value, setValue] = useState<T[]>(\n    typeof initialValue === 'function' ? initialValue() : initialValue\n  );\n\n  const setArray = useMemo(() => {\n    const setState: ArrayStateSetters<T> = (v: SetStateAction<T[]>) =>\n      setValue(v);\n\n    setState.push = (...items: T[]) => {\n      setValue((prev) => [...prev, ...items]);\n    };\n\n    setState.unshift = (...items: T[]) => {\n      setValue((prev) => [...items, ...prev]);\n    };\n\n    setState.shift = () => {\n      setValue((prev) => prev.slice(1));\n    };\n\n    setState.pop = () => {\n      setValue((prev) => prev.slice(0, -1));\n    };\n\n    setState.splice = (start: number, deleteCount: number, ...items: T[]) => {\n      setValue((prev) => {\n        const newArray = [...prev];\n        newArray.splice(start, deleteCount, ...items);\n        return newArray;\n      });\n    };\n\n    setState.insertAt = (index: number, item: T) => {\n      setValue((prev) => {\n        const newArray = [...prev];\n        newArray.splice(index, 0, item);\n        return newArray;\n      });\n    };\n\n    setState.remove = (...indexes: number[]) => {\n      setValue((prev) => prev.filter((_, i) => !indexes.includes(i)));\n    };\n\n    setState.removeAt = (index: number) => {\n      setValue((prev) => prev.filter((_, i) => i !== index));\n    };\n\n    setState.removeBy = (predicate: (item: T, index: number) => boolean) => {\n      setValue((prev) => prev.filter((item, index) => !predicate(item, index)));\n    };\n\n    setState.updateAt = (index: number, item: T) => {\n      setValue((prev) => {\n        const newArray = [...prev];\n        newArray[index] = item;\n        return newArray;\n      });\n    };\n\n    setState.updateBy = (iteratee: (item: T, index: number) => T) => {\n      setValue((prev) => prev.map((item, index) => iteratee(item, index)));\n    };\n\n    setState.clear = () => {\n      setValue([]);\n    };\n\n    return setState;\n  }, []);\n\n  return [value, setArray];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAa,iBACX,iBACgC;CAChC,MAAM,CAAC,OAAO,aAAA,GAAA,MAAA,UACZ,OAAO,iBAAiB,aAAa,cAAc,GAAG,aACvD;CAqED,OAAO,CAAC,QAAA,GAAA,MAAA,eAnEuB;EAC7B,MAAM,YAAkC,MACtC,SAAS,EAAE;EAEb,SAAS,QAAQ,GAAG,UAAe;GACjC,UAAU,SAAS,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC;;EAGzC,SAAS,WAAW,GAAG,UAAe;GACpC,UAAU,SAAS,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC;;EAGzC,SAAS,cAAc;GACrB,UAAU,SAAS,KAAK,MAAM,EAAE,CAAC;;EAGnC,SAAS,YAAY;GACnB,UAAU,SAAS,KAAK,MAAM,GAAG,GAAG,CAAC;;EAGvC,SAAS,UAAU,OAAe,aAAqB,GAAG,UAAe;GACvE,UAAU,SAAS;IACjB,MAAM,WAAW,CAAC,GAAG,KAAK;IAC1B,SAAS,OAAO,OAAO,aAAa,GAAG,MAAM;IAC7C,OAAO;KACP;;EAGJ,SAAS,YAAY,OAAe,SAAY;GAC9C,UAAU,SAAS;IACjB,MAAM,WAAW,CAAC,GAAG,KAAK;IAC1B,SAAS,OAAO,OAAO,GAAG,KAAK;IAC/B,OAAO;KACP;;EAGJ,SAAS,UAAU,GAAG,YAAsB;GAC1C,UAAU,SAAS,KAAK,QAAQ,GAAG,MAAM,CAAC,QAAQ,SAAS,EAAE,CAAC,CAAC;;EAGjE,SAAS,YAAY,UAAkB;GACrC,UAAU,SAAS,KAAK,QAAQ,GAAG,MAAM,MAAM,MAAM,CAAC;;EAGxD,SAAS,YAAY,cAAmD;GACtE,UAAU,SAAS,KAAK,QAAQ,MAAM,UAAU,CAAC,UAAU,MAAM,MAAM,CAAC,CAAC;;EAG3E,SAAS,YAAY,OAAe,SAAY;GAC9C,UAAU,SAAS;IACjB,MAAM,WAAW,CAAC,GAAG,KAAK;IAC1B,SAAS,SAAS;IAClB,OAAO;KACP;;EAGJ,SAAS,YAAY,aAA4C;GAC/D,UAAU,SAAS,KAAK,KAAK,MAAM,UAAU,SAAS,MAAM,MAAM,CAAC,CAAC;;EAGtE,SAAS,cAAc;GACrB,SAAS,EAAE,CAAC;;EAGd,OAAO;IACN,EAAE,CAEkB,CAAC"}