@ncds/ui-admin 1.7.0 → 1.8.0

package/dist/temp/assets/scripts/utils/unifiedBox/unifiedBoxController.js

@@ -1,20 +1,9 @@
-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);
-};
 /**
  * SelectBox 통합 컨트롤러
  * 이벤트 처리, UI 상태 제어, 사용자 인터랙션 담당
  */
-var UnifiedBoxController = /** @class */ (function () {
-    function UnifiedBoxController(config) {
+export class UnifiedBoxController {
+    constructor(config) {
         this.isOpen = false;
         this.focusedIndex = -1;
         this.isKeyboardNavigation = false;
@@ -34,8 +23,7 @@ var UnifiedBoxController = /** @class */ (function () {
     /**
      * 상태 변경 리스너 (Observer Pattern)
      */
-    UnifiedBoxController.prototype.onStateChange = function (newState, changedFields) {
-        var _a, _b;
+    onStateChange(newState, changedFields) {
         // 드롭다운 열기/닫기 상태 동기화
         if (changedFields.includes('isOpen')) {
             this.isOpen = newState.isOpen;
@@ -52,46 +40,43 @@ var UnifiedBoxController = /** @class */ (function () {
         }
         // 선택 상태 변경 알림
         if (changedFields.includes('selectedValues')) {
-            (_b = (_a = this.config).onSelectionChange) === null || _b === void 0 ? void 0 : _b.call(_a, newState.selectedValues);
+            this.config.onSelectionChange?.(newState.selectedValues);
         }
         // 검색어 변경 알림은 UnifiedSelectBox에서 디바운싱 적용 후 처리하므로 여기서는 호출하지 않음
         // (디바운싱이 적용되지 않은 즉시 호출을 방지하기 위해)
-    };
+    }
     /**
      * 이벤트 핸들러 설정
      */
-    UnifiedBoxController.prototype.setupEventHandlers = function () {
-        var _this = this;
+    setupEventHandlers() {
         // 외부 클릭 핸들러
-        this.outsideClickHandler = function (e) {
-            var target = e.target;
-            var isInsideTrigger = _this.config.triggerElement.contains(target);
-            var isInsideDropdown = _this.config.dropdownElement.contains(target);
+        this.outsideClickHandler = (e) => {
+            const target = e.target;
+            const isInsideTrigger = this.config.triggerElement.contains(target);
+            const isInsideDropdown = this.config.dropdownElement.contains(target);
             if (isInsideTrigger || isInsideDropdown) {
                 return;
             }
-            _this.close();
+            this.close();
         };
         // 키보드 핸들러
-        this.keyDownHandler = function (e) {
-            _this.handleKeyDown(e);
+        this.keyDownHandler = (e) => {
+            this.handleKeyDown(e);
         };
         if (this.config.type !== 'combobox') {
-            this.config.triggerElement.addEventListener('click', function () {
-                var _a, _b;
-                if (!_this.config.disabled && ((_b = (_a = _this.config).canToggle) === null || _b === void 0 ? void 0 : _b.call(_a)) !== false) {
-                    _this.toggle();
+            this.config.triggerElement.addEventListener('click', () => {
+                if (!this.config.disabled && this.config.canToggle?.() !== false) {
+                    this.toggle();
                 }
             });
         }
         // 키보드 이벤트
         this.config.triggerElement.addEventListener('keydown', this.keyDownHandler);
-    };
+    }
     /**
      * 드롭다운 열기
      */
-    UnifiedBoxController.prototype.open = function () {
-        var _a, _b;
+    open() {
         if (this.config.disabled || this.isOpen)
             return;
         this.config.model.setOpen(true);
@@ -99,13 +84,12 @@ var UnifiedBoxController = /** @class */ (function () {
         this.enableOutsideClick();
         this.enableScrollLock();
         this.enableScrollBottomDetection(); // 스크롤 감지 활성화
-        (_b = (_a = this.config).onOpen) === null || _b === void 0 ? void 0 : _b.call(_a);
-    };
+        this.config.onOpen?.();
+    }
     /**
      * 드롭다운 닫기
      */
-    UnifiedBoxController.prototype.close = function () {
-        var _a, _b;
+    close() {
         if (!this.isOpen)
             return;
         this.config.model.setOpen(false);
@@ -113,24 +97,24 @@ var UnifiedBoxController = /** @class */ (function () {
         this.disableScrollLock();
         this.disableScrollBottomDetection(); // 스크롤 감지 비활성화
         this.isKeyboardNavigation = false;
-        (_b = (_a = this.config).onClose) === null || _b === void 0 ? void 0 : _b.call(_a);
-    };
+        this.config.onClose?.();
+    }
     /**
      * 드롭다운 토글
      */
-    UnifiedBoxController.prototype.toggle = function () {
+    toggle() {
         if (this.isOpen) {
             this.close();
         }
         else {
             this.open();
         }
-    };
+    }
     /**
      * 키보드 입력 처리
      */
-    UnifiedBoxController.prototype.handleKeyDown = function (event) {
-        var state = this.config.model.getState();
+    handleKeyDown(event) {
+        const state = this.config.model.getState();
         switch (event.key) {
             case 'ArrowDown':
                 event.preventDefault();
@@ -152,7 +136,7 @@ var UnifiedBoxController = /** @class */ (function () {
             case 'Enter':
                 event.preventDefault();
                 if (state.isOpen && state.focusedIndex >= 0 && state.focusedIndex < state.filteredOptions.length) {
-                    var focusedOption = state.filteredOptions[state.focusedIndex];
+                    const focusedOption = state.filteredOptions[state.focusedIndex];
                     this.config.model.toggleOption(focusedOption.id);
                 }
                 break;
@@ -169,17 +153,17 @@ var UnifiedBoxController = /** @class */ (function () {
                 }
                 break;
         }
-    };
+    }
     /**
      * 옵션 검색
      */
-    UnifiedBoxController.prototype.searchOption = function (char) {
-        var state = this.config.model.getState();
-        var options = state.filteredOptions;
-        var startIndex = this.focusedIndex >= 0 ? this.focusedIndex + 1 : 0;
-        for (var i = 0; i < options.length; i++) {
-            var index = (startIndex + i) % options.length;
-            var option = options[index];
+    searchOption(char) {
+        const state = this.config.model.getState();
+        const options = state.filteredOptions;
+        const startIndex = this.focusedIndex >= 0 ? this.focusedIndex + 1 : 0;
+        for (let i = 0; i < options.length; i++) {
+            const index = (startIndex + i) % options.length;
+            const option = options[index];
             // option.label이 존재하고 문자열인지 확인
             if (option && option.label && typeof option.label === 'string') {
                 if (option.label.toLowerCase().startsWith(char.toLowerCase())) {
@@ -188,19 +172,19 @@ var UnifiedBoxController = /** @class */ (function () {
                 }
             }
         }
-    };
+    }
     /**
      * 드롭다운 표시/숨김 업데이트
      */
-    UnifiedBoxController.prototype.updateDropdownVisibility = function (isOpen) {
+    updateDropdownVisibility(isOpen) {
         this.config.dropdownElement.style.display = isOpen ? 'block' : 'none';
-    };
+    }
     /**
      * 옵션 표시 업데이트
      */
-    UnifiedBoxController.prototype.updateOptionsDisplay = function (state) {
-        var hasFilteredOptions = state.filteredOptions.length > 0;
-        var countChanged = this.lastFilteredOptionsCount !== state.filteredOptions.length;
+    updateOptionsDisplay(state) {
+        const hasFilteredOptions = state.filteredOptions.length > 0;
+        const countChanged = this.lastFilteredOptionsCount !== state.filteredOptions.length;
         // 빈 옵션일 때 해시 초기화 및 전체 렌더링
         if (!hasFilteredOptions) {
             this.lastFilteredOptionsHash = '';
@@ -208,10 +192,10 @@ var UnifiedBoxController = /** @class */ (function () {
         }
         else {
             // 옵션 개수가 변경되었는지 먼저 확인 (빠른 체크)
-            var optionsChanged = countChanged;
+            let optionsChanged = countChanged;
             // 개수가 변경되지 않았을 때만 해시 계산 (O(n) 연산 최소화)
             if (!optionsChanged) {
-                var currentHash = state.filteredOptions.map(function (opt) { return opt.id; }).join(',');
+                const currentHash = state.filteredOptions.map((opt) => opt.id).join(',');
                 optionsChanged = this.lastFilteredOptionsHash !== currentHash;
                 if (optionsChanged) {
                     this.lastFilteredOptionsHash = currentHash;
@@ -219,18 +203,17 @@ var UnifiedBoxController = /** @class */ (function () {
             }
             else {
                 // 개수가 변경되었으면 해시도 재계산
-                this.lastFilteredOptionsHash = state.filteredOptions.map(function (opt) { return opt.id; }).join(',');
+                this.lastFilteredOptionsHash = state.filteredOptions.map((opt) => opt.id).join(',');
             }
             // 옵션이 변경되지 않았고 선택 상태만 변경된 경우 DOM 조작만 수행
             if (!optionsChanged) {
                 // 선택 상태만 업데이트 (전체 재렌더링 방지)
-                this.optionElements.forEach(function (element, index) {
-                    var _a;
-                    var optionId = (_a = state.filteredOptions[index]) === null || _a === void 0 ? void 0 : _a.id;
+                this.optionElements.forEach((element, index) => {
+                    const optionId = state.filteredOptions[index]?.id;
                     if (!optionId)
                         return;
-                    var isSelected = state.selectedValues.includes(optionId);
-                    var isFocused = index === state.focusedIndex;
+                    const isSelected = state.selectedValues.includes(optionId);
+                    const isFocused = index === state.focusedIndex;
                     // 선택 상태 업데이트
                     if (isSelected) {
                         element.classList.add('ncua-select-dropdown__option--selected');
@@ -252,25 +235,29 @@ var UnifiedBoxController = /** @class */ (function () {
             }
         }
         // 옵션이 변경되었거나 빈 경우에만 전체 렌더링
-        var renderableOptions = state.filteredOptions.map(function (option, index) { return (__assign(__assign({}, option), { selected: state.selectedValues.includes(option.id), focused: index === state.focusedIndex })); });
-        var showNoResults = state.filteredOptions.length === 0 && (state.showAllItems || state.searchValue.length > 0);
-        var optionsList = this.config.dropdownElement.querySelector('.ncua-select-dropdown__options');
+        const renderableOptions = state.filteredOptions.map((option, index) => ({
+            ...option,
+            selected: state.selectedValues.includes(option.id),
+            focused: index === state.focusedIndex,
+        }));
+        const showNoResults = state.filteredOptions.length === 0 && (state.showAllItems || state.searchValue.length > 0);
+        const optionsList = this.config.dropdownElement.querySelector('.ncua-select-dropdown__options');
         if (optionsList) {
             this.optionElements = this.config.renderer.updateOptionsList(optionsList, renderableOptions, this.config.renderConfig, showNoResults);
             // 옵션 클릭 이벤트 등록
             this.attachOptionEventHandlers();
             // 캐시 업데이트 (이미 위에서 업데이트했으면 다시 업데이트하지 않음)
             if (!this.lastFilteredOptionsHash) {
-                this.lastFilteredOptionsHash = state.filteredOptions.map(function (opt) { return opt.id; }).join(',');
+                this.lastFilteredOptionsHash = state.filteredOptions.map((opt) => opt.id).join(',');
             }
             this.lastFilteredOptionsCount = state.filteredOptions.length;
         }
-    };
+    }
     /**
      * 포커스된 옵션 업데이트
      */
-    UnifiedBoxController.prototype.updateFocusedOption = function (focusedIndex) {
-        this.optionElements.forEach(function (element, index) {
+    updateFocusedOption(focusedIndex) {
+        this.optionElements.forEach((element, index) => {
             if (index === focusedIndex) {
                 element.classList.add('ncua-select-dropdown__option--focused');
                 element.scrollIntoView({ block: 'nearest' });
@@ -279,102 +266,97 @@ var UnifiedBoxController = /** @class */ (function () {
                 element.classList.remove('ncua-select-dropdown__option--focused');
             }
         });
-    };
+    }
     /**
      * 옵션 클릭 이벤트 핸들러 등록
      */
-    UnifiedBoxController.prototype.attachOptionEventHandlers = function () {
-        var _this = this;
+    attachOptionEventHandlers() {
         // 기존 이벤트 리스너 제거
         this.removeOptionEventHandlers();
-        this.optionElements.forEach(function (element, index) {
-            var optionId = element.getAttribute('data-value');
+        this.optionElements.forEach((element, index) => {
+            const optionId = element.getAttribute('data-value');
             // data-value가 없거나 빈 문자열인 경우에도 처리
             if (optionId === null)
                 return;
             // 클릭 이벤트 핸들러 생성 및 저장
-            var clickHandler = function (event) {
+            const clickHandler = (event) => {
                 event.preventDefault();
                 event.stopPropagation();
-                _this.config.model.toggleOption(optionId);
+                this.config.model.toggleOption(optionId);
                 // 단일 선택 모드에서는 선택 후 드롭다운 닫기
-                if (!_this.config.model.isMultiple()) {
-                    setTimeout(function () { return _this.close(); }, 100);
+                if (!this.config.model.isMultiple()) {
+                    setTimeout(() => this.close(), 100);
                 }
             };
-            var hoverHandler = function () {
-                if (!_this.isKeyboardNavigation) {
-                    _this.config.model.setFocusedIndex(index);
+            const hoverHandler = () => {
+                if (!this.isKeyboardNavigation) {
+                    this.config.model.setFocusedIndex(index);
                 }
             };
             // 이벤트 리스너 등록
             element.addEventListener('click', clickHandler);
             element.addEventListener('mouseenter', hoverHandler);
             // 나중에 제거할 수 있도록 핸들러 저장
-            _this.handlerMap.set(element, { click: clickHandler, hover: hoverHandler });
+            this.handlerMap.set(element, { click: clickHandler, hover: hoverHandler });
         });
         // 마우스 이동 감지 (한 번만 등록)
         if (!this.mouseMoveHandlerAttached) {
-            this.config.dropdownElement.addEventListener('mousemove', function () {
-                _this.isKeyboardNavigation = false;
+            this.config.dropdownElement.addEventListener('mousemove', () => {
+                this.isKeyboardNavigation = false;
             });
             this.mouseMoveHandlerAttached = true;
         }
-    };
+    }
     /**
      * 옵션 이벤트 핸들러 제거
      */
-    UnifiedBoxController.prototype.removeOptionEventHandlers = function () {
-        var _this = this;
-        this.optionElements.forEach(function (element) {
-            var handlers = _this.handlerMap.get(element);
+    removeOptionEventHandlers() {
+        this.optionElements.forEach((element) => {
+            const handlers = this.handlerMap.get(element);
             if (handlers) {
                 element.removeEventListener('click', handlers.click);
                 element.removeEventListener('mouseenter', handlers.hover);
-                _this.handlerMap.delete(element);
+                this.handlerMap.delete(element);
             }
         });
-    };
+    }
     /**
      * 옵션 업데이트가 필요한지 판단
      */
-    UnifiedBoxController.prototype.shouldUpdateOptions = function (changedFields) {
-        return changedFields.some(function (field) {
-            return ['options', 'filteredOptions', 'selectedValues', 'showAllItems'].includes(field);
-        });
-    };
+    shouldUpdateOptions(changedFields) {
+        return changedFields.some((field) => ['options', 'filteredOptions', 'selectedValues', 'showAllItems'].includes(field));
+    }
     /**
      * 외부 클릭 감지 활성화
      */
-    UnifiedBoxController.prototype.enableOutsideClick = function () {
+    enableOutsideClick() {
         document.addEventListener('mousedown', this.outsideClickHandler);
-    };
+    }
     /**
      * 외부 클릭 감지 비활성화
      */
-    UnifiedBoxController.prototype.disableOutsideClick = function () {
+    disableOutsideClick() {
         document.removeEventListener('mousedown', this.outsideClickHandler);
-    };
+    }
     /**
      * 스크롤 잠금 활성화 (드롭다운 내부 스크롤은 허용)
      * ComboBox 또는 multiple 모드에서는 스크롤 잠금 비활성화
      */
-    UnifiedBoxController.prototype.enableScrollLock = function () {
-        var _this = this;
+    enableScrollLock() {
         // ComboBox 또는 multiple 모드에서는 스크롤 잠금 비활성화
         if (this.config.type === 'combobox' || this.config.model.isMultiple()) {
             return;
         }
         this.scrollPosition = window.pageYOffset;
         this.scrollLockHandlers = {
-            wheel: function (e) {
+            wheel: (e) => {
                 // 드롭다운 내부에서 발생한 이벤트 처리
-                if (_this.config.dropdownElement && _this.config.dropdownElement.contains(e.target)) {
+                if (this.config.dropdownElement && this.config.dropdownElement.contains(e.target)) {
                     // 드롭다운 내부의 스크롤 가능한 요소 찾기
-                    var scrollableElement = _this.findScrollableParent(e.target, _this.config.dropdownElement);
+                    const scrollableElement = this.findScrollableParent(e.target, this.config.dropdownElement);
                     if (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();
@@ -392,10 +374,10 @@ var UnifiedBoxController = /** @class */ (function () {
                 // 드롭다운 외부의 모든 스크롤 방지
                 e.preventDefault();
             },
-            touchmove: function (e) {
+            touchmove: (e) => {
                 // 드롭다운 내부에서의 터치 스크롤 처리
-                if (_this.config.dropdownElement && _this.config.dropdownElement.contains(e.target)) {
-                    var scrollableElement = _this.findScrollableParent(e.target, _this.config.dropdownElement);
+                if (this.config.dropdownElement && this.config.dropdownElement.contains(e.target)) {
+                    const scrollableElement = this.findScrollableParent(e.target, this.config.dropdownElement);
                     if (scrollableElement) {
                         // 터치 스크롤은 브라우저가 자동으로 처리하도록 허용
                         return;
@@ -404,9 +386,9 @@ var UnifiedBoxController = /** @class */ (function () {
                 // 드롭다운 외부의 터치 스크롤 방지
                 e.preventDefault();
             },
-            keydown: function (e) {
+            keydown: (e) => {
                 // 페이지 스크롤 키만 막기 (화살표 키는 드롭다운 네비게이션에서 처리)
-                var keys = ['PageUp', 'PageDown', 'Home', 'End', 'Space'];
+                const keys = ['PageUp', 'PageDown', 'Home', 'End', 'Space'];
                 if (keys.includes(e.key) || e.key === ' ') {
                     e.preventDefault();
                 }
@@ -415,17 +397,17 @@ var UnifiedBoxController = /** @class */ (function () {
         document.addEventListener('wheel', this.scrollLockHandlers.wheel, { passive: false });
         document.addEventListener('touchmove', this.scrollLockHandlers.touchmove, { passive: false });
         document.addEventListener('keydown', this.scrollLockHandlers.keydown);
-    };
+    }
     /**
      * 스크롤 가능한 부모 요소 찾기
      */
-    UnifiedBoxController.prototype.findScrollableParent = function (element, boundary) {
-        var current = element;
+    findScrollableParent(element, boundary) {
+        let current = element;
         while (current && current !== boundary && boundary.contains(current)) {
-            var computedStyle = window.getComputedStyle(current);
-            var overflowY = computedStyle.overflowY;
+            const computedStyle = window.getComputedStyle(current);
+            const overflowY = computedStyle.overflowY;
             if (overflowY === 'auto' || overflowY === 'scroll') {
-                var scrollHeight = current.scrollHeight, clientHeight = current.clientHeight;
+                const { scrollHeight, clientHeight } = current;
                 if (scrollHeight > clientHeight) {
                     return current;
                 }
@@ -433,56 +415,55 @@ var UnifiedBoxController = /** @class */ (function () {
             current = current.parentElement;
         }
         return null;
-    };
+    }
     /**
      * 스크롤 잠금 해제
      */
-    UnifiedBoxController.prototype.disableScrollLock = function () {
+    disableScrollLock() {
         if (this.scrollLockHandlers) {
             document.removeEventListener('wheel', this.scrollLockHandlers.wheel);
             document.removeEventListener('touchmove', this.scrollLockHandlers.touchmove);
             document.removeEventListener('keydown', this.scrollLockHandlers.keydown);
             this.scrollLockHandlers = null;
         }
-    };
+    }
     /**
      * 마우스 호버 처리 (외부에서 호출용)
      */
-    UnifiedBoxController.prototype.handleMouseHover = function (index) {
+    handleMouseHover(index) {
         if (!this.isKeyboardNavigation) {
             this.config.model.setFocusedIndex(index);
         }
-    };
+    }
     /**
      * 옵션 배열 업데이트
      */
-    UnifiedBoxController.prototype.updateOptions = function (options) {
-        var _this = this;
+    updateOptions(options) {
         this.config.model.updateOptions(options);
         // 스크롤 리스너는 이미 등록되어 있으므로 제거/재등록 불필요
         // DOM이 완전히 교체되는 경우에만 재등록 필요 (현재는 updateContainerChildren에서 요소 재사용)
         // 옵션 업데이트 후 스크롤 감지가 필요한 경우에만 확인
         if (this.isOpen && this.config.onScrollBottom && !this.scrollBottomHandler) {
             // 스크롤 리스너가 없을 때만 등록 (드롭다운이 열려있고 리스너가 없는 경우)
-            requestAnimationFrame(function () {
-                _this.enableScrollBottomDetection();
+            requestAnimationFrame(() => {
+                this.enableScrollBottomDetection();
             });
         }
-    };
-    UnifiedBoxController.prototype.getIsOpen = function () {
+    }
+    getIsOpen() {
         return this.config.model.getState().isOpen;
-    };
-    UnifiedBoxController.prototype.setFocus = function (index) {
+    }
+    setFocus(index) {
         this.config.model.setFocusedIndex(index);
-    };
-    UnifiedBoxController.prototype.getFocusedIndex = function () {
+    }
+    getFocusedIndex() {
         return this.config.model.getState().focusedIndex;
-    };
+    }
     /**
      * 드롭다운 위치 조정 (화면 크기에 따라 up/down 방향 결정)
      * 단일 선택 모드에서만 적용
      */
-    UnifiedBoxController.prototype.adjustDropdownPosition = function () {
+    adjustDropdownPosition() {
         if (!this.config.dropdownElement || !this.config.triggerElement)
             return;
         // ComboBox 또는 multiple 모드에서는 위치 조정 비활성화
@@ -490,138 +471,134 @@ var UnifiedBoxController = /** @class */ (function () {
             return;
         }
         // 일시적으로 드롭다운을 보이게 해서 크기 측정
-        var dropdown = this.config.dropdownElement;
-        var originalDisplay = dropdown.style.display;
-        var originalVisibility = dropdown.style.visibility;
+        const dropdown = this.config.dropdownElement;
+        const originalDisplay = dropdown.style.display;
+        const originalVisibility = dropdown.style.visibility;
         dropdown.style.display = 'block';
         dropdown.style.visibility = 'hidden';
-        var result = this.calculateDropdownPosition();
+        const result = this.calculateDropdownPosition();
         // 방향에 따른 클래스 설정
         dropdown.classList.remove('ncua-select-dropdown--up', 'ncua-select-dropdown--down');
-        dropdown.classList.add("ncua-select-dropdown--".concat(result.direction));
+        dropdown.classList.add(`ncua-select-dropdown--${result.direction}`);
         // 미세 위치 조정
         this.adjustDropdownPositionDetails(dropdown);
         // 원래 상태로 복원
         dropdown.style.display = originalDisplay;
         dropdown.style.visibility = originalVisibility;
-    };
+    }
     /**
      * 드롭다운 위치 계산 (React dropdownUtils.ts 로직 참고)
      */
-    UnifiedBoxController.prototype.calculateDropdownPosition = function () {
+    calculateDropdownPosition() {
         if (!this.config.triggerElement || !this.config.dropdownElement) {
             return { direction: 'down', maxHeight: this.config.renderConfig.maxHeight };
         }
-        var triggerRect = this.config.triggerElement.getBoundingClientRect();
-        var viewportHeight = window.innerHeight;
-        var dropdownHeight = Math.min(this.config.renderConfig.maxHeight, this.estimateDropdownHeight());
-        var offset = 20; // 여유 공간
+        const triggerRect = this.config.triggerElement.getBoundingClientRect();
+        const viewportHeight = window.innerHeight;
+        const dropdownHeight = Math.min(this.config.renderConfig.maxHeight, this.estimateDropdownHeight());
+        const offset = 20; // 여유 공간
         // 아래쪽 공간이 충분한지 확인
-        var spaceBelow = viewportHeight - triggerRect.bottom;
+        const spaceBelow = viewportHeight - triggerRect.bottom;
         if (spaceBelow < dropdownHeight + offset) {
             return { direction: 'up', maxHeight: this.config.renderConfig.maxHeight };
         }
         else {
             return { direction: 'down', maxHeight: this.config.renderConfig.maxHeight };
         }
-    };
+    }
     /**
      * 드롭다운 예상 높이 계산
      */
-    UnifiedBoxController.prototype.estimateDropdownHeight = function () {
-        var itemHeight = 40; // 대략적인 옵션 항목 높이
-        var itemCount = this.config.model.getState().filteredOptions.length || this.config.model.getState().options.length;
+    estimateDropdownHeight() {
+        const itemHeight = 40; // 대략적인 옵션 항목 높이
+        const itemCount = this.config.model.getState().filteredOptions.length || this.config.model.getState().options.length;
         return Math.min(itemCount * itemHeight, this.config.renderConfig.maxHeight);
-    };
+    }
     /**
      * 드롭다운 세부 위치 조정 (뷰포트 경계 처리)
      */
-    UnifiedBoxController.prototype.adjustDropdownPositionDetails = function (dropdownElement) {
-        var dropdownRect = dropdownElement.getBoundingClientRect();
-        var viewportWidth = window.innerWidth;
-        var viewportHeight = window.innerHeight;
+    adjustDropdownPositionDetails(dropdownElement) {
+        const dropdownRect = dropdownElement.getBoundingClientRect();
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
         // 좌우 위치 조정
         if (dropdownRect.right > viewportWidth) {
-            var overflow = dropdownRect.right - viewportWidth;
-            var currentLeft = parseInt(dropdownElement.style.left || '0');
-            dropdownElement.style.left = "".concat(currentLeft - overflow - 10, "px");
+            const overflow = dropdownRect.right - viewportWidth;
+            const currentLeft = parseInt(dropdownElement.style.left || '0');
+            dropdownElement.style.left = `${currentLeft - overflow - 10}px`;
         }
         if (dropdownRect.left < 0) {
             dropdownElement.style.left = '10px';
         }
         // 상하 위치 조정 (이미 up/down 방향이 결정된 후 미세 조정)
         if (dropdownRect.bottom > viewportHeight) {
-            var overflow = dropdownRect.bottom - viewportHeight;
-            var currentMaxHeight = parseInt(dropdownElement.style.maxHeight || String(this.config.renderConfig.maxHeight));
-            dropdownElement.style.maxHeight = "".concat(currentMaxHeight - overflow - 10, "px");
+            const overflow = dropdownRect.bottom - viewportHeight;
+            const currentMaxHeight = parseInt(dropdownElement.style.maxHeight || String(this.config.renderConfig.maxHeight));
+            dropdownElement.style.maxHeight = `${currentMaxHeight - overflow - 10}px`;
         }
-    };
+    }
     /**
      * 스크롤 바닥 감지 활성화
      */
-    UnifiedBoxController.prototype.enableScrollBottomDetection = function () {
-        var _this = this;
+    enableScrollBottomDetection() {
         if (!this.config.onScrollBottom)
             return;
         // 이미 리스너가 등록되어 있으면 중복 등록 방지
         if (this.scrollBottomHandler)
             return;
-        var optionsList = this.config.dropdownElement.querySelector('.ncua-select-dropdown__options');
+        const optionsList = this.config.dropdownElement.querySelector('.ncua-select-dropdown__options');
         if (!optionsList)
             return;
-        this.scrollBottomHandler = function (e) {
-            var _a, _b;
-            var target = e.target;
-            var scrollTop = target.scrollTop;
-            var scrollHeight = target.scrollHeight;
-            var clientHeight = target.clientHeight;
+        this.scrollBottomHandler = (e) => {
+            const target = e.target;
+            const scrollTop = target.scrollTop;
+            const scrollHeight = target.scrollHeight;
+            const clientHeight = target.clientHeight;
             // 바닥에서 10px 이내에 도달했을 때
-            var threshold = 10;
-            var isAtBottom = scrollTop + clientHeight >= scrollHeight - threshold;
+            const threshold = 10;
+            const isAtBottom = scrollTop + clientHeight >= scrollHeight - threshold;
             if (isAtBottom) {
-                var now = Date.now();
+                const now = Date.now();
                 // 500ms 디바운스 (중복 호출 방지)
-                if (now - _this.lastScrollBottomTime > 100) {
-                    _this.lastScrollBottomTime = now;
-                    (_b = (_a = _this.config).onScrollBottom) === null || _b === void 0 ? void 0 : _b.call(_a);
+                if (now - this.lastScrollBottomTime > 100) {
+                    this.lastScrollBottomTime = now;
+                    this.config.onScrollBottom?.();
                 }
             }
         };
         optionsList.addEventListener('scroll', this.scrollBottomHandler);
-    };
+    }
     /**
      * 스크롤 바닥 감지 비활성화
      */
-    UnifiedBoxController.prototype.disableScrollBottomDetection = function () {
+    disableScrollBottomDetection() {
         if (this.scrollBottomHandler) {
-            var optionsList = this.config.dropdownElement.querySelector('.ncua-select-dropdown__options');
+            const optionsList = this.config.dropdownElement.querySelector('.ncua-select-dropdown__options');
             if (optionsList) {
                 optionsList.removeEventListener('scroll', this.scrollBottomHandler);
             }
             this.scrollBottomHandler = undefined;
         }
-    };
+    }
     /**
      * disabled 상태 설정
      */
-    UnifiedBoxController.prototype.setDisabled = function (disabled) {
+    setDisabled(disabled) {
         this.config.disabled = disabled;
         // disabled로 설정될 때 드롭다운이 열려있으면 닫기
         if (disabled && this.isOpen) {
             this.close();
         }
-    };
+    }
     /**
      * 정리
      */
-    UnifiedBoxController.prototype.destroy = function () {
+    destroy() {
         this.config.model.removeListener(this);
         this.disableOutsideClick();
         this.disableScrollLock();
         this.removeOptionEventHandlers();
         this.disableScrollBottomDetection(); // 스크롤 감지 정리
         this.config.triggerElement.removeEventListener('keydown', this.keyDownHandler);
-    };
-    return UnifiedBoxController;
-}());
-export { UnifiedBoxController };
+    }
+}