@ncds/ui-admin 1.6.4-alpha.1 → 1.7.0

package/dist/temp/assets/scripts/tooltip/const/types.d.ts

@@ -0,0 +1,14 @@
+export interface TooltipOptions {
+    tooltipType?: 'white' | 'black';
+    iconType?: 'stroke' | 'fill';
+    position?: 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'auto';
+    size?: 'sm' | 'md';
+    hideArrow?: boolean;
+    title?: string;
+    content?: string;
+    type?: 'long' | 'short';
+    zIndex?: number;
+    useShadowDOM?: boolean;
+    className?: string;
+}
+export type CalculatedPosition = 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';

package/dist/temp/assets/scripts/tooltip/const/types.js

@@ -0,0 +1 @@
+export {};

package/dist/temp/assets/scripts/tooltip/index.d.ts

@@ -0,0 +1,6 @@
+import { Tooltip } from './Tooltip';
+export { Tooltip } from './Tooltip';
+export type { TooltipOptions, CalculatedPosition } from './const';
+export { calculateOptimalPosition } from './utils';
+export { SVG_ICONS, MARGIN, DEFAULT_TOOLTIP_WIDTH, DEFAULT_TOOLTIP_HEIGHT, POSITION_PRIORITY } from './const';
+export default Tooltip;

package/dist/temp/assets/scripts/tooltip/index.js

@@ -0,0 +1,10 @@
+import { Tooltip } from './Tooltip';
+export { Tooltip } from './Tooltip';
+export { calculateOptimalPosition } from './utils';
+export { SVG_ICONS, MARGIN, DEFAULT_TOOLTIP_WIDTH, DEFAULT_TOOLTIP_HEIGHT, POSITION_PRIORITY } from './const';
+// 전역 등록 ( 추후 index.ts와 개별동작 할 수 있게끔 대비 )
+if (typeof window !== 'undefined') {
+    window.ncua = window.ncua || {};
+    window.ncua.Tooltip = Tooltip;
+}
+export default Tooltip;

package/dist/temp/assets/scripts/tooltip/utils.d.ts

@@ -0,0 +1,2 @@
+import { CalculatedPosition } from './const';
+export declare function calculateOptimalPosition(triggerElement: HTMLElement, tooltipElement: HTMLElement, preferredPosition?: string): CalculatedPosition;

package/dist/temp/assets/scripts/tooltip/utils.js

@@ -0,0 +1,35 @@
+import { MARGIN, DEFAULT_TOOLTIP_WIDTH, DEFAULT_TOOLTIP_HEIGHT, POSITION_PRIORITY } from './const';
+export function calculateOptimalPosition(triggerElement, tooltipElement, preferredPosition) {
+    if (preferredPosition === void 0) { preferredPosition = 'bottom'; }
+    var triggerRect = triggerElement.getBoundingClientRect();
+    var tooltipRect = tooltipElement.getBoundingClientRect();
+    var viewportWidth = window.innerWidth, viewportHeight = window.innerHeight;
+    var spaces = {
+        top: triggerRect.top,
+        bottom: viewportHeight - triggerRect.bottom,
+        left: triggerRect.left,
+        right: viewportWidth - triggerRect.right,
+    };
+    var tooltipWidth = tooltipRect.width || DEFAULT_TOOLTIP_WIDTH;
+    var tooltipHeight = tooltipRect.height || DEFAULT_TOOLTIP_HEIGHT;
+    for (var _i = 0, POSITION_PRIORITY_1 = POSITION_PRIORITY; _i < POSITION_PRIORITY_1.length; _i++) {
+        var position = POSITION_PRIORITY_1[_i];
+        var hasSpace = position === 'bottom' || position === 'top'
+            ? spaces[position] >= tooltipHeight + MARGIN
+            : spaces[position] >= tooltipWidth + MARGIN;
+        if (hasSpace) {
+            if (position === 'bottom' || position === 'top') {
+                var centerX = triggerRect.left + triggerRect.width / 2;
+                var tooltipHalfWidth = tooltipWidth / 2;
+                if (centerX - tooltipHalfWidth < MARGIN) {
+                    return "".concat(position, "-left");
+                }
+                else if (centerX + tooltipHalfWidth > viewportWidth - MARGIN) {
+                    return "".concat(position, "-right");
+                }
+            }
+            return position;
+        }
+    }
+    return preferredPosition;
+}

package/dist/temp/assets/scripts/utils/debounce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 디바운스 유틸리티
+ * 마지막 호출 후 지정된 시간이 지나야 콜백이 실행됨
+ */
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+};

package/dist/temp/assets/scripts/utils/debounce.js

@@ -0,0 +1,27 @@
+/**
+ * 디바운스 유틸리티
+ * 마지막 호출 후 지정된 시간이 지나야 콜백이 실행됨
+ */
+export function debounce(fn, ms) {
+    var timer;
+    var debounced = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        timer = window.setTimeout(function () {
+            timer = undefined;
+            fn.apply(void 0, args);
+        }, ms);
+    };
+    debounced.cancel = function () {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    };
+    return debounced;
+}

package/dist/temp/assets/scripts/utils/unifiedBox/domRenderer.d.ts

@@ -0,0 +1,107 @@
+export interface RenderableOption {
+    id: string | number;
+    label: string;
+    disabled?: boolean;
+    selected?: boolean;
+    focused?: boolean;
+}
+export interface DropdownRenderConfig {
+    maxHeight: number;
+    size: 'xs' | 'sm' | 'md';
+    listboxId: string;
+    noResultsText?: string;
+}
+export interface OptionElementData {
+    element: HTMLLIElement;
+    option: RenderableOption;
+    index: number;
+}
+export declare class DOMRenderer {
+    private optionElementCache;
+    /**
+     * 드롭다운 컨테이너 생성 (구조만)
+     */
+    createDropdownStructure(config: DropdownRenderConfig): {
+        dropdown: HTMLDivElement;
+        content: HTMLDivElement;
+        optionsList: HTMLUListElement;
+    };
+    /**
+     * 단일 옵션 엘리먼트 생성 (재사용 가능)
+     */
+    createOptionElement(option: RenderableOption, index: number, config: DropdownRenderConfig): HTMLLIElement;
+    /**
+     * 옵션 엘리먼트 상태 업데이트 (DOM 조작 최소화)
+     */
+    updateOptionElement(element: HTMLLIElement, option: RenderableOption, index: number, config: DropdownRenderConfig): void;
+    /**
+     * "결과 없음" 엘리먼트 생성
+     */
+    createNoResultsElement(text?: string): HTMLLIElement;
+    /**
+     * 옵션 리스트 효율적 업데이트 (Differential Rendering)
+     */
+    updateOptionsList(container: HTMLUListElement, newOptions: RenderableOption[], config: DropdownRenderConfig, showNoResults?: boolean): HTMLLIElement[];
+    /**
+     * 컨테이너 자식 엘리먼트 효율적 업데이트
+     */
+    private updateContainerChildren;
+    /**
+     * 클래스 토글 (변경이 필요한 경우에만)
+     */
+    private toggleClass;
+    /**
+     * 입력 필드 생성 (InputFieldUtils에서 이동)
+     */
+    createInputField(config: {
+        placeholder?: string;
+        disabled?: boolean;
+        size?: 'xs' | 'sm' | 'md';
+        showSearchIcon?: boolean;
+        onInput?: (value: string) => void;
+        onClick?: () => void;
+        onShowAll?: () => void;
+        onClear?: () => void;
+    }): {
+        container: HTMLElement;
+        input: HTMLInputElement;
+        setValue: (value: string) => void;
+        focus: () => void;
+        blur: () => void;
+    };
+    /**
+     * 캐시 정리
+     */
+    clearCache(): void;
+    /**
+     * 특정 옵션 캐시 제거
+     */
+    removeCachedOption(optionId: string | number): void;
+    /**
+     * 공통 DOM 생성 유틸리티
+     */
+    static createElementWithClass(tagName: string, className: string, textContent?: string): HTMLElement;
+    /**
+     * 버튼 엘리먼트 생성
+     */
+    static createButton(className: string, textContent: string, onClick?: (e: Event) => void): HTMLButtonElement;
+    /**
+     * SVG 아이콘 생성
+     */
+    static createSvgIcon(iconName: string, size?: number): SVGElement;
+    /**
+     * 푸터 생성
+     */
+    createFooter(config: {
+        multiple?: boolean;
+        showFooterButtons?: boolean;
+        onSelectAll?: () => void;
+        onEdit?: () => void;
+        onComplete?: () => void;
+        selectAllButtonText?: string;
+    }): HTMLElement;
+    /**
+     * 전체 선택 버튼 텍스트 업데이트
+     */
+    updateSelectAllButtonText(footerElement: HTMLElement, text: string): void;
+}

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

@@ -0,0 +1,376 @@
+var DOMRenderer = /** @class */ (function () {
+    function DOMRenderer() {
+        this.optionElementCache = new Map();
+    }
+    /**
+     * 드롭다운 컨테이너 생성 (구조만)
+     */
+    DOMRenderer.prototype.createDropdownStructure = function (config) {
+        var dropdown = document.createElement('div');
+        dropdown.className = "ncua-select-dropdown ncua-select-dropdown--down ncua-select-dropdown--".concat(config.size);
+        dropdown.style.display = 'none';
+        var content = document.createElement('div');
+        content.className = 'ncua-select-dropdown__content';
+        var optionsList = document.createElement('ul');
+        optionsList.className = 'ncua-select-dropdown__options';
+        optionsList.setAttribute('role', 'listbox');
+        optionsList.setAttribute('id', config.listboxId);
+        optionsList.style.maxHeight = "".concat(config.maxHeight, "px");
+        optionsList.style.overflowY = 'auto'; // 스크롤 활성화
+        content.appendChild(optionsList);
+        dropdown.appendChild(content);
+        return { dropdown: dropdown, content: content, optionsList: optionsList };
+    };
+    /**
+     * 단일 옵션 엘리먼트 생성 (재사용 가능)
+     */
+    DOMRenderer.prototype.createOptionElement = function (option, index, config) {
+        var cached = this.optionElementCache.get(option.id);
+        if (cached) {
+            this.updateOptionElement(cached, option, index, config);
+            return cached;
+        }
+        var element = document.createElement('li');
+        element.className = 'ncua-select-dropdown__option';
+        element.setAttribute('data-value', String(option.id));
+        element.setAttribute('data-index', String(index));
+        element.setAttribute('role', 'option');
+        element.id = "".concat(config.listboxId, "-").concat(option.id);
+        var span = document.createElement('span');
+        span.className = 'ncua-select-dropdown__option-text';
+        span.textContent = option.label;
+        element.appendChild(span);
+        this.updateOptionElement(element, option, index, config);
+        this.optionElementCache.set(option.id, element);
+        return element;
+    };
+    /**
+     * 옵션 엘리먼트 상태 업데이트 (DOM 조작 최소화)
+     */
+    DOMRenderer.prototype.updateOptionElement = function (element, option, index, config) {
+        // 클래스 업데이트 (필요한 경우에만)
+        var shouldHaveSelected = option.selected || false;
+        var shouldHaveFocused = option.focused || false;
+        var shouldHaveDisabled = option.disabled || false;
+        this.toggleClass(element, 'ncua-select-dropdown__option--selected', shouldHaveSelected);
+        this.toggleClass(element, 'ncua-select-dropdown__option--focused', shouldHaveFocused);
+        this.toggleClass(element, 'ncua-select-dropdown__option--disabled', shouldHaveDisabled);
+        // 속성 업데이트 (필요한 경우에만)
+        element.setAttribute('aria-selected', String(shouldHaveSelected));
+        element.setAttribute('data-index', String(index));
+    };
+    /**
+     * "결과 없음" 엘리먼트 생성
+     */
+    DOMRenderer.prototype.createNoResultsElement = function (text) {
+        if (text === void 0) { text = '일치하는 결과가 없습니다.'; }
+        var noResults = document.createElement('li');
+        noResults.className = 'ncua-select-dropdown__no-results';
+        noResults.textContent = text;
+        return noResults;
+    };
+    /**
+     * 옵션 리스트 효율적 업데이트 (Differential Rendering)
+     */
+    DOMRenderer.prototype.updateOptionsList = function (container, newOptions, config, showNoResults) {
+        var _this = this;
+        if (showNoResults === void 0) { showNoResults = false; }
+        // 스크롤 위치 저장
+        var scrollTop = container.scrollTop;
+        // 결과 없음 처리
+        if (showNoResults) {
+            container.innerHTML = '';
+            container.appendChild(this.createNoResultsElement(config.noResultsText));
+            return [];
+        }
+        var newElements = [];
+        // 새 옵션들로 엘리먼트 생성/업데이트
+        newOptions.forEach(function (option, index) {
+            var element = _this.createOptionElement(option, index, config);
+            newElements.push(element);
+        });
+        // DOM 업데이트 최소화 - 변경된 부분만 업데이트
+        this.updateContainerChildren(container, newElements);
+        // 스크롤 위치 복원 (다음 프레임에서 실행)
+        requestAnimationFrame(function () {
+            container.scrollTop = scrollTop;
+        });
+        return newElements;
+    };
+    /**
+     * 컨테이너 자식 엘리먼트 효율적 업데이트
+     */
+    DOMRenderer.prototype.updateContainerChildren = function (container, newChildren) {
+        // 기존 엘리먼트 제거 (새 리스트에 없는 것들)
+        Array.from(container.children).forEach(function (child) {
+            if (!newChildren.includes(child)) {
+                child.remove();
+            }
+        });
+        // 새 엘리먼트 추가 (순서 유지)
+        newChildren.forEach(function (child, index) {
+            var currentChild = container.children[index];
+            if (currentChild !== child) {
+                if (currentChild) {
+                    container.insertBefore(child, currentChild);
+                }
+                else {
+                    container.appendChild(child);
+                }
+            }
+        });
+    };
+    /**
+     * 클래스 토글 (변경이 필요한 경우에만)
+     */
+    DOMRenderer.prototype.toggleClass = function (element, className, shouldHave) {
+        var hasClass = element.classList.contains(className);
+        if (shouldHave && !hasClass) {
+            element.classList.add(className);
+        }
+        else if (!shouldHave && hasClass) {
+            element.classList.remove(className);
+        }
+    };
+    /**
+     * 입력 필드 생성 (InputFieldUtils에서 이동)
+     */
+    DOMRenderer.prototype.createInputField = function (config) {
+        var actualSize = config.size === 'md' ? 'sm' : config.size || 'sm';
+        // 최상위 ncua-input 컨테이너 (React 버전과 동일)
+        var inputContainer = document.createElement('div');
+        inputContainer.className = "ncua-input ncua-input--".concat(actualSize);
+        if (config.disabled)
+            inputContainer.classList.add('is-disabled');
+        // ncua-input__content 래퍼 (React 버전과 동일)
+        var inputContent = document.createElement('div');
+        inputContent.className = 'ncua-input__content';
+        // ncua-input__field 래퍼 (React 버전과 동일, size 포함)
+        var inputField = document.createElement('div');
+        inputField.className = "ncua-input__field ncua-input__field--".concat(actualSize);
+        // 실제 입력 필드 (React 버전과 동일)
+        var input = document.createElement('input');
+        input.type = 'text';
+        input.placeholder = config.placeholder || '';
+        if (config.disabled)
+            input.disabled = true;
+        // 이벤트 리스너
+        if (config.onInput) {
+            input.addEventListener('input', function (e) {
+                config.onInput(e.target.value);
+            });
+        }
+        if (config.onClick) {
+            input.addEventListener('click', function (event) {
+                event.stopPropagation(); // 이벤트 버블링 방지
+                config.onClick();
+            });
+        }
+        // 클리어 버튼 (React 버전의 renderClearButton과 동일)
+        var clearButton = null;
+        if (config.onClear) {
+            clearButton = document.createElement('button');
+            clearButton.type = 'button';
+            clearButton.className = 'ncua-input__icon-wrap ncua-input__right-icon ncua-input__clear';
+            clearButton.style.display = 'none'; // 초기에는 숨김
+            clearButton.addEventListener('click', config.onClear);
+            // 클리어 아이콘 (React와 동일한 크기)
+            var iconSize = actualSize === 'xs' ? 14 : 16;
+            var clearIcon = DOMRenderer.createSvgIcon('close', iconSize);
+            clearIcon.setAttribute('class', 'ncua-input__clear-icon');
+            clearButton.appendChild(clearIcon);
+            // 입력값 변경 시 클리어 버튼 표시/숨김
+            input.addEventListener('input', function () {
+                if (clearButton) {
+                    clearButton.style.display = input.value ? 'flex' : 'none';
+                }
+            });
+        }
+        // 전체 보기 버튼 (React 버전의 trailingElement와 동일)
+        var showAllButton = null;
+        if (config.onShowAll) {
+            showAllButton = document.createElement('div');
+            showAllButton.className = 'ncua-input__icon-wrap ncua-input__right-icon';
+            showAllButton.addEventListener('click', config.onShowAll);
+            // 전체 버튼 (React Button 컴포넌트와 유사한 구조)
+            var button = document.createElement('button');
+            button.type = 'button';
+            button.className = 'ncua-btn ncua-btn--xxs ncua-btn--text';
+            // 아이콘
+            var iconSize = 14;
+            var showAllIcon = DOMRenderer.createSvgIcon('chevron-selector-vertical', iconSize);
+            button.appendChild(showAllIcon);
+            // 텍스트
+            var label = document.createElement('span');
+            label.className = 'ncua-btn__label';
+            label.textContent = '전체';
+            button.appendChild(label);
+            showAllButton.appendChild(button);
+        }
+        // 검색 아이콘 (React 버전의 leadingElement와 동일)
+        var searchIcon = null;
+        if (config.showSearchIcon) {
+            searchIcon = document.createElement('div');
+            searchIcon.className = 'ncua-input__icon-wrap ncua-input__left-icon';
+            // 검색 아이콘 (React와 동일한 크기와 색상)
+            var searchSvg = DOMRenderer.createSvgIcon('search', 14);
+            searchSvg.style.color = '#98a2b3'; // gray300에 해당하는 색상
+            searchIcon.appendChild(searchSvg);
+        }
+        // 구조 조립 (React 버전과 동일한 순서)
+        if (searchIcon)
+            inputField.appendChild(searchIcon);
+        inputField.appendChild(input);
+        if (clearButton)
+            inputField.appendChild(clearButton);
+        if (showAllButton)
+            inputField.appendChild(showAllButton);
+        inputContent.appendChild(inputField);
+        inputContainer.appendChild(inputContent);
+        return {
+            container: inputContainer,
+            input: input,
+            setValue: function (value) {
+                input.value = value;
+                // 클리어 버튼 표시 상태 업데이트
+                if (clearButton) {
+                    clearButton.style.display = value ? 'flex' : 'none';
+                }
+            },
+            focus: function () { return input.focus(); },
+            blur: function () { return input.blur(); },
+        };
+    };
+    /**
+     * 캐시 정리
+     */
+    DOMRenderer.prototype.clearCache = function () {
+        this.optionElementCache.clear();
+    };
+    /**
+     * 특정 옵션 캐시 제거
+     */
+    DOMRenderer.prototype.removeCachedOption = function (optionId) {
+        this.optionElementCache.delete(optionId);
+    };
+    /**
+     * 공통 DOM 생성 유틸리티
+     */
+    DOMRenderer.createElementWithClass = function (tagName, className, textContent) {
+        var element = document.createElement(tagName);
+        element.className = className;
+        if (textContent) {
+            element.textContent = textContent;
+        }
+        return element;
+    };
+    /**
+     * 버튼 엘리먼트 생성
+     */
+    DOMRenderer.createButton = function (className, textContent, onClick) {
+        var button = document.createElement('button');
+        button.className = className;
+        // React 컴포넌트와 일치하도록 span.ncua-btn__label 구조 사용
+        var label = document.createElement('span');
+        label.className = 'ncua-btn__label';
+        label.textContent = textContent;
+        button.appendChild(label);
+        if (onClick) {
+            button.addEventListener('click', onClick);
+        }
+        return button;
+    };
+    /**
+     * SVG 아이콘 생성
+     */
+    DOMRenderer.createSvgIcon = function (iconName, size) {
+        if (size === void 0) { size = 16; }
+        var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+        svg.setAttribute('width', size.toString());
+        svg.setAttribute('height', size.toString());
+        svg.setAttribute('viewBox', '0 0 24 24');
+        svg.setAttribute('fill', 'none');
+        // 기본 아이콘들
+        switch (iconName) {
+            case 'close':
+                svg.innerHTML =
+                    '<path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M17 7 7 17M7 7l10 10"/>';
+                break;
+            case 'chevron-down':
+                svg.innerHTML =
+                    '<path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/>';
+                break;
+            case 'chevron-selector-vertical':
+                svg.innerHTML =
+                    '<path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="m7 15 5 5 5-5M7 9l5-5 5 5"/>';
+                break;
+            case 'search':
+                svg.innerHTML =
+                    '<path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="m21 21-3.5-3.5m2.5-6a8.5 8.5 0 1 1-17 0 8.5 8.5 0 0 1 17 0"></path>';
+                break;
+        }
+        return svg;
+    };
+    /**
+     * 푸터 생성
+     */
+    DOMRenderer.prototype.createFooter = function (config) {
+        // 푸터 생성
+        var footer = document.createElement('div');
+        footer.className = 'ncua-select-dropdown__footer';
+        var footerButtons = document.createElement('div');
+        footerButtons.className = 'ncua-select-dropdown__footer-buttons';
+        var footerLeft = document.createElement('div');
+        footerLeft.className = 'ncua-select-dropdown__footer-left';
+        var footerRight = document.createElement('div');
+        footerRight.className = 'ncua-select-dropdown__footer-right';
+        // 다중 선택인 경우 전체 선택 버튼 추가
+        if (config.multiple) {
+            var selectAllButton = DOMRenderer.createButton('ncua-btn ncua-btn--xs ncua-btn--text has-underline', config.selectAllButtonText || '전체 선택', function (e) {
+                var _a;
+                e.preventDefault();
+                e.stopPropagation();
+                (_a = config.onSelectAll) === null || _a === void 0 ? void 0 : _a.call(config);
+            });
+            footerLeft.appendChild(selectAllButton);
+        }
+        // 편집 버튼 (showFooterButtons가 true이고 onEdit가 있는 경우)
+        if (config.showFooterButtons && config.onEdit) {
+            var editButton = DOMRenderer.createButton('ncua-btn ncua-btn--xs ncua-btn--secondary-gray', '편집', function (e) {
+                var _a;
+                e.preventDefault();
+                e.stopPropagation();
+                (_a = config.onEdit) === null || _a === void 0 ? void 0 : _a.call(config);
+            });
+            footerRight.appendChild(editButton);
+        }
+        // 선택 완료 버튼 (다중 선택이거나 showFooterButtons가 true인 경우)
+        if (config.multiple || config.showFooterButtons) {
+            var completeButton = DOMRenderer.createButton('ncua-btn ncua-btn--xs ncua-btn--secondary', '선택 완료', function (e) {
+                var _a;
+                e.preventDefault();
+                e.stopPropagation();
+                (_a = config.onComplete) === null || _a === void 0 ? void 0 : _a.call(config);
+            });
+            footerRight.appendChild(completeButton);
+        }
+        footerButtons.appendChild(footerLeft);
+        footerButtons.appendChild(footerRight);
+        footer.appendChild(footerButtons);
+        return footer;
+    };
+    /**
+     * 전체 선택 버튼 텍스트 업데이트
+     */
+    DOMRenderer.prototype.updateSelectAllButtonText = function (footerElement, text) {
+        var selectAllButton = footerElement.querySelector('.ncua-select-dropdown__footer-left .ncua-btn');
+        if (selectAllButton) {
+            var label = selectAllButton.querySelector('.ncua-btn__label');
+            if (label) {
+                label.textContent = text;
+            }
+        }
+    };
+    return DOMRenderer;
+}());
+export { DOMRenderer };