@impartner/design-components 1.0.0

package/esm2020/lib/form-field/controls/select/select.component.mjs

@@ -0,0 +1,522 @@
+/* eslint-disable @angular-eslint/no-conflicting-lifecycle */
+import { Attribute, ChangeDetectionStrategy, Component, ContentChildren, ElementRef, EventEmitter, Inject, Input, Optional, Output, Self, ViewChild } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { NgbDropdown, NgbDropdownMenu } from '@ng-bootstrap/ng-bootstrap';
+import { nanoid } from 'nanoid';
+import { coerceBooleanPropertyValue } from '../../../../utilities';
+import { defer, merge, startWith, Subject, switchMap, take, takeUntil } from 'rxjs';
+import { IMPDC_FORM_ROOT } from '../../directives';
+import { ImpdcFormFieldControl, mixinDisabled, mixinErrorState, mixinTabIndex } from '../../shared';
+import { IMPDC_SELECT_OPTION_PARENT_COMPONENT } from './option-parent';
+import { SelectOptionComponent } from './option/select-option.component';
+import { SelectModel } from './select-model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/common";
+import * as i4 from "@ng-bootstrap/ng-bootstrap";
+export class SelectChangeEvent {
+    constructor(
+    /** The specific SelectComponent that changed. */
+    source, 
+    /** The selected value(s) */
+    value) {
+        this.source = source;
+        this.value = value;
+    }
+}
+/**
+ * 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.
+ * @ignore
+ */
+export function getImpdcSelectNonArrayValueError() {
+    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.
+ */
+export function getImpdcSelectNonFunctionValueError() {
+    return Error('`compareWith` must be a function.');
+}
+/**
+ * Returns an exception to be thrown when attempting to change a select's `multiple` option
+ * after initialization.
+ * @ignore
+ */
+export function getImpdcSelectDynamicMultipleError() {
+    return Error('Cannot change `multiple` mode of select after initialization.');
+}
+const _SelectComponentBase = mixinTabIndex(mixinDisabled(mixinErrorState(class {
+    constructor(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
+        this._formRoot = _formRoot;
+        this._parentForm = _parentForm;
+        this._parentFormGroup = _parentFormGroup;
+        this.ngControl = ngControl;
+        this.stateChanges = new Subject();
+    }
+})));
+/**
+ * The `SelectComponent` (`<impdc-select`) is a select-style dropdown input where an item (or multiple items) can be picked
+ * from a list of available options. This component can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `SelectModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export class SelectComponent extends _SelectComponentBase {
+    constructor(_changeDetector, _ngZone, tabIndex, _defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        super(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl);
+        this._changeDetector = _changeDetector;
+        this._ngZone = _ngZone;
+        /** @ignore */
+        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));
+        });
+        this._uid = `impdc-select-${nanoid()}`;
+        this._ngDestroy = new Subject();
+        this._compareWith = (o1, o2) => o1 === o2;
+        this._cvaOnChange = () => { };
+        this._cvaOnTouched = () => { };
+        this._placeholder = '- Select -';
+        this._multiple = false;
+        /** Events fire when selection has been changed by the user. */
+        this.selectionChange = new EventEmitter();
+        /**
+         * Events fire when raw value of select changes. Mainly exists to handle
+         * two-way binding of `value` input property.
+         * @ignore
+         */
+        this.valueChange = new EventEmitter();
+        /* ImpdcFormFieldControl */
+        this.controlType = 'impdc-select';
+        this.supportsAffixes = true;
+        this._focused = false;
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+        this.id = this.id;
+        this.tabIndex = parseInt(tabIndex) || 0;
+    }
+    /**
+     * The placeholder text that will be displayed when no selection has been made.
+     *
+     * @default \- Select -
+     */
+    get placeholder() {
+        return this._placeholder;
+    }
+    set placeholder(value) {
+        this._placeholder = value;
+        this.stateChanges.next();
+    }
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required() {
+        return (this._required ??
+            this.ngControl?.control?.hasValidator(Validators.required) ??
+            false);
+    }
+    set required(value) {
+        this._required = coerceBooleanPropertyValue(value);
+        this.stateChanges.next();
+    }
+    /**
+     * Sets whether the control is a single-select or multiple-select. Cannot be changed after component initialization.
+     */
+    get multiple() {
+        return this._multiple;
+    }
+    set multiple(value) {
+        if (this._selectionModel) {
+            throw getImpdcSelectDynamicMultipleError();
+        }
+        this._multiple = coerceBooleanPropertyValue(value);
+    }
+    /**
+     * Function used to compare option values with selected values. The first arg is a
+     * value from an option, and the second arg is a value from the selection.
+     *
+     * @returns Boolean indicating if the values are equivalent.
+     */
+    get compareWith() {
+        return this._compareWith;
+    }
+    set compareWith(fn) {
+        if (typeof fn !== 'function') {
+            throw getImpdcSelectNonFunctionValueError();
+        }
+        this._compareWith = fn;
+        if (this._selectionModel) {
+            // Changing the comparator function means the visual selection may have changed.
+            this._initializeSelection();
+        }
+    }
+    get dropdownOpen() {
+        return this._ngbDropdown?.isOpen() ?? false;
+    }
+    get empty() {
+        return !this._selectionModel || this._selectionModel.isEmpty();
+    }
+    get displayedValue() {
+        if (this.empty) {
+            return '';
+        }
+        if (!this._multiple) {
+            return this._selectionModel.selected[0].label;
+        }
+        return this._selectionModel.selected.map(opt => opt.label).join(', ');
+    }
+    get selected() {
+        return this.multiple
+            ? this._selectionModel?.selected || []
+            : this._selectionModel?.selected[0];
+    }
+    /** @ignore */
+    focus(options) {
+        this._toggleButtonRef.nativeElement.focus(options);
+    }
+    _handleOpenChange(isOpen) {
+        if (isOpen) {
+            this._onFocus();
+        }
+        else {
+            this._onBlur();
+        }
+        this.stateChanges.next();
+    }
+    /* Angular lifecycle hooks */
+    /** @ignore */
+    ngOnInit() {
+        this._selectionModel = new SelectModel(this.multiple);
+        this.stateChanges.next();
+    }
+    /** @ignore */
+    ngAfterContentInit() {
+        this._selectionModel.changed$
+            .pipe(takeUntil(this._ngDestroy))
+            .subscribe(changeEvent => {
+            changeEvent.added.forEach(option => option.select());
+            changeEvent.removed.forEach(option => option.deselect());
+        });
+        this.options.changes
+            .pipe(startWith(null), takeUntil(this._ngDestroy))
+            .subscribe(() => {
+            this._resetOptions();
+            this._initializeSelection();
+        });
+    }
+    /** @ignore */
+    ngAfterViewInit() {
+        this._ngbDropdownMenu.menuItems = this.options;
+    }
+    /** @ignore */
+    ngDoCheck() {
+        const ngControl = this.ngControl;
+        if (!ngControl) {
+            return;
+        }
+        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();
+    }
+    /** @ignore */
+    ngOnChanges(changes) {
+        // Managing disabled state is handled via the `mixinDisabled` mixin/generator, but we still need to signal
+        // to the parent form field so it can run change detection when disabled state is changed.
+        if (changes['disabled']) {
+            this.stateChanges.next();
+        }
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this._ngDestroy.next();
+        this._ngDestroy.complete();
+        this.stateChanges.complete();
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        const hasAssigned = this._assignValue(value);
+        if (hasAssigned) {
+            this._cvaOnChange(value);
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value || this._uid;
+        this.stateChanges.next();
+    }
+    get focused() {
+        return this._focused || this.dropdownOpen;
+    }
+    /* ControlValueAccessor */
+    /** @ignore */
+    writeValue(value) {
+        this._assignValue(value);
+    }
+    /** @ignore */
+    registerOnChange(fn) {
+        this._cvaOnChange = fn;
+    }
+    /** @ignore */
+    registerOnTouched(fn) {
+        this._cvaOnTouched = fn;
+    }
+    /** @ignore */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetector.markForCheck();
+        this.stateChanges.next();
+    }
+    /* Internals */
+    _onFocus() {
+        if (!this.disabled) {
+            this._focused = true;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Calls the CVA touched callback only if the dropdown is closed.
+     */
+    _onBlur() {
+        this._focused = false;
+        if (!this.disabled && !this.dropdownOpen) {
+            this._cvaOnTouched();
+            this._changeDetector.markForCheck();
+            this.stateChanges.next();
+        }
+    }
+    _initializeSelection() {
+        // We defer this work into a promise in order to avoid tripping Angular's
+        // "Expression has changed after it was checked" error.
+        Promise.resolve().then(() => {
+            if (this.ngControl) {
+                this._value = this.ngControl.value;
+            }
+            this._setSelectionByValue(this._value);
+            this.stateChanges.next();
+        });
+    }
+    _setSelectionByValue(value) {
+        this._selectionModel.clear();
+        if (this.multiple && value) {
+            if (!Array.isArray(value)) {
+                throw getImpdcSelectNonArrayValueError();
+            }
+            value.forEach(currentValue => this._selectOptionByValue(currentValue));
+            this._sortValues();
+        }
+        else {
+            this._selectOptionByValue(value);
+        }
+        this._changeDetector.detectChanges();
+    }
+    _selectOptionByValue(value) {
+        const correspondingOption = this.options.find((option) => {
+            if (this._selectionModel.isSelected(option)) {
+                return false;
+            }
+            try {
+                return option.value != null && this._compareWith(option.value, value);
+            }
+            catch (error) {
+                console.warn(error);
+                return false;
+            }
+        });
+        if (correspondingOption) {
+            this._selectionModel.select(correspondingOption);
+        }
+        return correspondingOption;
+    }
+    /** Assigns a value to the select control. Returns a boolean indicating whether or not
+     * the value has changed.
+     */
+    _assignValue(newValue) {
+        if (newValue !== this._value ||
+            (this._multiple && Array.isArray(newValue))) {
+            if (this.options) {
+                this._setSelectionByValue(newValue);
+            }
+            this._value = newValue;
+            return true;
+        }
+        return false;
+    }
+    _resetOptions() {
+        const changedOrDestroyed = merge(this.options.changes, this._ngDestroy);
+        this.optionSelectionChanges
+            .pipe(takeUntil(changedOrDestroyed))
+            .subscribe(event => {
+            this._onSelect(event.source, event.isUserInput);
+            if (event.isUserInput && !this.multiple && this.dropdownOpen) {
+                this._ngbDropdown.close();
+                this.focus();
+            }
+        });
+        merge(...this.options.map(option => option.stateChanges))
+            .pipe(takeUntil(changedOrDestroyed))
+            .subscribe(() => {
+            this._changeDetector.detectChanges();
+            this.stateChanges.next();
+        });
+    }
+    _onSelect(option, isUserInput) {
+        const wasSelected = this._selectionModel.isSelected(option);
+        if (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 (this.multiple) {
+                this._sortValues();
+                if (isUserInput) {
+                    this.focus();
+                }
+            }
+        }
+        if (wasSelected !== this._selectionModel.isSelected(option)) {
+            this._propagateChanges();
+        }
+        this._changeDetector.markForCheck();
+        this.stateChanges.next();
+    }
+    _sortValues() {
+        if (this.multiple) {
+            const options = this.options.toArray();
+            this._selectionModel.sort((a, b) => {
+                return options.indexOf(a) - options.indexOf(b);
+            });
+            this.stateChanges.next();
+        }
+    }
+    _propagateChanges(fallbackValue) {
+        let valToEmit = null;
+        if (this.multiple) {
+            valToEmit = this.selected.map(option => option.value);
+        }
+        else {
+            valToEmit = this.selected
+                ? this.selected.value
+                : fallbackValue;
+        }
+        this._value = valToEmit;
+        this.valueChange.emit(valToEmit);
+        this._cvaOnChange(valToEmit);
+        this.selectionChange.emit(this._buildChangeEvent(valToEmit));
+    }
+    _buildChangeEvent(value) {
+        return new SelectChangeEvent(this, value);
+    }
+}
+SelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: SelectComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: 'tabindex', attribute: true }, { token: i1.ErrorStateMatcher }, { token: IMPDC_FORM_ROOT, optional: true }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+SelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: SelectComponent, selector: "impdc-select", inputs: { disabled: "disabled", tabIndex: "tabIndex", placeholder: "placeholder", required: "required", multiple: "multiple", compareWith: "compareWith", errorStateMatcher: "errorStateMatcher", value: "value", id: "id" }, outputs: { selectionChange: "selectionChange", valueChange: "valueChange" }, host: { listeners: { "focus": "_onFocus(); focus()" }, properties: { "attr.id": "id", "attr.tabindex": "tabIndex", "attr.aria-required": "required.toString()", "attr.aria-disabled": "disabled.toString()", "attr.aria-invalid": "errorState", "class.form-select": "true", "class.is-invalid": "errorState", "class.impdc-form-field-control": "true", "class.impdc-select--required": "required", "class.impdc-select--disabled": "disabled", "class.impdc-select--invalid": "errorState", "class.impdc-select--empty": "empty", "class.impdc-select--multiple": "multiple" } }, providers: [
+        {
+            provide: ImpdcFormFieldControl,
+            useExisting: SelectComponent
+        },
+        {
+            provide: IMPDC_SELECT_OPTION_PARENT_COMPONENT,
+            useExisting: SelectComponent
+        }
+    ], queries: [{ propertyName: "options", predicate: SelectOptionComponent, descendants: true }], viewQueries: [{ propertyName: "_ngbDropdown", first: true, predicate: NgbDropdown, descendants: true }, { propertyName: "_ngbDropdownMenu", first: true, predicate: NgbDropdownMenu, descendants: true }, { propertyName: "_toggleButtonRef", first: true, predicate: ["toggleButton"], descendants: true, read: ElementRef, static: true }], exportAs: ["impdcSelect"], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div\n  ngbDropdown\n  [autoClose]=\"multiple ? 'outside' : true\"\n  container=\"body\"\n  dropdownClass=\"impartner-hex\"\n  (openChange)=\"_handleOpenChange($event)\"\n  class=\"w-100\">\n  <button\n    #toggleButton\n    class=\"impdc-select--toggle btn border-0 text-start\"\n    type=\"button\"\n    role=\"combobox\"\n    [disabled]=\"disabled\"\n    (focus)=\"_onFocus()\"\n    (blur)=\"_onBlur()\"\n    ngbDropdownToggle>\n    <ng-container [ngSwitch]=\"empty\">\n      <span\n        class=\"impdc-select--text impdc-select--placeholder\"\n        *ngSwitchCase=\"true\"\n        >{{ placeholder }}</span\n      >\n      <span\n        class=\"impdc-select--text impdc-select--value-text\"\n        *ngSwitchCase=\"false\"\n        >{{ displayedValue }}</span\n      >\n    </ng-container>\n  </button>\n  <div\n    ngbDropdownMenu\n    class=\"w-100 bg-white text-gray-600\"\n    role=\"listbox\"\n    tabindex=\"-1\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: [":host{padding:0!important;position:relative}:host.impdc-select--disabled{background-color:var(--impd-color-gray-100)}.impdc-select--toggle{font-weight:inherit;padding-right:3.6rem;cursor:pointer;-webkit-user-select:none;user-select:none;width:100%}:host-context(.is-invalid) .impdc-select--toggle{padding-right:6.6rem}.impdc-select--toggle:disabled{cursor:default}.impdc-select--text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;width:100%}button[ngbDropdownToggle].dropdown-toggle:after{display:none}\n"], dependencies: [{ kind: "directive", type: i3.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i3.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i4.NgbDropdown, selector: "[ngbDropdown]", inputs: ["autoClose", "dropdownClass", "open", "placement", "popperOptions", "container", "display"], outputs: ["openChange"], exportAs: ["ngbDropdown"] }, { kind: "directive", type: i4.NgbDropdownToggle, selector: "[ngbDropdownToggle]" }, { kind: "directive", type: i4.NgbDropdownMenu, selector: "[ngbDropdownMenu]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: SelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'impdc-select', exportAs: 'impdcSelect', inputs: ['disabled', 'tabIndex'], changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        '[attr.id]': 'id',
+                        '[attr.tabindex]': 'tabIndex',
+                        '[attr.aria-required]': 'required.toString()',
+                        '[attr.aria-disabled]': 'disabled.toString()',
+                        '[attr.aria-invalid]': 'errorState',
+                        '[class.form-select]': 'true',
+                        '[class.is-invalid]': 'errorState',
+                        '[class.impdc-form-field-control]': 'true',
+                        '[class.impdc-select--required]': 'required',
+                        '[class.impdc-select--disabled]': 'disabled',
+                        '[class.impdc-select--invalid]': 'errorState',
+                        '[class.impdc-select--empty]': 'empty',
+                        '[class.impdc-select--multiple]': 'multiple',
+                        '(focus)': '_onFocus(); focus()'
+                    }, providers: [
+                        {
+                            provide: ImpdcFormFieldControl,
+                            useExisting: SelectComponent
+                        },
+                        {
+                            provide: IMPDC_SELECT_OPTION_PARENT_COMPONENT,
+                            useExisting: SelectComponent
+                        }
+                    ], template: "<div\n  ngbDropdown\n  [autoClose]=\"multiple ? 'outside' : true\"\n  container=\"body\"\n  dropdownClass=\"impartner-hex\"\n  (openChange)=\"_handleOpenChange($event)\"\n  class=\"w-100\">\n  <button\n    #toggleButton\n    class=\"impdc-select--toggle btn border-0 text-start\"\n    type=\"button\"\n    role=\"combobox\"\n    [disabled]=\"disabled\"\n    (focus)=\"_onFocus()\"\n    (blur)=\"_onBlur()\"\n    ngbDropdownToggle>\n    <ng-container [ngSwitch]=\"empty\">\n      <span\n        class=\"impdc-select--text impdc-select--placeholder\"\n        *ngSwitchCase=\"true\"\n        >{{ placeholder }}</span\n      >\n      <span\n        class=\"impdc-select--text impdc-select--value-text\"\n        *ngSwitchCase=\"false\"\n        >{{ displayedValue }}</span\n      >\n    </ng-container>\n  </button>\n  <div\n    ngbDropdownMenu\n    class=\"w-100 bg-white text-gray-600\"\n    role=\"listbox\"\n    tabindex=\"-1\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: [":host{padding:0!important;position:relative}:host.impdc-select--disabled{background-color:var(--impd-color-gray-100)}.impdc-select--toggle{font-weight:inherit;padding-right:3.6rem;cursor:pointer;-webkit-user-select:none;user-select:none;width:100%}:host-context(.is-invalid) .impdc-select--toggle{padding-right:6.6rem}.impdc-select--toggle:disabled{cursor:default}.impdc-select--text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;width:100%}button[ngbDropdownToggle].dropdown-toggle:after{display:none}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['tabindex']
+                }] }, { type: i1.ErrorStateMatcher }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [IMPDC_FORM_ROOT]
+                }] }, { type: i2.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i2.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i2.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { options: [{
+                type: ContentChildren,
+                args: [SelectOptionComponent, { descendants: true }]
+            }], _ngbDropdown: [{
+                type: ViewChild,
+                args: [NgbDropdown]
+            }], _ngbDropdownMenu: [{
+                type: ViewChild,
+                args: [NgbDropdownMenu]
+            }], _toggleButtonRef: [{
+                type: ViewChild,
+                args: ['toggleButton', { static: true, read: ElementRef }]
+            }], placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], compareWith: [{
+                type: Input
+            }], errorStateMatcher: [{
+                type: Input
+            }], selectionChange: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../../../../../projects/design-components/src/lib/form-field/controls/select/select.component.ts","../../../../../../../../projects/design-components/src/lib/form-field/controls/select/select.component.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/no-conflicting-lifecycle */\nimport {\n  AfterContentInit,\n  AfterViewInit,\n  Attribute,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  DoCheck,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  QueryList,\n  Self,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  FormGroupDirective,\n  NgControl,\n  NgForm,\n  Validators\n} from '@angular/forms';\nimport { NgbDropdown, NgbDropdownMenu } from '@ng-bootstrap/ng-bootstrap';\nimport { nanoid } from 'nanoid';\nimport {\n  BooleanInput,\n  coerceBooleanPropertyValue\n} from '../../../../utilities';\nimport {\n  defer,\n  merge,\n  Observable,\n  startWith,\n  Subject,\n  switchMap,\n  take,\n  takeUntil\n} from 'rxjs';\nimport { ErrorStateMatcher } from '../../services';\nimport { ImpdcFormRoot, IMPDC_FORM_ROOT } from '../../directives';\nimport {\n  CanDisable,\n  HasTabIndex,\n  ICanUpdateErrorState,\n  IHasErrorState,\n  ImpdcFormFieldControl,\n  mixinDisabled,\n  mixinErrorState,\n  mixinTabIndex\n} from '../../shared';\nimport { IMPDC_SELECT_OPTION_PARENT_COMPONENT } from './option-parent';\nimport {\n  SelectOptionSelectionChangeEvent,\n  SelectOptionComponent\n} from './option/select-option.component';\nimport { SelectModel } from './select-model';\n\nexport class SelectChangeEvent {\n  constructor(\n    /** The specific SelectComponent that changed. */\n    public readonly source: SelectComponent,\n    /** The selected value(s) */\n    public readonly value: any\n  ) {}\n}\n\n/**\n * Returns an exception to be thrown when attempting to assign a non-array value to a select\n * in `multiple` mode. Note that `undefined` and `null` are still valid values to allow for\n * resetting the value.\n * @ignore\n */\nexport function getImpdcSelectNonArrayValueError(): Error {\n  return Error('Value must be an array in multiple-selection mode.');\n}\n\n/**\n * Returns an exception to be thrown when assigning a non-function value to the comparator\n * used to determine if a value corresponds to an option. Note that whether the function\n * actually takes two values and returns a boolean is not checked.\n */\nexport function getImpdcSelectNonFunctionValueError(): Error {\n  return Error('`compareWith` must be a function.');\n}\n\n/**\n * Returns an exception to be thrown when attempting to change a select's `multiple` option\n * after initialization.\n * @ignore\n */\nexport function getImpdcSelectDynamicMultipleError(): Error {\n  return Error('Cannot change `multiple` mode of select after initialization.');\n}\n\nconst _SelectComponentBase = mixinTabIndex(\n  mixinDisabled(\n    mixinErrorState(\n      class {\n        public readonly stateChanges = new Subject<void>();\n\n        constructor(\n          public _defaultErrorStateMatcher: ErrorStateMatcher,\n          public _formRoot: ImpdcFormRoot,\n          public _parentForm: NgForm,\n          public _parentFormGroup: FormGroupDirective,\n          public ngControl: NgControl | null\n        ) {}\n      }\n    )\n  )\n);\n\n/**\n * The `SelectComponent` (`<impdc-select`) is a select-style dropdown input where an item (or multiple items) can be picked\n * from a list of available options. This component can be used within a `FormFieldComponent` (`<impdc-form-field`).\n * To use, import `SelectModule` or another module that imports and exports that module from `@impartner/design-components`.\n */\n@Component({\n  selector: 'impdc-select',\n  exportAs: 'impdcSelect',\n  templateUrl: './select.component.html',\n  styleUrls: ['./select.component.scss'],\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['disabled', 'tabIndex'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    '[attr.id]': 'id',\n    '[attr.tabindex]': 'tabIndex',\n    '[attr.aria-required]': 'required.toString()',\n    '[attr.aria-disabled]': 'disabled.toString()',\n    '[attr.aria-invalid]': 'errorState',\n    '[class.form-select]': 'true',\n    '[class.is-invalid]': 'errorState',\n    '[class.impdc-form-field-control]': 'true',\n    '[class.impdc-select--required]': 'required',\n    '[class.impdc-select--disabled]': 'disabled',\n    '[class.impdc-select--invalid]': 'errorState',\n    '[class.impdc-select--empty]': 'empty',\n    '[class.impdc-select--multiple]': 'multiple',\n    '(focus)': '_onFocus(); focus()'\n  },\n  providers: [\n    {\n      provide: ImpdcFormFieldControl,\n      useExisting: SelectComponent\n    },\n    {\n      provide: IMPDC_SELECT_OPTION_PARENT_COMPONENT,\n      useExisting: SelectComponent\n    }\n  ]\n})\nexport class SelectComponent\n  extends _SelectComponentBase\n  implements\n    OnInit,\n    AfterContentInit,\n    AfterViewInit,\n    OnChanges,\n    DoCheck,\n    OnDestroy,\n    ControlValueAccessor,\n    HasTabIndex,\n    ImpdcFormFieldControl<any>,\n    CanDisable,\n    ICanUpdateErrorState,\n    IHasErrorState\n{\n  /** @ignore */\n  @ContentChildren(SelectOptionComponent, { descendants: true })\n  public options!: QueryList<SelectOptionComponent>;\n\n  @ViewChild(NgbDropdown)\n  protected _ngbDropdown!: NgbDropdown;\n\n  @ViewChild(NgbDropdownMenu)\n  protected _ngbDropdownMenu!: NgbDropdownMenu;\n\n  @ViewChild('toggleButton', { static: true, read: ElementRef })\n  protected _toggleButtonRef!: ElementRef<HTMLButtonElement>;\n\n  /** @ignore */\n  public readonly optionSelectionChanges: Observable<SelectOptionSelectionChangeEvent> =\n    defer(() => {\n      const options = this.options;\n\n      if (options) {\n        return options.changes.pipe(\n          startWith(options),\n          switchMap(() =>\n            merge(...options.map(option => option.onSelectionChange))\n          )\n        );\n      }\n\n      return this._ngZone.onStable.pipe(\n        take(1),\n        switchMap(() => this.optionSelectionChanges)\n      );\n    });\n\n  protected readonly _uid = `impdc-select-${nanoid()}`;\n  protected _selectionModel!: SelectModel<SelectOptionComponent>;\n\n  private readonly _ngDestroy = new Subject<void>();\n  private _previousControl?: AbstractControl | null;\n  private _compareWith = (o1: any, o2: any) => o1 === o2;\n  private _cvaOnChange: (value: any) => void = () => {};\n  private _cvaOnTouched = () => {};\n\n  /**\n   * The placeholder text that will be displayed when no selection has been made.\n   *\n   * @default \\- Select -\n   */\n  @Input()\n  public get placeholder(): string {\n    return this._placeholder;\n  }\n  public set placeholder(value: string) {\n    this._placeholder = value;\n    this.stateChanges.next();\n  }\n  private _placeholder: string = '- Select -';\n\n  /**\n   * Used to set requiredness of control in a template-based manner;\n   * not necessary when using the Angular reactive forms API and `required` validator.\n   */\n  @Input()\n  public get required(): boolean {\n    return (\n      this._required ??\n      this.ngControl?.control?.hasValidator(Validators.required) ??\n      false\n    );\n  }\n  public set required(value: BooleanInput) {\n    this._required = coerceBooleanPropertyValue(value);\n    this.stateChanges.next();\n  }\n  private _required: boolean | undefined;\n\n  /**\n   * Sets whether the control is a single-select or multiple-select. Cannot be changed after component initialization.\n   */\n  @Input()\n  public get multiple(): boolean {\n    return this._multiple;\n  }\n  public set multiple(value: BooleanInput) {\n    if (this._selectionModel) {\n      throw getImpdcSelectDynamicMultipleError();\n    }\n\n    this._multiple = coerceBooleanPropertyValue(value);\n  }\n  protected _multiple: boolean = false;\n\n  /**\n   * Function used to compare option values with selected values. The first arg is a\n   * value from an option, and the second arg is a value from the selection.\n   *\n   * @returns Boolean indicating if the values are equivalent.\n   */\n  @Input()\n  public get compareWith() {\n    return this._compareWith;\n  }\n  public set compareWith(fn: (a: any, b: any) => boolean) {\n    if (typeof fn !== 'function') {\n      throw getImpdcSelectNonFunctionValueError();\n    }\n\n    this._compareWith = fn;\n\n    if (this._selectionModel) {\n      // Changing the comparator function means the visual selection may have changed.\n      this._initializeSelection();\n    }\n  }\n\n  @Input()\n  public override errorStateMatcher!: ErrorStateMatcher;\n\n  /** Events fire when selection has been changed by the user. */\n  @Output()\n  public readonly selectionChange: EventEmitter<SelectChangeEvent> = new EventEmitter<SelectChangeEvent>();\n\n  /**\n   * Events fire when raw value of select changes. Mainly exists to handle\n   * two-way binding of `value` input property.\n   * @ignore\n   */\n  @Output()\n  public readonly valueChange: EventEmitter<any> = new EventEmitter<any>();\n\n  public get dropdownOpen(): boolean {\n    return this._ngbDropdown?.isOpen() ?? false;\n  }\n\n  constructor(\n    private readonly _changeDetector: ChangeDetectorRef,\n    protected readonly _ngZone: NgZone,\n    @Attribute('tabindex') tabIndex: string,\n    _defaultErrorStateMatcher: ErrorStateMatcher,\n    @Optional() @Inject(IMPDC_FORM_ROOT) _formRoot: ImpdcFormRoot,\n    @Optional() _parentForm: NgForm,\n    @Optional() _parentFormGroup: FormGroupDirective,\n    @Self() @Optional() ngControl: NgControl\n  ) {\n    super(\n      _defaultErrorStateMatcher,\n      _formRoot,\n      _parentForm,\n      _parentFormGroup,\n      ngControl\n    );\n\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n\n    this.id = this.id;\n    this.tabIndex = parseInt(tabIndex) || 0;\n  }\n\n  public get empty(): boolean {\n    return !this._selectionModel || this._selectionModel.isEmpty();\n  }\n\n  public get displayedValue(): string {\n    if (this.empty) {\n      return '';\n    }\n\n    if (!this._multiple) {\n      return this._selectionModel.selected[0].label;\n    }\n\n    return this._selectionModel.selected.map(opt => opt.label).join(', ');\n  }\n\n  public get selected(): SelectOptionComponent | SelectOptionComponent[] {\n    return this.multiple\n      ? this._selectionModel?.selected || []\n      : this._selectionModel?.selected[0];\n  }\n\n  /** @ignore */\n  public focus(options?: FocusOptions): void {\n    this._toggleButtonRef.nativeElement.focus(options);\n  }\n\n  protected _handleOpenChange(isOpen: boolean): void {\n    if (isOpen) {\n      this._onFocus();\n    } else {\n      this._onBlur();\n    }\n\n    this.stateChanges.next();\n  }\n\n  /* Angular lifecycle hooks */\n\n  /** @ignore */\n  public ngOnInit(): void {\n    this._selectionModel = new SelectModel<SelectOptionComponent>(\n      this.multiple\n    );\n    this.stateChanges.next();\n  }\n\n  /** @ignore */\n  public ngAfterContentInit(): void {\n    this._selectionModel.changed$\n      .pipe(takeUntil(this._ngDestroy))\n      .subscribe(changeEvent => {\n        changeEvent.added.forEach(option => option.select());\n        changeEvent.removed.forEach(option => option.deselect());\n      });\n\n    this.options.changes\n      .pipe(startWith(null), takeUntil(this._ngDestroy))\n      .subscribe(() => {\n        this._resetOptions();\n        this._initializeSelection();\n      });\n  }\n\n  /** @ignore */\n  public ngAfterViewInit(): void {\n    this._ngbDropdownMenu.menuItems = this.options;\n  }\n\n  /** @ignore */\n  public ngDoCheck(): void {\n    const ngControl = this.ngControl;\n\n    if (!ngControl) {\n      return;\n    }\n\n    if (this._previousControl !== ngControl.control) {\n      if (\n        this._previousControl !== undefined &&\n        ngControl.disabled !== null &&\n        ngControl.disabled !== this.disabled\n      ) {\n        this.disabled = ngControl?.disabled;\n      }\n\n      this._previousControl = ngControl.control;\n    }\n\n    this.updateErrorState();\n  }\n\n  /** @ignore */\n  public ngOnChanges(changes: SimpleChanges): void {\n    // Managing disabled state is handled via the `mixinDisabled` mixin/generator, but we still need to signal\n    // to the parent form field so it can run change detection when disabled state is changed.\n    if (changes['disabled']) {\n      this.stateChanges.next();\n    }\n  }\n\n  /** @ignore */\n  public ngOnDestroy(): void {\n    this._ngDestroy.next();\n    this._ngDestroy.complete();\n    this.stateChanges.complete();\n  }\n\n  /* ImpdcFormFieldControl */\n  public readonly controlType: string = 'impdc-select';\n\n  public readonly supportsAffixes: boolean = true;\n\n  @Input()\n  public get value(): any {\n    return this._value;\n  }\n  public set value(value: any) {\n    const hasAssigned = this._assignValue(value);\n\n    if (hasAssigned) {\n      this._cvaOnChange(value);\n    }\n  }\n  protected _value: any;\n\n  @Input()\n  public get id(): string {\n    return this._id;\n  }\n  public set id(value: string) {\n    this._id = value || this._uid;\n    this.stateChanges.next();\n  }\n  protected _id!: string;\n\n  public get focused(): boolean {\n    return this._focused || this.dropdownOpen;\n  }\n  protected _focused = false;\n\n  /* ControlValueAccessor */\n  /** @ignore */\n  public writeValue(value: any): void {\n    this._assignValue(value);\n  }\n\n  /** @ignore */\n  public registerOnChange(fn: (value: any) => void): void {\n    this._cvaOnChange = fn;\n  }\n\n  /** @ignore */\n  public registerOnTouched(fn: () => {}): void {\n    this._cvaOnTouched = fn;\n  }\n\n  /** @ignore */\n  public setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this._changeDetector.markForCheck();\n    this.stateChanges.next();\n  }\n\n  /* Internals */\n\n  protected _onFocus(): void {\n    if (!this.disabled) {\n      this._focused = true;\n      this.stateChanges.next();\n    }\n  }\n\n  /**\n   * Calls the CVA touched callback only if the dropdown is closed.\n   */\n  protected _onBlur(): void {\n    this._focused = false;\n\n    if (!this.disabled && !this.dropdownOpen) {\n      this._cvaOnTouched();\n      this._changeDetector.markForCheck();\n      this.stateChanges.next();\n    }\n  }\n\n  private _initializeSelection(): void {\n    // We defer this work into a promise in order to avoid tripping Angular's\n    // \"Expression has changed after it was checked\" error.\n    Promise.resolve().then(() => {\n      if (this.ngControl) {\n        this._value = this.ngControl.value;\n      }\n\n      this._setSelectionByValue(this._value);\n      this.stateChanges.next();\n    });\n  }\n\n  private _setSelectionByValue(value: any | any[]): void {\n    this._selectionModel.clear();\n\n    if (this.multiple && value) {\n      if (!Array.isArray(value)) {\n        throw getImpdcSelectNonArrayValueError();\n      }\n\n      value.forEach(currentValue => this._selectOptionByValue(currentValue));\n      this._sortValues();\n    } else {\n      this._selectOptionByValue(value);\n    }\n\n    this._changeDetector.detectChanges();\n  }\n\n  private _selectOptionByValue(value: any): SelectOptionComponent | undefined {\n    const correspondingOption = this.options.find(\n      (option: SelectOptionComponent) => {\n        if (this._selectionModel.isSelected(option)) {\n          return false;\n        }\n\n        try {\n          return option.value != null && this._compareWith(option.value, value);\n        } catch (error) {\n          console.warn(error);\n          return false;\n        }\n      }\n    );\n\n    if (correspondingOption) {\n      this._selectionModel.select(correspondingOption);\n    }\n\n    return correspondingOption;\n  }\n\n  /** Assigns a value to the select control. Returns a boolean indicating whether or not\n   * the value has changed.\n   */\n  private _assignValue(newValue: any | any[]): boolean {\n    if (\n      newValue !== this._value ||\n      (this._multiple && Array.isArray(newValue))\n    ) {\n      if (this.options) {\n        this._setSelectionByValue(newValue);\n      }\n\n      this._value = newValue;\n      return true;\n    }\n\n    return false;\n  }\n\n  private _resetOptions(): void {\n    const changedOrDestroyed = merge(this.options.changes, this._ngDestroy);\n\n    this.optionSelectionChanges\n      .pipe(takeUntil(changedOrDestroyed))\n      .subscribe(event => {\n        this._onSelect(event.source, event.isUserInput);\n\n        if (event.isUserInput && !this.multiple && this.dropdownOpen) {\n          this._ngbDropdown.close();\n          this.focus();\n        }\n      });\n\n    merge(...this.options.map(option => option.stateChanges))\n      .pipe(takeUntil(changedOrDestroyed))\n      .subscribe(() => {\n        this._changeDetector.detectChanges();\n        this.stateChanges.next();\n      });\n  }\n\n  private _onSelect(option: SelectOptionComponent, isUserInput: boolean): void {\n    const wasSelected = this._selectionModel.isSelected(option);\n\n    if (option.value == null && !this._multiple) {\n      option.deselect();\n      this._selectionModel.clear();\n\n      if (this.value != null) {\n        this._propagateChanges(option.value);\n      }\n    } else {\n      if (wasSelected !== option.selected) {\n        option.selected\n          ? this._selectionModel.select(option)\n          : this._selectionModel.deselect(option);\n      }\n\n      if (this.multiple) {\n        this._sortValues();\n\n        if (isUserInput) {\n          this.focus();\n        }\n      }\n    }\n\n    if (wasSelected !== this._selectionModel.isSelected(option)) {\n      this._propagateChanges();\n    }\n\n    this._changeDetector.markForCheck();\n    this.stateChanges.next();\n  }\n\n  private _sortValues(): void {\n    if (this.multiple) {\n      const options = this.options.toArray();\n\n      this._selectionModel.sort((a, b) => {\n        return options.indexOf(a) - options.indexOf(b);\n      });\n\n      this.stateChanges.next();\n    }\n  }\n\n  private _propagateChanges(fallbackValue?: any): void {\n    let valToEmit: any = null;\n\n    if (this.multiple) {\n      valToEmit = (this.selected as SelectOptionComponent[]).map(\n        option => option.value\n      );\n    } else {\n      valToEmit = this.selected\n        ? (this.selected as SelectOptionComponent).value\n        : fallbackValue;\n    }\n\n    this._value = valToEmit;\n    this.valueChange.emit(valToEmit);\n    this._cvaOnChange(valToEmit);\n    this.selectionChange.emit(this._buildChangeEvent(valToEmit));\n  }\n\n  private _buildChangeEvent(value: any): SelectChangeEvent {\n    return new SelectChangeEvent(this, value);\n  }\n}\n","<div\n  ngbDropdown\n  [autoClose]=\"multiple ? 'outside' : true\"\n  container=\"body\"\n  dropdownClass=\"impartner-hex\"\n  (openChange)=\"_handleOpenChange($event)\"\n  class=\"w-100\">\n  <button\n    #toggleButton\n    class=\"impdc-select--toggle btn border-0 text-start\"\n    type=\"button\"\n    role=\"combobox\"\n    [disabled]=\"disabled\"\n    (focus)=\"_onFocus()\"\n    (blur)=\"_onBlur()\"\n    ngbDropdownToggle>\n    <ng-container [ngSwitch]=\"empty\">\n      <span\n        class=\"impdc-select--text impdc-select--placeholder\"\n        *ngSwitchCase=\"true\"\n        >{{ placeholder }}</span\n      >\n      <span\n        class=\"impdc-select--text impdc-select--value-text\"\n        *ngSwitchCase=\"false\"\n        >{{ displayedValue }}</span\n      >\n    </ng-container>\n  </button>\n  <div\n    ngbDropdownMenu\n    class=\"w-100 bg-white text-gray-600\"\n    role=\"listbox\"\n    tabindex=\"-1\">\n    <ng-content></ng-content>\n  </div>\n</div>\n"]}

package/esm2020/lib/form-field/controls/select/select.module.mjs

@@ -0,0 +1,20 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { NgbDropdownModule } from '@ng-bootstrap/ng-bootstrap';
+import { SelectOptionComponent } from './option/select-option.component';
+import { SelectComponent } from './select.component';
+import * as i0 from "@angular/core";
+export class SelectModule {
+}
+SelectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: SelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SelectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: SelectModule, declarations: [SelectOptionComponent, SelectComponent], imports: [CommonModule, NgbDropdownModule], exports: [SelectOptionComponent, SelectComponent, NgbDropdownModule] });
+SelectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: SelectModule, imports: [CommonModule, NgbDropdownModule, NgbDropdownModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: SelectModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SelectOptionComponent, SelectComponent],
+                    imports: [CommonModule, NgbDropdownModule],
+                    exports: [SelectOptionComponent, SelectComponent, NgbDropdownModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rlc2lnbi1jb21wb25lbnRzL3NyYy9saWIvZm9ybS1maWVsZC9jb250cm9scy9zZWxlY3Qvc2VsZWN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUMvRCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUN6RSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBT3JELE1BQU0sT0FBTyxZQUFZOzswR0FBWixZQUFZOzJHQUFaLFlBQVksaUJBSlIscUJBQXFCLEVBQUUsZUFBZSxhQUMzQyxZQUFZLEVBQUUsaUJBQWlCLGFBQy9CLHFCQUFxQixFQUFFLGVBQWUsRUFBRSxpQkFBaUI7MkdBRXhELFlBQVksWUFIYixZQUFZLEVBQUUsaUJBQWlCLEVBQ1MsaUJBQWlCOzRGQUV4RCxZQUFZO2tCQUx4QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLHFCQUFxQixFQUFFLGVBQWUsQ0FBQztvQkFDdEQsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGlCQUFpQixDQUFDO29CQUMxQyxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsRUFBRSxlQUFlLEVBQUUsaUJBQWlCLENBQUM7aUJBQ3JFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBOZ2JEcm9wZG93bk1vZHVsZSB9IGZyb20gJ0BuZy1ib290c3RyYXAvbmctYm9vdHN0cmFwJztcbmltcG9ydCB7IFNlbGVjdE9wdGlvbkNvbXBvbmVudCB9IGZyb20gJy4vb3B0aW9uL3NlbGVjdC1vcHRpb24uY29tcG9uZW50JztcbmltcG9ydCB7IFNlbGVjdENvbXBvbmVudCB9IGZyb20gJy4vc2VsZWN0LmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1NlbGVjdE9wdGlvbkNvbXBvbmVudCwgU2VsZWN0Q29tcG9uZW50XSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgTmdiRHJvcGRvd25Nb2R1bGVdLFxuICBleHBvcnRzOiBbU2VsZWN0T3B0aW9uQ29tcG9uZW50LCBTZWxlY3RDb21wb25lbnQsIE5nYkRyb3Bkb3duTW9kdWxlXVxufSlcbmV4cG9ydCBjbGFzcyBTZWxlY3RNb2R1bGUge31cbiJdfQ==

package/esm2020/lib/form-field/controls/shared/index.mjs

@@ -0,0 +1,2 @@
+export * from './toggle';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tY29tcG9uZW50cy9zcmMvbGliL2Zvcm0tZmllbGQvY29udHJvbHMvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90b2dnbGUnO1xuIl19

package/esm2020/lib/form-field/controls/shared/toggle/components/index.mjs

@@ -0,0 +1,2 @@
+export * from './toggle-input/toggle-input.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tY29tcG9uZW50cy9zcmMvbGliL2Zvcm0tZmllbGQvY29udHJvbHMvc2hhcmVkL3RvZ2dsZS9jb21wb25lbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RvZ2dsZS1pbnB1dC90b2dnbGUtaW5wdXQuY29tcG9uZW50JztcbiJdfQ==