@up_si_vale/sivale-componentes-angular 1.0.0 → 1.0.2

package/esm2022/lib/molecules/multiselect/multiselect.component.mjs

@@ -0,0 +1,466 @@
+import { Component, Input, forwardRef, ViewChild, ElementRef, HostListener, ContentChildren, Inject, RendererStyleFlags2 } from '@angular/core';
+import { CommonModule, DOCUMENT } from '@angular/common';
+import { NG_VALUE_ACCESSOR, ReactiveFormsModule, FormsModule } from '@angular/forms';
+import { OptionComponent } from '../option/option.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class MultiselectComponent {
+    renderer;
+    document;
+    label = '';
+    id = '';
+    placeholder = '';
+    options = [];
+    hasError = false;
+    errorMessage = '';
+    disabled = false;
+    displayKey = 'label'; // Property to display as label
+    valueKey = 'value'; // Property to use as value
+    customClass = ''; // Custom CSS class for styling
+    trigger;
+    contentOptions;
+    value = [];
+    isOpen = false;
+    onChange = () => { };
+    onTouched = () => { };
+    _usingContentOptions = false;
+    dropdownElement = null;
+    backdropElement = null;
+    scrollHandler = null;
+    resizeHandler = null;
+    constructor(renderer, document) {
+        this.renderer = renderer;
+        this.document = document;
+    }
+    ngAfterContentInit() {
+        // Determine if using content projection or input options
+        this._usingContentOptions = this.contentOptions && this.contentOptions.length > 0;
+        // Subscribe to changes in content options
+        if (this.contentOptions) {
+            this.contentOptions.changes.subscribe(() => {
+                this._usingContentOptions = this.contentOptions.length > 0;
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.destroyDropdown();
+    }
+    /**
+     * Get all options (from content or input)
+     */
+    getAllOptions() {
+        if (this._usingContentOptions && this.contentOptions) {
+            return this.contentOptions.toArray();
+        }
+        return this.options || [];
+    }
+    /**
+     * Get display label from option
+     */
+    getOptionLabel(option) {
+        if (option instanceof OptionComponent) {
+            return option.viewValue;
+        }
+        return option?.[this.displayKey] || '';
+    }
+    /**
+     * Get value from option
+     */
+    getOptionValue(option) {
+        if (option instanceof OptionComponent) {
+            return option.value;
+        }
+        return option?.[this.valueKey];
+    }
+    /**
+     * Check if option is disabled
+     */
+    isOptionDisabled(option) {
+        if (option instanceof OptionComponent) {
+            return option.disabled;
+        }
+        return option?.disabled || false;
+    }
+    onDocumentClick(event) {
+        // Close dropdown if click is outside
+        if (this.isOpen && this.dropdownElement && !this.dropdownElement.contains(event.target)) {
+            const triggerElement = this.trigger?.nativeElement;
+            if (triggerElement && !triggerElement.contains(event.target)) {
+                this.closeDropdown();
+            }
+        }
+    }
+    toggleDropdown(event) {
+        event.stopPropagation();
+        if (this.disabled)
+            return;
+        if (this.isOpen) {
+            this.closeDropdown();
+        }
+        else {
+            this.openDropdown();
+        }
+    }
+    openDropdown() {
+        if (!this.trigger)
+            return;
+        // Create backdrop
+        this.backdropElement = this.renderer.createElement('div');
+        this.renderer.addClass(this.backdropElement, 'multiselect-custom-backdrop');
+        this.renderer.listen(this.backdropElement, 'click', () => this.closeDropdown());
+        this.renderer.appendChild(this.document.body, this.backdropElement);
+        // Create dropdown
+        this.dropdownElement = this.renderer.createElement('div');
+        this.renderer.addClass(this.dropdownElement, 'multiselect-custom-dropdown');
+        this.renderer.addClass(this.dropdownElement, 'multiselect-overlay-pane');
+        // Calculate position
+        const position = this.calculatePosition();
+        // Apply positioning styles
+        this.renderer.setStyle(this.dropdownElement, 'position', 'fixed');
+        this.renderer.setStyle(this.dropdownElement, 'left', position.left);
+        this.renderer.setStyle(this.dropdownElement, 'width', position.width);
+        this.renderer.setStyle(this.dropdownElement, 'max-height', position.maxHeight);
+        this.renderer.setStyle(this.dropdownElement, 'z-index', '100000', RendererStyleFlags2.Important);
+        if (position.top) {
+            this.renderer.setStyle(this.dropdownElement, 'top', position.top);
+        }
+        else if (position.bottom) {
+            this.renderer.setStyle(this.dropdownElement, 'bottom', position.bottom);
+        }
+        // Create dropdown content wrapper
+        const dropdownContent = this.renderer.createElement('div');
+        this.renderer.addClass(dropdownContent, 'multiselect-dropdown');
+        // Add options
+        const allOptions = this.getAllOptions();
+        allOptions.forEach(option => {
+            const optionElement = this.createOptionElement(option);
+            this.renderer.appendChild(dropdownContent, optionElement);
+        });
+        this.renderer.appendChild(this.dropdownElement, dropdownContent);
+        this.renderer.appendChild(this.document.body, this.dropdownElement);
+        this.isOpen = true;
+        // Add scroll and resize listeners to reposition dropdown
+        this.addRepositionListeners();
+        // Trigger animation
+        setTimeout(() => {
+            if (this.dropdownElement) {
+                this.renderer.addClass(this.dropdownElement, 'multiselect-dropdown-open');
+            }
+        }, 10);
+    }
+    calculatePosition() {
+        const triggerElement = this.trigger.nativeElement;
+        const rect = triggerElement.getBoundingClientRect();
+        const spaceBelow = window.innerHeight - rect.bottom;
+        const spaceAbove = rect.top;
+        const dropdownMaxHeight = 300;
+        const offsetY = 4;
+        const shouldOpenAbove = spaceBelow < 200 && spaceAbove > spaceBelow;
+        const position = {
+            left: `${rect.left}px`,
+            width: `${rect.width}px`,
+            maxHeight: `${dropdownMaxHeight}px`
+        };
+        if (shouldOpenAbove) {
+            position.bottom = `${window.innerHeight - rect.top + offsetY}px`;
+        }
+        else {
+            position.top = `${rect.bottom + offsetY}px`;
+        }
+        return position;
+    }
+    addRepositionListeners() {
+        // Create handlers
+        const scrollHandler = () => this.updateDropdownPosition();
+        const resizeHandler = () => this.updateDropdownPosition();
+        // Add scroll listener to window with capture phase to catch all scroll events
+        window.addEventListener('scroll', scrollHandler, true);
+        this.scrollHandler = () => window.removeEventListener('scroll', scrollHandler, true);
+        // Add resize listener
+        window.addEventListener('resize', resizeHandler);
+        this.resizeHandler = () => window.removeEventListener('resize', resizeHandler);
+    }
+    updateDropdownPosition() {
+        if (!this.dropdownElement || !this.trigger)
+            return;
+        const position = this.calculatePosition();
+        // Update position styles
+        this.renderer.setStyle(this.dropdownElement, 'left', position.left);
+        this.renderer.setStyle(this.dropdownElement, 'width', position.width);
+        // Remove old top/bottom styles
+        this.renderer.removeStyle(this.dropdownElement, 'top');
+        this.renderer.removeStyle(this.dropdownElement, 'bottom');
+        // Apply new top/bottom position
+        if (position.top) {
+            this.renderer.setStyle(this.dropdownElement, 'top', position.top);
+        }
+        else if (position.bottom) {
+            this.renderer.setStyle(this.dropdownElement, 'bottom', position.bottom);
+        }
+    }
+    createOptionElement(option) {
+        const labelElement = this.renderer.createElement('label');
+        this.renderer.addClass(labelElement, 'multiselect-option');
+        const optionValue = this.getOptionValue(option);
+        const optionLabel = this.getOptionLabel(option);
+        const optionDisabled = this.isOptionDisabled(option);
+        if (this.isSelected(optionValue)) {
+            this.renderer.addClass(labelElement, 'selected');
+        }
+        if (optionDisabled) {
+            this.renderer.addClass(labelElement, 'disabled');
+        }
+        // Stop propagation on label click
+        this.renderer.listen(labelElement, 'click', (event) => {
+            event.stopPropagation();
+        });
+        // Checkbox container
+        const checkboxDiv = this.renderer.createElement('div');
+        this.renderer.addClass(checkboxDiv, 'option-checkbox');
+        // Hidden native checkbox
+        const checkbox = this.renderer.createElement('input');
+        this.renderer.setAttribute(checkbox, 'type', 'checkbox');
+        this.renderer.setProperty(checkbox, 'checked', this.isSelected(optionValue));
+        if (optionDisabled) {
+            this.renderer.setProperty(checkbox, 'disabled', true);
+        }
+        // Custom checkbox span
+        const customCheckbox = this.renderer.createElement('span');
+        this.renderer.addClass(customCheckbox, 'checkbox-custom');
+        if (this.isSelected(optionValue)) {
+            this.renderer.addClass(customCheckbox, 'checked');
+        }
+        // Check icon
+        if (this.isSelected(optionValue)) {
+            const svg = this.createCheckIcon();
+            this.renderer.appendChild(customCheckbox, svg);
+        }
+        // Listen to change event
+        this.renderer.listen(checkbox, 'change', (event) => {
+            event.stopPropagation();
+            // Toggle the value
+            this.toggleOption(option);
+            // Update visual state
+            const isNowSelected = this.isSelected(optionValue);
+            this.renderer.setProperty(checkbox, 'checked', isNowSelected);
+            if (isNowSelected) {
+                this.renderer.addClass(labelElement, 'selected');
+                this.renderer.addClass(customCheckbox, 'checked');
+                // Add check icon if not present
+                if (!customCheckbox.querySelector('.check-icon')) {
+                    const svg = this.createCheckIcon();
+                    this.renderer.appendChild(customCheckbox, svg);
+                }
+            }
+            else {
+                this.renderer.removeClass(labelElement, 'selected');
+                this.renderer.removeClass(customCheckbox, 'checked');
+                // Remove check icon
+                const existingIcon = customCheckbox.querySelector('.check-icon');
+                if (existingIcon) {
+                    this.renderer.removeChild(customCheckbox, existingIcon);
+                }
+            }
+        });
+        this.renderer.appendChild(checkboxDiv, checkbox);
+        this.renderer.appendChild(checkboxDiv, customCheckbox);
+        this.renderer.appendChild(labelElement, checkboxDiv);
+        // Option text
+        const textSpan = this.renderer.createElement('span');
+        this.renderer.addClass(textSpan, 'option-text');
+        const text = this.renderer.createText(optionLabel);
+        this.renderer.appendChild(textSpan, text);
+        this.renderer.appendChild(labelElement, textSpan);
+        return labelElement;
+    }
+    createCheckIcon() {
+        const svg = this.renderer.createElement('svg', 'svg');
+        this.renderer.addClass(svg, 'check-icon');
+        this.renderer.setAttribute(svg, 'width', '14');
+        this.renderer.setAttribute(svg, 'height', '10');
+        this.renderer.setAttribute(svg, 'viewBox', '0 0 10 8');
+        this.renderer.setAttribute(svg, 'fill', 'none');
+        this.renderer.setAttribute(svg, 'xmlns', 'http://www.w3.org/2000/svg');
+        const path = this.renderer.createElement('path', 'svg');
+        this.renderer.setAttribute(path, 'd', 'M9 1L3.5 6.5L1 4');
+        this.renderer.setAttribute(path, 'stroke', '#F59100');
+        this.renderer.setAttribute(path, 'stroke-width', '1.6666');
+        this.renderer.setAttribute(path, 'stroke-linecap', 'round');
+        this.renderer.setAttribute(path, 'stroke-linejoin', 'round');
+        this.renderer.appendChild(svg, path);
+        return svg;
+    }
+    closeDropdown() {
+        this.destroyDropdown();
+        this.isOpen = false;
+        this.onTouched();
+    }
+    destroyDropdown() {
+        // Remove listeners
+        if (this.scrollHandler) {
+            this.scrollHandler();
+            this.scrollHandler = null;
+        }
+        if (this.resizeHandler) {
+            this.resizeHandler();
+            this.resizeHandler = null;
+        }
+        if (this.dropdownElement) {
+            this.renderer.removeChild(this.document.body, this.dropdownElement);
+            this.dropdownElement = null;
+        }
+        if (this.backdropElement) {
+            this.renderer.removeChild(this.document.body, this.backdropElement);
+            this.backdropElement = null;
+        }
+    }
+    toggleOption(option) {
+        if (this.isOptionDisabled(option))
+            return;
+        const optionValue = this.getOptionValue(option);
+        const index = this.value.indexOf(optionValue);
+        if (index > -1) {
+            this.value = this.value.filter(v => v !== optionValue);
+        }
+        else {
+            this.value = [...this.value, optionValue];
+        }
+        this.onChange(this.value);
+    }
+    isSelected(value) {
+        return this.value.includes(value);
+    }
+    getSelectedCount() {
+        return this.value.length;
+    }
+    getSelectedLabels() {
+        const allOptions = this.getAllOptions();
+        const selectedOptions = allOptions.filter(opt => this.isSelected(this.getOptionValue(opt)));
+        return selectedOptions.map(opt => this.getOptionLabel(opt)).join(', ');
+    }
+    writeValue(value) {
+        this.value = Array.isArray(value) ? value : [];
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MultiselectComponent, deps: [{ token: i0.Renderer2 }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: MultiselectComponent, isStandalone: true, selector: "app-multiselect", inputs: { label: "label", id: "id", placeholder: "placeholder", options: "options", hasError: "hasError", errorMessage: "errorMessage", disabled: "disabled", displayKey: "displayKey", valueKey: "valueKey", customClass: "customClass" }, host: { listeners: { "document:click": "onDocumentClick($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => MultiselectComponent),
+                multi: true
+            }
+        ], queries: [{ propertyName: "contentOptions", predicate: OptionComponent }], viewQueries: [{ propertyName: "trigger", first: true, predicate: ["trigger"], descendants: true, read: ElementRef }], ngImport: i0, template: `
+    <div class="multiselect-wrapper" [ngClass]="customClass">
+      <label *ngIf="label" [for]="id">{{ label }}</label>
+      <div class="multiselect-container">
+        <div
+          #trigger
+          class="multiselect-header"
+          (click)="toggleDropdown($event)"
+          [class.disabled]="disabled"
+          [class.open]="isOpen"
+          [class.error]="hasError">
+          <span class="multiselect-placeholder" *ngIf="getSelectedCount() === 0">
+            {{ placeholder || 'Selecciona uno o más...' }}
+          </span>
+          <span class="multiselect-selected" *ngIf="getSelectedCount() > 0">
+            {{ getSelectedLabels() }}
+          </span>
+          <svg class="multiselect-arrow" [class.open]="isOpen" width="12" height="8" viewBox="0 0 12 8" fill="none" xmlns="http://www.w3.org/2000/svg">
+            <path d="M1 1.5L6 6.5L11 1.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </div>
+      </div>
+      <div *ngIf="hasError && errorMessage" class="field-error">
+        {{ errorMessage }}
+      </div>
+
+      <!-- Hidden container for projected options -->
+      <div style="display: none;">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `, isInline: true, styles: [".multiselect-wrapper{width:100%;margin-bottom:6px;padding:0 4px}.multiselect-wrapper label{display:block;margin-bottom:.5rem;font-family:Quicksand,sans-serif;font-weight:500;font-size:14px;color:#585d61}.multiselect-container{position:relative;width:100%}.multiselect-header{display:flex;align-items:center;justify-content:space-between;padding:.75rem 1rem;border:1px solid #EAECF5;box-shadow:0 1px 2px #a1afec66;border-radius:8px;background:#fff;cursor:pointer;transition:all .2s;min-height:44px;height:44px}.multiselect-header:hover:not(.disabled){border-color:#fbd399}.multiselect-header:focus-within{border-color:#fbd399;box-shadow:0 0 0 4px #ffe8c8,0 1px 2px #0a0d120d}.multiselect-header.disabled{background:#f5f5f5;cursor:not-allowed;opacity:.6}.multiselect-header.error{border-color:#dc3545!important}.multiselect-header.error.open{box-shadow:0 0 0 3px #dc35451a!important}.multiselect-header .multiselect-placeholder{font-family:Quicksand,sans-serif;font-size:14px;color:#969a9c}.multiselect-header .multiselect-selected{font-family:Quicksand,sans-serif;font-size:14px;color:#1a1d20;font-weight:500;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.multiselect-header .multiselect-arrow{color:#969a9c;transition:transform .3s ease;margin-left:.5rem;flex-shrink:0;display:flex;align-items:center}.multiselect-header .multiselect-arrow.open{transform:rotate(180deg)}.multiselect-dropdown{margin-top:8px;background:#fff;border:1px solid #EAECF5;border-radius:8px;box-shadow:0 10px 16px -4px #edeffb;max-height:290px!important;width:100%;overflow-x:hidden;overflow-y:auto;animation:dropdownSlide .25s cubic-bezier(.4,0,.2,1)}.multiselect-dropdown::-webkit-scrollbar{width:8px}.multiselect-dropdown::-webkit-scrollbar-track{background:#f1f1f1;border-radius:0 12px 12px 0}.multiselect-dropdown::-webkit-scrollbar-thumb{background:#d5d7d8;border-radius:4px}.multiselect-dropdown::-webkit-scrollbar-thumb:hover{background:#969a9c}@keyframes dropdownSlide{0%{opacity:0;transform:translateY(-8px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}.multiselect-option{display:flex!important;align-items:center;padding:.6rem 1.25rem;cursor:pointer;transition:all .2s cubic-bezier(.4,0,.2,1);border-bottom:1px solid #F1F2F4;gap:1rem;margin:0!important;position:relative}.multiselect-option:first-child{border-radius:12px 12px 0 0}.multiselect-option:last-child{border-bottom:none;border-radius:0 0 12px 12px}.multiselect-option:hover:not(.disabled){background:linear-gradient(90deg,#fff9f0,#fffef9)}.multiselect-option:hover:not(.disabled):before{opacity:.5}.multiselect-option.disabled{opacity:.5;cursor:not-allowed;background:#f8f9fc}.multiselect-option.disabled:hover{transform:none;background:#f8f9fc}.multiselect-option .option-checkbox{position:relative;display:flex;align-items:center;flex-shrink:0}.multiselect-option .option-checkbox input[type=checkbox]{position:absolute;opacity:0;cursor:pointer;width:22px;height:22px;margin:0}.multiselect-option .option-checkbox .checkbox-custom{width:22px;height:22px;border:2.5px solid #D5D7D8;border-radius:6px;display:flex;align-items:center;justify-content:center;transition:all .25s cubic-bezier(.4,0,.2,1);background:#fff;position:relative}.multiselect-option .option-checkbox .checkbox-custom:after{content:\"\";position:absolute;width:100%;height:100%;border-radius:4px;background:#f59100;opacity:0;transform:scale(.5);transition:all .25s cubic-bezier(.4,0,.2,1)}.multiselect-option .option-checkbox .checkbox-custom.checked{background:#fff;border-color:#f59100;border-width:2.5px;transform:scale(1.05)}.multiselect-option .option-checkbox .checkbox-custom.checked:after{opacity:0}.multiselect-option .option-checkbox .checkbox-custom .check-icon{position:relative;z-index:1;display:flex;align-items:center;justify-content:center;animation:checkPop .3s cubic-bezier(.68,-.55,.265,1.55)}.multiselect-option .option-checkbox input[type=checkbox]:hover~.checkbox-custom:not(.checked){border-color:#f26d00;transform:scale(1.05)}.multiselect-option .option-text{flex:1;font-family:Quicksand,sans-serif;font-weight:500;font-size:14px;color:#1a1d20;line-height:1.5;transition:color .2s ease,font-weight .2s ease}@keyframes checkPop{0%{transform:scale(0);opacity:0}50%{transform:scale(1.2)}to{transform:scale(1);opacity:1}}.field-error{color:#f04438;font-size:.875rem;margin-top:.25rem;font-family:Quicksand,sans-serif}::ng-deep .multiselect-custom-backdrop{position:fixed;top:0;left:0;width:100%;height:100%;background:transparent;z-index:99999;pointer-events:auto}::ng-deep .multiselect-custom-dropdown{position:fixed;background:#fff;border-radius:8px;overflow:hidden;z-index:1000;opacity:0;transform:translateY(-8px) scale(.98);transition:opacity .25s cubic-bezier(.4,0,.2,1),transform .25s cubic-bezier(.4,0,.2,1)}::ng-deep .multiselect-custom-dropdown.multiselect-dropdown-open{opacity:1;transform:translateY(0) scale(1)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "ngmodule", type: FormsModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MultiselectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-multiselect', standalone: true, imports: [CommonModule, ReactiveFormsModule, FormsModule], template: `
+    <div class="multiselect-wrapper" [ngClass]="customClass">
+      <label *ngIf="label" [for]="id">{{ label }}</label>
+      <div class="multiselect-container">
+        <div
+          #trigger
+          class="multiselect-header"
+          (click)="toggleDropdown($event)"
+          [class.disabled]="disabled"
+          [class.open]="isOpen"
+          [class.error]="hasError">
+          <span class="multiselect-placeholder" *ngIf="getSelectedCount() === 0">
+            {{ placeholder || 'Selecciona uno o más...' }}
+          </span>
+          <span class="multiselect-selected" *ngIf="getSelectedCount() > 0">
+            {{ getSelectedLabels() }}
+          </span>
+          <svg class="multiselect-arrow" [class.open]="isOpen" width="12" height="8" viewBox="0 0 12 8" fill="none" xmlns="http://www.w3.org/2000/svg">
+            <path d="M1 1.5L6 6.5L11 1.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </div>
+      </div>
+      <div *ngIf="hasError && errorMessage" class="field-error">
+        {{ errorMessage }}
+      </div>
+
+      <!-- Hidden container for projected options -->
+      <div style="display: none;">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => MultiselectComponent),
+                            multi: true
+                        }
+                    ], styles: [".multiselect-wrapper{width:100%;margin-bottom:6px;padding:0 4px}.multiselect-wrapper label{display:block;margin-bottom:.5rem;font-family:Quicksand,sans-serif;font-weight:500;font-size:14px;color:#585d61}.multiselect-container{position:relative;width:100%}.multiselect-header{display:flex;align-items:center;justify-content:space-between;padding:.75rem 1rem;border:1px solid #EAECF5;box-shadow:0 1px 2px #a1afec66;border-radius:8px;background:#fff;cursor:pointer;transition:all .2s;min-height:44px;height:44px}.multiselect-header:hover:not(.disabled){border-color:#fbd399}.multiselect-header:focus-within{border-color:#fbd399;box-shadow:0 0 0 4px #ffe8c8,0 1px 2px #0a0d120d}.multiselect-header.disabled{background:#f5f5f5;cursor:not-allowed;opacity:.6}.multiselect-header.error{border-color:#dc3545!important}.multiselect-header.error.open{box-shadow:0 0 0 3px #dc35451a!important}.multiselect-header .multiselect-placeholder{font-family:Quicksand,sans-serif;font-size:14px;color:#969a9c}.multiselect-header .multiselect-selected{font-family:Quicksand,sans-serif;font-size:14px;color:#1a1d20;font-weight:500;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.multiselect-header .multiselect-arrow{color:#969a9c;transition:transform .3s ease;margin-left:.5rem;flex-shrink:0;display:flex;align-items:center}.multiselect-header .multiselect-arrow.open{transform:rotate(180deg)}.multiselect-dropdown{margin-top:8px;background:#fff;border:1px solid #EAECF5;border-radius:8px;box-shadow:0 10px 16px -4px #edeffb;max-height:290px!important;width:100%;overflow-x:hidden;overflow-y:auto;animation:dropdownSlide .25s cubic-bezier(.4,0,.2,1)}.multiselect-dropdown::-webkit-scrollbar{width:8px}.multiselect-dropdown::-webkit-scrollbar-track{background:#f1f1f1;border-radius:0 12px 12px 0}.multiselect-dropdown::-webkit-scrollbar-thumb{background:#d5d7d8;border-radius:4px}.multiselect-dropdown::-webkit-scrollbar-thumb:hover{background:#969a9c}@keyframes dropdownSlide{0%{opacity:0;transform:translateY(-8px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}.multiselect-option{display:flex!important;align-items:center;padding:.6rem 1.25rem;cursor:pointer;transition:all .2s cubic-bezier(.4,0,.2,1);border-bottom:1px solid #F1F2F4;gap:1rem;margin:0!important;position:relative}.multiselect-option:first-child{border-radius:12px 12px 0 0}.multiselect-option:last-child{border-bottom:none;border-radius:0 0 12px 12px}.multiselect-option:hover:not(.disabled){background:linear-gradient(90deg,#fff9f0,#fffef9)}.multiselect-option:hover:not(.disabled):before{opacity:.5}.multiselect-option.disabled{opacity:.5;cursor:not-allowed;background:#f8f9fc}.multiselect-option.disabled:hover{transform:none;background:#f8f9fc}.multiselect-option .option-checkbox{position:relative;display:flex;align-items:center;flex-shrink:0}.multiselect-option .option-checkbox input[type=checkbox]{position:absolute;opacity:0;cursor:pointer;width:22px;height:22px;margin:0}.multiselect-option .option-checkbox .checkbox-custom{width:22px;height:22px;border:2.5px solid #D5D7D8;border-radius:6px;display:flex;align-items:center;justify-content:center;transition:all .25s cubic-bezier(.4,0,.2,1);background:#fff;position:relative}.multiselect-option .option-checkbox .checkbox-custom:after{content:\"\";position:absolute;width:100%;height:100%;border-radius:4px;background:#f59100;opacity:0;transform:scale(.5);transition:all .25s cubic-bezier(.4,0,.2,1)}.multiselect-option .option-checkbox .checkbox-custom.checked{background:#fff;border-color:#f59100;border-width:2.5px;transform:scale(1.05)}.multiselect-option .option-checkbox .checkbox-custom.checked:after{opacity:0}.multiselect-option .option-checkbox .checkbox-custom .check-icon{position:relative;z-index:1;display:flex;align-items:center;justify-content:center;animation:checkPop .3s cubic-bezier(.68,-.55,.265,1.55)}.multiselect-option .option-checkbox input[type=checkbox]:hover~.checkbox-custom:not(.checked){border-color:#f26d00;transform:scale(1.05)}.multiselect-option .option-text{flex:1;font-family:Quicksand,sans-serif;font-weight:500;font-size:14px;color:#1a1d20;line-height:1.5;transition:color .2s ease,font-weight .2s ease}@keyframes checkPop{0%{transform:scale(0);opacity:0}50%{transform:scale(1.2)}to{transform:scale(1);opacity:1}}.field-error{color:#f04438;font-size:.875rem;margin-top:.25rem;font-family:Quicksand,sans-serif}::ng-deep .multiselect-custom-backdrop{position:fixed;top:0;left:0;width:100%;height:100%;background:transparent;z-index:99999;pointer-events:auto}::ng-deep .multiselect-custom-dropdown{position:fixed;background:#fff;border-radius:8px;overflow:hidden;z-index:1000;opacity:0;transform:translateY(-8px) scale(.98);transition:opacity .25s cubic-bezier(.4,0,.2,1),transform .25s cubic-bezier(.4,0,.2,1)}::ng-deep .multiselect-custom-dropdown.multiselect-dropdown-open{opacity:1;transform:translateY(0) scale(1)}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }], propDecorators: { label: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], hasError: [{
+                type: Input
+            }], errorMessage: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], displayKey: [{
+                type: Input
+            }], valueKey: [{
+                type: Input
+            }], customClass: [{
+                type: Input
+            }], trigger: [{
+                type: ViewChild,
+                args: ['trigger', { read: ElementRef }]
+            }], contentOptions: [{
+                type: ContentChildren,
+                args: [OptionComponent]
+            }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multiselect.component.js","sourceRoot":"","sources":["../../../../../src/lib/molecules/multiselect/multiselect.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  forwardRef,\n  ViewChild,\n  ElementRef,\n  HostListener,\n  ContentChildren,\n  QueryList,\n  AfterContentInit,\n  OnDestroy,\n  Renderer2,\n  Inject,\n  RendererStyleFlags2\n} from '@angular/core';\nimport { CommonModule, DOCUMENT } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, ReactiveFormsModule, FormsModule } from '@angular/forms';\nimport { OptionComponent } from '../option/option.component';\n\nexport interface MultiselectOption {\n  value: any;\n  label: string;\n  icon?: string;\n  disabled?: boolean;\n}\n\ninterface DropdownPosition {\n  top?: string;\n  bottom?: string;\n  left: string;\n  width: string;\n  maxHeight: string;\n}\n\n@Component({\n  selector: 'app-multiselect',\n  standalone: true,\n  imports: [CommonModule, ReactiveFormsModule, FormsModule],\n  template: `\n    <div class=\"multiselect-wrapper\" [ngClass]=\"customClass\">\n      <label *ngIf=\"label\" [for]=\"id\">{{ label }}</label>\n      <div class=\"multiselect-container\">\n        <div\n          #trigger\n          class=\"multiselect-header\"\n          (click)=\"toggleDropdown($event)\"\n          [class.disabled]=\"disabled\"\n          [class.open]=\"isOpen\"\n          [class.error]=\"hasError\">\n          <span class=\"multiselect-placeholder\" *ngIf=\"getSelectedCount() === 0\">\n            {{ placeholder || 'Selecciona uno o más...' }}\n          </span>\n          <span class=\"multiselect-selected\" *ngIf=\"getSelectedCount() > 0\">\n            {{ getSelectedLabels() }}\n          </span>\n          <svg class=\"multiselect-arrow\" [class.open]=\"isOpen\" width=\"12\" height=\"8\" viewBox=\"0 0 12 8\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path d=\"M1 1.5L6 6.5L11 1.5\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n          </svg>\n        </div>\n      </div>\n      <div *ngIf=\"hasError && errorMessage\" class=\"field-error\">\n        {{ errorMessage }}\n      </div>\n\n      <!-- Hidden container for projected options -->\n      <div style=\"display: none;\">\n        <ng-content></ng-content>\n      </div>\n    </div>\n  `,\n  styleUrls: ['./multiselect.component.scss'],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => MultiselectComponent),\n      multi: true\n    }\n  ]\n})\nexport class MultiselectComponent implements ControlValueAccessor, AfterContentInit, OnDestroy {\n  @Input() label = '';\n  @Input() id = '';\n  @Input() placeholder = '';\n  @Input() options: MultiselectOption[] | any[] = [];\n  @Input() hasError = false;\n  @Input() errorMessage = '';\n  @Input() disabled = false;\n  @Input() displayKey: string = 'label'; // Property to display as label\n  @Input() valueKey: string = 'value'; // Property to use as value\n  @Input() customClass: string = ''; // Custom CSS class for styling\n  @ViewChild('trigger', { read: ElementRef }) trigger!: ElementRef;\n  @ContentChildren(OptionComponent) contentOptions!: QueryList<OptionComponent>;\n\n  value: any[] = [];\n  isOpen = false;\n  onChange: any = () => {};\n  onTouched: any = () => {};\n  private _usingContentOptions = false;\n\n  private dropdownElement: HTMLElement | null = null;\n  private backdropElement: HTMLElement | null = null;\n  private scrollHandler: (() => void) | null = null;\n  private resizeHandler: (() => void) | null = null;\n\n  constructor(\n    private renderer: Renderer2,\n    @Inject(DOCUMENT) private document: Document\n  ) {}\n\n  ngAfterContentInit(): void {\n    // Determine if using content projection or input options\n    this._usingContentOptions = this.contentOptions && this.contentOptions.length > 0;\n\n    // Subscribe to changes in content options\n    if (this.contentOptions) {\n      this.contentOptions.changes.subscribe(() => {\n        this._usingContentOptions = this.contentOptions.length > 0;\n      });\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.destroyDropdown();\n  }\n\n  /**\n   * Get all options (from content or input)\n   */\n  getAllOptions(): any[] {\n    if (this._usingContentOptions && this.contentOptions) {\n      return this.contentOptions.toArray();\n    }\n    return this.options || [];\n  }\n\n  /**\n   * Get display label from option\n   */\n  getOptionLabel(option: any): string {\n    if (option instanceof OptionComponent) {\n      return option.viewValue;\n    }\n    return option?.[this.displayKey] || '';\n  }\n\n  /**\n   * Get value from option\n   */\n  getOptionValue(option: any): any {\n    if (option instanceof OptionComponent) {\n      return option.value;\n    }\n    return option?.[this.valueKey];\n  }\n\n  /**\n   * Check if option is disabled\n   */\n  isOptionDisabled(option: any): boolean {\n    if (option instanceof OptionComponent) {\n      return option.disabled;\n    }\n    return option?.disabled || false;\n  }\n\n  @HostListener('document:click', ['$event'])\n  onDocumentClick(event: MouseEvent): void {\n    // Close dropdown if click is outside\n    if (this.isOpen && this.dropdownElement && !this.dropdownElement.contains(event.target as Node)) {\n      const triggerElement = this.trigger?.nativeElement;\n      if (triggerElement && !triggerElement.contains(event.target as Node)) {\n        this.closeDropdown();\n      }\n    }\n  }\n\n  toggleDropdown(event: Event): void {\n    event.stopPropagation();\n    if (this.disabled) return;\n\n    if (this.isOpen) {\n      this.closeDropdown();\n    } else {\n      this.openDropdown();\n    }\n  }\n\n  private openDropdown(): void {\n    if (!this.trigger) return;\n\n    // Create backdrop\n    this.backdropElement = this.renderer.createElement('div');\n    this.renderer.addClass(this.backdropElement, 'multiselect-custom-backdrop');\n    this.renderer.listen(this.backdropElement, 'click', () => this.closeDropdown());\n    this.renderer.appendChild(this.document.body, this.backdropElement);\n\n    // Create dropdown\n    this.dropdownElement = this.renderer.createElement('div');\n    this.renderer.addClass(this.dropdownElement, 'multiselect-custom-dropdown');\n    this.renderer.addClass(this.dropdownElement, 'multiselect-overlay-pane');\n\n    // Calculate position\n    const position = this.calculatePosition();\n\n    // Apply positioning styles\n    this.renderer.setStyle(this.dropdownElement, 'position', 'fixed');\n    this.renderer.setStyle(this.dropdownElement, 'left', position.left);\n    this.renderer.setStyle(this.dropdownElement, 'width', position.width);\n    this.renderer.setStyle(this.dropdownElement, 'max-height', position.maxHeight);\n    this.renderer.setStyle(this.dropdownElement, 'z-index', '100000', RendererStyleFlags2.Important);\n\n    if (position.top) {\n      this.renderer.setStyle(this.dropdownElement, 'top', position.top);\n    } else if (position.bottom) {\n      this.renderer.setStyle(this.dropdownElement, 'bottom', position.bottom);\n    }\n\n    // Create dropdown content wrapper\n    const dropdownContent = this.renderer.createElement('div');\n    this.renderer.addClass(dropdownContent, 'multiselect-dropdown');\n\n    // Add options\n    const allOptions = this.getAllOptions();\n    allOptions.forEach(option => {\n      const optionElement = this.createOptionElement(option);\n      this.renderer.appendChild(dropdownContent, optionElement);\n    });\n\n    this.renderer.appendChild(this.dropdownElement, dropdownContent);\n    this.renderer.appendChild(this.document.body, this.dropdownElement);\n\n    this.isOpen = true;\n\n    // Add scroll and resize listeners to reposition dropdown\n    this.addRepositionListeners();\n\n    // Trigger animation\n    setTimeout(() => {\n      if (this.dropdownElement) {\n        this.renderer.addClass(this.dropdownElement, 'multiselect-dropdown-open');\n      }\n    }, 10);\n  }\n\n  private calculatePosition(): DropdownPosition {\n    const triggerElement = this.trigger.nativeElement;\n    const rect = triggerElement.getBoundingClientRect();\n\n    const spaceBelow = window.innerHeight - rect.bottom;\n    const spaceAbove = rect.top;\n    const dropdownMaxHeight = 300;\n    const offsetY = 4;\n\n    const shouldOpenAbove = spaceBelow < 200 && spaceAbove > spaceBelow;\n\n    const position: DropdownPosition = {\n      left: `${rect.left}px`,\n      width: `${rect.width}px`,\n      maxHeight: `${dropdownMaxHeight}px`\n    };\n\n    if (shouldOpenAbove) {\n      position.bottom = `${window.innerHeight - rect.top + offsetY}px`;\n    } else {\n      position.top = `${rect.bottom + offsetY}px`;\n    }\n\n    return position;\n  }\n\n  private addRepositionListeners(): void {\n    // Create handlers\n    const scrollHandler = () => this.updateDropdownPosition();\n    const resizeHandler = () => this.updateDropdownPosition();\n\n    // Add scroll listener to window with capture phase to catch all scroll events\n    window.addEventListener('scroll', scrollHandler, true);\n    this.scrollHandler = () => window.removeEventListener('scroll', scrollHandler, true);\n\n    // Add resize listener\n    window.addEventListener('resize', resizeHandler);\n    this.resizeHandler = () => window.removeEventListener('resize', resizeHandler);\n  }\n\n  private updateDropdownPosition(): void {\n    if (!this.dropdownElement || !this.trigger) return;\n\n    const position = this.calculatePosition();\n\n    // Update position styles\n    this.renderer.setStyle(this.dropdownElement, 'left', position.left);\n    this.renderer.setStyle(this.dropdownElement, 'width', position.width);\n\n    // Remove old top/bottom styles\n    this.renderer.removeStyle(this.dropdownElement, 'top');\n    this.renderer.removeStyle(this.dropdownElement, 'bottom');\n\n    // Apply new top/bottom position\n    if (position.top) {\n      this.renderer.setStyle(this.dropdownElement, 'top', position.top);\n    } else if (position.bottom) {\n      this.renderer.setStyle(this.dropdownElement, 'bottom', position.bottom);\n    }\n  }\n\n  private createOptionElement(option: any): HTMLElement {\n    const labelElement = this.renderer.createElement('label');\n    this.renderer.addClass(labelElement, 'multiselect-option');\n\n    const optionValue = this.getOptionValue(option);\n    const optionLabel = this.getOptionLabel(option);\n    const optionDisabled = this.isOptionDisabled(option);\n\n    if (this.isSelected(optionValue)) {\n      this.renderer.addClass(labelElement, 'selected');\n    }\n\n    if (optionDisabled) {\n      this.renderer.addClass(labelElement, 'disabled');\n    }\n\n    // Stop propagation on label click\n    this.renderer.listen(labelElement, 'click', (event: Event) => {\n      event.stopPropagation();\n    });\n\n    // Checkbox container\n    const checkboxDiv = this.renderer.createElement('div');\n    this.renderer.addClass(checkboxDiv, 'option-checkbox');\n\n    // Hidden native checkbox\n    const checkbox = this.renderer.createElement('input');\n    this.renderer.setAttribute(checkbox, 'type', 'checkbox');\n    this.renderer.setProperty(checkbox, 'checked', this.isSelected(optionValue));\n    if (optionDisabled) {\n      this.renderer.setProperty(checkbox, 'disabled', true);\n    }\n\n    // Custom checkbox span\n    const customCheckbox = this.renderer.createElement('span');\n    this.renderer.addClass(customCheckbox, 'checkbox-custom');\n    if (this.isSelected(optionValue)) {\n      this.renderer.addClass(customCheckbox, 'checked');\n    }\n\n    // Check icon\n    if (this.isSelected(optionValue)) {\n      const svg = this.createCheckIcon();\n      this.renderer.appendChild(customCheckbox, svg);\n    }\n\n    // Listen to change event\n    this.renderer.listen(checkbox, 'change', (event: Event) => {\n      event.stopPropagation();\n\n      // Toggle the value\n      this.toggleOption(option);\n\n      // Update visual state\n      const isNowSelected = this.isSelected(optionValue);\n      this.renderer.setProperty(checkbox, 'checked', isNowSelected);\n\n      if (isNowSelected) {\n        this.renderer.addClass(labelElement, 'selected');\n        this.renderer.addClass(customCheckbox, 'checked');\n        // Add check icon if not present\n        if (!customCheckbox.querySelector('.check-icon')) {\n          const svg = this.createCheckIcon();\n          this.renderer.appendChild(customCheckbox, svg);\n        }\n      } else {\n        this.renderer.removeClass(labelElement, 'selected');\n        this.renderer.removeClass(customCheckbox, 'checked');\n        // Remove check icon\n        const existingIcon = customCheckbox.querySelector('.check-icon');\n        if (existingIcon) {\n          this.renderer.removeChild(customCheckbox, existingIcon);\n        }\n      }\n    });\n\n    this.renderer.appendChild(checkboxDiv, checkbox);\n    this.renderer.appendChild(checkboxDiv, customCheckbox);\n    this.renderer.appendChild(labelElement, checkboxDiv);\n\n    // Option text\n    const textSpan = this.renderer.createElement('span');\n    this.renderer.addClass(textSpan, 'option-text');\n    const text = this.renderer.createText(optionLabel);\n    this.renderer.appendChild(textSpan, text);\n    this.renderer.appendChild(labelElement, textSpan);\n\n    return labelElement;\n  }\n\n  private createCheckIcon(): SVGElement {\n    const svg = this.renderer.createElement('svg', 'svg');\n    this.renderer.addClass(svg, 'check-icon');\n    this.renderer.setAttribute(svg, 'width', '14');\n    this.renderer.setAttribute(svg, 'height', '10');\n    this.renderer.setAttribute(svg, 'viewBox', '0 0 10 8');\n    this.renderer.setAttribute(svg, 'fill', 'none');\n    this.renderer.setAttribute(svg, 'xmlns', 'http://www.w3.org/2000/svg');\n\n    const path = this.renderer.createElement('path', 'svg');\n    this.renderer.setAttribute(path, 'd', 'M9 1L3.5 6.5L1 4');\n    this.renderer.setAttribute(path, 'stroke', '#F59100');\n    this.renderer.setAttribute(path, 'stroke-width', '1.6666');\n    this.renderer.setAttribute(path, 'stroke-linecap', 'round');\n    this.renderer.setAttribute(path, 'stroke-linejoin', 'round');\n\n    this.renderer.appendChild(svg, path);\n    return svg;\n  }\n\n  closeDropdown(): void {\n    this.destroyDropdown();\n    this.isOpen = false;\n    this.onTouched();\n  }\n\n  private destroyDropdown(): void {\n    // Remove listeners\n    if (this.scrollHandler) {\n      this.scrollHandler();\n      this.scrollHandler = null;\n    }\n\n    if (this.resizeHandler) {\n      this.resizeHandler();\n      this.resizeHandler = null;\n    }\n\n    if (this.dropdownElement) {\n      this.renderer.removeChild(this.document.body, this.dropdownElement);\n      this.dropdownElement = null;\n    }\n\n    if (this.backdropElement) {\n      this.renderer.removeChild(this.document.body, this.backdropElement);\n      this.backdropElement = null;\n    }\n  }\n\n  toggleOption(option: any): void {\n    if (this.isOptionDisabled(option)) return;\n\n    const optionValue = this.getOptionValue(option);\n    const index = this.value.indexOf(optionValue);\n    if (index > -1) {\n      this.value = this.value.filter(v => v !== optionValue);\n    } else {\n      this.value = [...this.value, optionValue];\n    }\n    this.onChange(this.value);\n  }\n\n  isSelected(value: any): boolean {\n    return this.value.includes(value);\n  }\n\n  getSelectedCount(): number {\n    return this.value.length;\n  }\n\n  getSelectedLabels(): string {\n    const allOptions = this.getAllOptions();\n    const selectedOptions = allOptions.filter(opt => this.isSelected(this.getOptionValue(opt)));\n    return selectedOptions.map(opt => this.getOptionLabel(opt)).join(', ');\n  }\n\n  writeValue(value: any): void {\n    this.value = Array.isArray(value) ? value : [];\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n}\n"]}

package/esm2022/lib/molecules/option/option.component.mjs

@@ -0,0 +1,55 @@
+import { Component, Input, HostBinding, ChangeDetectionStrategy } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+export class OptionComponent {
+    elementRef;
+    value;
+    disabled = false;
+    selected = false;
+    optionClass = true;
+    // Internal property to store text content
+    _viewValue = '';
+    get viewValue() {
+        return this._viewValue || this.getTextContent();
+    }
+    set viewValue(value) {
+        this._viewValue = value;
+    }
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    /**
+     * Get the text content from the element
+     */
+    getTextContent() {
+        return this.elementRef.nativeElement.textContent?.trim() || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OptionComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: OptionComponent, isStandalone: true, selector: "app-option", inputs: { value: "value", disabled: "disabled" }, host: { properties: { "class.disabled": "disabled", "class.selected": "this.selected", "class.app-option": "this.optionClass" }, classAttribute: "app-option" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OptionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-option',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `<ng-content></ng-content>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        'class': 'app-option',
+                        '[class.disabled]': 'disabled',
+                        '[class.selected]': 'selected'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { value: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], selected: [{
+                type: HostBinding,
+                args: ['class.selected']
+            }], optionClass: [{
+                type: HostBinding,
+                args: ['class.app-option']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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