valtech-components 2.0.510 → 2.0.511

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

@@ -0,0 +1,15 @@
+/**
+ * Valores por defecto para infinite list.
+ */
+export const DEFAULT_INFINITE_LIST_METADATA = {
+    direction: 'bottom',
+    pageSize: 20,
+    threshold: '100px',
+    debounceTime: 300,
+    autoLoad: true,
+    spinnerType: 'crescent',
+    useLoadMoreButton: false,
+    showDividers: false,
+    enableRefresh: false,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/infinite-list/types.ts"],"names":[],"mappings":"AA6NA;;GAEG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAkC;IAC3E,SAAS,EAAE,QAAQ;IACnB,QAAQ,EAAE,EAAE;IACZ,SAAS,EAAE,OAAO;IAClB,YAAY,EAAE,GAAG;IACjB,QAAQ,EAAE,IAAI;IACd,WAAW,EAAE,UAAU;IACvB,iBAAiB,EAAE,KAAK;IACxB,YAAY,EAAE,KAAK;IACnB,aAAa,EAAE,KAAK;CACrB,CAAC","sourcesContent":["import { TemplateRef } from '@angular/core';\nimport { Color } from '@ionic/core';\nimport { Observable } from 'rxjs';\nimport { SkeletonTemplateName, SkeletonTemplateConfig } from '../../../services/skeleton/types';\nimport { RefresherMetadata } from '../../molecules/refresher/types';\n\n/**\n * Direccion de carga de mas items.\n */\nexport type LoadDirection = 'bottom' | 'top' | 'both';\n\n/**\n * Estado de la lista infinita.\n */\nexport type InfiniteListState = 'idle' | 'loading' | 'error' | 'complete';\n\n/**\n * Parametros pasados a la funcion de carga.\n */\nexport interface LoadParams {\n  /** Direccion de carga */\n  direction: 'bottom' | 'top';\n  /** Pagina actual (para paginacion basada en offset) */\n  page: number;\n  /** Items por pagina */\n  pageSize: number;\n  /** Ultimo item (para paginacion basada en cursor) */\n  lastItem?: unknown;\n  /** Primer item (para carga top con cursor) */\n  firstItem?: unknown;\n  /** Cursor personalizado (del LoadResult anterior) */\n  cursor?: unknown;\n}\n\n/**\n * Resultado de la funcion de carga.\n */\nexport interface LoadResult<T> {\n  /** Items cargados */\n  items: T[];\n  /** Si hay mas items disponibles */\n  hasMore: boolean;\n  /** Cursor personalizado para proxima carga (opcional) */\n  cursor?: unknown;\n  /** Actualizacion de conteo total (opcional) */\n  totalCount?: number;\n}\n\n/**\n * Configuracion del data source.\n */\nexport interface InfiniteListDataSource<T> {\n  /** Items iniciales (opcional si usa loadFn) */\n  items?: T[];\n  /** Funcion para cargar mas items */\n  loadFn?: (params: LoadParams) => Observable<LoadResult<T>> | Promise<LoadResult<T>>;\n  /** Funcion track para ngFor (default: index) */\n  trackBy?: (index: number, item: T) => unknown;\n  /** Conteo total si se conoce (habilita indicador de progreso) */\n  totalCount?: number;\n}\n\n/**\n * Evento emitido al cargar mas items.\n */\nexport interface LoadMoreEvent {\n  /** Parametros de carga */\n  params: LoadParams;\n  /** Llamar cuando la carga completa */\n  complete: (result: LoadResult<unknown>) => void;\n  /** Llamar cuando la carga falla */\n  error: (error: Error) => void;\n}\n\n/**\n * Configuracion de estado vacio.\n */\nexport interface InfiniteListEmptyState {\n  /** Nombre del icono */\n  icon?: string;\n  /** Texto del titulo */\n  title?: string;\n  /** Texto del mensaje */\n  message?: string;\n  /** Template personalizado */\n  template?: TemplateRef<void>;\n  // Soporte i18n\n  titleKey?: string;\n  messageKey?: string;\n  contentClass?: string;\n}\n\n/**\n * Configuracion de estado de error.\n */\nexport interface InfiniteListErrorState {\n  /** Icono de error */\n  icon?: string;\n  /** Titulo del error */\n  title?: string;\n  /** Mensaje del error */\n  message?: string;\n  /** Mostrar boton de reintentar */\n  showRetry?: boolean;\n  /** Texto del boton de reintentar */\n  retryText?: string;\n  /** Template personalizado */\n  template?: TemplateRef<{ error: Error; retry: () => void }>;\n  // Soporte i18n\n  titleKey?: string;\n  messageKey?: string;\n  retryTextKey?: string;\n  contentClass?: string;\n}\n\n/**\n * Configuracion de skeleton para carga.\n */\nexport interface InfiniteListSkeletonConfig {\n  /** Template de skeleton a usar */\n  template?: SkeletonTemplateName | string;\n  /** Numero de items skeleton a mostrar */\n  count?: number;\n  /** Template personalizado */\n  customTemplate?: TemplateRef<void>;\n  /** Configuracion adicional */\n  config?: SkeletonTemplateConfig;\n}\n\n/**\n * Contexto para el template de items.\n */\nexport interface InfiniteListItemContext<T> {\n  /** El item actual */\n  $implicit: T;\n  /** Indice del item */\n  index: number;\n  /** Si es el primer item */\n  first: boolean;\n  /** Si es el ultimo item */\n  last: boolean;\n  /** Items totales */\n  count: number;\n}\n\n/**\n * Metadata para el componente val-infinite-list.\n */\nexport interface InfiniteListMetadata<T = unknown> {\n  /** Configuracion del data source */\n  dataSource: InfiniteListDataSource<T>;\n\n  // === Comportamiento de carga ===\n  /** Direccion de carga */\n  direction?: LoadDirection;\n  /** Items por pagina (default: 20) */\n  pageSize?: number;\n  /** Distancia del borde para activar carga (default: '100px') */\n  threshold?: string;\n  /** Tiempo de debounce para eventos de carga en ms (default: 300) */\n  debounceTime?: number;\n  /** Cargar primera pagina automaticamente al inicializar (default: true) */\n  autoLoad?: boolean;\n\n  // === Content projection ===\n  /** Template para renderizar cada item (requerido) */\n  itemTemplate: TemplateRef<InfiniteListItemContext<T>>;\n  /** Template para el indicador de carga en bottom */\n  loadingTemplate?: TemplateRef<void>;\n  /** Template para el indicador de carga en top */\n  topLoadingTemplate?: TemplateRef<void>;\n\n  // === Estados ===\n  /** Configuracion de estado vacio */\n  emptyState?: InfiniteListEmptyState;\n  /** Configuracion de estado de error */\n  errorState?: InfiniteListErrorState;\n  /** Configuracion de skeleton para carga inicial */\n  skeleton?: InfiniteListSkeletonConfig;\n\n  // === Indicadores de carga ===\n  /** Tipo de spinner */\n  spinnerType?: 'circular' | 'crescent' | 'dots' | 'lines-sharp';\n  /** Color del spinner */\n  color?: Color;\n  /** Usar boton \"Cargar mas\" en lugar de auto-carga */\n  useLoadMoreButton?: boolean;\n  /** Texto del boton \"Cargar mas\" */\n  loadMoreText?: string;\n  /** Texto cuando no hay mas items */\n  noMoreText?: string;\n\n  // === Integracion con pull to refresh ===\n  /** Habilitar pull-to-refresh */\n  enableRefresh?: boolean;\n  /** Configuracion del refresher */\n  refreshConfig?: RefresherMetadata;\n\n  // === Estilos ===\n  /** Clase CSS para el contenedor */\n  cssClass?: string;\n  /** Altura maxima (habilita scroll interno) */\n  maxHeight?: string;\n  /** Mostrar divisores entre items */\n  showDividers?: boolean;\n\n  // === Accesibilidad ===\n  /** ARIA label para la lista */\n  ariaLabel?: string;\n  /** ARIA description */\n  ariaDescription?: string;\n\n  /** Identificador unico */\n  token?: string;\n\n  // Soporte i18n\n  loadMoreTextKey?: string;\n  noMoreTextKey?: string;\n  contentClass?: string;\n}\n\n/**\n * Valores por defecto para infinite list.\n */\nexport const DEFAULT_INFINITE_LIST_METADATA: Partial<InfiniteListMetadata> = {\n  direction: 'bottom',\n  pageSize: 20,\n  threshold: '100px',\n  debounceTime: 300,\n  autoLoad: true,\n  spinnerType: 'crescent',\n  useLoadMoreButton: false,\n  showDividers: false,\n  enableRefresh: false,\n};\n"]}

package/esm2022/lib/components/templates/page-template/page-template.component.mjs

@@ -58,7 +58,7 @@ export class PageTemplateComponent {
     @if (props.pageTitle) {
       <ion-header [class.ion-no-border]="true">
         <ion-toolbar style="--background: transparent;">
-          <ion-title class="page-title" size="large">{{ props.pageTitle }}</ion-title>
+          <ion-title class="page-title" size="large" style="--padding-start: 0; --padding-end: 0;">{{ props.pageTitle }}</ion-title>
         </ion-toolbar>
       </ion-header>
     }
@@ -123,7 +123,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
     @if (props.pageTitle) {
       <ion-header [class.ion-no-border]="true">
         <ion-toolbar style="--background: transparent;">
-          <ion-title class="page-title" size="large">{{ props.pageTitle }}</ion-title>
+          <ion-title class="page-title" size="large" style="--padding-start: 0; --padding-end: 0;">{{ props.pageTitle }}</ion-title>
         </ion-toolbar>
       </ion-header>
     }
@@ -176,4 +176,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             }], onBack: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/pagination/index.mjs

@@ -0,0 +1,5 @@
+// Types
+export { createInitialPaginationState, } from './types';
+// Service
+export { PaginationService } from './pagination.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3BhZ2luYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsUUFBUTtBQUNSLE9BQU8sRUFPTCw0QkFBNEIsR0FDN0IsTUFBTSxTQUFTLENBQUM7QUFFakIsVUFBVTtBQUNWLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVHlwZXNcbmV4cG9ydCB7XG4gIFBhZ2luYXRpb25TdHJhdGVneSxcbiAgUGFnaW5hdGlvblN0YXRlLFxuICBQYWdpbmF0aW9uTG9hZFBhcmFtcyxcbiAgUGFnaW5hdGlvbkxvYWRSZXN1bHQsXG4gIFBhZ2luYXRpb25Db25maWcsXG4gIFBhZ2luYXRpb25Db250cm9sbGVyLFxuICBjcmVhdGVJbml0aWFsUGFnaW5hdGlvblN0YXRlLFxufSBmcm9tICcuL3R5cGVzJztcblxuLy8gU2VydmljZVxuZXhwb3J0IHsgUGFnaW5hdGlvblNlcnZpY2UgfSBmcm9tICcuL3BhZ2luYXRpb24uc2VydmljZSc7XG4iXX0=

package/esm2022/lib/services/pagination/pagination.service.mjs

@@ -0,0 +1,218 @@
+import { Injectable, signal, computed } from '@angular/core';
+import { firstValueFrom, isObservable } from 'rxjs';
+import { createInitialPaginationState, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Implementacion del controlador de paginacion.
+ */
+class PaginationControllerImpl {
+    constructor(config) {
+        this.config = config;
+        this._state = signal(createInitialPaginationState(this.config.pageSize ?? 20, this.config.initialItems));
+        this.state = this._state.asReadonly();
+        this.items = computed(() => this._state().items);
+        this.isLoading = computed(() => this._state().isLoading);
+        this.hasMore = computed(() => this._state().hasMore);
+        this.error = computed(() => this._state().error ?? null);
+        this.currentPage = computed(() => this._state().page);
+        this.total = computed(() => this._state().total);
+    }
+    async loadNext() {
+        const currentState = this._state();
+        if (currentState.isLoading || !currentState.hasMore)
+            return;
+        this._state.update((s) => ({ ...s, isLoading: true, error: undefined }));
+        try {
+            const params = {
+                strategy: this.config.strategy,
+                page: currentState.page,
+                pageSize: currentState.pageSize,
+                cursor: currentState.nextCursor,
+                direction: 'forward',
+            };
+            const result = await this.executeLoad(params);
+            this._state.update((s) => ({
+                ...s,
+                items: [...s.items, ...result.items],
+                page: s.page + 1,
+                hasMore: result.hasMore,
+                total: result.total ?? s.total,
+                nextCursor: result.nextCursor,
+                prevCursor: result.prevCursor ?? s.prevCursor,
+                isLoading: false,
+            }));
+        }
+        catch (err) {
+            this._state.update((s) => ({
+                ...s,
+                isLoading: false,
+                error: err,
+            }));
+        }
+    }
+    async loadPrevious() {
+        const currentState = this._state();
+        if (currentState.isLoading || currentState.page <= 0)
+            return;
+        this._state.update((s) => ({ ...s, isLoading: true, error: undefined }));
+        try {
+            const params = {
+                strategy: this.config.strategy,
+                page: currentState.page - 1,
+                pageSize: currentState.pageSize,
+                cursor: currentState.prevCursor,
+                direction: 'backward',
+            };
+            const result = await this.executeLoad(params);
+            this._state.update((s) => ({
+                ...s,
+                items: [...result.items, ...s.items],
+                page: s.page - 1,
+                prevCursor: result.prevCursor,
+                isLoading: false,
+            }));
+        }
+        catch (err) {
+            this._state.update((s) => ({
+                ...s,
+                isLoading: false,
+                error: err,
+            }));
+        }
+    }
+    async refresh() {
+        this._state.update((s) => ({
+            ...s,
+            items: [],
+            page: 0,
+            hasMore: true,
+            nextCursor: undefined,
+            prevCursor: undefined,
+            isLoading: true,
+            error: undefined,
+        }));
+        try {
+            const params = {
+                strategy: this.config.strategy,
+                page: 0,
+                pageSize: this._state().pageSize,
+                direction: 'forward',
+            };
+            const result = await this.executeLoad(params);
+            this._state.update((s) => ({
+                ...s,
+                items: result.items,
+                page: 1,
+                hasMore: result.hasMore,
+                total: result.total,
+                nextCursor: result.nextCursor,
+                isLoading: false,
+            }));
+        }
+        catch (err) {
+            this._state.update((s) => ({
+                ...s,
+                isLoading: false,
+                error: err,
+            }));
+        }
+    }
+    reset() {
+        this._state.set(createInitialPaginationState(this.config.pageSize ?? 20, this.config.initialItems));
+    }
+    updateItem(predicate, updates) {
+        this._state.update((s) => ({
+            ...s,
+            items: s.items.map((item) => (predicate(item) ? { ...item, ...updates } : item)),
+        }));
+    }
+    removeItem(predicate) {
+        this._state.update((s) => ({
+            ...s,
+            items: s.items.filter((item) => !predicate(item)),
+        }));
+    }
+    prependItems(items) {
+        this._state.update((s) => ({
+            ...s,
+            items: [...items, ...s.items],
+        }));
+    }
+    appendItems(items) {
+        this._state.update((s) => ({
+            ...s,
+            items: [...s.items, ...items],
+        }));
+    }
+    async executeLoad(params) {
+        const result = this.config.loadFn(params);
+        if (isObservable(result)) {
+            return await firstValueFrom(result);
+        }
+        return await result;
+    }
+}
+/**
+ * Servicio para crear controladores de paginacion reutilizables.
+ *
+ * @example
+ * // En un componente
+ * pagination = inject(PaginationService);
+ *
+ * usersController = this.pagination.createController<User>({
+ *   strategy: 'offset',
+ *   pageSize: 20,
+ *   loadFn: (params) => this.userService.getUsers(params.page, params.pageSize)
+ * });
+ *
+ * // En el template
+ * @for (user of usersController.items(); track user.id) {
+ *   <app-user-card [user]="user"></app-user-card>
+ * }
+ *
+ * @if (usersController.hasMore()) {
+ *   <ion-button (click)="usersController.loadNext()">Cargar mas</ion-button>
+ * }
+ */
+export class PaginationService {
+    /**
+     * Crea un controlador de paginacion para una fuente de datos.
+     *
+     * @param config Configuracion del controlador
+     * @returns Controlador de paginacion
+     */
+    createController(config) {
+        return new PaginationControllerImpl(config);
+    }
+    /**
+     * Crea un controlador simple para arrays estaticos con paginacion local.
+     *
+     * @param items Array completo de items
+     * @param pageSize Tamano de pagina
+     * @returns Controlador de paginacion
+     */
+    createLocalController(items, pageSize = 20) {
+        let currentIndex = 0;
+        return this.createController({
+            strategy: 'offset',
+            pageSize,
+            loadFn: async (params) => {
+                const start = params.page * params.pageSize;
+                const end = start + params.pageSize;
+                const pageItems = items.slice(start, end);
+                return {
+                    items: pageItems,
+                    hasMore: end < items.length,
+                    total: items.length,
+                };
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PaginationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PaginationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PaginationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/pagination/pagination.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed, Signal } from '@angular/core';\nimport { firstValueFrom, isObservable } from 'rxjs';\nimport {\n  PaginationConfig,\n  PaginationController,\n  PaginationLoadParams,\n  PaginationLoadResult,\n  PaginationState,\n  createInitialPaginationState,\n} from './types';\n\n/**\n * Implementacion del controlador de paginacion.\n */\nclass PaginationControllerImpl<T> implements PaginationController<T> {\n  private readonly _state = signal<PaginationState<T>>(\n    createInitialPaginationState(this.config.pageSize ?? 20, this.config.initialItems)\n  );\n\n  readonly state = this._state.asReadonly();\n  readonly items = computed(() => this._state().items);\n  readonly isLoading = computed(() => this._state().isLoading);\n  readonly hasMore = computed(() => this._state().hasMore);\n  readonly error = computed(() => this._state().error ?? null);\n  readonly currentPage = computed(() => this._state().page);\n  readonly total = computed(() => this._state().total);\n\n  constructor(private readonly config: PaginationConfig<T>) {}\n\n  async loadNext(): Promise<void> {\n    const currentState = this._state();\n    if (currentState.isLoading || !currentState.hasMore) return;\n\n    this._state.update((s) => ({ ...s, isLoading: true, error: undefined }));\n\n    try {\n      const params: PaginationLoadParams = {\n        strategy: this.config.strategy,\n        page: currentState.page,\n        pageSize: currentState.pageSize,\n        cursor: currentState.nextCursor,\n        direction: 'forward',\n      };\n\n      const result = await this.executeLoad(params);\n\n      this._state.update((s) => ({\n        ...s,\n        items: [...s.items, ...result.items],\n        page: s.page + 1,\n        hasMore: result.hasMore,\n        total: result.total ?? s.total,\n        nextCursor: result.nextCursor,\n        prevCursor: result.prevCursor ?? s.prevCursor,\n        isLoading: false,\n      }));\n    } catch (err) {\n      this._state.update((s) => ({\n        ...s,\n        isLoading: false,\n        error: err as Error,\n      }));\n    }\n  }\n\n  async loadPrevious(): Promise<void> {\n    const currentState = this._state();\n    if (currentState.isLoading || currentState.page <= 0) return;\n\n    this._state.update((s) => ({ ...s, isLoading: true, error: undefined }));\n\n    try {\n      const params: PaginationLoadParams = {\n        strategy: this.config.strategy,\n        page: currentState.page - 1,\n        pageSize: currentState.pageSize,\n        cursor: currentState.prevCursor,\n        direction: 'backward',\n      };\n\n      const result = await this.executeLoad(params);\n\n      this._state.update((s) => ({\n        ...s,\n        items: [...result.items, ...s.items],\n        page: s.page - 1,\n        prevCursor: result.prevCursor,\n        isLoading: false,\n      }));\n    } catch (err) {\n      this._state.update((s) => ({\n        ...s,\n        isLoading: false,\n        error: err as Error,\n      }));\n    }\n  }\n\n  async refresh(): Promise<void> {\n    this._state.update((s) => ({\n      ...s,\n      items: [],\n      page: 0,\n      hasMore: true,\n      nextCursor: undefined,\n      prevCursor: undefined,\n      isLoading: true,\n      error: undefined,\n    }));\n\n    try {\n      const params: PaginationLoadParams = {\n        strategy: this.config.strategy,\n        page: 0,\n        pageSize: this._state().pageSize,\n        direction: 'forward',\n      };\n\n      const result = await this.executeLoad(params);\n\n      this._state.update((s) => ({\n        ...s,\n        items: result.items,\n        page: 1,\n        hasMore: result.hasMore,\n        total: result.total,\n        nextCursor: result.nextCursor,\n        isLoading: false,\n      }));\n    } catch (err) {\n      this._state.update((s) => ({\n        ...s,\n        isLoading: false,\n        error: err as Error,\n      }));\n    }\n  }\n\n  reset(): void {\n    this._state.set(\n      createInitialPaginationState(this.config.pageSize ?? 20, this.config.initialItems)\n    );\n  }\n\n  updateItem(predicate: (item: T) => boolean, updates: Partial<T>): void {\n    this._state.update((s) => ({\n      ...s,\n      items: s.items.map((item) => (predicate(item) ? { ...item, ...updates } : item)),\n    }));\n  }\n\n  removeItem(predicate: (item: T) => boolean): void {\n    this._state.update((s) => ({\n      ...s,\n      items: s.items.filter((item) => !predicate(item)),\n    }));\n  }\n\n  prependItems(items: T[]): void {\n    this._state.update((s) => ({\n      ...s,\n      items: [...items, ...s.items],\n    }));\n  }\n\n  appendItems(items: T[]): void {\n    this._state.update((s) => ({\n      ...s,\n      items: [...s.items, ...items],\n    }));\n  }\n\n  private async executeLoad(params: PaginationLoadParams): Promise<PaginationLoadResult<T>> {\n    const result = this.config.loadFn(params);\n\n    if (isObservable(result)) {\n      return await firstValueFrom(result);\n    }\n    return await result;\n  }\n}\n\n/**\n * Servicio para crear controladores de paginacion reutilizables.\n *\n * @example\n * // En un componente\n * pagination = inject(PaginationService);\n *\n * usersController = this.pagination.createController<User>({\n *   strategy: 'offset',\n *   pageSize: 20,\n *   loadFn: (params) => this.userService.getUsers(params.page, params.pageSize)\n * });\n *\n * // En el template\n * @for (user of usersController.items(); track user.id) {\n *   <app-user-card [user]=\"user\"></app-user-card>\n * }\n *\n * @if (usersController.hasMore()) {\n *   <ion-button (click)=\"usersController.loadNext()\">Cargar mas</ion-button>\n * }\n */\n@Injectable({ providedIn: 'root' })\nexport class PaginationService {\n  /**\n   * Crea un controlador de paginacion para una fuente de datos.\n   *\n   * @param config Configuracion del controlador\n   * @returns Controlador de paginacion\n   */\n  createController<T>(config: PaginationConfig<T>): PaginationController<T> {\n    return new PaginationControllerImpl<T>(config);\n  }\n\n  /**\n   * Crea un controlador simple para arrays estaticos con paginacion local.\n   *\n   * @param items Array completo de items\n   * @param pageSize Tamano de pagina\n   * @returns Controlador de paginacion\n   */\n  createLocalController<T>(items: T[], pageSize = 20): PaginationController<T> {\n    let currentIndex = 0;\n\n    return this.createController<T>({\n      strategy: 'offset',\n      pageSize,\n      loadFn: async (params) => {\n        const start = params.page * params.pageSize;\n        const end = start + params.pageSize;\n        const pageItems = items.slice(start, end);\n\n        return {\n          items: pageItems,\n          hasMore: end < items.length,\n          total: items.length,\n        };\n      },\n    });\n  }\n}\n"]}

package/esm2022/lib/services/pagination/types.mjs

@@ -0,0 +1,14 @@
+/**
+ * Estado inicial para controladores de paginacion.
+ */
+export function createInitialPaginationState(pageSize, initialItems = []) {
+    return {
+        items: initialItems,
+        page: 0,
+        pageSize,
+        hasMore: true,
+        isLoading: false,
+        error: undefined,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/skeleton/config.mjs

@@ -0,0 +1,79 @@
+import { makeEnvironmentProviders, APP_INITIALIZER } from '@angular/core';
+import { DEFAULT_SKELETON_CONFIG } from './types';
+import { SkeletonService } from './skeleton.service';
+// Import built-in templates
+import { ListSkeletonComponent } from './templates/list-skeleton.component';
+import { GridSkeletonComponent } from './templates/grid-skeleton.component';
+import { FormSkeletonComponent } from './templates/form-skeleton.component';
+import { ProfileSkeletonComponent } from './templates/profile-skeleton.component';
+import { TableSkeletonComponent } from './templates/table-skeleton.component';
+import { DetailSkeletonComponent } from './templates/detail-skeleton.component';
+/**
+ * Configura el sistema de skeletons para Valtech Components.
+ *
+ * @param config Configuracion de skeletons
+ * @returns Providers para app.config.ts
+ *
+ * @example
+ * // app.config.ts
+ * import { provideValtechSkeleton } from 'valtech-components';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideValtechSkeleton({
+ *       animated: true,
+ *       defaultDelay: 100,
+ *       defaultMinTime: 500,
+ *       templates: [
+ *         { name: 'custom-card', component: MyCustomCardSkeleton }
+ *       ]
+ *     }),
+ *   ]
+ * };
+ *
+ * @example
+ * // Uso minimo - usa configuracion por defecto
+ * providers: [provideValtechSkeleton()]
+ */
+export function provideValtechSkeleton(config = {}) {
+    const mergedConfig = { ...DEFAULT_SKELETON_CONFIG, ...config };
+    return makeEnvironmentProviders([
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (skeletonService) => {
+                return () => {
+                    // Configurar servicio
+                    skeletonService.configure(mergedConfig);
+                    // Registrar templates built-in
+                    skeletonService.registerTemplate('list', ListSkeletonComponent, { count: 3 });
+                    skeletonService.registerTemplate('list-avatar', ListSkeletonComponent, {
+                        count: 3,
+                        variant: 'avatar',
+                    });
+                    skeletonService.registerTemplate('grid', GridSkeletonComponent, { count: 4 });
+                    skeletonService.registerTemplate('grid-cards', GridSkeletonComponent, {
+                        count: 6,
+                        variant: 'cards',
+                    });
+                    skeletonService.registerTemplate('form', FormSkeletonComponent, { count: 3 });
+                    skeletonService.registerTemplate('form-compact', FormSkeletonComponent, {
+                        count: 2,
+                        variant: 'compact',
+                    });
+                    skeletonService.registerTemplate('profile', ProfileSkeletonComponent, {});
+                    skeletonService.registerTemplate('profile-full', ProfileSkeletonComponent, {
+                        variant: 'full',
+                    });
+                    skeletonService.registerTemplate('table', TableSkeletonComponent, {
+                        columns: 4,
+                        rows: 5,
+                    });
+                    skeletonService.registerTemplate('detail', DetailSkeletonComponent, { sections: 2 });
+                };
+            },
+            deps: [SkeletonService],
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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