valtech-components 2.0.795 → 2.0.796

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

@@ -0,0 +1,166 @@
+import { Component, inject, Input, Output, EventEmitter } from '@angular/core';
+import { IonIcon } from '@ionic/angular/standalone';
+import { CommonModule } from '@angular/common';
+import { PresetService } from '../../../services/presets';
+import { addIcons } from 'ionicons';
+import { star, starOutline, starHalf, heart, heartOutline, heartHalf } from 'ionicons/icons';
+import * as i0 from "@angular/core";
+addIcons({ star, starOutline, starHalf, heart, heartOutline, heartHalf });
+/**
+ * val-rating
+ *
+ * A star rating component for feedback and reviews.
+ * Supports presets for reusable configurations.
+ *
+ * @example With preset:
+ * <val-rating preset="stars" [props]="{ value: 3.5 }"></val-rating>
+ *
+ * @example Basic usage
+ * <val-rating [props]="{
+ *   value: 3.5,
+ *   max: 5,
+ *   allowHalf: true
+ * }" (ratingChange)="onRatingChange($event)"></val-rating>
+ *
+ * @input preset: string - Name of preset to apply
+ * @input props: RatingMetadata - Configuration for the rating
+ * @output ratingChange: RatingChangeEvent - Emits when rating changes
+ */
+export class RatingComponent {
+    constructor() {
+        this.presets = inject(PresetService);
+        this.props = {};
+        this.resolvedProps = {};
+        this.ratingChange = new EventEmitter();
+        this.hoverValue = null;
+    }
+    ngOnInit() {
+        this.resolveProps();
+    }
+    ngOnChanges(changes) {
+        if (changes['preset'] || changes['props']) {
+            this.resolveProps();
+        }
+    }
+    resolveProps() {
+        const presetProps = this.preset
+            ? this.presets.get('rating', this.preset)
+            : {};
+        this.resolvedProps = {
+            ...presetProps,
+            ...this.props,
+        };
+    }
+    get displayValue() {
+        return this.hoverValue !== null ? this.hoverValue : this.resolvedProps.value;
+    }
+    getStars() {
+        const max = this.resolvedProps.max || 5;
+        return Array.from({ length: max }, (_, i) => i + 1);
+    }
+    getStarIcon(position) {
+        const value = this.hoverValue !== null ? this.hoverValue : this.resolvedProps.value;
+        const baseIcon = this.resolvedProps.icon || 'star';
+        const emptyIcon = this.resolvedProps.iconEmpty || `${baseIcon}-outline`;
+        const halfIcon = this.resolvedProps.iconHalf || `${baseIcon}-half`;
+        if (position <= value) {
+            return baseIcon;
+        }
+        else if (this.resolvedProps.allowHalf && position - 0.5 <= value) {
+            return halfIcon;
+        }
+        return emptyIcon;
+    }
+    getStarColor(position) {
+        const value = this.hoverValue !== null ? this.hoverValue : this.resolvedProps.value;
+        const isFilled = position <= value || (this.resolvedProps.allowHalf && position - 0.5 <= value);
+        return isFilled ? (this.resolvedProps.color || 'warning') : (this.resolvedProps.emptyColor || 'medium');
+    }
+    onStarClick(position) {
+        if (this.resolvedProps.readonly || this.resolvedProps.disabled)
+            return;
+        let newValue = position;
+        // Toggle half value if clicking same star and allowHalf is true
+        if (this.resolvedProps.allowHalf && position === Math.ceil(this.resolvedProps.value)) {
+            if (this.resolvedProps.value === position) {
+                newValue = position - 0.5;
+            }
+            else if (this.resolvedProps.value === position - 0.5) {
+                newValue = 0;
+            }
+        }
+        else if (position === this.resolvedProps.value) {
+            // Click same star again to clear
+            newValue = 0;
+        }
+        if (newValue !== this.resolvedProps.value) {
+            this.ratingChange.emit({
+                value: newValue,
+                previousValue: this.resolvedProps.value,
+            });
+        }
+    }
+    onStarHover(position) {
+        if (this.resolvedProps.readonly || this.resolvedProps.disabled)
+            return;
+        this.hoverValue = position;
+    }
+    onStarLeave() {
+        this.hoverValue = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RatingComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: RatingComponent, isStandalone: true, selector: "val-rating", inputs: { preset: "preset", props: "props" }, outputs: { ratingChange: "ratingChange" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      class="rating-container"
+      [class.readonly]="resolvedProps.readonly"
+      [class.disabled]="resolvedProps.disabled"
+      [class]="'size-' + (resolvedProps.size || 'medium')"
+    >
+      @for (i of getStars(); track i) {
+        <ion-icon
+          [name]="getStarIcon(i)"
+          [color]="getStarColor(i)"
+          [class.clickable]="!resolvedProps.readonly && !resolvedProps.disabled"
+          (click)="onStarClick(i)"
+          (mouseenter)="onStarHover(i)"
+          (mouseleave)="onStarLeave()"
+        ></ion-icon>
+      }
+      @if (resolvedProps.showValue) {
+        <span class="rating-value">{{ displayValue }}</span>
+      }
+    </div>
+  `, isInline: true, styles: [":host{display:inline-block}.rating-container{display:inline-flex;align-items:center;gap:4px}.rating-container.readonly{pointer-events:none}.rating-container.disabled{opacity:.5;pointer-events:none}.rating-container.size-small ion-icon{font-size:16px}.rating-container.size-medium ion-icon{font-size:24px}.rating-container.size-large ion-icon{font-size:32px}ion-icon{transition:transform .15s ease,color .15s ease}ion-icon.clickable{cursor:pointer}ion-icon.clickable:hover{transform:scale(1.2)}.rating-value{margin-left:8px;font-weight:600;color:var(--ion-color-dark)}.size-small .rating-value{font-size:12px}.size-medium .rating-value{font-size:14px}.size-large .rating-value{font-size:18px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { 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: RatingComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-rating', standalone: true, imports: [CommonModule, IonIcon], template: `
+    <div
+      class="rating-container"
+      [class.readonly]="resolvedProps.readonly"
+      [class.disabled]="resolvedProps.disabled"
+      [class]="'size-' + (resolvedProps.size || 'medium')"
+    >
+      @for (i of getStars(); track i) {
+        <ion-icon
+          [name]="getStarIcon(i)"
+          [color]="getStarColor(i)"
+          [class.clickable]="!resolvedProps.readonly && !resolvedProps.disabled"
+          (click)="onStarClick(i)"
+          (mouseenter)="onStarHover(i)"
+          (mouseleave)="onStarLeave()"
+        ></ion-icon>
+      }
+      @if (resolvedProps.showValue) {
+        <span class="rating-value">{{ displayValue }}</span>
+      }
+    </div>
+  `, styles: [":host{display:inline-block}.rating-container{display:inline-flex;align-items:center;gap:4px}.rating-container.readonly{pointer-events:none}.rating-container.disabled{opacity:.5;pointer-events:none}.rating-container.size-small ion-icon{font-size:16px}.rating-container.size-medium ion-icon{font-size:24px}.rating-container.size-large ion-icon{font-size:32px}ion-icon{transition:transform .15s ease,color .15s ease}ion-icon.clickable{cursor:pointer}ion-icon.clickable:hover{transform:scale(1.2)}.rating-value{margin-left:8px;font-weight:600;color:var(--ion-color-dark)}.size-small .rating-value{font-size:12px}.size-medium .rating-value{font-size:14px}.size-large .rating-value{font-size:18px}\n"] }]
+        }], propDecorators: { preset: [{
+                type: Input
+            }], props: [{
+                type: Input
+            }], ratingChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rating.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/molecules/rating/rating.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, inject, Input, OnChanges, OnInit, Output, EventEmitter, SimpleChanges } from '@angular/core';\nimport { IonIcon } from '@ionic/angular/standalone';\nimport { CommonModule } from '@angular/common';\nimport { PresetService } from '../../../services/presets';\nimport { RatingMetadata, RatingChangeEvent } from './types';\nimport { addIcons } from 'ionicons';\nimport { star, starOutline, starHalf, heart, heartOutline, heartHalf } from 'ionicons/icons';\n\naddIcons({ star, starOutline, starHalf, heart, heartOutline, heartHalf });\n\n@Component({\n  selector: 'val-rating',\n  standalone: true,\n  imports: [CommonModule, IonIcon],\n  template: `\n    <div\n      class=\"rating-container\"\n      [class.readonly]=\"resolvedProps.readonly\"\n      [class.disabled]=\"resolvedProps.disabled\"\n      [class]=\"'size-' + (resolvedProps.size || 'medium')\"\n    >\n      @for (i of getStars(); track i) {\n        <ion-icon\n          [name]=\"getStarIcon(i)\"\n          [color]=\"getStarColor(i)\"\n          [class.clickable]=\"!resolvedProps.readonly && !resolvedProps.disabled\"\n          (click)=\"onStarClick(i)\"\n          (mouseenter)=\"onStarHover(i)\"\n          (mouseleave)=\"onStarLeave()\"\n        ></ion-icon>\n      }\n      @if (resolvedProps.showValue) {\n        <span class=\"rating-value\">{{ displayValue }}</span>\n      }\n    </div>\n  `,\n  styleUrls: ['./rating.component.scss'],\n})\n/**\n * val-rating\n *\n * A star rating component for feedback and reviews.\n * Supports presets for reusable configurations.\n *\n * @example With preset:\n * <val-rating preset=\"stars\" [props]=\"{ value: 3.5 }\"></val-rating>\n *\n * @example Basic usage\n * <val-rating [props]=\"{\n *   value: 3.5,\n *   max: 5,\n *   allowHalf: true\n * }\" (ratingChange)=\"onRatingChange($event)\"></val-rating>\n *\n * @input preset: string - Name of preset to apply\n * @input props: RatingMetadata - Configuration for the rating\n * @output ratingChange: RatingChangeEvent - Emits when rating changes\n */\nexport class RatingComponent implements OnInit, OnChanges {\n  private presets = inject(PresetService);\n\n  @Input() preset?: string;\n  @Input() props: Partial<RatingMetadata> = {};\n\n  resolvedProps: RatingMetadata = {} as RatingMetadata;\n\n  @Output() ratingChange = new EventEmitter<RatingChangeEvent>();\n\n  hoverValue: number | null = null;\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('rating', this.preset) as Partial<RatingMetadata>)\n      : {};\n\n    this.resolvedProps = {\n      ...presetProps,\n      ...this.props,\n    } as RatingMetadata;\n  }\n\n  get displayValue(): number {\n    return this.hoverValue !== null ? this.hoverValue : this.resolvedProps.value;\n  }\n\n  getStars(): number[] {\n    const max = this.resolvedProps.max || 5;\n    return Array.from({ length: max }, (_, i) => i + 1);\n  }\n\n  getStarIcon(position: number): string {\n    const value = this.hoverValue !== null ? this.hoverValue : this.resolvedProps.value;\n    const baseIcon = this.resolvedProps.icon || 'star';\n    const emptyIcon = this.resolvedProps.iconEmpty || `${baseIcon}-outline`;\n    const halfIcon = this.resolvedProps.iconHalf || `${baseIcon}-half`;\n\n    if (position <= value) {\n      return baseIcon;\n    } else if (this.resolvedProps.allowHalf && position - 0.5 <= value) {\n      return halfIcon;\n    }\n    return emptyIcon;\n  }\n\n  getStarColor(position: number): string {\n    const value = this.hoverValue !== null ? this.hoverValue : this.resolvedProps.value;\n    const isFilled = position <= value || (this.resolvedProps.allowHalf && position - 0.5 <= value);\n    return isFilled ? (this.resolvedProps.color || 'warning') : (this.resolvedProps.emptyColor || 'medium');\n  }\n\n  onStarClick(position: number): void {\n    if (this.resolvedProps.readonly || this.resolvedProps.disabled) return;\n\n    let newValue = position;\n\n    // Toggle half value if clicking same star and allowHalf is true\n    if (this.resolvedProps.allowHalf && position === Math.ceil(this.resolvedProps.value)) {\n      if (this.resolvedProps.value === position) {\n        newValue = position - 0.5;\n      } else if (this.resolvedProps.value === position - 0.5) {\n        newValue = 0;\n      }\n    } else if (position === this.resolvedProps.value) {\n      // Click same star again to clear\n      newValue = 0;\n    }\n\n    if (newValue !== this.resolvedProps.value) {\n      this.ratingChange.emit({\n        value: newValue,\n        previousValue: this.resolvedProps.value,\n      });\n    }\n  }\n\n  onStarHover(position: number): void {\n    if (this.resolvedProps.readonly || this.resolvedProps.disabled) return;\n    this.hoverValue = position;\n  }\n\n  onStarLeave(): void {\n    this.hoverValue = null;\n  }\n}\n"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvbW9sZWN1bGVzL3JhdGluZy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29sb3IgfSBmcm9tICdAaW9uaWMvY29yZSc7XG5cbi8qKlxuICogTWV0YWRhdGEgZm9yIHRoZSByYXRpbmcgY29tcG9uZW50LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFJhdGluZ01ldGFkYXRhIHtcbiAgLyoqIEN1cnJlbnQgcmF0aW5nIHZhbHVlICovXG4gIHZhbHVlOiBudW1iZXI7XG4gIC8qKiBNYXhpbXVtIHJhdGluZyB2YWx1ZSAqL1xuICBtYXg/OiBudW1iZXI7XG4gIC8qKiBJY29uIG5hbWUgZm9yIGZpbGxlZCBzdGF0ZSAqL1xuICBpY29uPzogc3RyaW5nO1xuICAvKiogSWNvbiBuYW1lIGZvciBlbXB0eSBzdGF0ZSAqL1xuICBpY29uRW1wdHk/OiBzdHJpbmc7XG4gIC8qKiBJY29uIG5hbWUgZm9yIGhhbGYgc3RhdGUgKi9cbiAgaWNvbkhhbGY/OiBzdHJpbmc7XG4gIC8qKiBBbGxvdyBoYWxmIHZhbHVlcyAqL1xuICBhbGxvd0hhbGY/OiBib29sZWFuO1xuICAvKiogUmVhZG9ubHkgbW9kZSAqL1xuICByZWFkb25seT86IGJvb2xlYW47XG4gIC8qKiBEaXNhYmxlZCBzdGF0ZSAqL1xuICBkaXNhYmxlZD86IGJvb2xlYW47XG4gIC8qKiBSYXRpbmcgY29sb3IgKi9cbiAgY29sb3I/OiBDb2xvcjtcbiAgLyoqIEVtcHR5IGljb24gY29sb3IgKi9cbiAgZW1wdHlDb2xvcj86IENvbG9yO1xuICAvKiogU2l6ZSB2YXJpYW50ICovXG4gIHNpemU/OiAnc21hbGwnIHwgJ21lZGl1bScgfCAnbGFyZ2UnO1xuICAvKiogU2hvdyBudW1lcmljIHZhbHVlICovXG4gIHNob3dWYWx1ZT86IGJvb2xlYW47XG4gIC8qKiBVbmlxdWUgdG9rZW4gaWRlbnRpZmllciAqL1xuICB0b2tlbj86IHN0cmluZztcbn1cblxuLyoqXG4gKiBFdmVudCBlbWl0dGVkIHdoZW4gcmF0aW5nIGNoYW5nZXMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmF0aW5nQ2hhbmdlRXZlbnQge1xuICAvKiogTmV3IHJhdGluZyB2YWx1ZSAqL1xuICB2YWx1ZTogbnVtYmVyO1xuICAvKiogUHJldmlvdXMgcmF0aW5nIHZhbHVlICovXG4gIHByZXZpb3VzVmFsdWU6IG51bWJlcjtcbn1cbiJdfQ==

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

@@ -0,0 +1,271 @@
+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;
+        if (!detail || typeof detail.progress !== 'number')
+            return;
+        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    if (!detail || typeof detail.progress !== 'number') return;\n\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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