@up_si_vale/sivale-componentes-angular 1.0.0 → 1.0.2

package/esm2022/lib/molecules/phone-input/phone-input.component.mjs

@@ -0,0 +1,64 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { InputComponent } from '../../atoms/input/input.component';
+import { SelectComponent } from '../select/select.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class PhoneInputComponent {
+    label = 'Teléfono';
+    hasError = false;
+    errorMessage = '';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PhoneInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: PhoneInputComponent, isStandalone: true, selector: "app-phone-input", inputs: { label: "label", hasError: "hasError", errorMessage: "errorMessage" }, ngImport: i0, template: `
+    <div class="svu-phone-input" [class.svu-phone-input--error]="hasError">
+      <label *ngIf="label" class="svu-phone-input__label">
+        {{ label }}
+      </label>
+
+      <div class="svu-phone-input__field">
+        <div class="svu-phone-input__country">
+          <ng-content select="[countrySelect]"></ng-content>
+        </div>
+
+        <div class="svu-phone-input__number">
+          <ng-content select="[phoneInput]"></ng-content>
+        </div>
+      </div>
+
+      <span *ngIf="hasError && errorMessage" class="svu-phone-input__error">
+        {{ errorMessage }}
+      </span>
+    </div>
+  `, isInline: true, styles: [".svu-phone-input{display:flex;flex-direction:column;width:100%;margin-bottom:6px;padding:0 4px}.svu-phone-input__label{display:block;margin-bottom:.5rem;font-family:Quicksand,sans-serif;font-weight:500;font-size:14px;color:#585d61}.svu-phone-input__field{position:relative;display:flex;align-items:stretch;min-height:44px;height:44px;border:1px solid #EAECF5;box-shadow:0 1px 2px #a1afec66;border-radius:8px;transition:all .2s ease;background:#fff}.svu-phone-input__field:hover{border-color:#fbd399}.svu-phone-input__field:focus-within{border-color:#fbd399;box-shadow:0 0 0 4px #ffe8c8,0 1px 2px #0a0d120d}.svu-phone-input__country{flex:0;width:120px;display:flex;align-items:stretch;min-width:64px}.svu-phone-input__number{flex:1;min-width:0;display:flex;align-items:stretch}.svu-phone-input.svu-phone-input--error .svu-phone-input__field{border-color:#dc3545!important}.svu-phone-input.svu-phone-input--error .svu-phone-input__field:focus-within{box-shadow:0 0 0 3px #dc35451a!important}.svu-phone-input__error{color:#f04438;font-size:.875rem;margin-top:.25rem;font-family:Quicksand,sans-serif}@media (max-width: 640px){.svu-phone-input__country{width:100px}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PhoneInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-phone-input', standalone: true, imports: [CommonModule, InputComponent, SelectComponent], template: `
+    <div class="svu-phone-input" [class.svu-phone-input--error]="hasError">
+      <label *ngIf="label" class="svu-phone-input__label">
+        {{ label }}
+      </label>
+
+      <div class="svu-phone-input__field">
+        <div class="svu-phone-input__country">
+          <ng-content select="[countrySelect]"></ng-content>
+        </div>
+
+        <div class="svu-phone-input__number">
+          <ng-content select="[phoneInput]"></ng-content>
+        </div>
+      </div>
+
+      <span *ngIf="hasError && errorMessage" class="svu-phone-input__error">
+        {{ errorMessage }}
+      </span>
+    </div>
+  `, styles: [".svu-phone-input{display:flex;flex-direction:column;width:100%;margin-bottom:6px;padding:0 4px}.svu-phone-input__label{display:block;margin-bottom:.5rem;font-family:Quicksand,sans-serif;font-weight:500;font-size:14px;color:#585d61}.svu-phone-input__field{position:relative;display:flex;align-items:stretch;min-height:44px;height:44px;border:1px solid #EAECF5;box-shadow:0 1px 2px #a1afec66;border-radius:8px;transition:all .2s ease;background:#fff}.svu-phone-input__field:hover{border-color:#fbd399}.svu-phone-input__field:focus-within{border-color:#fbd399;box-shadow:0 0 0 4px #ffe8c8,0 1px 2px #0a0d120d}.svu-phone-input__country{flex:0;width:120px;display:flex;align-items:stretch;min-width:64px}.svu-phone-input__number{flex:1;min-width:0;display:flex;align-items:stretch}.svu-phone-input.svu-phone-input--error .svu-phone-input__field{border-color:#dc3545!important}.svu-phone-input.svu-phone-input--error .svu-phone-input__field:focus-within{box-shadow:0 0 0 3px #dc35451a!important}.svu-phone-input__error{color:#f04438;font-size:.875rem;margin-top:.25rem;font-family:Quicksand,sans-serif}@media (max-width: 640px){.svu-phone-input__country{width:100px}}\n"] }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], hasError: [{
+                type: Input
+            }], errorMessage: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,498 @@
+import { Component, Input, forwardRef, ViewChild, ElementRef, HostListener, ContentChildren, ContentChild, RendererStyleFlags2 } from '@angular/core';
+import { CommonModule, DOCUMENT } from '@angular/common';
+import { NG_VALUE_ACCESSOR, ReactiveFormsModule, FormsModule } from '@angular/forms';
+import { Inject } from '@angular/core';
+import { OptionComponent } from '../option/option.component';
+// Directive markers for prefix/suffix
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class SelectPrefixDirective {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectPrefixDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SelectPrefixDirective, isStandalone: true, selector: "[prefix]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectPrefixDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[prefix]',
+                    standalone: true
+                }]
+        }] });
+export class SelectSuffixDirective {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectSuffixDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: SelectSuffixDirective, isStandalone: true, selector: "[suffix]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SelectSuffixDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[suffix]',
+                    standalone: true
+                }]
+        }] });
+export class SelectComponent {
+    renderer;
+    document;
+    label = '';
+    id = '';
+    placeholder = '';
+    options = [];
+    hasError = false;
+    errorMessage = '';
+    disabled = false;
+    unstyled = false;
+    displayKey = 'label'; // Property to display as label
+    valueKey = 'value'; // Property to use as value
+    customClass = ''; // Custom CSS class for styling
+    trigger;
+    contentOptions;
+    prefixDirective;
+    suffixDirective;
+    get hasPrefix() {
+        return !!this.prefixDirective;
+    }
+    get hasSuffix() {
+        return !!this.suffixDirective;
+    }
+    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();
+    }
+    onEsc() {
+        this.closeDropdown();
+        this.onTouched();
+    }
+    handleBlur() {
+        this.onTouched();
+    }
+    /**
+     * 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, 'select-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, 'select-custom-dropdown');
+        this.renderer.addClass(this.dropdownElement, 'select-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, 'select-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, 'select-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 optionElement = this.renderer.createElement('div');
+        this.renderer.addClass(optionElement, 'select-option');
+        const optionValue = this.getOptionValue(option);
+        const optionLabel = this.getOptionLabel(option);
+        const optionDisabled = this.isOptionDisabled(option);
+        if (this.isEmptyValue(optionValue)) {
+            this.renderer.addClass(optionElement, 'select-option-placeholder');
+        }
+        if (this.isSelected(optionValue)) {
+            this.renderer.addClass(optionElement, 'selected');
+        }
+        if (optionDisabled) {
+            this.renderer.addClass(optionElement, 'disabled');
+        }
+        // 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(optionElement, textSpan);
+        // Check icon for selected option
+        if (this.isSelected(optionValue)) {
+            const svg = this.createCheckIcon();
+            this.renderer.appendChild(optionElement, svg);
+        }
+        // Click handler
+        if (!optionDisabled) {
+            this.renderer.listen(optionElement, 'click', (event) => {
+                event.stopPropagation();
+                this.selectOption(option);
+            });
+        }
+        return optionElement;
+    }
+    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;
+    }
+    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;
+        }
+    }
+    selectOption(option) {
+        if (this.isOptionDisabled(option))
+            return;
+        this.value = this.getOptionValue(option);
+        this.onChange(this.value);
+        this.onTouched();
+        this.closeDropdown();
+    }
+    isSelected(value) {
+        return this.value === value;
+    }
+    isEmptyValue(value) {
+        return value === '' || value === null || value === undefined;
+    }
+    getSelectedLabel() {
+        const allOptions = this.getAllOptions();
+        const selectedOption = allOptions.find(opt => this.getOptionValue(opt) === this.value);
+        return selectedOption ? this.getOptionLabel(selectedOption) : '';
+    }
+    writeValue(value) {
+        this.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: SelectComponent, deps: [{ token: i0.Renderer2 }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SelectComponent, isStandalone: true, selector: "app-select", inputs: { label: "label", id: "id", placeholder: "placeholder", options: "options", hasError: "hasError", errorMessage: "errorMessage", disabled: "disabled", unstyled: "unstyled", displayKey: "displayKey", valueKey: "valueKey", customClass: "customClass" }, host: { listeners: { "keydown.escape": "onEsc()", "document:click": "onDocumentClick($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => SelectComponent),
+                multi: true
+            }
+        ], queries: [{ propertyName: "prefixDirective", first: true, predicate: SelectPrefixDirective, descendants: true }, { propertyName: "suffixDirective", first: true, predicate: SelectSuffixDirective, descendants: true }, { propertyName: "contentOptions", predicate: OptionComponent }], viewQueries: [{ propertyName: "trigger", first: true, predicate: ["trigger"], descendants: true, read: ElementRef }], ngImport: i0, template: `
+    <div class="select-wrapper" [class.select-wrapper--unstyled]="unstyled" [ngClass]="customClass">
+      <label *ngIf="label && !unstyled" [for]="id">{{ label }}</label>
+      <div class="select-container" [class.select-container--unstyled]="unstyled">
+        <div
+          #trigger
+          class="select-header"
+          [attr.tabindex]="disabled ? -1 : 0"
+          [class.error]="hasError && !unstyled"
+          [class.disabled]="disabled"
+          [class.open]="isOpen"
+          [class.select-header--unstyled]="unstyled"
+          [class.select-header--has-prefix]="hasPrefix"
+           (blur)="handleBlur()"
+          (click)="!disabled && toggleDropdown($event)">
+          <span class="select-prefix" *ngIf="hasPrefix">
+            <ng-content select="[prefix]"></ng-content>
+          </span>
+          <span class="select-placeholder" *ngIf="!getSelectedLabel()">
+            {{ placeholder }}
+          </span>
+          <span class="select-selected" *ngIf="getSelectedLabel()">
+            {{ getSelectedLabel() }}
+          </span>
+          <span class="select-suffix" *ngIf="hasSuffix">
+            <ng-content select="[suffix]"></ng-content>
+          </span>
+          <svg class="select-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 && !unstyled" class="field-error">
+        {{ errorMessage }}
+      </div>
+
+      <!-- Hidden container for projected options -->
+      <div style="display: none;">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `, isInline: true, 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: SelectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-select',
+                    standalone: true,
+                    imports: [CommonModule, ReactiveFormsModule, FormsModule, SelectPrefixDirective, SelectSuffixDirective],
+                    template: `
+    <div class="select-wrapper" [class.select-wrapper--unstyled]="unstyled" [ngClass]="customClass">
+      <label *ngIf="label && !unstyled" [for]="id">{{ label }}</label>
+      <div class="select-container" [class.select-container--unstyled]="unstyled">
+        <div
+          #trigger
+          class="select-header"
+          [attr.tabindex]="disabled ? -1 : 0"
+          [class.error]="hasError && !unstyled"
+          [class.disabled]="disabled"
+          [class.open]="isOpen"
+          [class.select-header--unstyled]="unstyled"
+          [class.select-header--has-prefix]="hasPrefix"
+           (blur)="handleBlur()"
+          (click)="!disabled && toggleDropdown($event)">
+          <span class="select-prefix" *ngIf="hasPrefix">
+            <ng-content select="[prefix]"></ng-content>
+          </span>
+          <span class="select-placeholder" *ngIf="!getSelectedLabel()">
+            {{ placeholder }}
+          </span>
+          <span class="select-selected" *ngIf="getSelectedLabel()">
+            {{ getSelectedLabel() }}
+          </span>
+          <span class="select-suffix" *ngIf="hasSuffix">
+            <ng-content select="[suffix]"></ng-content>
+          </span>
+          <svg class="select-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 && !unstyled" 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(() => SelectComponent),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], 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
+            }], unstyled: [{
+                type: Input
+            }], displayKey: [{
+                type: Input
+            }], valueKey: [{
+                type: Input
+            }], customClass: [{
+                type: Input
+            }], trigger: [{
+                type: ViewChild,
+                args: ['trigger', { read: ElementRef }]
+            }], contentOptions: [{
+                type: ContentChildren,
+                args: [OptionComponent]
+            }], prefixDirective: [{
+                type: ContentChild,
+                args: [SelectPrefixDirective]
+            }], suffixDirective: [{
+                type: ContentChild,
+                args: [SelectSuffixDirective]
+            }], onEsc: [{
+                type: HostListener,
+                args: ['keydown.escape']
+            }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../../src/lib/molecules/select/select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  forwardRef,\n  ViewChild,\n  ElementRef,\n  OnDestroy,\n  HostListener,\n  Renderer2,\n  ContentChildren,\n  ContentChild,\n  QueryList,\n  AfterContentInit,\n  RendererStyleFlags2,\n  TemplateRef\n} from '@angular/core';\nimport { CommonModule, DOCUMENT } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, ReactiveFormsModule, FormsModule } from '@angular/forms';\nimport { Inject } from '@angular/core';\nimport { OptionComponent } from '../option/option.component';\n\n// Directive markers for prefix/suffix\nimport { Directive } from '@angular/core';\n\n@Directive({\n  selector: '[prefix]',\n  standalone: true\n})\nexport class SelectPrefixDirective {}\n\n@Directive({\n  selector: '[suffix]',\n  standalone: true\n})\nexport class SelectSuffixDirective {}\n\nexport interface SelectOption {\n  value: any;\n  label: 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-select',\n  standalone: true,\n  imports: [CommonModule, ReactiveFormsModule, FormsModule, SelectPrefixDirective, SelectSuffixDirective],\n  template: `\n    <div class=\"select-wrapper\" [class.select-wrapper--unstyled]=\"unstyled\" [ngClass]=\"customClass\">\n      <label *ngIf=\"label && !unstyled\" [for]=\"id\">{{ label }}</label>\n      <div class=\"select-container\" [class.select-container--unstyled]=\"unstyled\">\n        <div\n          #trigger\n          class=\"select-header\"\n          [attr.tabindex]=\"disabled ? -1 : 0\"\n          [class.error]=\"hasError && !unstyled\"\n          [class.disabled]=\"disabled\"\n          [class.open]=\"isOpen\"\n          [class.select-header--unstyled]=\"unstyled\"\n          [class.select-header--has-prefix]=\"hasPrefix\"\n           (blur)=\"handleBlur()\"\n          (click)=\"!disabled && toggleDropdown($event)\">\n          <span class=\"select-prefix\" *ngIf=\"hasPrefix\">\n            <ng-content select=\"[prefix]\"></ng-content>\n          </span>\n          <span class=\"select-placeholder\" *ngIf=\"!getSelectedLabel()\">\n            {{ placeholder }}\n          </span>\n          <span class=\"select-selected\" *ngIf=\"getSelectedLabel()\">\n            {{ getSelectedLabel() }}\n          </span>\n          <span class=\"select-suffix\" *ngIf=\"hasSuffix\">\n            <ng-content select=\"[suffix]\"></ng-content>\n          </span>\n          <svg class=\"select-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 && !unstyled\" 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  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => SelectComponent),\n      multi: true\n    }\n  ]\n})\nexport class SelectComponent implements ControlValueAccessor, OnDestroy, AfterContentInit {\n  @Input() label = '';\n  @Input() id = '';\n  @Input() placeholder = '';\n  @Input() options: SelectOption[] | any[] = [];\n  @Input() hasError = false;\n  @Input() errorMessage = '';\n  @Input() disabled = false;\n  @Input() unstyled = 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  @ContentChild(SelectPrefixDirective) prefixDirective!: SelectPrefixDirective;\n  @ContentChild(SelectSuffixDirective) suffixDirective!: SelectSuffixDirective;\n\n  get hasPrefix(): boolean {\n    return !!this.prefixDirective;\n  }\n\n  get hasSuffix(): boolean {\n    return !!this.suffixDirective;\n  }\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  @HostListener('keydown.escape')\nonEsc() {\n  this.closeDropdown();\n  this.onTouched();\n}\n\n  handleBlur() {\n    this.onTouched();\n  }\n\n  /**\n   * Get all options (from content or input)\n   */\n  private 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, 'select-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, 'select-custom-dropdown');\n    this.renderer.addClass(this.dropdownElement, 'select-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, 'select-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, 'select-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 optionElement = this.renderer.createElement('div');\n    this.renderer.addClass(optionElement, 'select-option');\n\n    const optionValue = this.getOptionValue(option);\n    const optionLabel = this.getOptionLabel(option);\n    const optionDisabled = this.isOptionDisabled(option);\n\n    if (this.isEmptyValue(optionValue)) {\n      this.renderer.addClass(optionElement, 'select-option-placeholder');\n    }\n\n    if (this.isSelected(optionValue)) {\n      this.renderer.addClass(optionElement, 'selected');\n    }\n\n    if (optionDisabled) {\n      this.renderer.addClass(optionElement, 'disabled');\n    }\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(optionElement, textSpan);\n\n    // Check icon for selected option\n    if (this.isSelected(optionValue)) {\n      const svg = this.createCheckIcon();\n      this.renderer.appendChild(optionElement, svg);\n    }\n\n    // Click handler\n    if (!optionDisabled) {\n      this.renderer.listen(optionElement, 'click', (event: Event) => {\n        event.stopPropagation();\n        this.selectOption(option);\n      });\n    }\n\n    return optionElement;\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  }\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  selectOption(option: any): void {\n    if (this.isOptionDisabled(option)) return;\n\n    this.value = this.getOptionValue(option);\n    this.onChange(this.value);\n    this.onTouched();\n    this.closeDropdown();\n  }\n\n  isSelected(value: any): boolean {\n    return this.value === value;\n  }\n\n  isEmptyValue(value: any): boolean {\n    return value === '' || value === null || value === undefined;\n  }\n\n  getSelectedLabel(): string {\n    const allOptions = this.getAllOptions();\n    const selectedOption = allOptions.find(opt => this.getOptionValue(opt) === this.value);\n    return selectedOption ? this.getOptionLabel(selectedOption) : '';\n  }\n\n  writeValue(value: any): void {\n    this.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"]}