@cute-widgets/base 20.0.1

package/fesm2022/cute-widgets-base-select.mjs

@@ -0,0 +1,1208 @@
+import { LiveAnnouncer, removeAriaReferencedId, addAriaReferencedId, ActiveDescendantKeyManager } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { SelectionModel } from '@angular/cdk/collections';
+import { DOWN_ARROW, UP_ARROW, LEFT_ARROW, RIGHT_ARROW, ENTER, SPACE, hasModifierKey, A } from '@angular/cdk/keycodes';
+import { Overlay, CdkOverlayOrigin, CdkConnectedOverlay } from '@angular/cdk/overlay';
+import { ViewportRuler } from '@angular/cdk/scrolling';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, isDevMode, NgZone, EventEmitter, HostAttributeToken, booleanAttribute, numberAttribute, Output, Input, ViewChild, ContentChild, ContentChildren, ChangeDetectionStrategy, ViewEncapsulation, Component, Directive, NgModule } from '@angular/core';
+import { Validators, NgControl, NgForm, FormGroupDirective } from '@angular/forms';
+import { NgClass, CommonModule } from '@angular/common';
+import { Subject, defer, merge } from 'rxjs';
+import { startWith, switchMap, take, filter, map, distinctUntilChanged, takeUntil } from 'rxjs/operators';
+import { trigger, state, transition, style, animate, query, animateChild } from '@angular/animations';
+import { _countGroupLabelsBeforeOption, _getOptionScrollPosition, CuteOption, CUTE_OPTGROUP, CUTE_OPTION_PARENT_COMPONENT, CuteOptgroup } from '@cute-widgets/base/core/option';
+import { CUTE_FORM_FIELD, CuteFormFieldControl } from '@cute-widgets/base/form-field';
+import { ErrorStateMatcher, _ErrorStateTracker } from '@cute-widgets/base/core/error';
+import { CuteInputDropdownControl } from '@cute-widgets/base/abstract';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * The following are all the animations for the mat-select component, with each
+ * const containing the metadata for one animation.
+ *
+ * The values below match the implementation of the AngularJS Material mat-select animation.
+ * @docs-private
+ */
+const cuteSelectAnimations = {
+    /**
+     * This animation ensures the select's overlay panel animation (transformPanel) is called when
+     * closing the select.
+     * This is needed due to https://github.com/angular/angular/issues/23302
+     */
+    transformPanelWrap: trigger('transformPanelWrap', [
+        transition('* => void', query('@transformPanel', [animateChild()], { optional: true })),
+    ]),
+    /** This animation transforms the select's overlay panel on and off the page. */
+    transformPanel: trigger('transformPanel', [
+        state('void', style({
+            opacity: 0,
+            transform: 'scale(1, 0.8)',
+        })),
+        transition('void => showing', animate('120ms cubic-bezier(0, 0, 0.2, 1)', style({
+            opacity: 1,
+            transform: 'scale(1, 1)',
+        }))),
+        transition('* => void', animate('100ms linear', style({ opacity: 0 }))),
+    ]),
+};
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Returns an exception to be thrown when attempting to change a select's `multiple` option
+ * after initialization.
+ */
+function getCuteSelectDynamicMultipleError() {
+    return Error('Cannot change `multiple` mode of select after initialization.');
+}
+/**
+ * Returns an exception to be thrown when attempting to assign a non-array value to a select
+ * in `multiple` mode. Note that `undefined` and `null` are still valid values to allow for
+ * resetting the value.
+ */
+function getCuteSelectNonArrayValueError() {
+    return Error('Value must be an array in multiple-selection mode.');
+}
+/**
+ * Returns an exception to be thrown when assigning a non-function value to the comparator
+ * used to determine if a value corresponds to an option. Note that whether the function
+ * actually takes two values and returns a boolean is not checked.
+ */
+function getCuteSelectNonFunctionValueError() {
+    return Error('`compareWith` must be a function.');
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+let nextUniqueId = 0;
+/** Injection token that determines the scroll handling while a select is open. */
+const CUTE_SELECT_SCROLL_STRATEGY = new InjectionToken('cute-select-scroll-strategy', {
+    providedIn: 'root',
+    factory: () => {
+        const overlay = inject(Overlay);
+        return () => overlay.scrollStrategies.reposition();
+    },
+});
+/** @docs-private */
+function CUTE_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+    return () => overlay.scrollStrategies.reposition();
+}
+/** Injection token that can be used to provide the default options the select module. */
+const CUTE_SELECT_CONFIG = new InjectionToken('CUTE_SELECT_CONFIG');
+/** @docs-private */
+const CUTE_SELECT_SCROLL_STRATEGY_PROVIDER = {
+    provide: CUTE_SELECT_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: CUTE_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY,
+};
+/**
+ * Injection token that can be used to reference instances of `CuteSelectTrigger`. It serves as
+ * an alternative token to the actual `CuteSelectTrigger` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+const CUTE_SELECT_TRIGGER = new InjectionToken('CuteSelectTrigger');
+/** Change event object that is emitted when the select value has changed. */
+class CuteSelectChange {
+    constructor(
+    /** Reference to the select that emitted the change event. */
+    source, 
+    /** Current value of the select that emitted the event. */
+    value) {
+        this.source = source;
+        this.value = value;
+    }
+}
+class CuteSelect extends CuteInputDropdownControl {
+    /** Scrolls a particular option into the view. */
+    _scrollOptionIntoView(index) {
+        const option = this.options?.toArray()[index];
+        if (option && this.panel) {
+            const panel = this.panel.nativeElement;
+            const content = panel.children[0]; // we place options on one level down in the DOM
+            const labelCount = _countGroupLabelsBeforeOption(index, this.options, this.optionGroups);
+            const element = option._getHostElement();
+            if (index === 0 && labelCount === 1) {
+                // If we've got one group label before the option, and we're at the top option,
+                // scroll the list to the top. This is better UX than scrolling the list to the
+                // top of the option, because it allows the user to read the top group's label.
+                //panel.scrollTop = 0;
+                content.scrollTop = 0;
+            }
+            else {
+                /*
+                panel.scrollTop = _getOptionScrollPosition(
+                  element.offsetTop,
+                  element.offsetHeight,
+                  panel.scrollTop,
+                  panel.offsetHeight,
+                );
+                */
+                content.scrollTop = _getOptionScrollPosition(element.offsetTop, element.offsetHeight, content.scrollTop, content.offsetHeight);
+            }
+        }
+    }
+    /** Generates unique identifier */
+    generateId() {
+        return `cute-select-${nextUniqueId++}`;
+    }
+    /** Called when the panel has been opened and the overlay has settled on its final position. */
+    _positioningSettled() {
+        this._scrollOptionIntoView(this._keyManager?.activeItemIndex || 0);
+    }
+    /** Creates a change event object that should be emitted by the select. */
+    _getChangeEvent(value) {
+        return new CuteSelectChange(this, value);
+    }
+    get expanded() { return this.panelOpen; }
+    /** Whether the select is focused. */
+    get focused() {
+        return this._focused || this._panelOpen;
+    }
+    /** Implemented as part of CuteFormFieldControl. */
+    get controlElementRef() { return this._elementRef; }
+    /** Whether the checkmark indicator for single-selection options is hidden. */
+    get hideSingleSelectionIndicator() {
+        return this._hideSingleSelectionIndicator;
+    }
+    set hideSingleSelectionIndicator(value) {
+        this._hideSingleSelectionIndicator = value;
+        this._syncParentProperties();
+    }
+    /** Placeholder to be shown if no value has been selected. */
+    get placeholder() { return this._placeholder; }
+    set placeholder(value) {
+        this._placeholder = value;
+        this.stateChanges.next();
+    }
+    /** Whether the component is required. */
+    get required() {
+        return super.required ?? this.ngControl?.control?.hasValidator(Validators.required) ?? false;
+    }
+    set required(value) {
+        super.required = value;
+        this.stateChanges.next();
+    }
+    /** Whether the user should be allowed to select multiple options. */
+    get multiple() { return this._multiple; }
+    set multiple(value) {
+        if (this._selectionModel && isDevMode()) {
+            throw getCuteSelectDynamicMultipleError();
+        }
+        this._multiple = value;
+    }
+    /**
+     * Function to compare the option values with the selected values. The first argument
+     * is a value from an option. The second is a value from the selection. A boolean
+     * should be returned.
+     */
+    get compareWith() { return this._compareWith; }
+    set compareWith(fn) {
+        if (typeof fn !== 'function' && isDevMode()) {
+            throw getCuteSelectNonFunctionValueError();
+        }
+        this._compareWith = fn;
+        if (this._selectionModel) {
+            // A different comparator means the selection could change.
+            this._initializeSelection();
+        }
+    }
+    /** Value of the select control. */
+    get value() { return this._value; }
+    set value(newValue) {
+        const hasAssigned = this._assignValue(newValue);
+        if (hasAssigned) {
+            this._onChange(newValue);
+        }
+    }
+    /** Object used to control when error messages are shown. */
+    get errorStateMatcher() { return this._errorStateTracker.matcher; }
+    set errorStateMatcher(value) {
+        this._errorStateTracker.matcher = value;
+    }
+    /** Whether the select is in an error state. */
+    get errorState() { return this._errorStateTracker.errorState; }
+    set errorState(value) {
+        this._errorStateTracker.errorState = value;
+    }
+    constructor() {
+        super();
+        this._viewportRuler = inject(ViewportRuler);
+        this._ngZone = inject(NgZone);
+        this._dir = inject(Directionality, { optional: true });
+        this._parentFormField = inject(CUTE_FORM_FIELD, { optional: true });
+        this.ngControl = inject(NgControl, { self: true, optional: true });
+        this._liveAnnouncer = inject(LiveAnnouncer);
+        this._defaultOptions = inject(CUTE_SELECT_CONFIG, { optional: true });
+        /**
+         * This position config ensures that the top "start" corner of the overlay
+         * is aligned with the top "start" of the origin by default (overlapping
+         * the trigger completely). If the panel cannot fit below the trigger, it
+         * will fall back to a position above the trigger.
+         */
+        this._positions = [
+            {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+                offsetY: 4,
+            },
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+                offsetY: 4,
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+                offsetY: -4,
+                //panelClass: 'cute-select-panel-above',
+            },
+            {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom',
+                offsetY: -4,
+                //panelClass: 'cute-select-panel-above',
+            },
+        ];
+        /** Factory function used to create a scroll strategy for this select. */
+        this._scrollStrategyFactory = inject(CUTE_SELECT_SCROLL_STRATEGY);
+        /** Whether the overlay panel is open. */
+        this._panelOpen = false;
+        /** Comparison function to specify which option is displayed. Defaults to object equality. */
+        this._compareWith = (o1, o2) => o1 === o2;
+        /** Current `aria-labelledby` value for the select trigger. */
+        this._triggerAriaLabelledBy = null;
+        /** Emits whenever the component is destroyed. */
+        this._destroy = new Subject();
+        /** Emits when the panel element is finished transforming in. */
+        this._panelDoneAnimatingStream = new Subject();
+        /** Disable the automatic labeling to avoid issues like #27241. */
+        this.disableAutomaticLabeling = true;
+        this._overlayPanelClass = this._defaultOptions?.overlayPanelClass || '';
+        this._focused = false;
+        /** A name for this control that can be used by `cute-form-field`. */
+        this.controlType = 'cute-select';
+        /** Classes to be passed to the select panel. Supports the same syntax as `ngClass`. */
+        this.panelClass = "";
+        /** Whether ripples in the select are disabled. */
+        this.disableRipple = false;
+        this._hideSingleSelectionIndicator = this._defaultOptions?.hideSingleSelectionIndicator ?? false;
+        this._placeholder = "";
+        this._multiple = false;
+        /** Whether to center the active option over the trigger. */
+        this.disableOptionCentering = this._defaultOptions?.disableOptionCentering ?? false;
+        /** Time to wait in milliseconds after the last keystroke before moving focus to an item. */
+        this.typeaheadDebounceInterval = 0;
+        /**
+         * Width of the panel. If set to `auto`, the panel will match the trigger width.
+         * If set to null or an empty string, the panel will grow to match the longest option's text.
+         */
+        this.panelWidth = this._defaultOptions && typeof this._defaultOptions.panelWidth !== 'undefined'
+            ? this._defaultOptions.panelWidth
+            : 'auto';
+        /**
+         * Height of the panel. If set to `auto`, _null_ or an empty string, the panel will display all options.
+         * If height is not empty, its value is set as a maximum height of the panel with vertical scrolling set to `auto`.
+         */
+        this.panelHeight = this._defaultOptions && typeof this._defaultOptions.panelHeight !== 'undefined'
+            ? this._defaultOptions.panelHeight
+            : null;
+        /**
+         * By default, selecting an option with a `null` or `undefined` value will reset the select's
+         * value. Enable this option if the reset behavior doesn't match your requirements and instead,
+         * the nullable options should become selected. The value of this input can be controlled app-wide
+         * using the `MAT_SELECT_CONFIG` injection token.
+         */
+        this.canSelectNullableOptions = this._defaultOptions?.canSelectNullableOptions ?? false;
+        /** Combined stream of all of the child options' change events. */
+        this.optionSelectionChanges = defer(() => {
+            const options = this.options;
+            if (options) {
+                return options.changes.pipe(startWith(options), switchMap(() => merge(...options.map(option => option.onSelectionChange))));
+            }
+            return this._ngZone.onStable.pipe(take(1), switchMap(() => this.optionSelectionChanges));
+        });
+        /** Event emitted when the select panel has been toggled. */
+        this.openedChange = new EventEmitter();
+        /** Event emitted when the select has been opened. */
+        this._openedStream = this.openedChange.pipe(filter(o => o), map(() => { }));
+        /** Event emitted when the select has been closed. */
+        this._closedStream = this.openedChange.pipe(filter(o => !o), map(() => { }));
+        /** Event emitted when the selected value has been changed by the user. */
+        this.selectionChange = new EventEmitter();
+        /**
+         * Event that emits whenever the raw value of the select changes. This is here primarily
+         * to facilitate the two-way binding for the `value` input.
+         */
+        this.valueChange = new EventEmitter();
+        /**
+         * Track which modal we have modified the `aria-owns` attribute of. When the combobox trigger is
+         * inside an aria-modal, we apply aria-owns to the parent modal with the `id` of the options
+         * panel. Track the modal we have changed so we can undo the changes on destroy.
+         */
+        this._trackedModal = null;
+        // `skipPredicate` determines if key manager should avoid putting a given option in the tab
+        // order. Allow disabled list items to receive focus via keyboard to align with WAI ARIA
+        // recommendation.
+        //
+        // Normally WAI ARIA's instructions are to exclude disabled items from the tab order, but it
+        // makes a few exceptions for compound widgets.
+        //
+        // From [Developing a Keyboard Interface](
+        // https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/):
+        //   "For the following composite widget elements, keep them focusable when disabled: Options in a
+        //   Listbox..."
+        //
+        // The user can focus on disabled options using the keyboard, but the user cannot click disabled
+        // options.
+        this._skipPredicate = (option) => {
+            if (this.panelOpen) {
+                // Support keyboard focusing disabled options in an ARIA listbox.
+                return false;
+            }
+            // When the panel is closed, skip over disabled options. Support options via the UP/DOWN arrow
+            // keys on closed select. ARIA listbox interaction pattern is less relevant when the panel is
+            // closed.
+            return option.disabled;
+        };
+        const defaultErrorStateMatcher = inject(ErrorStateMatcher);
+        const parentForm = inject(NgForm, { optional: true });
+        const parentFormGroup = inject(FormGroupDirective, { optional: true });
+        const tabIndex = inject(new HostAttributeToken('tabindex'), { optional: true });
+        if (this.ngControl) {
+            // Note: we provide the value accessor through here, instead of
+            // the `providers` to avoid running into a circular import.
+            this.ngControl.valueAccessor = this;
+        }
+        // Note that we only want to set this when the defaults pass it in; otherwise it should
+        // stay as `undefined` so that it falls back to the default in the key manager.
+        if (this._defaultOptions?.typeaheadDebounceInterval != null) {
+            this.typeaheadDebounceInterval = this._defaultOptions.typeaheadDebounceInterval;
+        }
+        this._errorStateTracker = new _ErrorStateTracker(defaultErrorStateMatcher, this.ngControl, parentFormGroup, parentForm, this.stateChanges);
+        this._scrollStrategy = this._scrollStrategyFactory();
+        this.tabIndex = tabIndex == null ? 0 : parseInt(tabIndex) || 0;
+        // Force setter to be called in case id was not specified.
+        this.id = this.id;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this._selectionModel = new SelectionModel(this.multiple);
+        this.stateChanges.next();
+        // We need `distinctUntilChanged` here, because some browsers will
+        // fire the animation end event twice for the same animation. See:
+        // https://github.com/angular/angular/issues/24084
+        this._panelDoneAnimatingStream
+            .pipe(distinctUntilChanged(), takeUntil(this._destroy))
+            .subscribe(() => this._panelDoneAnimating(this.panelOpen));
+        this._viewportRuler
+            .change()
+            .pipe(takeUntil(this._destroy))
+            .subscribe(() => {
+            if (this.panelOpen) {
+                this._overlayWidth = this._getOverlayWidth(this._preferredOverlayOrigin);
+                this._changeDetectorRef.detectChanges();
+            }
+        });
+    }
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+        this._initKeyManager();
+        this._selectionModel?.changed.pipe(takeUntil(this._destroy)).subscribe(event => {
+            event.added.forEach(option => option.select());
+            event.removed.forEach(option => option.deselect());
+        });
+        this.options?.changes.pipe(startWith(null), takeUntil(this._destroy)).subscribe(() => {
+            this._resetOptions();
+            this._initializeSelection();
+        });
+    }
+    ngDoCheck() {
+        const newAriaLabelledby = this._getTriggerAriaLabelledby();
+        const ngControl = this.ngControl;
+        // We have to manage setting the `aria-labelledby` ourselves, because part of its value
+        // is computed as a result of a content query which can cause this binding to trigger a
+        // "changed after checked" error.
+        if (newAriaLabelledby !== this._triggerAriaLabelledBy) {
+            const element = this._elementRef.nativeElement;
+            this._triggerAriaLabelledBy = newAriaLabelledby;
+            if (newAriaLabelledby) {
+                element.setAttribute('aria-labelledby', newAriaLabelledby);
+            }
+            else {
+                element.removeAttribute('aria-labelledby');
+            }
+        }
+        if (ngControl) {
+            // The disabled state might go out of sync if the form group is swapped out. See #17860.
+            if (this._previousControl !== ngControl.control) {
+                if (this._previousControl !== undefined &&
+                    ngControl.disabled !== null &&
+                    ngControl.disabled !== this.disabled) {
+                    this.disabled = ngControl.disabled;
+                }
+                this._previousControl = ngControl.control;
+            }
+            this.updateErrorState();
+        }
+    }
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        // Updating the disabled state is handled by the input, but we need to additionally let
+        // the parent form field know to run change detection when the disabled state changes.
+        if (changes['disabled'] || changes['userAriaDescribedBy']) {
+            this.stateChanges.next();
+        }
+        if (changes['typeaheadDebounceInterval'] && this._keyManager) {
+            this._keyManager.withTypeAhead(this.typeaheadDebounceInterval);
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._keyManager?.destroy();
+        this._destroy.next();
+        this._destroy.complete();
+        this.stateChanges.complete();
+        this._clearFromModal();
+    }
+    /** Toggles the overlay panel open or closed. */
+    toggle() {
+        this.panelOpen ? this.close() : this.open();
+    }
+    /** Opens the overlay panel. */
+    open() {
+        // It's important that we read this as late as possible, because doing so earlier will
+        // return a different element since it's based on queries in the form field which may
+        // not have run yet. Also, this needs to be assigned before we measure the overlay width.
+        if (this._parentFormField) {
+            this._preferredOverlayOrigin = this._parentFormField.getConnectedOverlayOrigin();
+        }
+        this._overlayWidth = this._getOverlayWidth(this._preferredOverlayOrigin);
+        if (this._canOpen()) {
+            this._applyModalPanelOwnership();
+            this._panelOpen = true;
+            this._keyManager?.withHorizontalOrientation(null);
+            this._highlightCorrectOption();
+            this.markForCheck();
+        }
+        // Required for the MDC form field to pick up when the overlay has been opened.
+        this.stateChanges.next();
+    }
+    /**
+     * If the autocomplete trigger is inside of an `aria-modal` element, connect
+     * that modal to the options panel with `aria-owns`.
+     *
+     * For some browser + screen reader combinations, when navigation is inside
+     * of an `aria-modal` element, the screen reader treats everything outside
+     * of that modal as hidden or invisible.
+     *
+     * This causes a problem when the combobox trigger is _inside_ of a modal, because the
+     * options panel is rendered _outside_ of that modal, preventing screen reader navigation
+     * from reaching the panel.
+     *
+     * We can work around this issue by applying `aria-owns` to the modal with the `id` of
+     * the options panel. This effectively communicates to assistive technology that the
+     * options panel is part of the same interaction as the modal.
+     *
+     * At the time of this writing, this issue is present in VoiceOver.
+     * See https://github.com/angular/components/issues/20694
+     */
+    _applyModalPanelOwnership() {
+        // TODO(http://github.com/angular/components/issues/26853): consider de-duplicating this with
+        // the `LiveAnnouncer` and any other usages.
+        //
+        // Note that the selector here is limited to CDK overlays at the moment in order to reduce the
+        // section of the DOM we need to look through. This should cover all the cases we support, but
+        // the selector can be expanded if it turns out to be too narrow.
+        const modal = this._elementRef.nativeElement.closest('body > .cdk-overlay-container [aria-modal="true"]');
+        if (!modal) {
+            // Most commonly, the autocomplete trigger is not inside a modal.
+            return;
+        }
+        const panelId = `${this.id}-panel`;
+        if (this._trackedModal) {
+            removeAriaReferencedId(this._trackedModal, 'aria-owns', panelId);
+        }
+        addAriaReferencedId(modal, 'aria-owns', panelId);
+        this._trackedModal = modal;
+    }
+    /** Clears the reference to the listbox overlay element from the modal it was added to. */
+    _clearFromModal() {
+        if (!this._trackedModal) {
+            // Most commonly, the autocomplete trigger is not used inside a modal.
+            return;
+        }
+        const panelId = `${this.id}-panel`;
+        removeAriaReferencedId(this._trackedModal, 'aria-owns', panelId);
+        this._trackedModal = null;
+    }
+    /** Closes the overlay panel and focuses the host element. */
+    close() {
+        if (this._panelOpen) {
+            this._panelOpen = false;
+            this._keyManager?.withHorizontalOrientation(this._isRtl() ? 'rtl' : 'ltr');
+            this.markForCheck();
+            this._onTouched();
+        }
+        this.focus();
+        // Required for the MDC form field to pick up when the overlay has been closed.
+        this.stateChanges.next();
+    }
+    /**
+     * Sets the select' value. Part of the ControlValueAccessor interface
+     * required to integrate with Angular core forms API.
+     *
+     * @param value New value to be written to the model.
+     */
+    writeValue(value) {
+        this._assignValue(value);
+    }
+    /** Whether the overlay panel is open. */
+    get panelOpen() {
+        return this._panelOpen;
+    }
+    /** The currently selected option. */
+    get selected() {
+        return this.multiple ? this._selectionModel?.selected || [] : this._selectionModel?.selected[0];
+    }
+    /** The value displayed in the trigger. */
+    get triggerValue() {
+        if (this.empty) {
+            return '';
+        }
+        if (this._multiple) {
+            const selectedOptions = this._selectionModel.selected.map(option => option.viewValue);
+            if (this._isRtl()) {
+                selectedOptions.reverse();
+            }
+            // TODO(crisbeto): delimiter should be configurable for proper localization.
+            return selectedOptions.join(', ');
+        }
+        return this._selectionModel.selected[0].viewValue;
+    }
+    /** Refreshes the error state of the select. */
+    updateErrorState() {
+        this._errorStateTracker.updateErrorState();
+    }
+    /** Whether the element is in RTL mode. */
+    _isRtl() {
+        return this._dir ? this._dir.value === 'rtl' : false;
+    }
+    /** Handles all keydown events on the select. */
+    _handleKeydown(event) {
+        if (!this.disabled) {
+            this.panelOpen ? this._handleOpenKeydown(event) : this._handleClosedKeydown(event);
+        }
+    }
+    /** Handles keyboard events while the select is closed. */
+    _handleClosedKeydown(event) {
+        const keyCode = event.keyCode;
+        const isArrowKey = keyCode === DOWN_ARROW ||
+            keyCode === UP_ARROW ||
+            keyCode === LEFT_ARROW ||
+            keyCode === RIGHT_ARROW;
+        const isOpenKey = keyCode === ENTER || keyCode === SPACE;
+        const manager = this._keyManager;
+        // Open the select on ALT + arrow key to match the native <select>
+        if ((manager && !manager.isTyping() && isOpenKey && !hasModifierKey(event)) ||
+            ((this.multiple || event.altKey) && isArrowKey)) {
+            event.preventDefault(); // prevents the page from scrolling down when pressing space
+            this.open();
+        }
+        else if (!this.multiple) {
+            const previouslySelectedOption = this.selected;
+            manager.onKeydown(event);
+            const selectedOption = this.selected;
+            // Since the value has changed, we need to announce it ourselves.
+            if (selectedOption && previouslySelectedOption !== selectedOption) {
+                // We set a duration on the live announcement, because we want the live element to be
+                // cleared after a while so that users can't navigate to it using the arrow keys.
+                this._liveAnnouncer.announce(selectedOption.viewValue, 10000);
+            }
+        }
+    }
+    /** Handles keyboard events when the selected is open. */
+    _handleOpenKeydown(event) {
+        const manager = this._keyManager;
+        const keyCode = event.keyCode;
+        const isArrowKey = keyCode === DOWN_ARROW || keyCode === UP_ARROW;
+        const isTyping = manager.isTyping();
+        if (isArrowKey && event.altKey) {
+            // Close the select on ALT + arrow key to match the native <select>
+            event.preventDefault();
+            this.close();
+            // Don't do anything in this case if the user is typing,
+            // because the typing sequence can include the space key.
+        }
+        else if (!isTyping &&
+            (keyCode === ENTER || keyCode === SPACE) &&
+            manager.activeItem &&
+            !hasModifierKey(event)) {
+            event.preventDefault();
+            manager.activeItem._selectViaInteraction();
+        }
+        else if (!isTyping && this._multiple && keyCode === A && event.ctrlKey) {
+            event.preventDefault();
+            const hasDeselectedOptions = this.options?.some(opt => !opt.disabled && !opt.selected);
+            this.options?.forEach(option => {
+                if (!option.disabled) {
+                    hasDeselectedOptions ? option.select() : option.deselect();
+                }
+            });
+        }
+        else {
+            const previouslyFocusedIndex = manager.activeItemIndex;
+            manager.onKeydown(event);
+            if (this._multiple &&
+                isArrowKey &&
+                event.shiftKey &&
+                manager.activeItem &&
+                manager.activeItemIndex !== previouslyFocusedIndex) {
+                manager.activeItem._selectViaInteraction();
+            }
+        }
+    }
+    _onFocus() {
+        if (!this.disabled) {
+            this._focused = true;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Calls the touched callback only if the panel is closed. Otherwise, the trigger will
+     * "blur" to the panel when it opens, causing a false positive.
+     */
+    _onBlur() {
+        this._focused = false;
+        this._keyManager?.cancelTypeahead();
+        if (!this.disabled && !this.panelOpen) {
+            this._onTouched();
+            this.markForCheck();
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Callback that is invoked when the overlay panel has been attached.
+     */
+    _onAttached() {
+        this._overlayDir?.positionChange.pipe(take(1)).subscribe(() => {
+            this._changeDetectorRef.detectChanges();
+            this._positioningSettled();
+        });
+    }
+    /** Returns the theme to be used on the panel. */
+    _getPanelTheme() {
+        return this._parentFormField ? `cute-${this._parentFormField.color}` : '';
+    }
+    /** Whether the select has a value. */
+    get empty() {
+        return !this._selectionModel || this._selectionModel.isEmpty();
+    }
+    _initializeSelection() {
+        // Defers setting the value to avoid the "Expression
+        // has changed after it was checked" errors from Angular.
+        Promise.resolve().then(() => {
+            if (this.ngControl) {
+                this._value = this.ngControl.value;
+            }
+            this._setSelectionByValue(this._value);
+            this.stateChanges.next();
+        });
+    }
+    /**
+     * Sets the selected option based on a value. If no option can be
+     * found with the designated value, the select trigger is cleared.
+     */
+    _setSelectionByValue(value) {
+        this.options?.forEach(option => option.setInactiveStyles());
+        this._selectionModel?.clear();
+        if (this.multiple && value) {
+            if (!Array.isArray(value) && isDevMode()) {
+                throw getCuteSelectNonArrayValueError();
+            }
+            value.forEach((currentValue) => this._selectOptionByValue(currentValue));
+            this._sortValues();
+        }
+        else {
+            const correspondingOption = this._selectOptionByValue(value);
+            // Shift focus to the active item. Note that we shouldn't do this in multiple
+            // mode, because we don't know what option the user interacted with last.
+            if (correspondingOption) {
+                this._keyManager?.updateActiveItem(correspondingOption);
+            }
+            else if (!this.panelOpen) {
+                // Otherwise, reset the highlighted option. Note that we only want to do this while
+                // closed, because doing it while open can shift the user's focus unnecessarily.
+                this._keyManager?.updateActiveItem(-1);
+            }
+        }
+        this.markForCheck();
+    }
+    /**
+     * Finds and selects and option based on its value.
+     * @returns Option that has the corresponding value.
+     */
+    _selectOptionByValue(value) {
+        const correspondingOption = this.options?.find((option) => {
+            // Skip options that are already in the model. This allows us to handle cases
+            // where the same primitive value is selected multiple times.
+            if (this._selectionModel?.isSelected(option)) {
+                return false;
+            }
+            try {
+                // Treat null as a special reset value.
+                return (option.value != null || this.canSelectNullableOptions) &&
+                    this._compareWith(option.value, value);
+            }
+            catch (error) {
+                if (isDevMode()) {
+                    // Notify developers of errors in their comparator.
+                    console.warn(error);
+                }
+                return false;
+            }
+        });
+        if (correspondingOption) {
+            this._selectionModel?.select(correspondingOption);
+        }
+        return correspondingOption;
+    }
+    /** Assigns a specific value to the select. Returns whether the value has changed. */
+    _assignValue(newValue) {
+        // Always re-assign an array, because it might have been mutated.
+        if (newValue !== this._value || (this._multiple && Array.isArray(newValue))) {
+            if (this.options) {
+                this._setSelectionByValue(newValue);
+            }
+            this._value = newValue;
+            return true;
+        }
+        return false;
+    }
+    /** Gets how wide the overlay panel should be. */
+    _getOverlayWidth(preferredOrigin) {
+        if (this.panelWidth === 'auto') {
+            const refToMeasure = preferredOrigin instanceof CdkOverlayOrigin
+                ? preferredOrigin.elementRef
+                : preferredOrigin || this._elementRef;
+            return refToMeasure.nativeElement.getBoundingClientRect().width;
+        }
+        return this.panelWidth === null ? '' : this.panelWidth;
+    }
+    /** Syncs the parent state with the individual options. */
+    _syncParentProperties() {
+        if (this.options) {
+            for (const option of this.options) {
+                option.markForCheck();
+            }
+        }
+    }
+    /** Sets up a key manager to listen to keyboard events on the overlay panel. */
+    _initKeyManager() {
+        this._keyManager = new ActiveDescendantKeyManager(this.options)
+            .withTypeAhead(this.typeaheadDebounceInterval)
+            .withVerticalOrientation()
+            .withHorizontalOrientation(this._isRtl() ? 'rtl' : 'ltr')
+            .withHomeAndEnd()
+            .withPageUpDown()
+            .withAllowedModifierKeys(['shiftKey'])
+            .skipPredicate(this._skipPredicate);
+        this._keyManager.tabOut.subscribe(() => {
+            if (this.panelOpen) {
+                // Select the active item when tabbing away. This is consistent with how the native
+                // select behaves. Note that we only want to do this in single selection mode.
+                if (!this.multiple && this._keyManager?.activeItem) {
+                    this._keyManager.activeItem._selectViaInteraction();
+                }
+                // Restore focus to the trigger before closing. Ensures that the focus
+                // position won't be lost if the user got focus into the overlay.
+                this.focus();
+                this.close();
+            }
+        });
+        this._keyManager.change.subscribe(() => {
+            if (this._panelOpen && this.panel) {
+                this._scrollOptionIntoView(this._keyManager?.activeItemIndex || 0);
+            }
+            else if (!this._panelOpen && !this.multiple && this._keyManager?.activeItem) {
+                this._keyManager.activeItem._selectViaInteraction();
+            }
+        });
+    }
+    /** Drops current option subscriptions and IDs and resets from scratch. */
+    _resetOptions() {
+        const changedOrDestroyed = merge(this.options.changes, this._destroy);
+        this.optionSelectionChanges.pipe(takeUntil(changedOrDestroyed)).subscribe(event => {
+            this._onSelect(event.source, event.isUserInput);
+            if (event.isUserInput && !this.multiple && this._panelOpen) {
+                this.close();
+                this.focus();
+            }
+        });
+        // Listen to changes in the internal state of the options and react accordingly.
+        // Handles cases like the labels of the selected options changing.
+        merge(...this.options.map(option => option._stateChanges))
+            .pipe(takeUntil(changedOrDestroyed))
+            .subscribe(() => {
+            // `_stateChanges` can fire as a result of a change in the label's DOM value which may
+            // be the result of an expression changing. We have to use `detectChanges` in order
+            // to avoid "changed after checked" errors (see #14793).
+            this._changeDetectorRef.detectChanges();
+            this.stateChanges.next();
+        });
+    }
+    /** Invoked when an option is clicked. */
+    _onSelect(option, isUserInput) {
+        const wasSelected = this._selectionModel?.isSelected(option);
+        if (!this.canSelectNullableOptions && option.value == null && !this._multiple) {
+            option.deselect();
+            this._selectionModel?.clear();
+            if (this.value != null) {
+                this._propagateChanges(option.value);
+            }
+        }
+        else {
+            if (wasSelected !== option.selected) {
+                option.selected
+                    ? this._selectionModel?.select(option)
+                    : this._selectionModel?.deselect(option);
+            }
+            if (isUserInput) {
+                this._keyManager?.setActiveItem(option);
+            }
+            if (this.multiple) {
+                this._sortValues();
+                if (isUserInput) {
+                    // In case the user selected the option with their mouse, we
+                    // want to restore focus back to the trigger, in order to
+                    // prevent the select keyboard controls from clashing with
+                    // the ones from `cute-option`.
+                    this.focus();
+                }
+            }
+        }
+        if (wasSelected !== this._selectionModel?.isSelected(option)) {
+            this._propagateChanges();
+        }
+        this.stateChanges.next();
+    }
+    /** Sorts the selected values in the selected based on their order in the panel. */
+    _sortValues() {
+        if (this.multiple) {
+            const options = this.options.toArray();
+            this._selectionModel?.sort((a, b) => {
+                return this.sortComparator
+                    ? this.sortComparator(a, b, options)
+                    : options.indexOf(a) - options.indexOf(b);
+            });
+            this.stateChanges.next();
+        }
+    }
+    /** Emits change event to set the model value. */
+    _propagateChanges(fallbackValue) {
+        let valueToEmit;
+        if (this.multiple) {
+            valueToEmit = this.selected.map(option => option.value);
+        }
+        else {
+            valueToEmit = this.selected ? this.selected.value : fallbackValue;
+        }
+        this._value = valueToEmit;
+        this.valueChange.emit(valueToEmit);
+        this._onChange(valueToEmit);
+        this.selectionChange.emit(this._getChangeEvent(valueToEmit));
+        this.markForCheck();
+    }
+    /**
+     * Highlights the selected item. If no option is selected, it will highlight
+     * the first *enabled* option.
+     */
+    _highlightCorrectOption() {
+        if (this._keyManager) {
+            if (this.empty) {
+                // Find the index of the first *enabled* option. Avoid calling `_keyManager.setActiveItem`
+                // because it activates the first option that passes the skip predicate, rather than the
+                // first *enabled* option.
+                let firstEnabledOptionIndex = -1;
+                for (let index = 0; index < this.options.length; index++) {
+                    const option = this.options.get(index);
+                    if (!option.disabled) {
+                        firstEnabledOptionIndex = index;
+                        break;
+                    }
+                }
+                this._keyManager.setActiveItem(firstEnabledOptionIndex);
+            }
+            else {
+                this._keyManager.setActiveItem(this._selectionModel.selected[0]);
+            }
+        }
+    }
+    /** Whether the panel is allowed to open. */
+    _canOpen() {
+        return !this._panelOpen && !this.disabled && this.options.length > 0;
+    }
+    /** Focuses the select element. */
+    focus(origin, options) {
+        //this._elementRef.nativeElement.focus(options);
+        this.trigger?.nativeElement.focus(options);
+    }
+    /** Gets the aria-labelledby for the select panel. */
+    _getPanelAriaLabelledby() {
+        if (this.ariaLabel) {
+            return null;
+        }
+        const labelId = this._parentFormField?.getLabelId() || null;
+        const labelExpression = labelId ? labelId + ' ' : '';
+        return this.ariaLabelledby ? labelExpression + this.ariaLabelledby : labelId;
+    }
+    /** Determines the `aria-activedescendant` to be set on the host. */
+    _getAriaActiveDescendant() {
+        if (this.panelOpen && this._keyManager && this._keyManager.activeItem) {
+            return this._keyManager.activeItem.id || null;
+        }
+        return null;
+    }
+    /** Gets the aria-labelledby of the select component trigger. */
+    _getTriggerAriaLabelledby() {
+        if (this.ariaLabel) {
+            return null;
+        }
+        const labelId = this._parentFormField?.getLabelId();
+        let value = (labelId ? labelId + ' ' : '') + this.inputId;
+        if (this.ariaLabelledby) {
+            value += ' ' + this.ariaLabelledby;
+        }
+        return value;
+    }
+    /** Called when the overlay panel is done animating. */
+    _panelDoneAnimating(isOpen) {
+        this.openedChange.emit(isOpen);
+    }
+    /**
+     * Implemented as part of CuteFormFieldControl.
+     */
+    setDescribedByIds(ids) {
+        if (ids.length) {
+            this._elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));
+        }
+        else {
+            this._elementRef.nativeElement.removeAttribute('aria-describedby');
+        }
+    }
+    /**
+     * Implemented as part of CuteFormFieldControl.
+     */
+    onContainerClick() {
+        this.focus();
+        this.open();
+    }
+    /**
+     * Implemented as part of CuteFormFieldControl.
+     */
+    get shouldLabelFloat() {
+        // Since the panel doesn't overlap the trigger, we
+        // want the label to only float when there's a value.
+        return this.panelOpen || !this.empty || (this.focused && !!this.placeholder);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSelect, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: CuteSelect, isStandalone: true, selector: "cute-select", inputs: { userAriaDescribedBy: ["aria-describedby", "userAriaDescribedBy"], panelClass: "panelClass", disableRipple: ["disableRipple", "disableRipple", booleanAttribute], hideSingleSelectionIndicator: ["hideSingleSelectionIndicator", "hideSingleSelectionIndicator", booleanAttribute], placeholder: "placeholder", multiple: ["multiple", "multiple", booleanAttribute], disableOptionCentering: ["disableOptionCentering", "disableOptionCentering", booleanAttribute], compareWith: "compareWith", value: "value", errorStateMatcher: "errorStateMatcher", magnitude: "magnitude", typeaheadDebounceInterval: ["typeaheadDebounceInterval", "typeaheadDebounceInterval", numberAttribute], sortComparator: "sortComparator", panelWidth: "panelWidth", panelHeight: "panelHeight", canSelectNullableOptions: ["canSelectNullableOptions", "canSelectNullableOptions", booleanAttribute] }, outputs: { openedChange: "openedChange", _openedStream: "opened", _closedStream: "closed", selectionChange: "selectionChange", valueChange: "valueChange" }, host: { attributes: { "role": "combobox", "aria-autocomplete": "none", "aria-haspopup": "listbox", "ngSkipHydration": "" }, listeners: { "keydown": "_handleKeydown($event)", "focus": "_onFocus()", "blur": "_onBlur()" }, properties: { "class.active": "focused", "class.cute-select-disabled": "disabled", "class.cute-select-invalid": "errorState", "class.cute-select-required": "required", "class.cute-select-empty": "empty", "class.cute-select-multiple": "multiple", "attr.id": "id", "attr.tabindex": "-1", "attr.aria-controls": "panelOpen ? id + \"-panel\" : null", "attr.aria-expanded": "panelOpen", "attr.aria-label": "ariaLabel || null", "attr.aria-required": "required", "attr.aria-disabled": "disabled", "attr.aria-invalid": "errorState", "attr.aria-activedescendant": "_getAriaActiveDescendant()" }, classAttribute: "cute-select" }, providers: [
+            { provide: CuteFormFieldControl, useExisting: CuteSelect },
+            { provide: CUTE_OPTION_PARENT_COMPONENT, useExisting: CuteSelect },
+        ], queries: [{ propertyName: "customTrigger", first: true, predicate: CUTE_SELECT_TRIGGER, descendants: true }, { propertyName: "options", predicate: CuteOption, descendants: true }, { propertyName: "optionGroups", predicate: CUTE_OPTGROUP, descendants: true }], viewQueries: [{ propertyName: "trigger", first: true, predicate: ["trigger"], descendants: true }, { propertyName: "panel", first: true, predicate: ["panel"], descendants: true }, { propertyName: "_overlayDir", first: true, predicate: CdkConnectedOverlay, descendants: true }], exportAs: ["cuteSelect"], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div cdk-overlay-origin\r\n     class=\"cute-select-trigger-wrapper\"\r\n     [class.required]=\"required\"\r\n     #fallbackOverlayOrigin=\"cdkOverlayOrigin\"\r\n>\r\n\r\n  @if (!customTrigger) {\r\n    <input #trigger\r\n           class=\"form-select cute-select-trigger__input\"\r\n           [class.form-select-sm]=\"magnitude=='small'\"\r\n           [class.form-select-lg]=\"magnitude=='large'\"\r\n           [attr.id]=\"inputId\"\r\n           [attr.tabindex]=\"disabled ? -1 : tabIndex\"\r\n           [disabled]=\"disabled\"\r\n           [placeholder]=\"placeholder\"\r\n           readonly\r\n           [value]=\"triggerValue\"\r\n           (click)=\"toggle()\"\r\n           autocomplete=\"off\">\r\n  } @else {\r\n    <div #trigger\r\n         class=\"form-select cute-select-trigger__custom\"\r\n         [attr.tabindex]=\"disabled ? -1 : tabIndex\"\r\n         [attr.id]=\"inputId\">\r\n      <ng-content select=\"cute-select-trigger\"></ng-content>\r\n    </div>\r\n  }\r\n\r\n</div>\r\n\r\n<ng-template  cdk-connected-overlay\r\n              cdkConnectedOverlayHasBackdrop\r\n              cdkConnectedOverlayBackdropClass=\"cdk-overlay-transparent-backdrop\"\r\n              [cdkConnectedOverlayPanelClass]=\"_overlayPanelClass\"\r\n              [cdkConnectedOverlayScrollStrategy]=\"_scrollStrategy\"\r\n              [cdkConnectedOverlayOrigin]=\"_preferredOverlayOrigin || fallbackOverlayOrigin\"\r\n              [cdkConnectedOverlayOpen]=\"panelOpen\"\r\n              [cdkConnectedOverlayPositions]=\"_positions\"\r\n              [cdkConnectedOverlayWidth]=\"_overlayWidth!\"\r\n              (backdropClick)=\"close()\"\r\n              (attach)=\"_onAttached()\"\r\n              (detach)=\"close()\"> <!-- cdkConnectedOverlayLockPosition -->\r\n  <div #panel\r\n       role=\"listbox\"\r\n       tabindex=\"-1\"\r\n       class=\"cute-dropdown-overlay-content bg-body-tertiary shadow\"\r\n       [style.max-height]=\"panelHeight || null\"\r\n       [attr.id]=\"id + '-panel'\"\r\n       [attr.aria-multiselectable]=\"multiple\"\r\n       [attr.aria-label]=\"ariaLabel || null\"\r\n       [attr.aria-labelledby]=\"_getPanelAriaLabelledby()\"\r\n       [ngClass]=\"panelClass\"\r\n       [@transformPanel]=\"'showing'\"\r\n       (@transformPanel.done)=\"_panelDoneAnimatingStream.next($event.toState)\"\r\n       (keydown)=\"_handleKeydown($event)\">\r\n    <div class=\"cute-dropdown-content\">\r\n      <ng-content></ng-content>\r\n    </div>\r\n    <!--<ng-template [cdkPortalOutlet]=\"_portal\"></ng-template>-->\r\n  </div>\r\n</ng-template>\r\n\r\n", styles: [".cute-select{display:inline-block;width:100%}.cute-dropdown-overlay-content{display:block;width:100%;max-height:272px;overflow-y:auto;padding:var(--cute-select-padding-y, .5rem) 0;font-size:var(--bs-body-font-size);color:var(--bs-body-color);text-align:start;list-style:none;background-color:var(--bs-body-bg);border:var(--bs-border-width) solid var(--bs-border-color-translucent);border-radius:var(--bs-border-radius)}.cute-dropdown-overlay-content .cute-dropdown-content{overflow:auto;height:100%}.cute-dropdown-overlay-content .cute-dropdown-content .cute-option:hover:not(.disabled){background-color:var(--bs-secondary-bg)}.cute-select-trigger__input,.cute-select-trigger__custom{position:relative;cursor:pointer;-webkit-user-select:none;user-select:none}.cute-select-trigger__input:disabled,.cute-select-trigger__custom:disabled{cursor:auto;opacity:.65}cute-select-trigger{display:inline-block;-webkit-user-select:none;user-select:none}[dir=rtl] .form-select{padding:.375rem .75rem .375rem 2.25rem;background-position:left .75rem center}\n"], dependencies: [{ kind: "directive", type: CdkOverlayOrigin, selector: "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", exportAs: ["cdkOverlayOrigin"] }, { kind: "directive", type: CdkConnectedOverlay, selector: "[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]", inputs: ["cdkConnectedOverlayOrigin", "cdkConnectedOverlayPositions", "cdkConnectedOverlayPositionStrategy", "cdkConnectedOverlayOffsetX", "cdkConnectedOverlayOffsetY", "cdkConnectedOverlayWidth", "cdkConnectedOverlayHeight", "cdkConnectedOverlayMinWidth", "cdkConnectedOverlayMinHeight", "cdkConnectedOverlayBackdropClass", "cdkConnectedOverlayPanelClass", "cdkConnectedOverlayViewportMargin", "cdkConnectedOverlayScrollStrategy", "cdkConnectedOverlayOpen", "cdkConnectedOverlayDisableClose", "cdkConnectedOverlayTransformOriginOn", "cdkConnectedOverlayHasBackdrop", "cdkConnectedOverlayLockPosition", "cdkConnectedOverlayFlexibleDimensions", "cdkConnectedOverlayGrowAfterOpen", "cdkConnectedOverlayPush", "cdkConnectedOverlayDisposeOnNavigation"], outputs: ["backdropClick", "positionChange", "attach", "detach", "overlayKeydown", "overlayOutsideClick"], exportAs: ["cdkConnectedOverlay"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], animations: [cuteSelectAnimations.transformPanel], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSelect, decorators: [{
+            type: Component,
+            args: [{ selector: 'cute-select', exportAs: 'cuteSelect', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        'class': 'cute-select',
+                        '[class.active]': 'focused',
+                        '[class.cute-select-disabled]': 'disabled',
+                        '[class.cute-select-invalid]': 'errorState',
+                        '[class.cute-select-required]': 'required',
+                        '[class.cute-select-empty]': 'empty',
+                        '[class.cute-select-multiple]': 'multiple',
+                        'role': 'combobox',
+                        'aria-autocomplete': 'none',
+                        'aria-haspopup': 'listbox',
+                        '[attr.id]': 'id',
+                        '[attr.tabindex]': '-1', //'disabled ? -1 : tabIndex',
+                        '[attr.aria-controls]': 'panelOpen ? id + "-panel" : null',
+                        '[attr.aria-expanded]': 'panelOpen',
+                        '[attr.aria-label]': 'ariaLabel || null',
+                        '[attr.aria-required]': 'required',
+                        '[attr.aria-disabled]': 'disabled',
+                        '[attr.aria-invalid]': 'errorState',
+                        '[attr.aria-activedescendant]': '_getAriaActiveDescendant()',
+                        'ngSkipHydration': '',
+                        '(keydown)': '_handleKeydown($event)',
+                        '(focus)': '_onFocus()',
+                        '(blur)': '_onBlur()',
+                    }, animations: [cuteSelectAnimations.transformPanel], providers: [
+                        { provide: CuteFormFieldControl, useExisting: CuteSelect },
+                        { provide: CUTE_OPTION_PARENT_COMPONENT, useExisting: CuteSelect },
+                    ], imports: [CdkOverlayOrigin, CdkConnectedOverlay, NgClass], template: "<div cdk-overlay-origin\r\n     class=\"cute-select-trigger-wrapper\"\r\n     [class.required]=\"required\"\r\n     #fallbackOverlayOrigin=\"cdkOverlayOrigin\"\r\n>\r\n\r\n  @if (!customTrigger) {\r\n    <input #trigger\r\n           class=\"form-select cute-select-trigger__input\"\r\n           [class.form-select-sm]=\"magnitude=='small'\"\r\n           [class.form-select-lg]=\"magnitude=='large'\"\r\n           [attr.id]=\"inputId\"\r\n           [attr.tabindex]=\"disabled ? -1 : tabIndex\"\r\n           [disabled]=\"disabled\"\r\n           [placeholder]=\"placeholder\"\r\n           readonly\r\n           [value]=\"triggerValue\"\r\n           (click)=\"toggle()\"\r\n           autocomplete=\"off\">\r\n  } @else {\r\n    <div #trigger\r\n         class=\"form-select cute-select-trigger__custom\"\r\n         [attr.tabindex]=\"disabled ? -1 : tabIndex\"\r\n         [attr.id]=\"inputId\">\r\n      <ng-content select=\"cute-select-trigger\"></ng-content>\r\n    </div>\r\n  }\r\n\r\n</div>\r\n\r\n<ng-template  cdk-connected-overlay\r\n              cdkConnectedOverlayHasBackdrop\r\n              cdkConnectedOverlayBackdropClass=\"cdk-overlay-transparent-backdrop\"\r\n              [cdkConnectedOverlayPanelClass]=\"_overlayPanelClass\"\r\n              [cdkConnectedOverlayScrollStrategy]=\"_scrollStrategy\"\r\n              [cdkConnectedOverlayOrigin]=\"_preferredOverlayOrigin || fallbackOverlayOrigin\"\r\n              [cdkConnectedOverlayOpen]=\"panelOpen\"\r\n              [cdkConnectedOverlayPositions]=\"_positions\"\r\n              [cdkConnectedOverlayWidth]=\"_overlayWidth!\"\r\n              (backdropClick)=\"close()\"\r\n              (attach)=\"_onAttached()\"\r\n              (detach)=\"close()\"> <!-- cdkConnectedOverlayLockPosition -->\r\n  <div #panel\r\n       role=\"listbox\"\r\n       tabindex=\"-1\"\r\n       class=\"cute-dropdown-overlay-content bg-body-tertiary shadow\"\r\n       [style.max-height]=\"panelHeight || null\"\r\n       [attr.id]=\"id + '-panel'\"\r\n       [attr.aria-multiselectable]=\"multiple\"\r\n       [attr.aria-label]=\"ariaLabel || null\"\r\n       [attr.aria-labelledby]=\"_getPanelAriaLabelledby()\"\r\n       [ngClass]=\"panelClass\"\r\n       [@transformPanel]=\"'showing'\"\r\n       (@transformPanel.done)=\"_panelDoneAnimatingStream.next($event.toState)\"\r\n       (keydown)=\"_handleKeydown($event)\">\r\n    <div class=\"cute-dropdown-content\">\r\n      <ng-content></ng-content>\r\n    </div>\r\n    <!--<ng-template [cdkPortalOutlet]=\"_portal\"></ng-template>-->\r\n  </div>\r\n</ng-template>\r\n\r\n", styles: [".cute-select{display:inline-block;width:100%}.cute-dropdown-overlay-content{display:block;width:100%;max-height:272px;overflow-y:auto;padding:var(--cute-select-padding-y, .5rem) 0;font-size:var(--bs-body-font-size);color:var(--bs-body-color);text-align:start;list-style:none;background-color:var(--bs-body-bg);border:var(--bs-border-width) solid var(--bs-border-color-translucent);border-radius:var(--bs-border-radius)}.cute-dropdown-overlay-content .cute-dropdown-content{overflow:auto;height:100%}.cute-dropdown-overlay-content .cute-dropdown-content .cute-option:hover:not(.disabled){background-color:var(--bs-secondary-bg)}.cute-select-trigger__input,.cute-select-trigger__custom{position:relative;cursor:pointer;-webkit-user-select:none;user-select:none}.cute-select-trigger__input:disabled,.cute-select-trigger__custom:disabled{cursor:auto;opacity:.65}cute-select-trigger{display:inline-block;-webkit-user-select:none;user-select:none}[dir=rtl] .form-select{padding:.375rem .75rem .375rem 2.25rem;background-position:left .75rem center}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { options: [{
+                type: ContentChildren,
+                args: [CuteOption, { descendants: true }]
+            }], optionGroups: [{
+                type: ContentChildren,
+                args: [CUTE_OPTGROUP, { descendants: true }]
+            }], customTrigger: [{
+                type: ContentChild,
+                args: [CUTE_SELECT_TRIGGER]
+            }], trigger: [{
+                type: ViewChild,
+                args: ['trigger']
+            }], panel: [{
+                type: ViewChild,
+                args: ['panel']
+            }], _overlayDir: [{
+                type: ViewChild,
+                args: [CdkConnectedOverlay]
+            }], userAriaDescribedBy: [{
+                type: Input,
+                args: ['aria-describedby']
+            }], panelClass: [{
+                type: Input
+            }], disableRipple: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], hideSingleSelectionIndicator: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], placeholder: [{
+                type: Input
+            }], multiple: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], disableOptionCentering: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], compareWith: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], errorStateMatcher: [{
+                type: Input
+            }], magnitude: [{
+                type: Input
+            }], typeaheadDebounceInterval: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], sortComparator: [{
+                type: Input
+            }], panelWidth: [{
+                type: Input
+            }], panelHeight: [{
+                type: Input
+            }], canSelectNullableOptions: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], openedChange: [{
+                type: Output
+            }], _openedStream: [{
+                type: Output,
+                args: ['opened']
+            }], _closedStream: [{
+                type: Output,
+                args: ['closed']
+            }], selectionChange: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }] } });
+/**
+ * Allows the user to customize the trigger that is displayed when the select has a value.
+ */
+class CuteSelectTrigger {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSelectTrigger, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteSelectTrigger, isStandalone: true, selector: "cute-select-trigger", providers: [{ provide: CUTE_SELECT_TRIGGER, useExisting: CuteSelectTrigger }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSelectTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'cute-select-trigger',
+                    providers: [{ provide: CUTE_SELECT_TRIGGER, useExisting: CuteSelectTrigger }],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+const TYPES = [
+    CuteSelect,
+    CuteSelectTrigger,
+    CuteOptgroup,
+    CuteOption,
+];
+class CuteSelectModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteSelectModule, imports: [CommonModule, CuteSelect,
+            CuteSelectTrigger,
+            CuteOptgroup,
+            CuteOption], exports: [CuteSelect,
+            CuteSelectTrigger,
+            CuteOptgroup,
+            CuteOption] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSelectModule, providers: [
+            CUTE_SELECT_SCROLL_STRATEGY_PROVIDER
+        ], imports: [CommonModule, CuteOptgroup,
+            CuteOption] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSelectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ...TYPES],
+                    exports: TYPES,
+                    providers: [
+                        CUTE_SELECT_SCROLL_STRATEGY_PROVIDER
+                    ],
+                    declarations: [],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CUTE_SELECT_CONFIG, CUTE_SELECT_SCROLL_STRATEGY, CUTE_SELECT_SCROLL_STRATEGY_PROVIDER, CUTE_SELECT_SCROLL_STRATEGY_PROVIDER_FACTORY, CUTE_SELECT_TRIGGER, CuteSelect, CuteSelectChange, CuteSelectModule, CuteSelectTrigger, cuteSelectAnimations };
+//# sourceMappingURL=cute-widgets-base-select.mjs.map