valtech-components 2.0.510 → 2.0.512

package/esm2022/lib/services/skeleton/directives/loading.directive.mjs

@@ -0,0 +1,215 @@
+import { Directive, Input, TemplateRef, ViewContainerRef, inject, effect, signal, isSignal, DestroyRef, } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { isObservable } from 'rxjs';
+import { SkeletonService } from '../skeleton.service';
+import * as i0 from "@angular/core";
+/**
+ * Directiva estructural simplificada para estados de carga.
+ *
+ * Soporta multiples fuentes de estado de carga:
+ * - Angular Signal<boolean>
+ * - RxJS Observable<boolean>
+ * - Promise<any> (cargando hasta que se resuelve)
+ * - boolean literal
+ *
+ * @example
+ * <!-- Uso simple con signal -->
+ * <ng-container *valLoading="isLoading(); skeleton: 'list'">
+ *   <app-list [items]="items()"></app-list>
+ * </ng-container>
+ *
+ * @example
+ * <!-- Con configuracion -->
+ * <ng-container *valLoading="loading$; skeleton: 'grid-cards'; count: 8">
+ *   <app-grid [data]="data"></app-grid>
+ * </ng-container>
+ *
+ * @example
+ * <!-- Con template personalizado -->
+ * <ng-container *valLoading="isLoading(); skeletonTpl: customSkeleton">
+ *   <app-content></app-content>
+ * </ng-container>
+ * <ng-template #customSkeleton>
+ *   <val-skeleton [props]="{ type: 'card' }"></val-skeleton>
+ * </ng-template>
+ */
+export class LoadingDirective {
+    constructor() {
+        this.templateRef = inject((TemplateRef));
+        this.viewContainer = inject(ViewContainerRef);
+        this.skeletonService = inject(SkeletonService);
+        this.destroyRef = inject(DestroyRef);
+        this._loading = signal(false);
+        this.hasContentView = false;
+        this.skeletonComponentRef = null;
+        /** Template de skeleton a usar */
+        this.skeleton = 'list';
+        /** Template personalizado para skeleton */
+        this.skeletonTpl = null;
+        /** Cantidad de items skeleton */
+        this.count = 3;
+        /** Animacion habilitada */
+        this.animated = true;
+        /** Mostrar spinner en lugar de skeleton */
+        this.spinner = false;
+        effect(() => {
+            const isLoading = this._loading();
+            this.updateView(isLoading);
+        });
+    }
+    /**
+     * Input principal - puede ser boolean, Signal, Observable o Promise.
+     */
+    set loading(source) {
+        this.resolveLoadingSource(source);
+    }
+    ngOnDestroy() {
+        this.viewContainer.clear();
+        this.skeletonComponentRef = null;
+    }
+    resolveLoadingSource(source) {
+        if (typeof source === 'boolean') {
+            this._loading.set(source);
+        }
+        else if (isSignal(source)) {
+            // Sincronizar signal con effect
+            effect(() => {
+                this._loading.set(source());
+            }, { injector: this.viewContainer.injector });
+        }
+        else if (isObservable(source)) {
+            // Convertir observable a signal
+            const signalValue = toSignal(source, {
+                initialValue: true,
+                injector: this.viewContainer.injector,
+            });
+            effect(() => {
+                this._loading.set(signalValue());
+            }, { injector: this.viewContainer.injector });
+        }
+        else if (source instanceof Promise) {
+            this._loading.set(true);
+            source.finally(() => this._loading.set(false));
+        }
+    }
+    updateView(isLoading) {
+        if (isLoading) {
+            this.showSkeleton();
+        }
+        else {
+            this.showContent();
+        }
+    }
+    showSkeleton() {
+        // Limpiar contenido previo
+        this.viewContainer.clear();
+        this.hasContentView = false;
+        if (this.skeletonTpl) {
+            // Usar template personalizado
+            this.viewContainer.createEmbeddedView(this.skeletonTpl);
+        }
+        else if (this.spinner) {
+            // Mostrar spinner (usar val-content-loader si esta disponible)
+            this.showSpinner();
+        }
+        else {
+            // Usar template de skeleton registrado
+            this.showSkeletonTemplate();
+        }
+    }
+    showSkeletonTemplate() {
+        const template = this.skeletonService.getTemplate(this.skeleton);
+        if (template) {
+            this.skeletonComponentRef = this.viewContainer.createComponent(template.component);
+            // Combinar config por defecto con inputs
+            const config = {
+                ...template.defaultConfig,
+                count: this.count,
+                animated: this.animated,
+                gap: this.gap,
+                variant: this.variant,
+            };
+            this.skeletonComponentRef.instance.config = config;
+        }
+        else {
+            // Fallback: mostrar texto de carga si no hay template
+            console.warn(`[valLoading] Template '${this.skeleton}' not found. Using fallback.`);
+            this.showFallback();
+        }
+    }
+    showSpinner() {
+        // Crear un div con spinner simple
+        const element = document.createElement('div');
+        element.className = 'val-loading-spinner';
+        element.innerHTML = `
+      <ion-spinner name="crescent"></ion-spinner>
+    `;
+        element.style.cssText = 'display: flex; justify-content: center; padding: 20px;';
+        const hostElement = this.viewContainer.element.nativeElement;
+        hostElement.parentElement?.insertBefore(element, hostElement);
+    }
+    showFallback() {
+        // Fallback simple si no hay template registrado
+        const element = document.createElement('div');
+        element.className = 'val-loading-fallback';
+        element.style.cssText =
+            'display: flex; flex-direction: column; gap: 12px; padding: 16px;';
+        for (let i = 0; i < this.count; i++) {
+            const skeleton = document.createElement('div');
+            skeleton.style.cssText = `
+        background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
+        background-size: 200% 100%;
+        animation: skeleton-loading 1.5s infinite;
+        height: 56px;
+        border-radius: 8px;
+      `;
+            element.appendChild(skeleton);
+        }
+        const hostElement = this.viewContainer.element.nativeElement;
+        hostElement.parentElement?.insertBefore(element, hostElement);
+    }
+    showContent() {
+        // Limpiar skeleton
+        this.viewContainer.clear();
+        this.skeletonComponentRef = null;
+        // Mostrar contenido real
+        if (!this.hasContentView) {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+            this.hasContentView = true;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LoadingDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: LoadingDirective, isStandalone: true, selector: "[valLoading]", inputs: { skeleton: ["valLoadingSkeleton", "skeleton"], skeletonTpl: ["valLoadingSkeletonTpl", "skeletonTpl"], count: ["valLoadingCount", "count"], animated: ["valLoadingAnimated", "animated"], gap: ["valLoadingGap", "gap"], variant: ["valLoadingVariant", "variant"], spinner: ["valLoadingSpinner", "spinner"], loading: ["valLoading", "loading"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LoadingDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[valLoading]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { skeleton: [{
+                type: Input,
+                args: ['valLoadingSkeleton']
+            }], skeletonTpl: [{
+                type: Input,
+                args: ['valLoadingSkeletonTpl']
+            }], count: [{
+                type: Input,
+                args: ['valLoadingCount']
+            }], animated: [{
+                type: Input,
+                args: ['valLoadingAnimated']
+            }], gap: [{
+                type: Input,
+                args: ['valLoadingGap']
+            }], variant: [{
+                type: Input,
+                args: ['valLoadingVariant']
+            }], spinner: [{
+                type: Input,
+                args: ['valLoadingSpinner']
+            }], loading: [{
+                type: Input,
+                args: ['valLoading']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loading.directive.js","sourceRoot":"","sources":["../../../../../../../src/lib/services/skeleton/directives/loading.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  Input,\n  TemplateRef,\n  ViewContainerRef,\n  inject,\n  effect,\n  signal,\n  OnDestroy,\n  isSignal,\n  DestroyRef,\n  ComponentRef,\n} from '@angular/core';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { isObservable } from 'rxjs';\nimport { SkeletonService } from '../skeleton.service';\nimport { LoadingSource, SkeletonTemplateName, SkeletonTemplateComponent } from '../types';\n\n/**\n * Directiva estructural simplificada para estados de carga.\n *\n * Soporta multiples fuentes de estado de carga:\n * - Angular Signal<boolean>\n * - RxJS Observable<boolean>\n * - Promise<any> (cargando hasta que se resuelve)\n * - boolean literal\n *\n * @example\n * <!-- Uso simple con signal -->\n * <ng-container *valLoading=\"isLoading(); skeleton: 'list'\">\n *   <app-list [items]=\"items()\"></app-list>\n * </ng-container>\n *\n * @example\n * <!-- Con configuracion -->\n * <ng-container *valLoading=\"loading$; skeleton: 'grid-cards'; count: 8\">\n *   <app-grid [data]=\"data\"></app-grid>\n * </ng-container>\n *\n * @example\n * <!-- Con template personalizado -->\n * <ng-container *valLoading=\"isLoading(); skeletonTpl: customSkeleton\">\n *   <app-content></app-content>\n * </ng-container>\n * <ng-template #customSkeleton>\n *   <val-skeleton [props]=\"{ type: 'card' }\"></val-skeleton>\n * </ng-template>\n */\n@Directive({\n  selector: '[valLoading]',\n  standalone: true,\n})\nexport class LoadingDirective implements OnDestroy {\n  private readonly templateRef = inject(TemplateRef<unknown>);\n  private readonly viewContainer = inject(ViewContainerRef);\n  private readonly skeletonService = inject(SkeletonService);\n  private readonly destroyRef = inject(DestroyRef);\n\n  private readonly _loading = signal(false);\n  private hasContentView = false;\n  private skeletonComponentRef: ComponentRef<SkeletonTemplateComponent> | null = null;\n\n  /** Template de skeleton a usar */\n  @Input('valLoadingSkeleton') skeleton: SkeletonTemplateName | string = 'list';\n\n  /** Template personalizado para skeleton */\n  @Input('valLoadingSkeletonTpl') skeletonTpl: TemplateRef<unknown> | null = null;\n\n  /** Cantidad de items skeleton */\n  @Input('valLoadingCount') count = 3;\n\n  /** Animacion habilitada */\n  @Input('valLoadingAnimated') animated = true;\n\n  /** Gap entre items */\n  @Input('valLoadingGap') gap: string | undefined;\n\n  /** Variante del template */\n  @Input('valLoadingVariant') variant: string | undefined;\n\n  /** Mostrar spinner en lugar de skeleton */\n  @Input('valLoadingSpinner') spinner = false;\n\n  constructor() {\n    effect(() => {\n      const isLoading = this._loading();\n      this.updateView(isLoading);\n    });\n  }\n\n  /**\n   * Input principal - puede ser boolean, Signal, Observable o Promise.\n   */\n  @Input('valLoading')\n  set loading(source: LoadingSource) {\n    this.resolveLoadingSource(source);\n  }\n\n  ngOnDestroy(): void {\n    this.viewContainer.clear();\n    this.skeletonComponentRef = null;\n  }\n\n  private resolveLoadingSource(source: LoadingSource): void {\n    if (typeof source === 'boolean') {\n      this._loading.set(source);\n    } else if (isSignal(source)) {\n      // Sincronizar signal con effect\n      effect(\n        () => {\n          this._loading.set((source as () => boolean)());\n        },\n        { injector: this.viewContainer.injector }\n      );\n    } else if (isObservable(source)) {\n      // Convertir observable a signal\n      const signalValue = toSignal(source, {\n        initialValue: true,\n        injector: this.viewContainer.injector,\n      });\n      effect(\n        () => {\n          this._loading.set(signalValue());\n        },\n        { injector: this.viewContainer.injector }\n      );\n    } else if (source instanceof Promise) {\n      this._loading.set(true);\n      source.finally(() => this._loading.set(false));\n    }\n  }\n\n  private updateView(isLoading: boolean): void {\n    if (isLoading) {\n      this.showSkeleton();\n    } else {\n      this.showContent();\n    }\n  }\n\n  private showSkeleton(): void {\n    // Limpiar contenido previo\n    this.viewContainer.clear();\n    this.hasContentView = false;\n\n    if (this.skeletonTpl) {\n      // Usar template personalizado\n      this.viewContainer.createEmbeddedView(this.skeletonTpl);\n    } else if (this.spinner) {\n      // Mostrar spinner (usar val-content-loader si esta disponible)\n      this.showSpinner();\n    } else {\n      // Usar template de skeleton registrado\n      this.showSkeletonTemplate();\n    }\n  }\n\n  private showSkeletonTemplate(): void {\n    const template = this.skeletonService.getTemplate(this.skeleton);\n\n    if (template) {\n      this.skeletonComponentRef = this.viewContainer.createComponent(\n        template.component as new () => SkeletonTemplateComponent\n      );\n\n      // Combinar config por defecto con inputs\n      const config = {\n        ...template.defaultConfig,\n        count: this.count,\n        animated: this.animated,\n        gap: this.gap,\n        variant: this.variant,\n      };\n\n      this.skeletonComponentRef.instance.config = config;\n    } else {\n      // Fallback: mostrar texto de carga si no hay template\n      console.warn(`[valLoading] Template '${this.skeleton}' not found. Using fallback.`);\n      this.showFallback();\n    }\n  }\n\n  private showSpinner(): void {\n    // Crear un div con spinner simple\n    const element = document.createElement('div');\n    element.className = 'val-loading-spinner';\n    element.innerHTML = `\n      <ion-spinner name=\"crescent\"></ion-spinner>\n    `;\n    element.style.cssText = 'display: flex; justify-content: center; padding: 20px;';\n\n    const hostElement = this.viewContainer.element.nativeElement as HTMLElement;\n    hostElement.parentElement?.insertBefore(element, hostElement);\n  }\n\n  private showFallback(): void {\n    // Fallback simple si no hay template registrado\n    const element = document.createElement('div');\n    element.className = 'val-loading-fallback';\n    element.style.cssText =\n      'display: flex; flex-direction: column; gap: 12px; padding: 16px;';\n\n    for (let i = 0; i < this.count; i++) {\n      const skeleton = document.createElement('div');\n      skeleton.style.cssText = `\n        background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);\n        background-size: 200% 100%;\n        animation: skeleton-loading 1.5s infinite;\n        height: 56px;\n        border-radius: 8px;\n      `;\n      element.appendChild(skeleton);\n    }\n\n    const hostElement = this.viewContainer.element.nativeElement as HTMLElement;\n    hostElement.parentElement?.insertBefore(element, hostElement);\n  }\n\n  private showContent(): void {\n    // Limpiar skeleton\n    this.viewContainer.clear();\n    this.skeletonComponentRef = null;\n\n    // Mostrar contenido real\n    if (!this.hasContentView) {\n      this.viewContainer.createEmbeddedView(this.templateRef);\n      this.hasContentView = true;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,16 @@
+// Types
+export { DEFAULT_SKELETON_CONFIG, } from './types';
+// Service
+export { SkeletonService } from './skeleton.service';
+// Directives
+export { LoadingDirective } from './directives/loading.directive';
+// Templates
+export { ListSkeletonComponent } from './templates/list-skeleton.component';
+export { GridSkeletonComponent } from './templates/grid-skeleton.component';
+export { FormSkeletonComponent } from './templates/form-skeleton.component';
+export { ProfileSkeletonComponent } from './templates/profile-skeleton.component';
+export { TableSkeletonComponent } from './templates/table-skeleton.component';
+export { DetailSkeletonComponent } from './templates/detail-skeleton.component';
+// Config / Provider
+export { provideValtechSkeleton } from './config';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,198 @@
+import { Injectable, signal, computed } from '@angular/core';
+import { DEFAULT_SKELETON_CONFIG, } from './types';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para gestionar templates de skeleton y estados de carga globales.
+ *
+ * @example
+ * // En un componente
+ * skeleton = inject(SkeletonService);
+ *
+ * // Registrar template personalizado
+ * skeleton.registerTemplate('my-custom', MyCustomSkeletonComponent);
+ *
+ * // Obtener componente de template
+ * const component = skeleton.getTemplate('list');
+ *
+ * // Gestionar estados de carga globales
+ * skeleton.setLoadingState('dashboard', true);
+ * const isDashboardLoading = skeleton.loadingState('dashboard');
+ */
+export class SkeletonService {
+    constructor() {
+        this._config = signal(DEFAULT_SKELETON_CONFIG);
+        this._templates = signal(new Map());
+        this._loadingStates = signal(new Map());
+        this._initialized = false;
+        /** Configuracion actual (solo lectura) */
+        this.config = this._config.asReadonly();
+        /** Templates registrados (solo lectura) */
+        this.templates = this._templates.asReadonly();
+        /** Estado de carga global (cualquier estado registrado esta cargando) */
+        this.isAnyLoading = computed(() => {
+            const states = this._loadingStates();
+            return Array.from(states.values()).some((v) => v);
+        });
+        /** Cantidad de templates registrados */
+        this.templateCount = computed(() => this._templates().size);
+    }
+    /**
+     * Configura el servicio de skeleton.
+     * Llamado por provideValtechSkeleton().
+     */
+    configure(config) {
+        if (this._initialized) {
+            console.warn('[SkeletonService] Service already configured. Ignoring reconfiguration.');
+            return;
+        }
+        this._config.set({ ...DEFAULT_SKELETON_CONFIG, ...config });
+        // Registrar templates personalizados de la configuracion
+        config.templates?.forEach((t) => {
+            this.registerTemplate(t.name, t.component, t.defaultConfig);
+        });
+        this._initialized = true;
+    }
+    /**
+     * Registra un template de skeleton personalizado.
+     *
+     * @param name Nombre unico del template
+     * @param component Componente a usar
+     * @param defaultConfig Configuracion por defecto opcional
+     */
+    registerTemplate(name, component, defaultConfig) {
+        this._templates.update((map) => {
+            const newMap = new Map(map);
+            newMap.set(name, { name, component, defaultConfig });
+            return newMap;
+        });
+    }
+    /**
+     * Obtiene un template de skeleton registrado.
+     *
+     * @param name Nombre del template
+     * @returns Template registrado o undefined si no existe
+     */
+    getTemplate(name) {
+        return this._templates().get(name);
+    }
+    /**
+     * Verifica si un template esta registrado.
+     *
+     * @param name Nombre del template
+     * @returns true si el template existe
+     */
+    hasTemplate(name) {
+        return this._templates().has(name);
+    }
+    /**
+     * Obtiene todos los nombres de templates registrados.
+     *
+     * @returns Array de nombres de templates
+     */
+    getTemplateNames() {
+        return Array.from(this._templates().keys());
+    }
+    /**
+     * Registra un estado de carga nombrado.
+     * Util para indicadores de carga globales.
+     *
+     * @param key Identificador unico del estado
+     * @param isLoading Estado de carga
+     */
+    setLoadingState(key, isLoading) {
+        this._loadingStates.update((map) => {
+            const newMap = new Map(map);
+            if (isLoading) {
+                newMap.set(key, true);
+            }
+            else {
+                newMap.delete(key);
+            }
+            return newMap;
+        });
+    }
+    /**
+     * Obtiene el estado de carga para una clave especifica.
+     *
+     * @param key Identificador del estado
+     * @returns Estado de carga actual
+     */
+    getLoadingState(key) {
+        return this._loadingStates().get(key) ?? false;
+    }
+    /**
+     * Crea un signal computado para un estado de carga especifico.
+     *
+     * @param key Identificador del estado
+     * @returns Signal reactivo del estado de carga
+     */
+    loadingState(key) {
+        return computed(() => this._loadingStates().get(key) ?? false);
+    }
+    /**
+     * Obtiene todas las claves de estados de carga activos.
+     *
+     * @returns Array de claves con estado de carga activo
+     */
+    getActiveLoadingKeys() {
+        const states = this._loadingStates();
+        return Array.from(states.entries())
+            .filter(([, isLoading]) => isLoading)
+            .map(([key]) => key);
+    }
+    /**
+     * Limpia todos los estados de carga.
+     */
+    clearLoadingStates() {
+        this._loadingStates.set(new Map());
+    }
+    /**
+     * Limpia un estado de carga especifico.
+     *
+     * @param key Identificador del estado a limpiar
+     */
+    clearLoadingState(key) {
+        this.setLoadingState(key, false);
+    }
+    /**
+     * Ejecuta una funcion async con tracking de estado de carga.
+     *
+     * @param key Identificador del estado
+     * @param fn Funcion async a ejecutar
+     * @returns Resultado de la funcion
+     */
+    async withLoading(key, fn) {
+        this.setLoadingState(key, true);
+        try {
+            return await fn();
+        }
+        finally {
+            this.setLoadingState(key, false);
+        }
+    }
+    /**
+     * Obtiene la configuracion de animacion por defecto.
+     */
+    get animated() {
+        return this._config().animated ?? true;
+    }
+    /**
+     * Obtiene el delay por defecto.
+     */
+    get defaultDelay() {
+        return this._config().defaultDelay ?? 0;
+    }
+    /**
+     * Obtiene el tiempo minimo por defecto.
+     */
+    get defaultMinTime() {
+        return this._config().defaultMinTime ?? 300;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SkeletonService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SkeletonService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SkeletonService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skeleton.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/skeleton/skeleton.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed, Type } from '@angular/core';\nimport {\n  SkeletonTemplateName,\n  SkeletonTemplateConfig,\n  RegisteredSkeletonTemplate,\n  SkeletonConfig,\n  DEFAULT_SKELETON_CONFIG,\n} from './types';\n\n/**\n * Servicio para gestionar templates de skeleton y estados de carga globales.\n *\n * @example\n * // En un componente\n * skeleton = inject(SkeletonService);\n *\n * // Registrar template personalizado\n * skeleton.registerTemplate('my-custom', MyCustomSkeletonComponent);\n *\n * // Obtener componente de template\n * const component = skeleton.getTemplate('list');\n *\n * // Gestionar estados de carga globales\n * skeleton.setLoadingState('dashboard', true);\n * const isDashboardLoading = skeleton.loadingState('dashboard');\n */\n@Injectable({ providedIn: 'root' })\nexport class SkeletonService {\n  private readonly _config = signal<SkeletonConfig>(DEFAULT_SKELETON_CONFIG);\n  private readonly _templates = signal<Map<string, RegisteredSkeletonTemplate>>(new Map());\n  private readonly _loadingStates = signal<Map<string, boolean>>(new Map());\n  private _initialized = false;\n\n  /** Configuracion actual (solo lectura) */\n  readonly config = this._config.asReadonly();\n\n  /** Templates registrados (solo lectura) */\n  readonly templates = this._templates.asReadonly();\n\n  /** Estado de carga global (cualquier estado registrado esta cargando) */\n  readonly isAnyLoading = computed(() => {\n    const states = this._loadingStates();\n    return Array.from(states.values()).some((v) => v);\n  });\n\n  /** Cantidad de templates registrados */\n  readonly templateCount = computed(() => this._templates().size);\n\n  /**\n   * Configura el servicio de skeleton.\n   * Llamado por provideValtechSkeleton().\n   */\n  configure(config: SkeletonConfig): void {\n    if (this._initialized) {\n      console.warn('[SkeletonService] Service already configured. Ignoring reconfiguration.');\n      return;\n    }\n\n    this._config.set({ ...DEFAULT_SKELETON_CONFIG, ...config });\n\n    // Registrar templates personalizados de la configuracion\n    config.templates?.forEach((t) => {\n      this.registerTemplate(t.name, t.component, t.defaultConfig);\n    });\n\n    this._initialized = true;\n  }\n\n  /**\n   * Registra un template de skeleton personalizado.\n   *\n   * @param name Nombre unico del template\n   * @param component Componente a usar\n   * @param defaultConfig Configuracion por defecto opcional\n   */\n  registerTemplate(\n    name: string,\n    component: Type<unknown>,\n    defaultConfig?: SkeletonTemplateConfig\n  ): void {\n    this._templates.update((map) => {\n      const newMap = new Map(map);\n      newMap.set(name, { name, component, defaultConfig });\n      return newMap;\n    });\n  }\n\n  /**\n   * Obtiene un template de skeleton registrado.\n   *\n   * @param name Nombre del template\n   * @returns Template registrado o undefined si no existe\n   */\n  getTemplate(name: SkeletonTemplateName | string): RegisteredSkeletonTemplate | undefined {\n    return this._templates().get(name);\n  }\n\n  /**\n   * Verifica si un template esta registrado.\n   *\n   * @param name Nombre del template\n   * @returns true si el template existe\n   */\n  hasTemplate(name: string): boolean {\n    return this._templates().has(name);\n  }\n\n  /**\n   * Obtiene todos los nombres de templates registrados.\n   *\n   * @returns Array de nombres de templates\n   */\n  getTemplateNames(): string[] {\n    return Array.from(this._templates().keys());\n  }\n\n  /**\n   * Registra un estado de carga nombrado.\n   * Util para indicadores de carga globales.\n   *\n   * @param key Identificador unico del estado\n   * @param isLoading Estado de carga\n   */\n  setLoadingState(key: string, isLoading: boolean): void {\n    this._loadingStates.update((map) => {\n      const newMap = new Map(map);\n      if (isLoading) {\n        newMap.set(key, true);\n      } else {\n        newMap.delete(key);\n      }\n      return newMap;\n    });\n  }\n\n  /**\n   * Obtiene el estado de carga para una clave especifica.\n   *\n   * @param key Identificador del estado\n   * @returns Estado de carga actual\n   */\n  getLoadingState(key: string): boolean {\n    return this._loadingStates().get(key) ?? false;\n  }\n\n  /**\n   * Crea un signal computado para un estado de carga especifico.\n   *\n   * @param key Identificador del estado\n   * @returns Signal reactivo del estado de carga\n   */\n  loadingState(key: string) {\n    return computed(() => this._loadingStates().get(key) ?? false);\n  }\n\n  /**\n   * Obtiene todas las claves de estados de carga activos.\n   *\n   * @returns Array de claves con estado de carga activo\n   */\n  getActiveLoadingKeys(): string[] {\n    const states = this._loadingStates();\n    return Array.from(states.entries())\n      .filter(([, isLoading]) => isLoading)\n      .map(([key]) => key);\n  }\n\n  /**\n   * Limpia todos los estados de carga.\n   */\n  clearLoadingStates(): void {\n    this._loadingStates.set(new Map());\n  }\n\n  /**\n   * Limpia un estado de carga especifico.\n   *\n   * @param key Identificador del estado a limpiar\n   */\n  clearLoadingState(key: string): void {\n    this.setLoadingState(key, false);\n  }\n\n  /**\n   * Ejecuta una funcion async con tracking de estado de carga.\n   *\n   * @param key Identificador del estado\n   * @param fn Funcion async a ejecutar\n   * @returns Resultado de la funcion\n   */\n  async withLoading<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    this.setLoadingState(key, true);\n    try {\n      return await fn();\n    } finally {\n      this.setLoadingState(key, false);\n    }\n  }\n\n  /**\n   * Obtiene la configuracion de animacion por defecto.\n   */\n  get animated(): boolean {\n    return this._config().animated ?? true;\n  }\n\n  /**\n   * Obtiene el delay por defecto.\n   */\n  get defaultDelay(): number {\n    return this._config().defaultDelay ?? 0;\n  }\n\n  /**\n   * Obtiene el tiempo minimo por defecto.\n   */\n  get defaultMinTime(): number {\n    return this._config().defaultMinTime ?? 300;\n  }\n}\n"]}