@ncds/ui-admin 1.6.4 → 1.7.0

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

@@ -1,5 +1,26 @@
 import { useEffect, useRef } from 'react';
 import { findScrollableParent } from '../../utils';
+var SCROLL_KEYS = ['PageUp', 'PageDown', 'Home', 'End', ' '];
+/** 이벤트 대상이 드롭다운 내부에 있는지 확인 */
+function isInsideDropdown(target, dropdownRef) {
+  return !!(dropdownRef === null || dropdownRef === void 0 ? void 0 : dropdownRef.current) && dropdownRef.current.contains(target);
+}
+/** 스크롤 가능한 요소의 경계에 도달했는지 확인하고, 도달했으면 이벤트 차단 */
+function preventScrollBeyondBounds(e, scrollableElement) {
+  var deltaY = e.deltaY;
+  var scrollTop = scrollableElement.scrollTop,
+    scrollHeight = scrollableElement.scrollHeight,
+    clientHeight = scrollableElement.clientHeight;
+  // 스크롤이 위쪽 끝에 도달했고 위로 스크롤하려는 경우
+  if (scrollTop === 0 && deltaY < 0) {
+    e.preventDefault();
+    return;
+  }
+  // 스크롤이 아래쪽 끝에 도달했고 아래로 스크롤하려는 경우
+  if (scrollTop + clientHeight >= scrollHeight && deltaY > 0) {
+    e.preventDefault();
+  }
+}
 /**
  * 페이지 스크롤을 잠그는 커스텀 훅 (드롭다운 내부 스크롤은 허용)
  */
@@ -12,27 +33,15 @@ export var useScrollLock = function (isLocked, dropdownRef) {
       // 스크롤 방지 함수 (드롭다운 내부는 스크롤 체이닝 방지)
       var preventScroll_1 = function (e) {
         // 드롭다운 내부에서 발생하지 않은 이벤트는 차단
-        if (!(dropdownRef === null || dropdownRef === void 0 ? void 0 : dropdownRef.current) || !dropdownRef.current.contains(e.target)) {
+        if (!isInsideDropdown(e.target, dropdownRef)) {
           e.preventDefault();
           return;
         }
         // 드롭다운 내부의 스크롤 가능한 요소 찾기
         var scrollableElement = findScrollableParent(e.target, dropdownRef.current);
         if (scrollableElement && e instanceof WheelEvent) {
-          var deltaY = e.deltaY;
-          var scrollTop = scrollableElement.scrollTop,
-            scrollHeight = scrollableElement.scrollHeight,
-            clientHeight = scrollableElement.clientHeight;
-          // 스크롤이 위쪽 끝에 도달했고 위로 스크롤하려는 경우
-          if (scrollTop === 0 && deltaY < 0) {
-            e.preventDefault();
-            return;
-          }
-          // 스크롤이 아래쪽 끝에 도달했고 아래로 스크롤하려는 경우
-          if (scrollTop + clientHeight >= scrollHeight && deltaY > 0) {
-            e.preventDefault();
-            return;
-          }
+          preventScrollBeyondBounds(e, scrollableElement);
+          return;
         }
         // 드롭다운 내부에 스크롤 가능한 요소가 없으면 차단
         if (!scrollableElement) {
@@ -41,12 +50,10 @@ export var useScrollLock = function (isLocked, dropdownRef) {
       };
       // 키보드 스크롤 방지 함수 (드롭다운 내부는 제외)
       var preventKeyboardScroll_1 = function (e) {
-        // 드롭다운 내부에서 발생한 이벤트는 허용
-        if ((dropdownRef === null || dropdownRef === void 0 ? void 0 : dropdownRef.current) && dropdownRef.current.contains(e.target)) {
+        if (isInsideDropdown(e.target, dropdownRef)) {
           return;
         }
-        var scrollKeys = ['PageUp', 'PageDown', 'Home', 'End', ' '];
-        if (scrollKeys.includes(e.key)) {
+        if (SCROLL_KEYS.includes(e.key)) {
           e.preventDefault();
         }
       };

package/dist/esm/src/hooks/index.js

@@ -1,6 +1,6 @@
 // 기존 공통 hooks
+// 드롭다운 관련 hooks
+export * from './dropdown';
 export { useCallbackRef } from './useCallbackRef';
 export { useMediaQuery } from './useMediaQuery';
-export { useMergeRefs } from './useMergeRefs';
-// 드롭다운 관련 hooks
-export * from './dropdown';
+export { useMergeRefs } from './useMergeRefs';

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

@@ -1,4 +1,11 @@
 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();
@@ -19,9 +26,9 @@ 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])$/;
   if (dateRegex.test(input)) {
     // 20231112 -> 2023-11-12 형식으로 변환
-    var year = input.substring(0, 4);
-    var month = input.substring(4, 6);
-    var day = input.substring(6, 8);
+    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);
   }
   return input;
@@ -29,8 +36,8 @@ export var formatDateInput = function (input) {
 export var formatHourInput = function (input) {
   var numbers = input.replace(/\D/g, '');
   var hourStr = numbers.substring(0, 2);
-  var hourNum = parseInt(hourStr, 10);
-  if (hourNum >= 0 && hourNum <= 23) {
+  var hourNum = Number.parseInt(hourStr, 10);
+  if (hourNum >= 0 && hourNum <= MAX_HOUR) {
     return hourStr;
   }
   return input;
@@ -40,9 +47,9 @@ export var formatMinuteInput = function (input) {
   var numbers = input.replace(/\D/g, '');
   // 2자리 숫자로 제한
   var minuteStr = numbers.substring(0, 2);
-  var minuteNum = parseInt(minuteStr, 10);
+  var minuteNum = Number.parseInt(minuteStr, 10);
   // 00-59 범위 체크
-  if (minuteNum >= 0 && minuteNum <= 59) {
+  if (minuteNum >= 0 && minuteNum <= MAX_MINUTE) {
     return minuteStr; // 2자리로 패딩
   }
   return input;

package/dist/esm/src/utils/dropdown/dropdownUtils.js

@@ -25,12 +25,11 @@ export var calculateDropdownPosition = function (_a) {
       direction: 'up',
       maxHeight: maxHeight
     };
-  } else {
-    return {
-      direction: 'down',
-      maxHeight: maxHeight
-    };
   }
+  return {
+    direction: 'down',
+    maxHeight: maxHeight
+  };
 };
 /**
  * 키보드 네비게이션을 위한 포커스 인덱스 계산
@@ -39,14 +38,13 @@ export var calculateNextFocusIndex = function (currentIndex, direction, validOpt
   if (validOptionsLength === 0) return -1;
   if (direction === 'down') {
     return currentIndex < validOptionsLength - 1 ? currentIndex + 1 : 0;
-  } else {
-    return currentIndex > 0 ? currentIndex - 1 : validOptionsLength - 1;
   }
+  return currentIndex > 0 ? currentIndex - 1 : validOptionsLength - 1;
 };
 /**
  * 드롭다운이 뷰포트를 벗어나지 않도록 위치 조정
  */
-export var adjustDropdownPosition = function (dropdownElement, triggerElement) {
+export var adjustDropdownPosition = function (dropdownElement) {
   var dropdownRect = dropdownElement.getBoundingClientRect();
   var viewportWidth = window.innerWidth;
   var viewportHeight = window.innerHeight;

package/dist/temp/assets/scripts/baseBox.d.ts

@@ -0,0 +1,55 @@
+import { OptionValue } from '../../src/types';
+import { DropdownOption } from './utils/unifiedBox/dropdownModel';
+import { UnifiedBoxManager } from './utils/unifiedBox/unifiedBoxManager';
+/**
+ * SelectBox와 ComboBox의 공통 기능을 담는 베이스 클래스
+ */
+export declare abstract class BaseBox {
+    protected element: HTMLElement;
+    protected unifiedSelectBox: UnifiedBoxManager;
+    protected targetSelect: HTMLSelectElement | null;
+    protected isInitializing: boolean;
+    protected lastValue: OptionValue;
+    /** 서브클래스에서 기본 placeholder를 지정 */
+    protected abstract get defaultPlaceholder(): string;
+    constructor(element: HTMLElement);
+    /** 초기화 완료 처리 (서브클래스 생성자 마지막에 호출) */
+    protected completeInitialization(): void;
+    /**
+     * 타겟 select 요소 찾기
+     */
+    protected findTargetSelect(element: HTMLElement): HTMLSelectElement | null;
+    /**
+     * HTML에서 속성 파싱
+     */
+    protected parseAttributesFromHTML(): {
+        placeholder?: string;
+        value?: string;
+        disabled?: boolean;
+        size?: 'xs' | 'sm' | 'md';
+    };
+    /**
+     * 값 변환 훅 - SelectBox에서 originalValue 매핑을 위해 오버라이드
+     * 기본 동작: 그대로 문자열 변환
+     */
+    protected resolveValue(value: string | number): string;
+    /**
+     * 타겟 select와 동기화 (Single 모드)
+     */
+    protected syncWithTargetSelect(value: string | number): void;
+    /**
+     * 타겟 select와 동기화 (Multiple 모드)
+     */
+    protected syncWithTargetSelectMultiple(values: (string | number)[]): void;
+    getOptions(): DropdownOption[];
+    updateOptions(newOptions: DropdownOption[]): void;
+    setDisabled(disabled: boolean): void;
+    open(): void;
+    close(): void;
+    focus(): void;
+    destroy(): void;
+    selectAll(): void;
+    deselectAll(): void;
+    isMultiple(): boolean;
+    toggleSelectAll(): void;
+}

package/dist/temp/assets/scripts/baseBox.js

@@ -0,0 +1,144 @@
+/**
+ * SelectBox와 ComboBox의 공통 기능을 담는 베이스 클래스
+ */
+var BaseBox = /** @class */ (function () {
+    function BaseBox(element) {
+        this.targetSelect = null;
+        this.isInitializing = true;
+        this.lastValue = '';
+        this.element = element;
+        this.targetSelect = this.findTargetSelect(element);
+    }
+    /** 초기화 완료 처리 (서브클래스 생성자 마지막에 호출) */
+    BaseBox.prototype.completeInitialization = function () {
+        var _this = this;
+        setTimeout(function () {
+            _this.isInitializing = false;
+        }, 0);
+    };
+    /**
+     * 타겟 select 요소 찾기
+     */
+    BaseBox.prototype.findTargetSelect = function (element) {
+        // 1. 직접 select 태그인 경우
+        if (element.tagName === 'SELECT') {
+            return element;
+        }
+        // 2. 자식으로 select 태그가 있는 경우
+        var selectChild = element.querySelector('select');
+        if (selectChild) {
+            return selectChild;
+        }
+        // 3. data-target 속성으로 지정된 경우
+        var targetId = element.getAttribute('data-target');
+        if (targetId) {
+            var targetElement = document.getElementById(targetId);
+            if (targetElement && targetElement.tagName === 'SELECT') {
+                return targetElement;
+            }
+        }
+        return null;
+    };
+    /**
+     * HTML에서 속성 파싱
+     */
+    BaseBox.prototype.parseAttributesFromHTML = function () {
+        var attributes = {};
+        if (this.targetSelect) {
+            // select 요소의 속성들
+            if (this.targetSelect.disabled)
+                attributes.disabled = true;
+            if (this.targetSelect.value)
+                attributes.value = this.targetSelect.value;
+            // placeholder는 첫 번째 빈 option에서 가져오기
+            var firstOption = this.targetSelect.querySelector('option[value=""], option:not([value])');
+            if (firstOption) {
+                attributes.placeholder = firstOption.textContent || this.defaultPlaceholder;
+            }
+        }
+        // 컨테이너 요소의 data 속성들
+        var containerAttributes = this.element.dataset;
+        if (containerAttributes.placeholder)
+            attributes.placeholder = containerAttributes.placeholder;
+        if (containerAttributes.size)
+            attributes.size = containerAttributes.size;
+        if (containerAttributes.disabled === 'true')
+            attributes.disabled = true;
+        return attributes;
+    };
+    /**
+     * 값 변환 훅 - SelectBox에서 originalValue 매핑을 위해 오버라이드
+     * 기본 동작: 그대로 문자열 변환
+     */
+    BaseBox.prototype.resolveValue = function (value) {
+        return String(value);
+    };
+    /**
+     * 타겟 select와 동기화 (Single 모드)
+     */
+    BaseBox.prototype.syncWithTargetSelect = function (value) {
+        if (this.targetSelect) {
+            this.targetSelect.value = this.resolveValue(value);
+            var event_1 = new Event('change', { bubbles: true });
+            this.targetSelect.dispatchEvent(event_1);
+        }
+    };
+    /**
+     * 타겟 select와 동기화 (Multiple 모드)
+     */
+    BaseBox.prototype.syncWithTargetSelectMultiple = function (values) {
+        var _this = this;
+        if (this.targetSelect && this.targetSelect.multiple) {
+            // 모든 옵션 선택 해제
+            Array.from(this.targetSelect.options).forEach(function (option) {
+                option.selected = false;
+            });
+            // 선택된 값들에 해당하는 옵션들 선택
+            values.forEach(function (value) {
+                var resolved = _this.resolveValue(value);
+                var option = _this.targetSelect.querySelector("option[value=\"".concat(resolved, "\"]"));
+                if (option) {
+                    option.selected = true;
+                }
+            });
+            var event_2 = new Event('change', { bubbles: true });
+            this.targetSelect.dispatchEvent(event_2);
+        }
+    };
+    // UnifiedBoxManager 위임 메서드들
+    BaseBox.prototype.getOptions = function () {
+        return this.unifiedSelectBox.getOptions();
+    };
+    BaseBox.prototype.updateOptions = function (newOptions) {
+        this.unifiedSelectBox.updateOptions(newOptions);
+    };
+    BaseBox.prototype.setDisabled = function (disabled) {
+        this.unifiedSelectBox.setDisabled(disabled);
+    };
+    BaseBox.prototype.open = function () {
+        this.unifiedSelectBox.open();
+    };
+    BaseBox.prototype.close = function () {
+        this.unifiedSelectBox.close();
+    };
+    BaseBox.prototype.focus = function () {
+        this.unifiedSelectBox.focus();
+    };
+    BaseBox.prototype.destroy = function () {
+        this.unifiedSelectBox.destroy();
+    };
+    BaseBox.prototype.selectAll = function () {
+        this.unifiedSelectBox.selectAll();
+    };
+    BaseBox.prototype.deselectAll = function () {
+        this.unifiedSelectBox.deselectAll();
+    };
+    BaseBox.prototype.isMultiple = function () {
+        return this.unifiedSelectBox.isMultiple();
+    };
+    BaseBox.prototype.toggleSelectAll = function () {
+        this.unifiedSelectBox.toggleSelectAll();
+    };
+    return BaseBox;
+}());
+export { BaseBox };

package/dist/temp/assets/scripts/comboBox.d.ts

@@ -0,0 +1,60 @@
+import type { Size } from '../../constant/size';
+import type { OptionValue } from '../../src/types';
+import { BaseBox } from './baseBox';
+import type { DropdownOption } from './utils/unifiedBox/dropdownModel';
+import { type UnifiedBoxManagerConfig } from './utils/unifiedBox/unifiedBoxManager';
+export interface ComboBoxOptionType {
+    id: string | number;
+    label: string;
+    disabled?: boolean;
+}
+export interface ComboBoxConfig {
+    options?: ComboBoxOptionType[];
+    placeholder?: string;
+    value?: OptionValue;
+    onChange?: (value: OptionValue) => void;
+    onSearch?: (searchValue: string) => void;
+    onEdit?: () => void;
+    onSelectAll?: () => void;
+    onSearchAll?: () => void;
+    onComplete?: () => void;
+    onTagRemove?: (tagId: string | number) => void;
+    onScrollBottom?: () => void;
+    searchDebounceMs?: number;
+    maxHeight?: number;
+    disabled?: boolean;
+    size?: Extract<Size, 'xs' | 'sm'>;
+    multiple?: boolean;
+    showFooterButtons?: boolean;
+    label?: string;
+    required?: boolean;
+}
+export declare class ComboBox extends BaseBox {
+    protected get defaultPlaceholder(): string;
+    constructor(element: HTMLElement, config?: ComboBoxConfig);
+    /**
+     * HTML select에서 옵션 파싱
+     */
+    private parseOptionsFromHTML;
+    getValues(): DropdownOption[];
+    setValues(value: DropdownOption[]): void;
+    clearInput(): void;
+    getDebugInfo(): {
+        config: UnifiedBoxManagerConfig;
+        modelState: any;
+        isOpen: boolean;
+    };
+    getSelectedCount(): number;
+    /**
+     * 드롭다운을 스크롤의 바닥으로 이동
+     */
+    scrollToBottom(): void;
+    /**
+     * 전체 선택 버튼의 텍스트를 외부에서 변경
+     */
+    setSelectAllButtonText(text: string): void;
+    /**
+     * 특정 인덱스의 옵션으로 포커스 이동
+     */
+    setFocusIndex(index: number): void;
+}

package/dist/temp/assets/scripts/comboBox.js

@@ -0,0 +1,163 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { BaseBox } from './baseBox';
+import { UnifiedBoxManager } from './utils/unifiedBox/unifiedBoxManager';
+var ComboBox = /** @class */ (function (_super) {
+    __extends(ComboBox, _super);
+    function ComboBox(element, config) {
+        if (config === void 0) { config = {}; }
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f;
+        _this = _super.call(this, element) || this;
+        // HTML에서 옵션 파싱 (config.options가 없을 경우)
+        var htmlOptions = _this.parseOptionsFromHTML();
+        // JavaScript 옵션을 DropdownOption 형식으로 변환 (이제 구조가 동일하므로 단순 복사)
+        var normalizedOptions = config.options ? __spreadArray([], config.options, true) : htmlOptions;
+        var finalOptions = normalizedOptions;
+        // HTML에서 속성 파싱
+        var htmlAttributes = _this.parseAttributesFromHTML();
+        // 기존 API를 새 API로 변환
+        var unifiedConfig = __assign(__assign({}, config), { type: 'combobox', multiple: (_a = config.multiple) !== null && _a !== void 0 ? _a : false, showFooterButtons: (_b = config.showFooterButtons) !== null && _b !== void 0 ? _b : false, onSelectAll: config.onSelectAll, onSearchAll: config.onSearchAll, onComplete: config.onComplete, onScrollBottom: config.onScrollBottom, searchDebounceMs: config.searchDebounceMs, options: finalOptions, placeholder: config.placeholder || htmlAttributes.placeholder || _this.defaultPlaceholder, value: (_d = (_c = config.value) !== null && _c !== void 0 ? _c : htmlAttributes.value) !== null && _d !== void 0 ? _d : (config.multiple ? [] : ''), disabled: (_f = (_e = config.disabled) !== null && _e !== void 0 ? _e : htmlAttributes.disabled) !== null && _f !== void 0 ? _f : false, size: config.size || htmlAttributes.size || 'md', onChange: function (value) {
+                var _a;
+                // 초기화 중에는 동기화하지 않음 (무한 루프 방지)
+                if (_this.isInitializing) {
+                    _this.lastValue = value;
+                    return;
+                }
+                // 값이 실제로 변경되지 않았으면 동기화 생략 (무한 루프 방지)
+                if (JSON.stringify(_this.lastValue) === JSON.stringify(value)) {
+                    return;
+                }
+                _this.lastValue = value;
+                // 타겟 select와 동기화
+                if (config.multiple) {
+                    _this.syncWithTargetSelectMultiple(value);
+                }
+                else {
+                    _this.syncWithTargetSelect(value);
+                }
+                (_a = config.onChange) === null || _a === void 0 ? void 0 : _a.call(config, value);
+            } });
+        _this.unifiedSelectBox = new UnifiedBoxManager(element, unifiedConfig);
+        _this.completeInitialization();
+        return _this;
+    }
+    Object.defineProperty(ComboBox.prototype, "defaultPlaceholder", {
+        get: function () {
+            return '검색하고 선택하세요';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * HTML select에서 옵션 파싱
+     */
+    ComboBox.prototype.parseOptionsFromHTML = function () {
+        if (!this.targetSelect)
+            return [];
+        var options = [];
+        var optionElements = this.targetSelect.querySelectorAll('option');
+        optionElements.forEach(function (optionElement) {
+            if (optionElement.value) {
+                // value가 있는 옵션만 추가
+                options.push({
+                    id: optionElement.value,
+                    label: optionElement.textContent || optionElement.value,
+                    disabled: optionElement.disabled,
+                });
+            }
+        });
+        return options;
+    };
+    // ComboBox 고유 API
+    ComboBox.prototype.getValues = function () {
+        return this.unifiedSelectBox.getValues();
+    };
+    ComboBox.prototype.setValues = function (value) {
+        // 옵션 객체 배열에서 id 배열로 변환하여 lastValue 비교
+        var ids = value.map(function (option) { return option.id; });
+        var valueForComparison = this.unifiedSelectBox.isMultiple() ? ids : ids[0] || '';
+        // 값이 변경되지 않았으면 무시
+        if (JSON.stringify(this.lastValue) === JSON.stringify(valueForComparison)) {
+            return;
+        }
+        this.lastValue = valueForComparison;
+        this.unifiedSelectBox.setValues(value);
+        // setValues 호출 시에도 타겟 select와 동기화
+        if (this.targetSelect) {
+            if (this.unifiedSelectBox.isMultiple()) {
+                this.syncWithTargetSelectMultiple(ids);
+            }
+            else {
+                this.syncWithTargetSelect(ids[0] || '');
+            }
+        }
+    };
+    ComboBox.prototype.clearInput = function () {
+        // UnifiedBoxManager의 handleClearInput과 동일한 로직
+        this.unifiedSelectBox.close();
+    };
+    ComboBox.prototype.getDebugInfo = function () {
+        return this.unifiedSelectBox.getDebugInfo();
+    };
+    ComboBox.prototype.getSelectedCount = function () {
+        var value = this.getValues();
+        if (Array.isArray(value)) {
+            return value.length;
+        }
+        return value ? 1 : 0;
+    };
+    /**
+     * 드롭다운을 스크롤의 바닥으로 이동
+     */
+    ComboBox.prototype.scrollToBottom = function () {
+        this.unifiedSelectBox.scrollToBottom();
+    };
+    /**
+     * 전체 선택 버튼의 텍스트를 외부에서 변경
+     */
+    ComboBox.prototype.setSelectAllButtonText = function (text) {
+        this.unifiedSelectBox.setSelectAllButtonText(text);
+    };
+    /**
+     * 특정 인덱스의 옵션으로 포커스 이동
+     */
+    ComboBox.prototype.setFocusIndex = function (index) {
+        this.unifiedSelectBox.setFocusIndex(index);
+    };
+    return ComboBox;
+}(BaseBox));
+export { ComboBox };

package/dist/temp/assets/scripts/datePicker.d.ts

@@ -0,0 +1,86 @@
+import { Options as FlatpickrOptions } from 'flatpickr/dist/types/options';
+export type DatePickerSize = 'xs' | 'sm';
+export interface ValidationError {
+    index: number;
+    date: string | Date;
+    minDate?: string | Date;
+    maxDate?: string | Date;
+    violations: Array<'minDate' | 'maxDate'>;
+    previousDate?: string | Date;
+}
+interface Options {
+    buttons?: DatePickerButton[];
+    size: DatePickerSize;
+    autoComplete?: 'on' | 'off';
+    datePickerOptions: DatePickerOptionWrapper[];
+    onValidationError?: (error: ValidationError) => void;
+}
+interface DatePickerOptionWrapper {
+    element: string;
+    attrName?: string;
+    placeholder?: string;
+    options: FlatpickrOptions;
+}
+interface DatePickerButton {
+    text: string;
+    period: number;
+    unit: 'days' | 'weeks' | 'months' | 'years';
+    isCurrent: boolean;
+}
+export declare class DatePicker {
+    private static instanceCounter;
+    private static usedWrappers;
+    private readonly contentWrapper;
+    private readonly datePickerOptions;
+    private readonly size;
+    private readonly instanceId;
+    private separator;
+    private autoComplete;
+    private buttons;
+    private flatpickrInstances;
+    private currentButton;
+    private dateFormat;
+    private onValidationError?;
+    constructor(wrapper: HTMLElement, options: Options);
+    private validateWrapper;
+    private init;
+    private validationDependencies;
+    private initializeWrapper;
+    private initButtonGroup;
+    private createButtonElement;
+    private reRenderButtonGroup;
+    private initDatePicker;
+    private initializeFlatpickr;
+    private createBlurHandler;
+    private setupFlatpickrLocale;
+    private createInputHandler;
+    private findFlatpickrInstanceByInput;
+    private clearInputValue;
+    private restorePreviousDate;
+    private createHourInputHandler;
+    private createMinuteInputHandler;
+    private createMouseDownHandler;
+    private createOnChangeHandler;
+    private invokeOriginalOnChange;
+    private isValidDate;
+    private validateAndRestoreIfNeeded;
+    private findFlatpickrInstanceIndexByInput;
+    private restoreDateToInstance;
+    private createOnReadyHandler;
+    private createOnDestroyHandler;
+    private convertDateOption;
+    private validateDate;
+    private checkDateViolations;
+    setDate(dates: string[]): void;
+    private formatDateForOption;
+    private parseDateWithMultipleFormats;
+    private formatMomentDate;
+    private calculatePeriod;
+    private updateDateWithButton;
+    private setMultipleDates;
+    private updateButtonsByPeriod;
+    private calculateDatesFromButton;
+    private convertFlatpickrFormatToMoment;
+    getDates(): string[];
+}
+export {};