valtech-components 2.0.510 → 2.0.512

package/esm2022/lib/components/organisms/infinite-list/infinite-list.component.mjs

@@ -0,0 +1,618 @@
+import { Component, Input, Output, EventEmitter, signal, computed, ViewChild, inject, ChangeDetectorRef, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonInfiniteScroll, IonInfiniteScrollContent, IonButton, IonSpinner, IonIcon, IonText, IonList, IonItem, } from '@ionic/angular/standalone';
+import { firstValueFrom, isObservable } from 'rxjs';
+import { DEFAULT_INFINITE_LIST_METADATA, } from './types';
+import { RefresherComponent } from '../../molecules/refresher/refresher.component';
+import { SkeletonService } from '../../../services/skeleton/skeleton.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Componente wrapper para listas con infinite scroll.
+ *
+ * @example
+ * <!-- Uso basico con data source -->
+ * <val-infinite-list
+ *   [props]="{
+ *     dataSource: { loadFn: loadUsers, trackBy: trackByUserId },
+ *     itemTemplate: userTemplate,
+ *     pageSize: 20,
+ *     threshold: '150px'
+ *   }"
+ * ></val-infinite-list>
+ *
+ * <ng-template #userTemplate let-user let-index="index">
+ *   <val-card [props]="{ title: user.name, subtitle: user.email }">
+ *     <p>{{ user.bio }}</p>
+ *   </val-card>
+ * </ng-template>
+ *
+ * @example
+ * <!-- Con pull-to-refresh y estado vacio personalizado -->
+ * <val-infinite-list
+ *   [props]="{
+ *     dataSource: { loadFn: loadMessages },
+ *     itemTemplate: messageTemplate,
+ *     direction: 'both',
+ *     enableRefresh: true,
+ *     emptyState: {
+ *       icon: 'chatbubbles-outline',
+ *       title: 'Sin mensajes',
+ *       message: 'Inicia una conversacion'
+ *     },
+ *     skeleton: { template: 'list', count: 5 }
+ *   }"
+ *   (refresh)="onRefresh($event)"
+ * ></val-infinite-list>
+ */
+export class InfiniteListComponent {
+    constructor() {
+        this.skeletonService = inject(SkeletonService);
+        this.cdr = inject(ChangeDetectorRef);
+        // === Events ===
+        this.loadMore = new EventEmitter();
+        this.refresh = new EventEmitter();
+        this.stateChange = new EventEmitter();
+        this.itemsChange = new EventEmitter();
+        this.errorOccurred = new EventEmitter();
+        // === Reactive State ===
+        this.items = signal([]);
+        this.state = signal('idle');
+        this.hasMoreBottom = signal(true);
+        this.hasMoreTop = signal(false);
+        this.error = signal(null);
+        this.isInitialLoad = signal(true);
+        this.currentPage = 0;
+        this.currentCursor = null;
+        /** Progreso de carga (0-1 si totalCount conocido) */
+        this.loadProgress = computed(() => {
+            if (!this.props?.dataSource?.totalCount)
+                return null;
+            return this.items().length / this.props.dataSource.totalCount;
+        });
+        /** Anuncio de estado para lectores de pantalla */
+        this.statusAnnouncement = computed(() => {
+            switch (this.state()) {
+                case 'loading':
+                    return 'Cargando items...';
+                case 'error':
+                    return `Error: ${this.error()?.message || 'Ocurrio un error'}`;
+                case 'complete':
+                    return 'Todos los items han sido cargados';
+                default:
+                    return '';
+            }
+        });
+    }
+    /** Props combinados con defaults */
+    get mergedProps() {
+        return { ...DEFAULT_INFINITE_LIST_METADATA, ...this.props };
+    }
+    /** Config del refresher */
+    get refresherConfig() {
+        return this.mergedProps.refreshConfig ?? {};
+    }
+    /** Componente de skeleton a usar */
+    get skeletonComponent() {
+        const templateName = this.mergedProps.skeleton?.template || 'list';
+        const template = this.skeletonService.getTemplate(templateName);
+        return template?.component ?? null;
+    }
+    /** Inputs para el skeleton */
+    get skeletonInputs() {
+        return {
+            config: {
+                count: this.mergedProps.skeleton?.count ?? 3,
+                animated: true,
+                ...this.mergedProps.skeleton?.config,
+            },
+        };
+    }
+    ngOnInit() {
+        // Cargar items iniciales del dataSource si existen
+        if (this.props.dataSource.items?.length) {
+            this.items.set([...this.props.dataSource.items]);
+            this.isInitialLoad.set(false);
+        }
+        // Auto-cargar si esta habilitado
+        if (this.mergedProps.autoLoad && !this.items().length) {
+            this.loadInitial();
+        }
+    }
+    ngOnDestroy() {
+        // Cleanup
+    }
+    /** Funcion de tracking para ngFor */
+    trackByFn(index, item) {
+        if (this.props.dataSource.trackBy) {
+            return this.props.dataSource.trackBy(index, item);
+        }
+        return index;
+    }
+    /** Si debe mostrar el scroll inferior */
+    shouldShowBottomScroll() {
+        const dir = this.mergedProps.direction;
+        return (dir === 'bottom' || dir === 'both') && this.items().length > 0;
+    }
+    /** Carga inicial de datos */
+    async loadInitial() {
+        if (!this.props.dataSource.loadFn)
+            return;
+        this.state.set('loading');
+        this.stateChange.emit('loading');
+        this.error.set(null);
+        try {
+            const params = {
+                direction: 'bottom',
+                page: 0,
+                pageSize: this.mergedProps.pageSize ?? 20,
+            };
+            const result = await this.executeLoad(params);
+            this.items.set(result.items);
+            this.hasMoreBottom.set(result.hasMore);
+            this.currentPage = 1;
+            this.currentCursor = result.cursor;
+            this.isInitialLoad.set(false);
+            this.state.set('idle');
+            this.stateChange.emit('idle');
+            this.itemsChange.emit(this.items());
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    /** Cargar mas items en la parte inferior */
+    async loadBottom() {
+        if (!this.hasMoreBottom() || this.state() === 'loading')
+            return;
+        if (!this.props.dataSource.loadFn)
+            return;
+        this.state.set('loading');
+        this.stateChange.emit('loading');
+        try {
+            const params = {
+                direction: 'bottom',
+                page: this.currentPage,
+                pageSize: this.mergedProps.pageSize ?? 20,
+                cursor: this.currentCursor,
+                lastItem: this.items()[this.items().length - 1],
+            };
+            const result = await this.executeLoad(params);
+            this.items.update((current) => [...current, ...result.items]);
+            this.hasMoreBottom.set(result.hasMore);
+            this.currentPage++;
+            this.currentCursor = result.cursor;
+            this.state.set(result.hasMore ? 'idle' : 'complete');
+            this.stateChange.emit(result.hasMore ? 'idle' : 'complete');
+            this.itemsChange.emit(this.items());
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    /** Cargar mas items en la parte superior */
+    async loadTop() {
+        if (!this.hasMoreTop() || this.state() === 'loading')
+            return;
+        if (!this.props.dataSource.loadFn)
+            return;
+        this.state.set('loading');
+        try {
+            const params = {
+                direction: 'top',
+                page: 0,
+                pageSize: this.mergedProps.pageSize ?? 20,
+                firstItem: this.items()[0],
+            };
+            const result = await this.executeLoad(params);
+            this.items.update((current) => [...result.items, ...current]);
+            this.hasMoreTop.set(result.hasMore);
+            this.state.set('idle');
+            this.itemsChange.emit(this.items());
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    /** Refresh - recargar desde cero */
+    async refreshList() {
+        this.currentPage = 0;
+        this.currentCursor = null;
+        this.hasMoreBottom.set(true);
+        this.items.set([]);
+        await this.loadInitial();
+    }
+    /** Reintentar despues de error */
+    async retry() {
+        this.error.set(null);
+        if (this.items().length === 0) {
+            await this.loadInitial();
+        }
+        else {
+            await this.loadBottom();
+        }
+    }
+    /** Reset completo */
+    async reset() {
+        this.items.set([]);
+        this.currentPage = 0;
+        this.currentCursor = null;
+        this.hasMoreBottom.set(true);
+        this.hasMoreTop.set(false);
+        this.error.set(null);
+        this.isInitialLoad.set(true);
+        this.state.set('idle');
+        if (this.mergedProps.autoLoad) {
+            await this.loadInitial();
+        }
+    }
+    /** Agregar items al inicio */
+    prependItems(newItems) {
+        this.items.update((current) => [...newItems, ...current]);
+        this.itemsChange.emit(this.items());
+    }
+    /** Agregar items al final */
+    appendItems(newItems) {
+        this.items.update((current) => [...current, ...newItems]);
+        this.itemsChange.emit(this.items());
+    }
+    /** Actualizar un item por indice */
+    updateItem(index, item) {
+        this.items.update((current) => {
+            const updated = [...current];
+            updated[index] = item;
+            return updated;
+        });
+        this.itemsChange.emit(this.items());
+    }
+    /** Remover un item por indice */
+    removeItem(index) {
+        this.items.update((current) => current.filter((_, i) => i !== index));
+        this.itemsChange.emit(this.items());
+    }
+    /** Handler para evento de infinite scroll */
+    async onInfiniteScroll(event) {
+        await this.loadBottom();
+        event.target.complete();
+    }
+    /** Handler para evento de refresh */
+    async onRefreshTriggered(event) {
+        this.refresh.emit(event);
+        await this.refreshList();
+        event.complete();
+    }
+    async executeLoad(params) {
+        const loadFn = this.props.dataSource.loadFn;
+        const result = loadFn(params);
+        if (isObservable(result)) {
+            return await firstValueFrom(result);
+        }
+        return await result;
+    }
+    handleError(err) {
+        this.error.set(err);
+        this.state.set('error');
+        this.stateChange.emit('error');
+        this.errorOccurred.emit(err);
+        console.error('[InfiniteList] Error loading items:', err);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InfiniteListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: InfiniteListComponent, isStandalone: true, selector: "val-infinite-list", inputs: { props: "props" }, outputs: { loadMore: "loadMore", refresh: "refresh", stateChange: "stateChange", itemsChange: "itemsChange", errorOccurred: "errorOccurred" }, viewQueries: [{ propertyName: "infiniteScroll", first: true, predicate: IonInfiniteScroll, descendants: true }], ngImport: i0, template: `
+    <!-- Pull to refresh wrapper -->
+    @if (mergedProps.enableRefresh) {
+      <val-refresher [props]="refresherConfig" (refresh)="onRefreshTriggered($event)">
+        <ng-container *ngTemplateOutlet="listContent"></ng-container>
+      </val-refresher>
+    } @else {
+      <ng-container *ngTemplateOutlet="listContent"></ng-container>
+    }
+
+    <!-- Main list content template -->
+    <ng-template #listContent>
+      <div
+        class="infinite-list-container"
+        [class]="mergedProps.cssClass"
+        [style.max-height]="mergedProps.maxHeight"
+        [style.overflow-y]="mergedProps.maxHeight ? 'auto' : 'visible'"
+        role="feed"
+        [attr.aria-busy]="state() === 'loading'"
+        [attr.aria-label]="mergedProps.ariaLabel"
+        [attr.aria-description]="mergedProps.ariaDescription"
+      >
+        <!-- Loading state (initial) -->
+        @if (state() === 'loading' && items().length === 0) {
+          <div class="infinite-list-skeleton">
+            @if (mergedProps.skeleton?.customTemplate) {
+              <ng-container *ngTemplateOutlet="mergedProps.skeleton.customTemplate"></ng-container>
+            } @else {
+              <ng-container *ngComponentOutlet="skeletonComponent; inputs: skeletonInputs"></ng-container>
+            }
+          </div>
+        }
+
+        <!-- Empty state -->
+        @if (state() === 'idle' && items().length === 0 && !isInitialLoad()) {
+          <div class="infinite-list-empty">
+            @if (mergedProps.emptyState?.template) {
+              <ng-container *ngTemplateOutlet="mergedProps.emptyState.template"></ng-container>
+            } @else {
+              @if (mergedProps.emptyState?.icon) {
+                <ion-icon [name]="mergedProps.emptyState.icon" size="large"></ion-icon>
+              }
+              @if (mergedProps.emptyState?.title) {
+                <h3>{{ mergedProps.emptyState.title }}</h3>
+              }
+              @if (mergedProps.emptyState?.message) {
+                <p>{{ mergedProps.emptyState.message }}</p>
+              }
+            }
+          </div>
+        }
+
+        <!-- Error state -->
+        @if (state() === 'error') {
+          <div class="infinite-list-error">
+            @if (mergedProps.errorState?.template) {
+              <ng-container
+                *ngTemplateOutlet="mergedProps.errorState.template; context: { error: error(), retry: retry.bind(this) }"
+              ></ng-container>
+            } @else {
+              @if (mergedProps.errorState?.icon) {
+                <ion-icon [name]="mergedProps.errorState.icon" color="danger" size="large"></ion-icon>
+              } @else {
+                <ion-icon name="alert-circle-outline" color="danger" size="large"></ion-icon>
+              }
+              <h3>{{ mergedProps.errorState?.title || 'Error' }}</h3>
+              <p>{{ mergedProps.errorState?.message || error()?.message || 'Ocurrio un error' }}</p>
+              @if (mergedProps.errorState?.showRetry !== false) {
+                <ion-button fill="outline" (click)="retry()">
+                  {{ mergedProps.errorState?.retryText || 'Reintentar' }}
+                </ion-button>
+              }
+            }
+          </div>
+        }
+
+        <!-- Items list -->
+        @if (items().length > 0) {
+          <div class="infinite-list-items" [class.with-dividers]="mergedProps.showDividers">
+            @for (item of items(); track trackByFn($index, item); let i = $index; let first = $first; let last = $last) {
+              <article
+                class="infinite-list-item"
+                [attr.aria-setsize]="mergedProps.dataSource.totalCount || null"
+                [attr.aria-posinset]="i + 1"
+              >
+                <ng-container
+                  *ngTemplateOutlet="
+                    mergedProps.itemTemplate;
+                    context: { $implicit: item, index: i, first: first, last: last, count: items().length }
+                  "
+                ></ng-container>
+              </article>
+            }
+          </div>
+        }
+
+        <!-- Bottom infinite scroll -->
+        @if (shouldShowBottomScroll()) {
+          @if (mergedProps.useLoadMoreButton) {
+            <div class="infinite-list-load-more">
+              @if (hasMoreBottom()) {
+                <ion-button
+                  fill="outline"
+                  [color]="mergedProps.color"
+                  [disabled]="state() === 'loading'"
+                  (click)="loadBottom()"
+                >
+                  @if (state() === 'loading') {
+                    <ion-spinner [name]="mergedProps.spinnerType" slot="start"></ion-spinner>
+                  }
+                  {{ mergedProps.loadMoreText || 'Cargar mas' }}
+                </ion-button>
+              } @else {
+                <ion-text color="medium">{{ mergedProps.noMoreText || 'No hay mas items' }}</ion-text>
+              }
+            </div>
+          } @else {
+            <ion-infinite-scroll
+              [threshold]="mergedProps.threshold"
+              [disabled]="!hasMoreBottom()"
+              (ionInfinite)="onInfiniteScroll($event)"
+            >
+              <ion-infinite-scroll-content
+                [loadingSpinner]="mergedProps.spinnerType"
+                [loadingText]="state() === 'loading' ? 'Cargando...' : ''"
+              ></ion-infinite-scroll-content>
+            </ion-infinite-scroll>
+          }
+        }
+
+        <!-- No more items indicator -->
+        @if (!hasMoreBottom() && items().length > 0 && !mergedProps.useLoadMoreButton) {
+          <div class="infinite-list-end">
+            <ion-text color="medium">{{ mergedProps.noMoreText || 'No hay mas items' }}</ion-text>
+          </div>
+        }
+      </div>
+    </ng-template>
+
+    <!-- Live region for accessibility announcements -->
+    <div class="sr-only" role="status" aria-live="polite" [attr.aria-atomic]="true">
+      {{ statusAnnouncement() }}
+    </div>
+  `, isInline: true, styles: [":host{display:block}.infinite-list-container{width:100%}.infinite-list-skeleton,.infinite-list-empty,.infinite-list-error{padding:24px 16px;display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center;gap:12px}.infinite-list-empty ion-icon,.infinite-list-error ion-icon{font-size:48px;opacity:.6}.infinite-list-empty h3,.infinite-list-error h3{margin:0;font-size:18px;font-weight:600}.infinite-list-empty p,.infinite-list-error p{margin:0;color:var(--ion-color-medium);font-size:14px}.infinite-list-items{&.with-dividers .infinite-list-item:not(:last-child){border-bottom:1px solid var(--ion-color-light-shade, #d7d8da)}}.infinite-list-load-more{display:flex;justify-content:center;padding:16px}.infinite-list-end{display:flex;justify-content:center;padding:16px;font-size:14px}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: IonInfiniteScroll, selector: "ion-infinite-scroll", inputs: ["disabled", "position", "threshold"] }, { kind: "component", type: IonInfiniteScrollContent, selector: "ion-infinite-scroll-content", inputs: ["loadingSpinner", "loadingText"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: IonText, selector: "ion-text", inputs: ["color", "mode"] }, { kind: "component", type: RefresherComponent, selector: "val-refresher", inputs: ["props"], outputs: ["refresh", "pullProgressChange", "stateChange"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InfiniteListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-infinite-list', standalone: true, imports: [
+                        CommonModule,
+                        IonInfiniteScroll,
+                        IonInfiniteScrollContent,
+                        IonButton,
+                        IonSpinner,
+                        IonIcon,
+                        IonText,
+                        IonList,
+                        IonItem,
+                        RefresherComponent,
+                    ], template: `
+    <!-- Pull to refresh wrapper -->
+    @if (mergedProps.enableRefresh) {
+      <val-refresher [props]="refresherConfig" (refresh)="onRefreshTriggered($event)">
+        <ng-container *ngTemplateOutlet="listContent"></ng-container>
+      </val-refresher>
+    } @else {
+      <ng-container *ngTemplateOutlet="listContent"></ng-container>
+    }
+
+    <!-- Main list content template -->
+    <ng-template #listContent>
+      <div
+        class="infinite-list-container"
+        [class]="mergedProps.cssClass"
+        [style.max-height]="mergedProps.maxHeight"
+        [style.overflow-y]="mergedProps.maxHeight ? 'auto' : 'visible'"
+        role="feed"
+        [attr.aria-busy]="state() === 'loading'"
+        [attr.aria-label]="mergedProps.ariaLabel"
+        [attr.aria-description]="mergedProps.ariaDescription"
+      >
+        <!-- Loading state (initial) -->
+        @if (state() === 'loading' && items().length === 0) {
+          <div class="infinite-list-skeleton">
+            @if (mergedProps.skeleton?.customTemplate) {
+              <ng-container *ngTemplateOutlet="mergedProps.skeleton.customTemplate"></ng-container>
+            } @else {
+              <ng-container *ngComponentOutlet="skeletonComponent; inputs: skeletonInputs"></ng-container>
+            }
+          </div>
+        }
+
+        <!-- Empty state -->
+        @if (state() === 'idle' && items().length === 0 && !isInitialLoad()) {
+          <div class="infinite-list-empty">
+            @if (mergedProps.emptyState?.template) {
+              <ng-container *ngTemplateOutlet="mergedProps.emptyState.template"></ng-container>
+            } @else {
+              @if (mergedProps.emptyState?.icon) {
+                <ion-icon [name]="mergedProps.emptyState.icon" size="large"></ion-icon>
+              }
+              @if (mergedProps.emptyState?.title) {
+                <h3>{{ mergedProps.emptyState.title }}</h3>
+              }
+              @if (mergedProps.emptyState?.message) {
+                <p>{{ mergedProps.emptyState.message }}</p>
+              }
+            }
+          </div>
+        }
+
+        <!-- Error state -->
+        @if (state() === 'error') {
+          <div class="infinite-list-error">
+            @if (mergedProps.errorState?.template) {
+              <ng-container
+                *ngTemplateOutlet="mergedProps.errorState.template; context: { error: error(), retry: retry.bind(this) }"
+              ></ng-container>
+            } @else {
+              @if (mergedProps.errorState?.icon) {
+                <ion-icon [name]="mergedProps.errorState.icon" color="danger" size="large"></ion-icon>
+              } @else {
+                <ion-icon name="alert-circle-outline" color="danger" size="large"></ion-icon>
+              }
+              <h3>{{ mergedProps.errorState?.title || 'Error' }}</h3>
+              <p>{{ mergedProps.errorState?.message || error()?.message || 'Ocurrio un error' }}</p>
+              @if (mergedProps.errorState?.showRetry !== false) {
+                <ion-button fill="outline" (click)="retry()">
+                  {{ mergedProps.errorState?.retryText || 'Reintentar' }}
+                </ion-button>
+              }
+            }
+          </div>
+        }
+
+        <!-- Items list -->
+        @if (items().length > 0) {
+          <div class="infinite-list-items" [class.with-dividers]="mergedProps.showDividers">
+            @for (item of items(); track trackByFn($index, item); let i = $index; let first = $first; let last = $last) {
+              <article
+                class="infinite-list-item"
+                [attr.aria-setsize]="mergedProps.dataSource.totalCount || null"
+                [attr.aria-posinset]="i + 1"
+              >
+                <ng-container
+                  *ngTemplateOutlet="
+                    mergedProps.itemTemplate;
+                    context: { $implicit: item, index: i, first: first, last: last, count: items().length }
+                  "
+                ></ng-container>
+              </article>
+            }
+          </div>
+        }
+
+        <!-- Bottom infinite scroll -->
+        @if (shouldShowBottomScroll()) {
+          @if (mergedProps.useLoadMoreButton) {
+            <div class="infinite-list-load-more">
+              @if (hasMoreBottom()) {
+                <ion-button
+                  fill="outline"
+                  [color]="mergedProps.color"
+                  [disabled]="state() === 'loading'"
+                  (click)="loadBottom()"
+                >
+                  @if (state() === 'loading') {
+                    <ion-spinner [name]="mergedProps.spinnerType" slot="start"></ion-spinner>
+                  }
+                  {{ mergedProps.loadMoreText || 'Cargar mas' }}
+                </ion-button>
+              } @else {
+                <ion-text color="medium">{{ mergedProps.noMoreText || 'No hay mas items' }}</ion-text>
+              }
+            </div>
+          } @else {
+            <ion-infinite-scroll
+              [threshold]="mergedProps.threshold"
+              [disabled]="!hasMoreBottom()"
+              (ionInfinite)="onInfiniteScroll($event)"
+            >
+              <ion-infinite-scroll-content
+                [loadingSpinner]="mergedProps.spinnerType"
+                [loadingText]="state() === 'loading' ? 'Cargando...' : ''"
+              ></ion-infinite-scroll-content>
+            </ion-infinite-scroll>
+          }
+        }
+
+        <!-- No more items indicator -->
+        @if (!hasMoreBottom() && items().length > 0 && !mergedProps.useLoadMoreButton) {
+          <div class="infinite-list-end">
+            <ion-text color="medium">{{ mergedProps.noMoreText || 'No hay mas items' }}</ion-text>
+          </div>
+        }
+      </div>
+    </ng-template>
+
+    <!-- Live region for accessibility announcements -->
+    <div class="sr-only" role="status" aria-live="polite" [attr.aria-atomic]="true">
+      {{ statusAnnouncement() }}
+    </div>
+  `, styles: [":host{display:block}.infinite-list-container{width:100%}.infinite-list-skeleton,.infinite-list-empty,.infinite-list-error{padding:24px 16px;display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center;gap:12px}.infinite-list-empty ion-icon,.infinite-list-error ion-icon{font-size:48px;opacity:.6}.infinite-list-empty h3,.infinite-list-error h3{margin:0;font-size:18px;font-weight:600}.infinite-list-empty p,.infinite-list-error p{margin:0;color:var(--ion-color-medium);font-size:14px}.infinite-list-items{&.with-dividers .infinite-list-item:not(:last-child){border-bottom:1px solid var(--ion-color-light-shade, #d7d8da)}}.infinite-list-load-more{display:flex;justify-content:center;padding:16px}.infinite-list-end{display:flex;justify-content:center;padding:16px;font-size:14px}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}\n"] }]
+        }], propDecorators: { infiniteScroll: [{
+                type: ViewChild,
+                args: [IonInfiniteScroll]
+            }], props: [{
+                type: Input
+            }], loadMore: [{
+                type: Output
+            }], refresh: [{
+                type: Output
+            }], stateChange: [{
+                type: Output
+            }], itemsChange: [{
+                type: Output
+            }], errorOccurred: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infinite-list.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/infinite-list/infinite-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  signal,\n  computed,\n  OnInit,\n  OnDestroy,\n  ViewChild,\n  inject,\n  ChangeDetectorRef,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport {\n  IonInfiniteScroll,\n  IonInfiniteScrollContent,\n  IonButton,\n  IonSpinner,\n  IonIcon,\n  IonText,\n  IonList,\n  IonItem,\n} from '@ionic/angular/standalone';\nimport { firstValueFrom, isObservable } from 'rxjs';\nimport {\n  InfiniteListMetadata,\n  InfiniteListState,\n  LoadMoreEvent,\n  LoadParams,\n  LoadResult,\n  DEFAULT_INFINITE_LIST_METADATA,\n} from './types';\nimport { RefreshEvent, RefresherMetadata } from '../../molecules/refresher/types';\nimport { RefresherComponent } from '../../molecules/refresher/refresher.component';\nimport { SkeletonService } from '../../../services/skeleton/skeleton.service';\nimport { SkeletonTemplateComponent } from '../../../services/skeleton/types';\n\n/**\n * Componente wrapper para listas con infinite scroll.\n *\n * @example\n * <!-- Uso basico con data source -->\n * <val-infinite-list\n *   [props]=\"{\n *     dataSource: { loadFn: loadUsers, trackBy: trackByUserId },\n *     itemTemplate: userTemplate,\n *     pageSize: 20,\n *     threshold: '150px'\n *   }\"\n * ></val-infinite-list>\n *\n * <ng-template #userTemplate let-user let-index=\"index\">\n *   <val-card [props]=\"{ title: user.name, subtitle: user.email }\">\n *     <p>{{ user.bio }}</p>\n *   </val-card>\n * </ng-template>\n *\n * @example\n * <!-- Con pull-to-refresh y estado vacio personalizado -->\n * <val-infinite-list\n *   [props]=\"{\n *     dataSource: { loadFn: loadMessages },\n *     itemTemplate: messageTemplate,\n *     direction: 'both',\n *     enableRefresh: true,\n *     emptyState: {\n *       icon: 'chatbubbles-outline',\n *       title: 'Sin mensajes',\n *       message: 'Inicia una conversacion'\n *     },\n *     skeleton: { template: 'list', count: 5 }\n *   }\"\n *   (refresh)=\"onRefresh($event)\"\n * ></val-infinite-list>\n */\n@Component({\n  selector: 'val-infinite-list',\n  standalone: true,\n  imports: [\n    CommonModule,\n    IonInfiniteScroll,\n    IonInfiniteScrollContent,\n    IonButton,\n    IonSpinner,\n    IonIcon,\n    IonText,\n    IonList,\n    IonItem,\n    RefresherComponent,\n  ],\n  template: `\n    <!-- Pull to refresh wrapper -->\n    @if (mergedProps.enableRefresh) {\n      <val-refresher [props]=\"refresherConfig\" (refresh)=\"onRefreshTriggered($event)\">\n        <ng-container *ngTemplateOutlet=\"listContent\"></ng-container>\n      </val-refresher>\n    } @else {\n      <ng-container *ngTemplateOutlet=\"listContent\"></ng-container>\n    }\n\n    <!-- Main list content template -->\n    <ng-template #listContent>\n      <div\n        class=\"infinite-list-container\"\n        [class]=\"mergedProps.cssClass\"\n        [style.max-height]=\"mergedProps.maxHeight\"\n        [style.overflow-y]=\"mergedProps.maxHeight ? 'auto' : 'visible'\"\n        role=\"feed\"\n        [attr.aria-busy]=\"state() === 'loading'\"\n        [attr.aria-label]=\"mergedProps.ariaLabel\"\n        [attr.aria-description]=\"mergedProps.ariaDescription\"\n      >\n        <!-- Loading state (initial) -->\n        @if (state() === 'loading' && items().length === 0) {\n          <div class=\"infinite-list-skeleton\">\n            @if (mergedProps.skeleton?.customTemplate) {\n              <ng-container *ngTemplateOutlet=\"mergedProps.skeleton.customTemplate\"></ng-container>\n            } @else {\n              <ng-container *ngComponentOutlet=\"skeletonComponent; inputs: skeletonInputs\"></ng-container>\n            }\n          </div>\n        }\n\n        <!-- Empty state -->\n        @if (state() === 'idle' && items().length === 0 && !isInitialLoad()) {\n          <div class=\"infinite-list-empty\">\n            @if (mergedProps.emptyState?.template) {\n              <ng-container *ngTemplateOutlet=\"mergedProps.emptyState.template\"></ng-container>\n            } @else {\n              @if (mergedProps.emptyState?.icon) {\n                <ion-icon [name]=\"mergedProps.emptyState.icon\" size=\"large\"></ion-icon>\n              }\n              @if (mergedProps.emptyState?.title) {\n                <h3>{{ mergedProps.emptyState.title }}</h3>\n              }\n              @if (mergedProps.emptyState?.message) {\n                <p>{{ mergedProps.emptyState.message }}</p>\n              }\n            }\n          </div>\n        }\n\n        <!-- Error state -->\n        @if (state() === 'error') {\n          <div class=\"infinite-list-error\">\n            @if (mergedProps.errorState?.template) {\n              <ng-container\n                *ngTemplateOutlet=\"mergedProps.errorState.template; context: { error: error(), retry: retry.bind(this) }\"\n              ></ng-container>\n            } @else {\n              @if (mergedProps.errorState?.icon) {\n                <ion-icon [name]=\"mergedProps.errorState.icon\" color=\"danger\" size=\"large\"></ion-icon>\n              } @else {\n                <ion-icon name=\"alert-circle-outline\" color=\"danger\" size=\"large\"></ion-icon>\n              }\n              <h3>{{ mergedProps.errorState?.title || 'Error' }}</h3>\n              <p>{{ mergedProps.errorState?.message || error()?.message || 'Ocurrio un error' }}</p>\n              @if (mergedProps.errorState?.showRetry !== false) {\n                <ion-button fill=\"outline\" (click)=\"retry()\">\n                  {{ mergedProps.errorState?.retryText || 'Reintentar' }}\n                </ion-button>\n              }\n            }\n          </div>\n        }\n\n        <!-- Items list -->\n        @if (items().length > 0) {\n          <div class=\"infinite-list-items\" [class.with-dividers]=\"mergedProps.showDividers\">\n            @for (item of items(); track trackByFn($index, item); let i = $index; let first = $first; let last = $last) {\n              <article\n                class=\"infinite-list-item\"\n                [attr.aria-setsize]=\"mergedProps.dataSource.totalCount || null\"\n                [attr.aria-posinset]=\"i + 1\"\n              >\n                <ng-container\n                  *ngTemplateOutlet=\"\n                    mergedProps.itemTemplate;\n                    context: { $implicit: item, index: i, first: first, last: last, count: items().length }\n                  \"\n                ></ng-container>\n              </article>\n            }\n          </div>\n        }\n\n        <!-- Bottom infinite scroll -->\n        @if (shouldShowBottomScroll()) {\n          @if (mergedProps.useLoadMoreButton) {\n            <div class=\"infinite-list-load-more\">\n              @if (hasMoreBottom()) {\n                <ion-button\n                  fill=\"outline\"\n                  [color]=\"mergedProps.color\"\n                  [disabled]=\"state() === 'loading'\"\n                  (click)=\"loadBottom()\"\n                >\n                  @if (state() === 'loading') {\n                    <ion-spinner [name]=\"mergedProps.spinnerType\" slot=\"start\"></ion-spinner>\n                  }\n                  {{ mergedProps.loadMoreText || 'Cargar mas' }}\n                </ion-button>\n              } @else {\n                <ion-text color=\"medium\">{{ mergedProps.noMoreText || 'No hay mas items' }}</ion-text>\n              }\n            </div>\n          } @else {\n            <ion-infinite-scroll\n              [threshold]=\"mergedProps.threshold\"\n              [disabled]=\"!hasMoreBottom()\"\n              (ionInfinite)=\"onInfiniteScroll($event)\"\n            >\n              <ion-infinite-scroll-content\n                [loadingSpinner]=\"mergedProps.spinnerType\"\n                [loadingText]=\"state() === 'loading' ? 'Cargando...' : ''\"\n              ></ion-infinite-scroll-content>\n            </ion-infinite-scroll>\n          }\n        }\n\n        <!-- No more items indicator -->\n        @if (!hasMoreBottom() && items().length > 0 && !mergedProps.useLoadMoreButton) {\n          <div class=\"infinite-list-end\">\n            <ion-text color=\"medium\">{{ mergedProps.noMoreText || 'No hay mas items' }}</ion-text>\n          </div>\n        }\n      </div>\n    </ng-template>\n\n    <!-- Live region for accessibility announcements -->\n    <div class=\"sr-only\" role=\"status\" aria-live=\"polite\" [attr.aria-atomic]=\"true\">\n      {{ statusAnnouncement() }}\n    </div>\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n      }\n\n      .infinite-list-container {\n        width: 100%;\n      }\n\n      .infinite-list-skeleton,\n      .infinite-list-empty,\n      .infinite-list-error {\n        padding: 24px 16px;\n        display: flex;\n        flex-direction: column;\n        align-items: center;\n        justify-content: center;\n        text-align: center;\n        gap: 12px;\n      }\n\n      .infinite-list-empty ion-icon,\n      .infinite-list-error ion-icon {\n        font-size: 48px;\n        opacity: 0.6;\n      }\n\n      .infinite-list-empty h3,\n      .infinite-list-error h3 {\n        margin: 0;\n        font-size: 18px;\n        font-weight: 600;\n      }\n\n      .infinite-list-empty p,\n      .infinite-list-error p {\n        margin: 0;\n        color: var(--ion-color-medium);\n        font-size: 14px;\n      }\n\n      .infinite-list-items {\n        &.with-dividers .infinite-list-item:not(:last-child) {\n          border-bottom: 1px solid var(--ion-color-light-shade, #d7d8da);\n        }\n      }\n\n      .infinite-list-load-more {\n        display: flex;\n        justify-content: center;\n        padding: 16px;\n      }\n\n      .infinite-list-end {\n        display: flex;\n        justify-content: center;\n        padding: 16px;\n        font-size: 14px;\n      }\n\n      .sr-only {\n        position: absolute;\n        width: 1px;\n        height: 1px;\n        padding: 0;\n        margin: -1px;\n        overflow: hidden;\n        clip: rect(0, 0, 0, 0);\n        white-space: nowrap;\n        border: 0;\n      }\n    `,\n  ],\n})\nexport class InfiniteListComponent<T = unknown> implements OnInit, OnDestroy {\n  private readonly skeletonService = inject(SkeletonService);\n  private readonly cdr = inject(ChangeDetectorRef);\n\n  @ViewChild(IonInfiniteScroll) infiniteScroll?: IonInfiniteScroll;\n\n  /** Configuracion del componente */\n  @Input() props!: InfiniteListMetadata<T>;\n\n  // === Events ===\n  @Output() loadMore = new EventEmitter<LoadMoreEvent>();\n  @Output() refresh = new EventEmitter<RefreshEvent>();\n  @Output() stateChange = new EventEmitter<InfiniteListState>();\n  @Output() itemsChange = new EventEmitter<T[]>();\n  @Output() errorOccurred = new EventEmitter<Error>();\n\n  // === Reactive State ===\n  readonly items = signal<T[]>([]);\n  readonly state = signal<InfiniteListState>('idle');\n  readonly hasMoreBottom = signal<boolean>(true);\n  readonly hasMoreTop = signal<boolean>(false);\n  readonly error = signal<Error | null>(null);\n  readonly isInitialLoad = signal<boolean>(true);\n\n  private currentPage = 0;\n  private currentCursor: unknown = null;\n\n  /** Progreso de carga (0-1 si totalCount conocido) */\n  readonly loadProgress = computed(() => {\n    if (!this.props?.dataSource?.totalCount) return null;\n    return this.items().length / this.props.dataSource.totalCount;\n  });\n\n  /** Props combinados con defaults */\n  get mergedProps(): InfiniteListMetadata<T> {\n    return { ...DEFAULT_INFINITE_LIST_METADATA, ...this.props } as InfiniteListMetadata<T>;\n  }\n\n  /** Config del refresher */\n  get refresherConfig(): RefresherMetadata {\n    return this.mergedProps.refreshConfig ?? {};\n  }\n\n  /** Componente de skeleton a usar */\n  get skeletonComponent() {\n    const templateName = this.mergedProps.skeleton?.template || 'list';\n    const template = this.skeletonService.getTemplate(templateName);\n    return template?.component ?? null;\n  }\n\n  /** Inputs para el skeleton */\n  get skeletonInputs(): { config: unknown } {\n    return {\n      config: {\n        count: this.mergedProps.skeleton?.count ?? 3,\n        animated: true,\n        ...this.mergedProps.skeleton?.config,\n      },\n    };\n  }\n\n  /** Anuncio de estado para lectores de pantalla */\n  readonly statusAnnouncement = computed(() => {\n    switch (this.state()) {\n      case 'loading':\n        return 'Cargando items...';\n      case 'error':\n        return `Error: ${this.error()?.message || 'Ocurrio un error'}`;\n      case 'complete':\n        return 'Todos los items han sido cargados';\n      default:\n        return '';\n    }\n  });\n\n  ngOnInit(): void {\n    // Cargar items iniciales del dataSource si existen\n    if (this.props.dataSource.items?.length) {\n      this.items.set([...this.props.dataSource.items]);\n      this.isInitialLoad.set(false);\n    }\n\n    // Auto-cargar si esta habilitado\n    if (this.mergedProps.autoLoad && !this.items().length) {\n      this.loadInitial();\n    }\n  }\n\n  ngOnDestroy(): void {\n    // Cleanup\n  }\n\n  /** Funcion de tracking para ngFor */\n  trackByFn(index: number, item: T): unknown {\n    if (this.props.dataSource.trackBy) {\n      return this.props.dataSource.trackBy(index, item);\n    }\n    return index;\n  }\n\n  /** Si debe mostrar el scroll inferior */\n  shouldShowBottomScroll(): boolean {\n    const dir = this.mergedProps.direction;\n    return (dir === 'bottom' || dir === 'both') && this.items().length > 0;\n  }\n\n  /** Carga inicial de datos */\n  async loadInitial(): Promise<void> {\n    if (!this.props.dataSource.loadFn) return;\n\n    this.state.set('loading');\n    this.stateChange.emit('loading');\n    this.error.set(null);\n\n    try {\n      const params: LoadParams = {\n        direction: 'bottom',\n        page: 0,\n        pageSize: this.mergedProps.pageSize ?? 20,\n      };\n\n      const result = await this.executeLoad(params);\n\n      this.items.set(result.items as T[]);\n      this.hasMoreBottom.set(result.hasMore);\n      this.currentPage = 1;\n      this.currentCursor = result.cursor;\n      this.isInitialLoad.set(false);\n\n      this.state.set('idle');\n      this.stateChange.emit('idle');\n      this.itemsChange.emit(this.items());\n    } catch (err) {\n      this.handleError(err as Error);\n    }\n  }\n\n  /** Cargar mas items en la parte inferior */\n  async loadBottom(): Promise<void> {\n    if (!this.hasMoreBottom() || this.state() === 'loading') return;\n    if (!this.props.dataSource.loadFn) return;\n\n    this.state.set('loading');\n    this.stateChange.emit('loading');\n\n    try {\n      const params: LoadParams = {\n        direction: 'bottom',\n        page: this.currentPage,\n        pageSize: this.mergedProps.pageSize ?? 20,\n        cursor: this.currentCursor,\n        lastItem: this.items()[this.items().length - 1],\n      };\n\n      const result = await this.executeLoad(params);\n\n      this.items.update((current) => [...current, ...(result.items as T[])]);\n      this.hasMoreBottom.set(result.hasMore);\n      this.currentPage++;\n      this.currentCursor = result.cursor;\n\n      this.state.set(result.hasMore ? 'idle' : 'complete');\n      this.stateChange.emit(result.hasMore ? 'idle' : 'complete');\n      this.itemsChange.emit(this.items());\n    } catch (err) {\n      this.handleError(err as Error);\n    }\n  }\n\n  /** Cargar mas items en la parte superior */\n  async loadTop(): Promise<void> {\n    if (!this.hasMoreTop() || this.state() === 'loading') return;\n    if (!this.props.dataSource.loadFn) return;\n\n    this.state.set('loading');\n\n    try {\n      const params: LoadParams = {\n        direction: 'top',\n        page: 0,\n        pageSize: this.mergedProps.pageSize ?? 20,\n        firstItem: this.items()[0],\n      };\n\n      const result = await this.executeLoad(params);\n\n      this.items.update((current) => [...(result.items as T[]), ...current]);\n      this.hasMoreTop.set(result.hasMore);\n\n      this.state.set('idle');\n      this.itemsChange.emit(this.items());\n    } catch (err) {\n      this.handleError(err as Error);\n    }\n  }\n\n  /** Refresh - recargar desde cero */\n  async refreshList(): Promise<void> {\n    this.currentPage = 0;\n    this.currentCursor = null;\n    this.hasMoreBottom.set(true);\n    this.items.set([]);\n    await this.loadInitial();\n  }\n\n  /** Reintentar despues de error */\n  async retry(): Promise<void> {\n    this.error.set(null);\n    if (this.items().length === 0) {\n      await this.loadInitial();\n    } else {\n      await this.loadBottom();\n    }\n  }\n\n  /** Reset completo */\n  async reset(): Promise<void> {\n    this.items.set([]);\n    this.currentPage = 0;\n    this.currentCursor = null;\n    this.hasMoreBottom.set(true);\n    this.hasMoreTop.set(false);\n    this.error.set(null);\n    this.isInitialLoad.set(true);\n    this.state.set('idle');\n\n    if (this.mergedProps.autoLoad) {\n      await this.loadInitial();\n    }\n  }\n\n  /** Agregar items al inicio */\n  prependItems(newItems: T[]): void {\n    this.items.update((current) => [...newItems, ...current]);\n    this.itemsChange.emit(this.items());\n  }\n\n  /** Agregar items al final */\n  appendItems(newItems: T[]): void {\n    this.items.update((current) => [...current, ...newItems]);\n    this.itemsChange.emit(this.items());\n  }\n\n  /** Actualizar un item por indice */\n  updateItem(index: number, item: T): void {\n    this.items.update((current) => {\n      const updated = [...current];\n      updated[index] = item;\n      return updated;\n    });\n    this.itemsChange.emit(this.items());\n  }\n\n  /** Remover un item por indice */\n  removeItem(index: number): void {\n    this.items.update((current) => current.filter((_, i) => i !== index));\n    this.itemsChange.emit(this.items());\n  }\n\n  /** Handler para evento de infinite scroll */\n  async onInfiniteScroll(event: CustomEvent): Promise<void> {\n    await this.loadBottom();\n    (event.target as HTMLIonInfiniteScrollElement).complete();\n  }\n\n  /** Handler para evento de refresh */\n  async onRefreshTriggered(event: RefreshEvent): Promise<void> {\n    this.refresh.emit(event);\n    await this.refreshList();\n    event.complete();\n  }\n\n  private async executeLoad(params: LoadParams): Promise<LoadResult<unknown>> {\n    const loadFn = this.props.dataSource.loadFn!;\n    const result = loadFn(params);\n\n    if (isObservable(result)) {\n      return await firstValueFrom(result);\n    }\n    return await result;\n  }\n\n  private handleError(err: Error): void {\n    this.error.set(err);\n    this.state.set('error');\n    this.stateChange.emit('error');\n    this.errorOccurred.emit(err);\n    console.error('[InfiniteList] Error loading items:', err);\n  }\n}\n"]}