@ncds/ui-admin 1.7.0 → 1.8.0

package/dist/temp/src/constant/date-picker.js

@@ -1,4 +1,4 @@
-export var PERIOD_ITEM = {
+export const PERIOD_ITEM = {
     TODAY: {
         text: '오늘',
         period: 0,

package/dist/temp/src/constant/size.js

@@ -1 +1 @@
-export var MINIMUM_PC_SIZE = 768;
+export const MINIMUM_PC_SIZE = 768;

package/dist/temp/src/hooks/dropdown/useDropdown.js

@@ -6,36 +6,36 @@ import { useWindowResize } from './useWindowResize';
 /**
  * 드롭다운 기능을 통합한 커스텀 훅
  */
-export var useDropdown = function (config) {
-    var triggerRef = config.triggerRef, dropdownRef = config.dropdownRef, maxHeight = config.maxHeight, itemCount = config.itemCount, optionItems = config.optionItems, _a = config.disabled, disabled = _a === void 0 ? false : _a, _b = config.multiple, multiple = _b === void 0 ? false : _b, onSelect = config.onSelect, onChange = config.onChange;
-    var _c = useState(false), isOpen = _c[0], setIsOpen = _c[1];
-    var _d = useState(-1), focusedIndex = _d[0], setFocusedIndex = _d[1];
+export const useDropdown = (config) => {
+    const { triggerRef, dropdownRef, maxHeight, itemCount, optionItems, disabled = false, multiple = false, onSelect, onChange, } = config;
+    const [isOpen, setIsOpen] = useState(false);
+    const [focusedIndex, setFocusedIndex] = useState(-1);
     // 드롭다운 위치 계산
-    var _e = useDropdownPosition({
-        triggerRef: triggerRef,
-        maxHeight: maxHeight,
-        itemCount: itemCount,
-    }), direction = _e.direction, updatePosition = _e.updatePosition;
+    const { direction, updatePosition } = useDropdownPosition({
+        triggerRef,
+        maxHeight,
+        itemCount,
+    });
     // 드롭다운 토글
-    var toggleDropdown = useCallback(function () {
+    const toggleDropdown = useCallback(() => {
         if (disabled)
             return;
-        var newIsOpen = !isOpen;
+        const newIsOpen = !isOpen;
         if (newIsOpen) {
             updatePosition();
             setFocusedIndex(-1);
         }
         setIsOpen(newIsOpen);
-        onChange === null || onChange === void 0 ? void 0 : onChange(newIsOpen);
+        onChange?.(newIsOpen);
     }, [disabled, isOpen, updatePosition, onChange]);
     // 드롭다운 닫기
-    var closeDropdown = useCallback(function () {
+    const closeDropdown = useCallback(() => {
         setIsOpen(false);
         setFocusedIndex(-1);
-        onChange === null || onChange === void 0 ? void 0 : onChange(false);
+        onChange?.(false);
     }, [onChange]);
     // 옵션 선택 처리
-    var handleOptionSelect = useCallback(function (option) {
+    const handleOptionSelect = useCallback((option) => {
         onSelect(option);
         // multiple 모드가 아니어야 드롭다운을 닫음
         if (!multiple) {
@@ -43,42 +43,42 @@ export var useDropdown = function (config) {
         }
     }, [onSelect, closeDropdown, multiple]);
     // 키보드 이벤트 처리
-    var _f = useDropdownKeyboard({
-        isOpen: isOpen,
-        disabled: disabled,
-        focusedIndex: focusedIndex,
-        optionItems: optionItems,
+    const { handleKeyDown, handleMouseMove, isKeyboardNavigation } = useDropdownKeyboard({
+        isOpen,
+        disabled,
+        focusedIndex,
+        optionItems,
         onToggle: toggleDropdown,
         onSelect: handleOptionSelect,
         onClose: closeDropdown,
         onFocusChange: setFocusedIndex,
-        triggerRef: triggerRef,
-        dropdownRef: dropdownRef,
-    }), handleKeyDown = _f.handleKeyDown, handleMouseMove = _f.handleMouseMove, isKeyboardNavigation = _f.isKeyboardNavigation;
+        triggerRef,
+        dropdownRef,
+    });
     // 외부 클릭 감지
-    var refs = dropdownRef ? [triggerRef, dropdownRef] : [triggerRef];
+    const refs = dropdownRef ? [triggerRef, dropdownRef] : [triggerRef];
     useOutsideClick({
-        isOpen: isOpen,
-        refs: refs,
+        isOpen,
+        refs,
         onClose: closeDropdown,
     });
     // 윈도우 리사이즈 시 위치 재계산
     useWindowResize(updatePosition, isOpen, triggerRef.current);
     return {
         // 상태
-        isOpen: isOpen,
-        direction: direction,
-        focusedIndex: focusedIndex,
+        isOpen,
+        direction,
+        focusedIndex,
         // 액션
-        toggleDropdown: toggleDropdown,
-        closeDropdown: closeDropdown,
-        handleOptionSelect: handleOptionSelect,
-        handleKeyDown: handleKeyDown,
-        setFocusedIndex: setFocusedIndex,
+        toggleDropdown,
+        closeDropdown,
+        handleOptionSelect,
+        handleKeyDown,
+        setFocusedIndex,
         // 키보드 네비게이션
-        handleMouseMove: handleMouseMove,
-        isKeyboardNavigation: isKeyboardNavigation,
+        handleMouseMove,
+        isKeyboardNavigation,
         // 유틸리티
-        updatePosition: updatePosition,
+        updatePosition,
     };
 };

package/dist/temp/src/hooks/dropdown/useDropdownKeyboard.js

@@ -1,26 +1,26 @@
 import { useCallback, useRef } from 'react';
 import { calculateNextFocusIndex } from '../../utils/dropdown';
-var SCROLL_DELAY_MS = 100;
+const SCROLL_DELAY_MS = 100;
 /**
  * 드롭다운 키보드 네비게이션을 위한 커스텀 훅
  */
-export var useDropdownKeyboard = function (config) {
-    var isOpen = config.isOpen, disabled = config.disabled, focusedIndex = config.focusedIndex, optionItems = config.optionItems, onToggle = config.onToggle, onSelect = config.onSelect, onClose = config.onClose, onFocusChange = config.onFocusChange, triggerRef = config.triggerRef, dropdownRef = config.dropdownRef;
+export const useDropdownKeyboard = (config) => {
+    const { isOpen, disabled, focusedIndex, optionItems, onToggle, onSelect, onClose, onFocusChange, triggerRef, dropdownRef, } = config;
     // 키보드 네비게이션 플래그
-    var isKeyboardNavigationRef = useRef(false);
+    const isKeyboardNavigationRef = useRef(false);
     // 포커스된 옵션이 보이도록 스크롤 조정
-    var scrollToFocusedOption = useCallback(function (index) {
-        if (!(dropdownRef === null || dropdownRef === void 0 ? void 0 : dropdownRef.current) || index < 0)
+    const scrollToFocusedOption = useCallback((index) => {
+        if (!dropdownRef?.current || index < 0)
             return;
-        var optionsList = dropdownRef.current.querySelector('.ncua-select-dropdown__options');
+        const optionsList = dropdownRef.current.querySelector('.ncua-select-dropdown__options');
         if (!optionsList)
             return;
-        var options = optionsList.querySelectorAll('.ncua-select-dropdown__option');
-        var focusedOption = options[index];
+        const options = optionsList.querySelectorAll('.ncua-select-dropdown__option');
+        const focusedOption = options[index];
         if (!focusedOption)
             return;
-        var optionsListRect = optionsList.getBoundingClientRect();
-        var focusedOptionRect = focusedOption.getBoundingClientRect();
+        const optionsListRect = optionsList.getBoundingClientRect();
+        const focusedOptionRect = focusedOption.getBoundingClientRect();
         // 옵션이 위쪽으로 벗어났을 때
         if (focusedOptionRect.top < optionsListRect.top) {
             optionsList.scrollTop = focusedOption.offsetTop;
@@ -30,7 +30,7 @@ export var useDropdownKeyboard = function (config) {
             optionsList.scrollTop = focusedOption.offsetTop + focusedOption.offsetHeight - optionsList.clientHeight;
         }
     }, [dropdownRef]);
-    var handleEnterOrSpace = useCallback(function (e) {
+    const handleEnterOrSpace = useCallback((e) => {
         e.preventDefault();
         if (!isOpen) {
             onToggle();
@@ -39,35 +39,34 @@ export var useDropdownKeyboard = function (config) {
             onSelect(optionItems[focusedIndex]);
         }
     }, [isOpen, focusedIndex, optionItems, onToggle, onSelect]);
-    var handleEscape = useCallback(function (e) {
-        var _a;
+    const handleEscape = useCallback((e) => {
         if (isOpen) {
             e.preventDefault();
             onClose();
-            (_a = triggerRef === null || triggerRef === void 0 ? void 0 : triggerRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+            triggerRef?.current?.focus();
         }
     }, [isOpen, onClose, triggerRef]);
-    var handleArrowNavigation = useCallback(function (e, direction) {
+    const handleArrowNavigation = useCallback((e, direction) => {
         e.preventDefault();
         isKeyboardNavigationRef.current = true;
         if (isOpen) {
-            var nextIndex_1 = calculateNextFocusIndex(focusedIndex, direction, optionItems.length);
-            onFocusChange(nextIndex_1);
-            setTimeout(function () { return scrollToFocusedOption(nextIndex_1); }, SCROLL_DELAY_MS);
+            const nextIndex = calculateNextFocusIndex(focusedIndex, direction, optionItems.length);
+            onFocusChange(nextIndex);
+            setTimeout(() => scrollToFocusedOption(nextIndex), SCROLL_DELAY_MS);
         }
         else {
             onToggle();
         }
     }, [isOpen, focusedIndex, optionItems.length, onFocusChange, onToggle, scrollToFocusedOption]);
-    var handleHomeEnd = useCallback(function (e, targetIndex) {
+    const handleHomeEnd = useCallback((e, targetIndex) => {
         if (isOpen) {
             e.preventDefault();
             isKeyboardNavigationRef.current = true;
             onFocusChange(targetIndex);
-            setTimeout(function () { return scrollToFocusedOption(targetIndex); }, 0);
+            setTimeout(() => scrollToFocusedOption(targetIndex), 0);
         }
     }, [isOpen, onFocusChange, scrollToFocusedOption]);
-    var handleKeyDown = useCallback(function (e) {
+    const handleKeyDown = useCallback((e) => {
         if (disabled)
             return;
         switch (e.key) {
@@ -93,16 +92,16 @@ export var useDropdownKeyboard = function (config) {
         }
     }, [disabled, optionItems.length, handleEnterOrSpace, handleEscape, handleArrowNavigation, handleHomeEnd]);
     // 마우스 움직임 감지 함수
-    var handleMouseMove = useCallback(function () {
+    const handleMouseMove = useCallback(() => {
         isKeyboardNavigationRef.current = false;
     }, []);
     // 키보드 네비게이션 상태 확인 함수
-    var isKeyboardNavigation = useCallback(function () {
+    const isKeyboardNavigation = useCallback(() => {
         return isKeyboardNavigationRef.current;
     }, []);
     return {
-        handleKeyDown: handleKeyDown,
-        handleMouseMove: handleMouseMove,
-        isKeyboardNavigation: isKeyboardNavigation,
+        handleKeyDown,
+        handleMouseMove,
+        isKeyboardNavigation,
     };
 };

package/dist/temp/src/hooks/dropdown/useDropdownPosition.js

@@ -3,16 +3,16 @@ import { calculateDropdownPosition } from '../../utils/dropdown';
 /**
  * 드롭다운 위치 계산을 위한 커스텀 훅
  */
-export var useDropdownPosition = function (config) {
-    var _a = useState('down'), direction = _a[0], setDirection = _a[1];
-    var updatePosition = useCallback(function () {
-        var result = calculateDropdownPosition(config);
+export const useDropdownPosition = (config) => {
+    const [direction, setDirection] = useState('down');
+    const updatePosition = useCallback(() => {
+        const result = calculateDropdownPosition(config);
         setDirection(result.direction);
         return result;
     }, [config]);
     return {
-        direction: direction,
-        updatePosition: updatePosition,
-        setDirection: setDirection,
+        direction,
+        updatePosition,
+        setDirection,
     };
 };

package/dist/temp/src/hooks/dropdown/useOutsideClick.js

@@ -2,21 +2,21 @@ import { useEffect } from 'react';
 /**
  * 외부 클릭 감지를 위한 커스텀 훅
  */
-export var useOutsideClick = function (config) {
-    var isOpen = config.isOpen, refs = config.refs, onClose = config.onClose;
-    useEffect(function () {
+export const useOutsideClick = (config) => {
+    const { isOpen, refs, onClose } = config;
+    useEffect(() => {
         if (!isOpen)
             return;
-        var handleClickOutside = function (event) {
-            var target = event.target;
+        const handleClickOutside = (event) => {
+            const target = event.target;
             // 모든 ref들에 대해 클릭이 외부에서 발생했는지 확인
-            var isOutside = refs.every(function (ref) { return !ref.current || !ref.current.contains(target); });
+            const isOutside = refs.every((ref) => !ref.current || !ref.current.contains(target));
             if (isOutside) {
                 onClose();
             }
         };
         document.addEventListener('mousedown', handleClickOutside);
-        return function () {
+        return () => {
             document.removeEventListener('mousedown', handleClickOutside);
         };
     }, [isOpen, refs, onClose]);

package/dist/temp/src/hooks/dropdown/useScrollLock.js

@@ -1,14 +1,14 @@
 import { useEffect, useRef } from 'react';
 import { findScrollableParent } from '../../utils';
-var SCROLL_KEYS = ['PageUp', 'PageDown', 'Home', 'End', ' '];
+const SCROLL_KEYS = ['PageUp', 'PageDown', 'Home', 'End', ' '];
 /** 이벤트 대상이 드롭다운 내부에 있는지 확인 */
 function isInsideDropdown(target, dropdownRef) {
-    return !!(dropdownRef === null || dropdownRef === void 0 ? void 0 : dropdownRef.current) && dropdownRef.current.contains(target);
+    return !!dropdownRef?.current && dropdownRef.current.contains(target);
 }
 /** 스크롤 가능한 요소의 경계에 도달했는지 확인하고, 도달했으면 이벤트 차단 */
 function preventScrollBeyondBounds(e, scrollableElement) {
-    var deltaY = e.deltaY;
-    var scrollTop = scrollableElement.scrollTop, scrollHeight = scrollableElement.scrollHeight, clientHeight = scrollableElement.clientHeight;
+    const { deltaY } = e;
+    const { scrollTop, scrollHeight, clientHeight } = scrollableElement;
     // 스크롤이 위쪽 끝에 도달했고 위로 스크롤하려는 경우
     if (scrollTop === 0 && deltaY < 0) {
         e.preventDefault();
@@ -22,21 +22,21 @@ function preventScrollBeyondBounds(e, scrollableElement) {
 /**
  * 페이지 스크롤을 잠그는 커스텀 훅 (드롭다운 내부 스크롤은 허용)
  */
-export var useScrollLock = function (isLocked, dropdownRef) {
-    var scrollPosition = useRef(0);
-    useEffect(function () {
+export const useScrollLock = (isLocked, dropdownRef) => {
+    const scrollPosition = useRef(0);
+    useEffect(() => {
         if (isLocked) {
             // 현재 스크롤 위치 저장
             scrollPosition.current = window.pageYOffset;
             // 스크롤 방지 함수 (드롭다운 내부는 스크롤 체이닝 방지)
-            var preventScroll_1 = function (e) {
+            const preventScroll = (e) => {
                 // 드롭다운 내부에서 발생하지 않은 이벤트는 차단
                 if (!isInsideDropdown(e.target, dropdownRef)) {
                     e.preventDefault();
                     return;
                 }
                 // 드롭다운 내부의 스크롤 가능한 요소 찾기
-                var scrollableElement = findScrollableParent(e.target, dropdownRef.current);
+                const scrollableElement = findScrollableParent(e.target, dropdownRef.current);
                 if (scrollableElement && e instanceof WheelEvent) {
                     preventScrollBeyondBounds(e, scrollableElement);
                     return;
@@ -47,7 +47,7 @@ export var useScrollLock = function (isLocked, dropdownRef) {
                 }
             };
             // 키보드 스크롤 방지 함수 (드롭다운 내부는 제외)
-            var preventKeyboardScroll_1 = function (e) {
+            const preventKeyboardScroll = (e) => {
                 if (isInsideDropdown(e.target, dropdownRef)) {
                     return;
                 }
@@ -56,14 +56,14 @@ export var useScrollLock = function (isLocked, dropdownRef) {
                 }
             };
             // 이벤트 리스너 추가
-            document.addEventListener('wheel', preventScroll_1, { passive: false });
-            document.addEventListener('touchmove', preventScroll_1, { passive: false });
-            document.addEventListener('keydown', preventKeyboardScroll_1);
-            return function () {
+            document.addEventListener('wheel', preventScroll, { passive: false });
+            document.addEventListener('touchmove', preventScroll, { passive: false });
+            document.addEventListener('keydown', preventKeyboardScroll);
+            return () => {
                 // 이벤트 리스너 제거
-                document.removeEventListener('wheel', preventScroll_1);
-                document.removeEventListener('touchmove', preventScroll_1);
-                document.removeEventListener('keydown', preventKeyboardScroll_1);
+                document.removeEventListener('wheel', preventScroll);
+                document.removeEventListener('touchmove', preventScroll);
+                document.removeEventListener('keydown', preventKeyboardScroll);
                 // 스크롤 위치 복원
                 window.scrollTo(0, scrollPosition.current);
             };

package/dist/temp/src/hooks/dropdown/useWindowResize.js

@@ -5,36 +5,35 @@ import { useEffect, useRef } from 'react';
  * @param isActive 옵저버 활성화 여부
  * @param target 관찰할 대상 요소 (기본값: document.body)
  */
-export var useWindowResize = function (callback, isActive, target) {
-    if (isActive === void 0) { isActive = true; }
-    var resizeObserverRef = useRef(null);
-    useEffect(function () {
+export const useWindowResize = (callback, isActive = true, target) => {
+    const resizeObserverRef = useRef(null);
+    useEffect(() => {
         if (!isActive)
             return;
         // Resize Observer 지원 여부 확인
         if (!window.ResizeObserver) {
             // Resize Observer를 지원하지 않는 브라우저의 경우 기존 방식 사용
-            var handleResize_1 = function () {
+            const handleResize = () => {
                 callback();
             };
-            window.addEventListener('resize', handleResize_1);
-            return function () {
-                window.removeEventListener('resize', handleResize_1);
+            window.addEventListener('resize', handleResize);
+            return () => {
+                window.removeEventListener('resize', handleResize);
             };
         }
         // Resize Observer 생성
-        resizeObserverRef.current = new ResizeObserver(function (entries) {
+        resizeObserverRef.current = new ResizeObserver((entries) => {
             // entries가 비어있지 않을 때만 콜백 실행
             if (entries.length > 0) {
                 callback();
             }
         });
         // 관찰할 대상 요소 결정
-        var targetElement = target || document.body;
+        const targetElement = target || document.body;
         if (targetElement) {
             resizeObserverRef.current.observe(targetElement);
         }
-        return function () {
+        return () => {
             if (resizeObserverRef.current) {
                 resizeObserverRef.current.disconnect();
                 resizeObserverRef.current = null;

package/dist/temp/src/hooks/useCallbackRef.js

@@ -26,8 +26,8 @@ import { useCallback, useRef } from 'react';
  * ```
  */
 export function useCallbackRef(callback) {
-    var cleanupRef = useRef();
-    return useCallback(function (node) {
+    const cleanupRef = useRef();
+    return useCallback((node) => {
         // Cleanup previous ref
         if (cleanupRef.current) {
             cleanupRef.current();

package/dist/temp/src/hooks/useMediaQuery.js

@@ -1,20 +1,19 @@
 import { useEffect, useState } from 'react';
-export var useMediaQuery = function (query, options) {
-    var _a = useState(false), matches = _a[0], setMatches = _a[1];
-    useEffect(function () {
-        var mediaQuery = window.matchMedia(query);
+export const useMediaQuery = (query, options) => {
+    const [matches, setMatches] = useState(false);
+    useEffect(() => {
+        const mediaQuery = window.matchMedia(query);
         setMatches(mediaQuery.matches);
-        var handleChange = function (e) {
-            var _a;
+        const handleChange = (e) => {
             setMatches(e.matches);
             if (e.matches) {
-                (_a = options === null || options === void 0 ? void 0 : options.onMatched) === null || _a === void 0 ? void 0 : _a.call(options);
+                options?.onMatched?.();
             }
         };
         mediaQuery.addEventListener('change', handleChange);
-        return function () {
+        return () => {
             mediaQuery.removeEventListener('change', handleChange);
         };
-    }, [query, options === null || options === void 0 ? void 0 : options.onMatched]);
+    }, [query, options?.onMatched]);
     return matches;
 };

package/dist/temp/src/hooks/useMergeRefs.js

@@ -16,8 +16,8 @@
  * ```
  */
 export function useMergeRefs(refs) {
-    return function (node) {
-        refs.forEach(function (ref) {
+    return (node) => {
+        refs.forEach((ref) => {
             if (ref) {
                 if (typeof ref === 'function') {
                     ref(node);

package/dist/temp/src/utils/date-picker.js

@@ -1,48 +1,46 @@
 import moment from 'moment';
-var YEAR_LENGTH = 4;
-var MONTH_START = 4;
-var MONTH_END = 6;
-var DAY_START = 6;
-var DAY_END = 8;
-var MAX_HOUR = 23;
-var MAX_MINUTE = 59;
-export function getDateFormat(date) {
-    if (date === void 0) { date = getToday(); }
+const YEAR_LENGTH = 4;
+const MONTH_START = 4;
+const MONTH_END = 6;
+const DAY_START = 6;
+const DAY_END = 8;
+const MAX_HOUR = 23;
+const MAX_MINUTE = 59;
+export function getDateFormat(date = getToday()) {
     return moment(date).format('YYYY-MM-DD');
 }
 export function getToday() {
     return moment().toDate();
 }
-export function getSubtractDate(_a) {
-    var _b = _a.date, date = _b === void 0 ? getToday() : _b, period = _a.period, unit = _a.unit;
+export function getSubtractDate({ date = getToday(), period, unit, }) {
     return moment(date).subtract(period, unit).toDate();
 }
-export var formatDateInput = function (input) {
-    var dateRegex = /^(19|20)\d{2}(0[1-9]|1[012])(0[1-9]|[12][0-9]|3[0-1])$/;
+export const formatDateInput = (input) => {
+    const dateRegex = /^(19|20)\d{2}(0[1-9]|1[012])(0[1-9]|[12][0-9]|3[0-1])$/;
     if (dateRegex.test(input)) {
         // 20231112 -> 2023-11-12 형식으로 변환
-        var year = input.substring(0, YEAR_LENGTH);
-        var month = input.substring(MONTH_START, MONTH_END);
-        var day = input.substring(DAY_START, DAY_END);
-        return "".concat(year, "-").concat(month, "-").concat(day);
+        const year = input.substring(0, YEAR_LENGTH);
+        const month = input.substring(MONTH_START, MONTH_END);
+        const day = input.substring(DAY_START, DAY_END);
+        return `${year}-${month}-${day}`;
     }
     return input;
 };
-export var formatHourInput = function (input) {
-    var numbers = input.replace(/\D/g, '');
-    var hourStr = numbers.substring(0, 2);
-    var hourNum = Number.parseInt(hourStr, 10);
+export const formatHourInput = (input) => {
+    const numbers = input.replace(/\D/g, '');
+    const hourStr = numbers.substring(0, 2);
+    const hourNum = Number.parseInt(hourStr, 10);
     if (hourNum >= 0 && hourNum <= MAX_HOUR) {
         return hourStr;
     }
     return input;
 };
-export var formatMinuteInput = function (input) {
+export const formatMinuteInput = (input) => {
     // 숫자만 추출
-    var numbers = input.replace(/\D/g, '');
+    const numbers = input.replace(/\D/g, '');
     // 2자리 숫자로 제한
-    var minuteStr = numbers.substring(0, 2);
-    var minuteNum = Number.parseInt(minuteStr, 10);
+    const minuteStr = numbers.substring(0, 2);
+    const minuteNum = Number.parseInt(minuteStr, 10);
     // 00-59 범위 체크
     if (minuteNum >= 0 && minuteNum <= MAX_MINUTE) {
         return minuteStr; // 2자리로 패딩