valtech-components 2.0.691 → 2.0.692

package/esm2022/lib/components/molecules/refresher/refresher.component.mjs

@@ -0,0 +1,269 @@
+import { Component, Input, Output, EventEmitter, signal, ViewChild, ContentChild, inject, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonRefresher, IonRefresherContent, IonSpinner, IonText, } from '@ionic/angular/standalone';
+import { I18nService } from '../../../services/i18n';
+import { DEFAULT_REFRESHER_METADATA, } from './types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Componente de pull-to-refresh para movil y web.
+ *
+ * @example
+ * <!-- Uso basico -->
+ * <val-refresher
+ *   [props]="{
+ *     color: 'primary',
+ *     pullingText: 'Arrastra para actualizar',
+ *     refreshingText: 'Cargando...'
+ *   }"
+ *   (refresh)="onRefresh($event)"
+ * >
+ *   <ion-content>
+ *     <!-- Contenido scrolleable -->
+ *   </ion-content>
+ * </val-refresher>
+ *
+ * @example
+ * <!-- Con indicador personalizado -->
+ * <val-refresher [props]="{ color: 'primary' }" (refresh)="onRefresh($event)">
+ *   <ng-template #pullingIndicator let-progress="progress">
+ *     <div class="custom-indicator">
+ *       <ion-icon name="arrow-down" [style.transform]="'rotate(' + progress * 180 + 'deg)'"></ion-icon>
+ *     </div>
+ *   </ng-template>
+ *   <ion-content>...</ion-content>
+ * </val-refresher>
+ */
+export class RefresherComponent {
+    constructor() {
+        /** Configuracion del refresher */
+        this.props = {};
+        /** Evento emitido cuando se activa el refresh */
+        this.refresh = new EventEmitter();
+        /** Evento de progreso durante el pull */
+        this.pullProgressChange = new EventEmitter();
+        /** Evento de cambio de estado */
+        this.stateChange = new EventEmitter();
+        this.i18n = inject(I18nService);
+        /** Estado actual del refresher */
+        this.state = signal('idle');
+        /** Progreso actual del pull (0-1) */
+        this.pullProgress = signal(0);
+    }
+    /** Get pulling text with i18n fallback */
+    getPullingText() {
+        return this.props.pullingText || this.i18n.t('pullToRefresh');
+    }
+    /** Get refreshing text with i18n fallback */
+    getRefreshingText() {
+        return this.props.refreshingText || this.i18n.t('loading');
+    }
+    /** Props combinados con defaults */
+    get mergedProps() {
+        return {
+            ...DEFAULT_REFRESHER_METADATA,
+            ...this.props,
+            pullingText: this.getPullingText(),
+            refreshingText: this.getRefreshingText(),
+        };
+    }
+    /** Si hay indicadores personalizados */
+    get hasCustomIndicator() {
+        return !!(this.pullingIndicator ||
+            this.refreshingIndicator ||
+            this.completingIndicator ||
+            this.props.indicatorConfig);
+    }
+    /**
+     * Activa programaticamente el refresh.
+     */
+    triggerRefresh() {
+        this.state.set('refreshing');
+        this.emitRefreshEvent();
+    }
+    /**
+     * Completa la operacion de refresh actual.
+     */
+    complete() {
+        this.state.set('completing');
+        this.stateChange.emit('completing');
+        this.ionRefresher?.complete();
+        // Resetear a idle despues de la animacion
+        setTimeout(() => {
+            this.state.set('idle');
+            this.stateChange.emit('idle');
+        }, this.mergedProps.closeDuration ?? 280);
+    }
+    /**
+     * Cancela la operacion de refresh actual.
+     */
+    cancel() {
+        this.ionRefresher?.cancel();
+        this.state.set('idle');
+        this.stateChange.emit('idle');
+    }
+    /** Handler para evento ionRefresh */
+    onIonRefresh(event) {
+        this.state.set('refreshing');
+        this.stateChange.emit('refreshing');
+        this.emitRefreshEvent();
+    }
+    /** Handler para evento ionPull */
+    onIonPull(event) {
+        const detail = event.detail;
+        const progress = Math.min(detail.progress, 1);
+        this.pullProgress.set(progress);
+        this.pullProgressChange.emit({
+            progress,
+            thresholdReached: progress >= 1,
+        });
+    }
+    /** Handler para evento ionStart */
+    onIonStart() {
+        this.state.set('pulling');
+        this.stateChange.emit('pulling');
+    }
+    emitRefreshEvent() {
+        const event = {
+            complete: () => this.complete(),
+            cancel: () => this.cancel(),
+            timestamp: new Date(),
+        };
+        this.refresh.emit(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RefresherComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: RefresherComponent, isStandalone: true, selector: "val-refresher", inputs: { props: "props" }, outputs: { refresh: "refresh", pullProgressChange: "pullProgressChange", stateChange: "stateChange" }, queries: [{ propertyName: "pullingIndicator", first: true, predicate: ["pullingIndicator"], descendants: true }, { propertyName: "refreshingIndicator", first: true, predicate: ["refreshingIndicator"], descendants: true }, { propertyName: "completingIndicator", first: true, predicate: ["completingIndicator"], descendants: true }], viewQueries: [{ propertyName: "ionRefresher", first: true, predicate: ["refresher"], descendants: true }], ngImport: i0, template: `
+    <ion-refresher
+      #refresher
+      slot="fixed"
+      [disabled]="mergedProps.disabled"
+      [pullMin]="mergedProps.pullThreshold"
+      [pullMax]="mergedProps.pullMax"
+      [pullFactor]="mergedProps.pullFactor"
+      [snapbackDuration]="mergedProps.snapbackDuration"
+      [closeDuration]="mergedProps.closeDuration"
+      (ionRefresh)="onIonRefresh($event)"
+      (ionPull)="onIonPull($event)"
+      (ionStart)="onIonStart()"
+    >
+      @if (hasCustomIndicator) {
+        <!-- Custom indicator templates -->
+        <div class="refresher-custom-content">
+          @switch (state()) {
+            @case ('pulling') {
+              @if (pullingIndicator) {
+                <ng-container
+                  *ngTemplateOutlet="pullingIndicator; context: { progress: pullProgress() }"
+                ></ng-container>
+              }
+            }
+            @case ('refreshing') {
+              @if (refreshingIndicator) {
+                <ng-container *ngTemplateOutlet="refreshingIndicator"></ng-container>
+              } @else {
+                <ion-spinner [name]="mergedProps.spinnerType" [color]="mergedProps.color"></ion-spinner>
+                @if (mergedProps.refreshingText) {
+                  <ion-text [color]="mergedProps.color">{{ mergedProps.refreshingText }}</ion-text>
+                }
+              }
+            }
+            @case ('completing') {
+              @if (completingIndicator) {
+                <ng-container *ngTemplateOutlet="completingIndicator"></ng-container>
+              }
+            }
+          }
+        </div>
+      } @else {
+        <!-- Default Ionic refresher content -->
+        <ion-refresher-content
+          [pullingIcon]="mergedProps.spinnerType === 'crescent' ? 'chevron-down-circle-outline' : undefined"
+          [pullingText]="mergedProps.pullingText"
+          [refreshingSpinner]="mergedProps.spinnerType"
+          [refreshingText]="mergedProps.refreshingText"
+        ></ion-refresher-content>
+      }
+    </ion-refresher>
+
+    <ng-content></ng-content>
+  `, isInline: true, styles: [":host{display:block;position:relative}.refresher-custom-content{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;padding:16px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: IonRefresher, selector: "ion-refresher", inputs: ["closeDuration", "disabled", "mode", "pullFactor", "pullMax", "pullMin", "snapbackDuration"] }, { kind: "component", type: IonRefresherContent, selector: "ion-refresher-content", inputs: ["pullingIcon", "pullingText", "refreshingSpinner", "refreshingText"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonText, selector: "ion-text", inputs: ["color", "mode"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RefresherComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-refresher', standalone: true, imports: [CommonModule, IonRefresher, IonRefresherContent, IonSpinner, IonText], template: `
+    <ion-refresher
+      #refresher
+      slot="fixed"
+      [disabled]="mergedProps.disabled"
+      [pullMin]="mergedProps.pullThreshold"
+      [pullMax]="mergedProps.pullMax"
+      [pullFactor]="mergedProps.pullFactor"
+      [snapbackDuration]="mergedProps.snapbackDuration"
+      [closeDuration]="mergedProps.closeDuration"
+      (ionRefresh)="onIonRefresh($event)"
+      (ionPull)="onIonPull($event)"
+      (ionStart)="onIonStart()"
+    >
+      @if (hasCustomIndicator) {
+        <!-- Custom indicator templates -->
+        <div class="refresher-custom-content">
+          @switch (state()) {
+            @case ('pulling') {
+              @if (pullingIndicator) {
+                <ng-container
+                  *ngTemplateOutlet="pullingIndicator; context: { progress: pullProgress() }"
+                ></ng-container>
+              }
+            }
+            @case ('refreshing') {
+              @if (refreshingIndicator) {
+                <ng-container *ngTemplateOutlet="refreshingIndicator"></ng-container>
+              } @else {
+                <ion-spinner [name]="mergedProps.spinnerType" [color]="mergedProps.color"></ion-spinner>
+                @if (mergedProps.refreshingText) {
+                  <ion-text [color]="mergedProps.color">{{ mergedProps.refreshingText }}</ion-text>
+                }
+              }
+            }
+            @case ('completing') {
+              @if (completingIndicator) {
+                <ng-container *ngTemplateOutlet="completingIndicator"></ng-container>
+              }
+            }
+          }
+        </div>
+      } @else {
+        <!-- Default Ionic refresher content -->
+        <ion-refresher-content
+          [pullingIcon]="mergedProps.spinnerType === 'crescent' ? 'chevron-down-circle-outline' : undefined"
+          [pullingText]="mergedProps.pullingText"
+          [refreshingSpinner]="mergedProps.spinnerType"
+          [refreshingText]="mergedProps.refreshingText"
+        ></ion-refresher-content>
+      }
+    </ion-refresher>
+
+    <ng-content></ng-content>
+  `, styles: [":host{display:block;position:relative}.refresher-custom-content{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:8px;padding:16px}\n"] }]
+        }], propDecorators: { ionRefresher: [{
+                type: ViewChild,
+                args: ['refresher']
+            }], pullingIndicator: [{
+                type: ContentChild,
+                args: ['pullingIndicator']
+            }], refreshingIndicator: [{
+                type: ContentChild,
+                args: ['refreshingIndicator']
+            }], completingIndicator: [{
+                type: ContentChild,
+                args: ['completingIndicator']
+            }], props: [{
+                type: Input
+            }], refresh: [{
+                type: Output
+            }], pullProgressChange: [{
+                type: Output
+            }], stateChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"refresher.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/molecules/refresher/refresher.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  signal,\n  ViewChild,\n  TemplateRef,\n  ContentChild,\n  inject,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport {\n  IonRefresher,\n  IonRefresherContent,\n  IonSpinner,\n  IonText,\n} from '@ionic/angular/standalone';\nimport { I18nService } from '../../../services/i18n';\nimport {\n  RefresherMetadata,\n  RefresherState,\n  RefreshEvent,\n  RefreshPullEvent,\n  DEFAULT_REFRESHER_METADATA,\n} from './types';\n\n/**\n * Componente de pull-to-refresh para movil y web.\n *\n * @example\n * <!-- Uso basico -->\n * <val-refresher\n *   [props]=\"{\n *     color: 'primary',\n *     pullingText: 'Arrastra para actualizar',\n *     refreshingText: 'Cargando...'\n *   }\"\n *   (refresh)=\"onRefresh($event)\"\n * >\n *   <ion-content>\n *     <!-- Contenido scrolleable -->\n *   </ion-content>\n * </val-refresher>\n *\n * @example\n * <!-- Con indicador personalizado -->\n * <val-refresher [props]=\"{ color: 'primary' }\" (refresh)=\"onRefresh($event)\">\n *   <ng-template #pullingIndicator let-progress=\"progress\">\n *     <div class=\"custom-indicator\">\n *       <ion-icon name=\"arrow-down\" [style.transform]=\"'rotate(' + progress * 180 + 'deg)'\"></ion-icon>\n *     </div>\n *   </ng-template>\n *   <ion-content>...</ion-content>\n * </val-refresher>\n */\n@Component({\n  selector: 'val-refresher',\n  standalone: true,\n  imports: [CommonModule, IonRefresher, IonRefresherContent, IonSpinner, IonText],\n  template: `\n    <ion-refresher\n      #refresher\n      slot=\"fixed\"\n      [disabled]=\"mergedProps.disabled\"\n      [pullMin]=\"mergedProps.pullThreshold\"\n      [pullMax]=\"mergedProps.pullMax\"\n      [pullFactor]=\"mergedProps.pullFactor\"\n      [snapbackDuration]=\"mergedProps.snapbackDuration\"\n      [closeDuration]=\"mergedProps.closeDuration\"\n      (ionRefresh)=\"onIonRefresh($event)\"\n      (ionPull)=\"onIonPull($event)\"\n      (ionStart)=\"onIonStart()\"\n    >\n      @if (hasCustomIndicator) {\n        <!-- Custom indicator templates -->\n        <div class=\"refresher-custom-content\">\n          @switch (state()) {\n            @case ('pulling') {\n              @if (pullingIndicator) {\n                <ng-container\n                  *ngTemplateOutlet=\"pullingIndicator; context: { progress: pullProgress() }\"\n                ></ng-container>\n              }\n            }\n            @case ('refreshing') {\n              @if (refreshingIndicator) {\n                <ng-container *ngTemplateOutlet=\"refreshingIndicator\"></ng-container>\n              } @else {\n                <ion-spinner [name]=\"mergedProps.spinnerType\" [color]=\"mergedProps.color\"></ion-spinner>\n                @if (mergedProps.refreshingText) {\n                  <ion-text [color]=\"mergedProps.color\">{{ mergedProps.refreshingText }}</ion-text>\n                }\n              }\n            }\n            @case ('completing') {\n              @if (completingIndicator) {\n                <ng-container *ngTemplateOutlet=\"completingIndicator\"></ng-container>\n              }\n            }\n          }\n        </div>\n      } @else {\n        <!-- Default Ionic refresher content -->\n        <ion-refresher-content\n          [pullingIcon]=\"mergedProps.spinnerType === 'crescent' ? 'chevron-down-circle-outline' : undefined\"\n          [pullingText]=\"mergedProps.pullingText\"\n          [refreshingSpinner]=\"mergedProps.spinnerType\"\n          [refreshingText]=\"mergedProps.refreshingText\"\n        ></ion-refresher-content>\n      }\n    </ion-refresher>\n\n    <ng-content></ng-content>\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n        position: relative;\n      }\n\n      .refresher-custom-content {\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n        gap: 8px;\n        padding: 16px;\n      }\n    `,\n  ],\n})\nexport class RefresherComponent {\n  @ViewChild('refresher') ionRefresher!: IonRefresher;\n\n  /** Templates personalizados via content projection */\n  @ContentChild('pullingIndicator') pullingIndicator?: TemplateRef<{ progress: number }>;\n  @ContentChild('refreshingIndicator') refreshingIndicator?: TemplateRef<void>;\n  @ContentChild('completingIndicator') completingIndicator?: TemplateRef<void>;\n\n  /** Configuracion del refresher */\n  @Input() props: RefresherMetadata = {};\n\n  /** Evento emitido cuando se activa el refresh */\n  @Output() refresh = new EventEmitter<RefreshEvent>();\n\n  /** Evento de progreso durante el pull */\n  @Output() pullProgressChange = new EventEmitter<RefreshPullEvent>();\n\n  /** Evento de cambio de estado */\n  @Output() stateChange = new EventEmitter<RefresherState>();\n\n  private i18n = inject(I18nService);\n\n  /** Estado actual del refresher */\n  readonly state = signal<RefresherState>('idle');\n\n  /** Progreso actual del pull (0-1) */\n  readonly pullProgress = signal<number>(0);\n\n  /** Get pulling text with i18n fallback */\n  getPullingText(): string {\n    return this.props.pullingText || this.i18n.t('pullToRefresh');\n  }\n\n  /** Get refreshing text with i18n fallback */\n  getRefreshingText(): string {\n    return this.props.refreshingText || this.i18n.t('loading');\n  }\n\n  /** Props combinados con defaults */\n  get mergedProps(): RefresherMetadata {\n    return {\n      ...DEFAULT_REFRESHER_METADATA,\n      ...this.props,\n      pullingText: this.getPullingText(),\n      refreshingText: this.getRefreshingText(),\n    };\n  }\n\n  /** Si hay indicadores personalizados */\n  get hasCustomIndicator(): boolean {\n    return !!(\n      this.pullingIndicator ||\n      this.refreshingIndicator ||\n      this.completingIndicator ||\n      this.props.indicatorConfig\n    );\n  }\n\n  /**\n   * Activa programaticamente el refresh.\n   */\n  triggerRefresh(): void {\n    this.state.set('refreshing');\n    this.emitRefreshEvent();\n  }\n\n  /**\n   * Completa la operacion de refresh actual.\n   */\n  complete(): void {\n    this.state.set('completing');\n    this.stateChange.emit('completing');\n    this.ionRefresher?.complete();\n\n    // Resetear a idle despues de la animacion\n    setTimeout(() => {\n      this.state.set('idle');\n      this.stateChange.emit('idle');\n    }, this.mergedProps.closeDuration ?? 280);\n  }\n\n  /**\n   * Cancela la operacion de refresh actual.\n   */\n  cancel(): void {\n    this.ionRefresher?.cancel();\n    this.state.set('idle');\n    this.stateChange.emit('idle');\n  }\n\n  /** Handler para evento ionRefresh */\n  onIonRefresh(event: CustomEvent): void {\n    this.state.set('refreshing');\n    this.stateChange.emit('refreshing');\n    this.emitRefreshEvent();\n  }\n\n  /** Handler para evento ionPull */\n  onIonPull(event: CustomEvent): void {\n    const detail = event.detail;\n    const progress = Math.min(detail.progress, 1);\n    this.pullProgress.set(progress);\n\n    this.pullProgressChange.emit({\n      progress,\n      thresholdReached: progress >= 1,\n    });\n  }\n\n  /** Handler para evento ionStart */\n  onIonStart(): void {\n    this.state.set('pulling');\n    this.stateChange.emit('pulling');\n  }\n\n  private emitRefreshEvent(): void {\n    const event: RefreshEvent = {\n      complete: () => this.complete(),\n      cancel: () => this.cancel(),\n      timestamp: new Date(),\n    };\n    this.refresh.emit(event);\n  }\n}\n"]}

package/esm2022/lib/components/molecules/refresher/types.mjs

@@ -0,0 +1,15 @@
+/**
+ * Valores por defecto para el refresher.
+ */
+export const DEFAULT_REFRESHER_METADATA = {
+    disabled: false,
+    pullThreshold: 70,
+    pullMax: 200,
+    pullFactor: 0.5,
+    snapbackDuration: 280,
+    closeDuration: 280,
+    spinnerType: 'crescent',
+    hapticFeedback: true,
+    webMode: false,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/molecules/searchbar/searchbar.component.mjs

@@ -0,0 +1,127 @@
+import { Component, EventEmitter, inject, Input, Output } from '@angular/core';
+import { IonSearchbar } from '@ionic/angular/standalone';
+import { I18nService } from '../../../services/i18n';
+import { PresetService } from '../../../services/presets';
+import * as i0 from "@angular/core";
+/**
+ * val-searchbar
+ *
+ * A search bar component with debounce and event emitters for filtering, focus, and blur.
+ * Supports presets for reusable configurations.
+ *
+ * @example With preset:
+ * <val-searchbar preset="default" (filterEvent)="onFilter($event)"></val-searchbar>
+ *
+ * @example With props:
+ * <val-searchbar [props]="{ placeholder: 'Search...', debounce: 300 }"></val-searchbar>
+ *
+ * @input preset: string - Name of preset to apply
+ * @input props: SearchbarMetadata - Configuration for the searchbar
+ * @output filterEvent - Emits the search term on input.
+ * @output focusEvent - Emits when the searchbar gains focus.
+ * @output blurEvent - Emits when the searchbar loses focus.
+ */
+export class SearchbarComponent {
+    constructor() {
+        this.presets = inject(PresetService);
+        this.i18n = inject(I18nService);
+        /**
+         * Configuration object. Values here override preset values.
+         */
+        this.props = {};
+        /**
+         * Resolved props after merging preset + explicit props.
+         */
+        this.resolvedProps = {};
+        /**
+         * Emits the search term on input.
+         */
+        this.filterEvent = new EventEmitter();
+        /**
+         * Emits when the searchbar gains focus.
+         */
+        this.focusEvent = new EventEmitter();
+        /**
+         * Emits when the searchbar loses focus.
+         */
+        this.blurEvent = new EventEmitter();
+    }
+    ngOnInit() {
+        this.resolveProps();
+    }
+    ngOnChanges(changes) {
+        if (changes['preset'] || changes['props']) {
+            this.resolveProps();
+        }
+    }
+    resolveProps() {
+        const presetProps = this.preset
+            ? this.presets.get('searchbar', this.preset)
+            : {};
+        this.resolvedProps = {
+            ...presetProps,
+            ...this.props,
+        };
+    }
+    /** Get placeholder text */
+    getPlaceholder() {
+        return this.resolvedProps.placeholder || this.i18n.t('search');
+    }
+    /** Get cancel button text */
+    getCancelText() {
+        return this.resolvedProps.cancelText || this.i18n.t('cancel');
+    }
+    onSearch($event) {
+        const searchTerm = $event.detail.value;
+        this.filterEvent.emit(searchTerm);
+    }
+    onFocus() {
+        this.focusEvent.emit();
+    }
+    onBlur() {
+        this.blurEvent.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SearchbarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SearchbarComponent, isStandalone: true, selector: "val-searchbar", inputs: { preset: "preset", props: "props" }, outputs: { filterEvent: "filterEvent", focusEvent: "focusEvent", blurEvent: "blurEvent" }, usesOnChanges: true, ngImport: i0, template: `
+    <ion-searchbar
+      [mode]="resolvedProps.mode || 'ios'"
+      [debounce]="resolvedProps.debounce || 500"
+      [placeholder]="getPlaceholder()"
+      [disabled]="resolvedProps.disabled"
+      [showCancelButton]="resolvedProps.showCancelButton || 'focus'"
+      [cancelButtonText]="getCancelText()"
+      (ionInput)="onSearch($event)"
+      (ionBlur)="onBlur()"
+      (ionFocus)="onFocus()"
+    >
+    </ion-searchbar>
+  `, isInline: true, styles: [":root{--ion-color-primary: #7026df;--ion-color-primary-rgb: 112, 38, 223;--ion-color-primary-contrast: #ffffff;--ion-color-primary-contrast-rgb: 255, 255, 255;--ion-color-primary-shade: #6321c4;--ion-color-primary-tint: #7e3ce2;--ion-color-secondary: #e2ccff;--ion-color-secondary-rgb: 226, 204, 255;--ion-color-secondary-contrast: #000000;--ion-color-secondary-contrast-rgb: 0, 0, 0;--ion-color-secondary-shade: #c7b4e0;--ion-color-secondary-tint: #e5d1ff;--ion-color-texti: #354c69;--ion-color-texti-rgb: 53, 76, 105;--ion-color-texti-contrast: #ffffff;--ion-color-texti-contrast-rgb: 255, 255, 255;--ion-color-texti-shade: #2f435c;--ion-color-texti-tint: #495e78;--ion-color-darki: #090f1b;--ion-color-darki-rgb: 9, 15, 27;--ion-color-darki-contrast: #ffffff;--ion-color-darki-contrast-rgb: 255, 255, 255;--ion-color-darki-shade: #080d18;--ion-color-darki-tint: #222732;--ion-color-medium: #9e9e9e;--ion-color-medium-rgb: 158, 158, 158;--ion-color-medium-contrast: #000000;--ion-color-medium-contrast-rgb: 0, 0, 0;--ion-color-medium-shade: #8b8b8b;--ion-color-medium-tint: #a8a8a8;--swiper-pagination-color: var(--ion-color-primary);--swiper-navigation-color: var(--ion-color-primary);--swiper-pagination-bullet-inactive-color: var(--ion-color-medium)}@media (prefers-color-scheme: dark){:root{--ion-color-texti: #8fc1ff;--ion-color-texti-rgb: 143, 193, 255;--ion-color-texti-contrast: #000000;--ion-color-texti-contrast-rgb: 0, 0, 0;--ion-color-texti-shade: #7eaae0;--ion-color-texti-tint: #9ac7ff;--ion-color-darki: #ffffff;--ion-color-darki-rgb: 255, 255, 255;--ion-color-darki-contrast: #000000;--ion-color-darki-contrast-rgb: 0, 0, 0;--ion-color-darki-shade: #e0e0e0;--ion-color-darki-tint: #ffffff;--ion-color-primary: #8f49f8;--ion-color-primary-rgb: 143, 73, 248;--ion-color-primary-contrast: #ffffff;--ion-color-primary-contrast-rgb: 255, 255, 255;--ion-color-primary-shade: #7e40da;--ion-color-primary-tint: #9a5bf9}}.ion-color-texti{--ion-color-base: var(--ion-color-texti);--ion-color-base-rgb: var(--ion-color-texti-rgb);--ion-color-contrast: var(--ion-color-texti-contrast);--ion-color-contrast-rgb: var(--ion-color-texti-contrast-rgb);--ion-color-shade: var(--ion-color-texti-shade);--ion-color-tint: var(--ion-color-texti-tint)}.ion-color-darki{--ion-color-base: var(--ion-color-darki);--ion-color-base-rgb: var(--ion-color-darki-rgb);--ion-color-contrast: var(--ion-color-darki-contrast);--ion-color-contrast-rgb: var(--ion-color-darki-contrast-rgb);--ion-color-shade: var(--ion-color-darki-shade);--ion-color-tint: var(--ion-color-darki-tint)}ion-searchbar{--cancel-button-color: var(--ion-color-dark);--background: var(--ion-color-light);font-family:var(--ion-default-font),Arial,sans-serif}\n"], dependencies: [{ kind: "component", type: IonSearchbar, selector: "ion-searchbar", inputs: ["animated", "autocomplete", "autocorrect", "cancelButtonIcon", "cancelButtonText", "clearIcon", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "mode", "name", "placeholder", "searchIcon", "showCancelButton", "showClearButton", "spellcheck", "type", "value"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SearchbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-searchbar', standalone: true, imports: [IonSearchbar], template: `
+    <ion-searchbar
+      [mode]="resolvedProps.mode || 'ios'"
+      [debounce]="resolvedProps.debounce || 500"
+      [placeholder]="getPlaceholder()"
+      [disabled]="resolvedProps.disabled"
+      [showCancelButton]="resolvedProps.showCancelButton || 'focus'"
+      [cancelButtonText]="getCancelText()"
+      (ionInput)="onSearch($event)"
+      (ionBlur)="onBlur()"
+      (ionFocus)="onFocus()"
+    >
+    </ion-searchbar>
+  `, styles: [":root{--ion-color-primary: #7026df;--ion-color-primary-rgb: 112, 38, 223;--ion-color-primary-contrast: #ffffff;--ion-color-primary-contrast-rgb: 255, 255, 255;--ion-color-primary-shade: #6321c4;--ion-color-primary-tint: #7e3ce2;--ion-color-secondary: #e2ccff;--ion-color-secondary-rgb: 226, 204, 255;--ion-color-secondary-contrast: #000000;--ion-color-secondary-contrast-rgb: 0, 0, 0;--ion-color-secondary-shade: #c7b4e0;--ion-color-secondary-tint: #e5d1ff;--ion-color-texti: #354c69;--ion-color-texti-rgb: 53, 76, 105;--ion-color-texti-contrast: #ffffff;--ion-color-texti-contrast-rgb: 255, 255, 255;--ion-color-texti-shade: #2f435c;--ion-color-texti-tint: #495e78;--ion-color-darki: #090f1b;--ion-color-darki-rgb: 9, 15, 27;--ion-color-darki-contrast: #ffffff;--ion-color-darki-contrast-rgb: 255, 255, 255;--ion-color-darki-shade: #080d18;--ion-color-darki-tint: #222732;--ion-color-medium: #9e9e9e;--ion-color-medium-rgb: 158, 158, 158;--ion-color-medium-contrast: #000000;--ion-color-medium-contrast-rgb: 0, 0, 0;--ion-color-medium-shade: #8b8b8b;--ion-color-medium-tint: #a8a8a8;--swiper-pagination-color: var(--ion-color-primary);--swiper-navigation-color: var(--ion-color-primary);--swiper-pagination-bullet-inactive-color: var(--ion-color-medium)}@media (prefers-color-scheme: dark){:root{--ion-color-texti: #8fc1ff;--ion-color-texti-rgb: 143, 193, 255;--ion-color-texti-contrast: #000000;--ion-color-texti-contrast-rgb: 0, 0, 0;--ion-color-texti-shade: #7eaae0;--ion-color-texti-tint: #9ac7ff;--ion-color-darki: #ffffff;--ion-color-darki-rgb: 255, 255, 255;--ion-color-darki-contrast: #000000;--ion-color-darki-contrast-rgb: 0, 0, 0;--ion-color-darki-shade: #e0e0e0;--ion-color-darki-tint: #ffffff;--ion-color-primary: #8f49f8;--ion-color-primary-rgb: 143, 73, 248;--ion-color-primary-contrast: #ffffff;--ion-color-primary-contrast-rgb: 255, 255, 255;--ion-color-primary-shade: #7e40da;--ion-color-primary-tint: #9a5bf9}}.ion-color-texti{--ion-color-base: var(--ion-color-texti);--ion-color-base-rgb: var(--ion-color-texti-rgb);--ion-color-contrast: var(--ion-color-texti-contrast);--ion-color-contrast-rgb: var(--ion-color-texti-contrast-rgb);--ion-color-shade: var(--ion-color-texti-shade);--ion-color-tint: var(--ion-color-texti-tint)}.ion-color-darki{--ion-color-base: var(--ion-color-darki);--ion-color-base-rgb: var(--ion-color-darki-rgb);--ion-color-contrast: var(--ion-color-darki-contrast);--ion-color-contrast-rgb: var(--ion-color-darki-contrast-rgb);--ion-color-shade: var(--ion-color-darki-shade);--ion-color-tint: var(--ion-color-darki-tint)}ion-searchbar{--cancel-button-color: var(--ion-color-dark);--background: var(--ion-color-light);font-family:var(--ion-default-font),Arial,sans-serif}\n"] }]
+        }], propDecorators: { preset: [{
+                type: Input
+            }], props: [{
+                type: Input
+            }], filterEvent: [{
+                type: Output
+            }], focusEvent: [{
+                type: Output
+            }], blurEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/molecules/searchbar/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvbW9sZWN1bGVzL3NlYXJjaGJhci90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb25maWd1cmF0aW9uIGZvciB2YWwtc2VhcmNoYmFyIGNvbXBvbmVudC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTZWFyY2hiYXJNZXRhZGF0YSB7XG4gIC8qKlxuICAgKiBXaGV0aGVyIHRoZSBzZWFyY2hiYXIgaXMgZGlzYWJsZWQuXG4gICAqL1xuICBkaXNhYmxlZD86IGJvb2xlYW47XG5cbiAgLyoqXG4gICAqIEN1c3RvbSBwbGFjZWhvbGRlciB0ZXh0LlxuICAgKiBJZiBub3QgcHJvdmlkZWQsIHVzZXMgaTE4biBkZWZhdWx0ICgnc2VhcmNoJykuXG4gICAqL1xuICBwbGFjZWhvbGRlcj86IHN0cmluZztcblxuICAvKipcbiAgICogQ3VzdG9tIGNhbmNlbCBidXR0b24gdGV4dC5cbiAgICogSWYgbm90IHByb3ZpZGVkLCB1c2VzIGkxOG4gZGVmYXVsdCAoJ2NhbmNlbCcpLlxuICAgKi9cbiAgY2FuY2VsVGV4dD86IHN0cmluZztcblxuICAvKipcbiAgICogRGVib3VuY2UgdGltZSBpbiBtaWxsaXNlY29uZHMgZm9yIHNlYXJjaCBpbnB1dC5cbiAgICogRGVmYXVsdDogNTAwXG4gICAqL1xuICBkZWJvdW5jZT86IG51bWJlcjtcblxuICAvKipcbiAgICogV2hlbiB0byBzaG93IHRoZSBjYW5jZWwgYnV0dG9uLlxuICAgKiBEZWZhdWx0OiAnZm9jdXMnXG4gICAqL1xuICBzaG93Q2FuY2VsQnV0dG9uPzogJ2Fsd2F5cycgfCAnZm9jdXMnIHwgJ25ldmVyJztcblxuICAvKipcbiAgICogTW9kZSBmb3Igc3R5bGluZyAoaU9TIG9yIE1EKS5cbiAgICovXG4gIG1vZGU/OiAnaW9zJyB8ICdtZCc7XG59XG4iXX0=

package/esm2022/lib/components/molecules/segment-control/segment-control.component.mjs

@@ -0,0 +1,137 @@
+import { Component, inject, Input, Output, EventEmitter } from '@angular/core';
+import { IonSegment, IonSegmentButton, IonLabel, IonIcon } from '@ionic/angular/standalone';
+import { CommonModule } from '@angular/common';
+import { PresetService } from '../../../services/presets';
+import { ComponentStates } from '../../types';
+import { addIcons } from 'ionicons';
+import { list, grid, apps, menu, settings, home, search, person, heart, star } from 'ionicons/icons';
+import * as i0 from "@angular/core";
+// Register common icons
+addIcons({ list, grid, apps, menu, settings, home, search, person, heart, star });
+/**
+ * val-segment-control
+ *
+ * A segmented control for switching between views or options.
+ * Supports presets for reusable configurations.
+ *
+ * @example With preset:
+ * <val-segment-control preset="view-toggle" [props]="{ options: [...] }"></val-segment-control>
+ *
+ * @example Basic usage
+ * <val-segment-control [props]="{
+ *   options: [
+ *     { value: 'list', label: 'List', icon: 'list' },
+ *     { value: 'grid', label: 'Grid', icon: 'grid' }
+ *   ],
+ *   value: 'list'
+ * }" (segmentChange)="onViewChange($event)"></val-segment-control>
+ *
+ * @input preset: string - Name of preset to apply
+ * @input props: SegmentControlMetadata - Configuration for the segment control
+ * @output segmentChange: string - Emits the selected value when changed
+ */
+export class SegmentControlComponent {
+    constructor() {
+        this.presets = inject(PresetService);
+        /**
+         * Input configuration object. Values here override preset values.
+         */
+        this.props = {};
+        /**
+         * Resolved props after merging preset + explicit props.
+         */
+        this.resolvedProps = {};
+        /**
+         * Emits the selected value when the segment changes.
+         */
+        this.segmentChange = new EventEmitter();
+        this.states = ComponentStates;
+    }
+    ngOnInit() {
+        this.resolveProps();
+    }
+    ngOnChanges(changes) {
+        if (changes['preset'] || changes['props']) {
+            this.resolveProps();
+        }
+    }
+    resolveProps() {
+        const presetProps = this.preset
+            ? this.presets.get('segmentControl', this.preset)
+            : {};
+        this.resolvedProps = {
+            ...presetProps,
+            ...this.props,
+        };
+    }
+    onSegmentChange(event) {
+        const value = event.detail.value;
+        this.segmentChange.emit(value);
+    }
+    getOptionLabel(option) {
+        return option.label || option.contentFallback || '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SegmentControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SegmentControlComponent, isStandalone: true, selector: "val-segment-control", inputs: { preset: "preset", props: "props" }, outputs: { segmentChange: "segmentChange" }, usesOnChanges: true, ngImport: i0, template: `
+    <ion-segment
+      [value]="resolvedProps.value"
+      [color]="resolvedProps.color || 'primary'"
+      [disabled]="resolvedProps.state === states.DISABLED || resolvedProps.disabled"
+      [scrollable]="resolvedProps.scrollable ?? false"
+      [swipeGesture]="resolvedProps.swipeGesture ?? true"
+      [mode]="resolvedProps.mode"
+      (ionChange)="onSegmentChange($event)"
+    >
+      @for (option of resolvedProps.options; track option.value) {
+        <ion-segment-button
+          [value]="option.value"
+          [disabled]="option.disabled"
+          [layout]="option.layout || 'icon-top'"
+        >
+          @if (option.icon) {
+            <ion-icon [name]="option.icon"></ion-icon>
+          }
+          @if (getOptionLabel(option)) {
+            <ion-label>{{ getOptionLabel(option) }}</ion-label>
+          }
+        </ion-segment-button>
+      }
+    </ion-segment>
+  `, isInline: true, styles: [":host{display:block}ion-segment{--background: var(--ion-color-light);border-radius:8px}ion-segment-button{--indicator-box-shadow: none;--indicator-color: var(--ion-color-primary);--color: var(--ion-color-medium);--color-checked: var(--ion-color-primary-contrast);--border-radius: 6px;min-width:80px;text-transform:none;font-weight:500}ion-icon{font-size:18px}ion-label{font-size:13px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: IonSegment, selector: "ion-segment", inputs: ["color", "disabled", "mode", "scrollable", "selectOnFocus", "swipeGesture", "value"] }, { kind: "component", type: IonSegmentButton, selector: "ion-segment-button", inputs: ["contentId", "disabled", "layout", "mode", "type", "value"] }, { kind: "component", type: IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SegmentControlComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-segment-control', standalone: true, imports: [CommonModule, IonSegment, IonSegmentButton, IonLabel, IonIcon], template: `
+    <ion-segment
+      [value]="resolvedProps.value"
+      [color]="resolvedProps.color || 'primary'"
+      [disabled]="resolvedProps.state === states.DISABLED || resolvedProps.disabled"
+      [scrollable]="resolvedProps.scrollable ?? false"
+      [swipeGesture]="resolvedProps.swipeGesture ?? true"
+      [mode]="resolvedProps.mode"
+      (ionChange)="onSegmentChange($event)"
+    >
+      @for (option of resolvedProps.options; track option.value) {
+        <ion-segment-button
+          [value]="option.value"
+          [disabled]="option.disabled"
+          [layout]="option.layout || 'icon-top'"
+        >
+          @if (option.icon) {
+            <ion-icon [name]="option.icon"></ion-icon>
+          }
+          @if (getOptionLabel(option)) {
+            <ion-label>{{ getOptionLabel(option) }}</ion-label>
+          }
+        </ion-segment-button>
+      }
+    </ion-segment>
+  `, styles: [":host{display:block}ion-segment{--background: var(--ion-color-light);border-radius:8px}ion-segment-button{--indicator-box-shadow: none;--indicator-color: var(--ion-color-primary);--color: var(--ion-color-medium);--color-checked: var(--ion-color-primary-contrast);--border-radius: 6px;min-width:80px;text-transform:none;font-weight:500}ion-icon{font-size:18px}ion-label{font-size:13px}\n"] }]
+        }], propDecorators: { preset: [{
+                type: Input
+            }], props: [{
+                type: Input
+            }], segmentChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"segment-control.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/molecules/segment-control/segment-control.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAqB,MAAM,EAAE,YAAY,EAAiB,MAAM,eAAe,CAAC;AACjH,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;;AAErG,wBAAwB;AACxB,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;AAkClF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,uBAAuB;IAtDpC;QAuDU,YAAO,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QAOxC;;WAEG;QACM,UAAK,GAAoC,EAAE,CAAC;QAErD;;WAEG;QACH,kBAAa,GAA2B,EAA4B,CAAC;QAErE;;WAEG;QACO,kBAAa,GAAG,IAAI,YAAY,EAAU,CAAC;QAErD,WAAM,GAAG,eAAe,CAAC;KA+B1B;IA7BC,QAAQ;QACN,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IAEO,YAAY;QAClB,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM;YAC7B,CAAC,CAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE,IAAI,CAAC,MAAM,CAAqC;YACtF,CAAC,CAAC,EAAE,CAAC;QAEP,IAAI,CAAC,aAAa,GAAG;YACnB,GAAG,WAAW;YACd,GAAG,IAAI,CAAC,KAAK;SACY,CAAC;IAC9B,CAAC;IAED,eAAe,CAAC,KAAkB;QAChC,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;QACjC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,cAAc,CAAC,MAAqB;QAClC,OAAO,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC;IACtD,CAAC;+GArDU,uBAAuB;mGAAvB,uBAAuB,+LAlDxB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBT,2cA1BS,YAAY,+BAAE,UAAU,uJAAE,gBAAgB,qIAAE,QAAQ,6FAAE,OAAO;;4FAmD5D,uBAAuB;kBAtDnC,SAAS;+BACE,qBAAqB,cACnB,IAAI,WACP,CAAC,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,CAAC,YAC9D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBT;8BA+BQ,MAAM;sBAAd,KAAK;gBAKG,KAAK;sBAAb,KAAK;gBAUI,aAAa;sBAAtB,MAAM","sourcesContent":["import { Component, inject, Input, OnChanges, OnInit, Output, EventEmitter, SimpleChanges } from '@angular/core';\nimport { IonSegment, IonSegmentButton, IonLabel, IonIcon } from '@ionic/angular/standalone';\nimport { CommonModule } from '@angular/common';\nimport { PresetService } from '../../../services/presets';\nimport { SegmentControlMetadata, SegmentOption } from './types';\nimport { ComponentStates } from '../../types';\nimport { addIcons } from 'ionicons';\nimport { list, grid, apps, menu, settings, home, search, person, heart, star } from 'ionicons/icons';\n\n// Register common icons\naddIcons({ list, grid, apps, menu, settings, home, search, person, heart, star });\n\n@Component({\n  selector: 'val-segment-control',\n  standalone: true,\n  imports: [CommonModule, IonSegment, IonSegmentButton, IonLabel, IonIcon],\n  template: `\n    <ion-segment\n      [value]=\"resolvedProps.value\"\n      [color]=\"resolvedProps.color || 'primary'\"\n      [disabled]=\"resolvedProps.state === states.DISABLED || resolvedProps.disabled\"\n      [scrollable]=\"resolvedProps.scrollable ?? false\"\n      [swipeGesture]=\"resolvedProps.swipeGesture ?? true\"\n      [mode]=\"resolvedProps.mode\"\n      (ionChange)=\"onSegmentChange($event)\"\n    >\n      @for (option of resolvedProps.options; track option.value) {\n        <ion-segment-button\n          [value]=\"option.value\"\n          [disabled]=\"option.disabled\"\n          [layout]=\"option.layout || 'icon-top'\"\n        >\n          @if (option.icon) {\n            <ion-icon [name]=\"option.icon\"></ion-icon>\n          }\n          @if (getOptionLabel(option)) {\n            <ion-label>{{ getOptionLabel(option) }}</ion-label>\n          }\n        </ion-segment-button>\n      }\n    </ion-segment>\n  `,\n  styleUrls: ['./segment-control.component.scss'],\n})\n/**\n * val-segment-control\n *\n * A segmented control for switching between views or options.\n * Supports presets for reusable configurations.\n *\n * @example With preset:\n * <val-segment-control preset=\"view-toggle\" [props]=\"{ options: [...] }\"></val-segment-control>\n *\n * @example Basic usage\n * <val-segment-control [props]=\"{\n *   options: [\n *     { value: 'list', label: 'List', icon: 'list' },\n *     { value: 'grid', label: 'Grid', icon: 'grid' }\n *   ],\n *   value: 'list'\n * }\" (segmentChange)=\"onViewChange($event)\"></val-segment-control>\n *\n * @input preset: string - Name of preset to apply\n * @input props: SegmentControlMetadata - Configuration for the segment control\n * @output segmentChange: string - Emits the selected value when changed\n */\nexport class SegmentControlComponent implements OnInit, OnChanges {\n  private presets = inject(PresetService);\n\n  /**\n   * Preset name to apply. Presets define reusable segment configurations.\n   */\n  @Input() preset?: string;\n\n  /**\n   * Input configuration object. Values here override preset values.\n   */\n  @Input() props: Partial<SegmentControlMetadata> = {};\n\n  /**\n   * Resolved props after merging preset + explicit props.\n   */\n  resolvedProps: SegmentControlMetadata = {} as SegmentControlMetadata;\n\n  /**\n   * Emits the selected value when the segment changes.\n   */\n  @Output() segmentChange = new EventEmitter<string>();\n\n  states = ComponentStates;\n\n  ngOnInit() {\n    this.resolveProps();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['preset'] || changes['props']) {\n      this.resolveProps();\n    }\n  }\n\n  private resolveProps(): void {\n    const presetProps = this.preset\n      ? (this.presets.get('segmentControl', this.preset) as Partial<SegmentControlMetadata>)\n      : {};\n\n    this.resolvedProps = {\n      ...presetProps,\n      ...this.props,\n    } as SegmentControlMetadata;\n  }\n\n  onSegmentChange(event: CustomEvent): void {\n    const value = event.detail.value;\n    this.segmentChange.emit(value);\n  }\n\n  getOptionLabel(option: SegmentOption): string {\n    return option.label || option.contentFallback || '';\n  }\n}\n"]}

package/esm2022/lib/components/molecules/segment-control/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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