valtech-components 2.0.795 → 2.0.797

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

@@ -0,0 +1,172 @@
+import { DestroyRef, Inject, Injectable, Optional, effect, inject, signal } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { VALTECH_AUTH_CONFIG } from '../auth/config';
+import * as i0 from "@angular/core";
+import * as i1 from "../firebase/firestore.service";
+import * as i2 from "../auth/auth.service";
+import * as i3 from "@angular/common/http";
+import * as i4 from "../theme.service";
+import * as i5 from "../i18n/i18n.service";
+/**
+ * PreferencesService — preferencias del user en el doc canónico Firestore
+ * `/apps/{appId}/users/{uid}/preferences/main`.
+ *
+ * Read reactivo (signals) via listener Firestore.
+ * Write via `PUT /v2/auth/preferences` (cliente NUNCA escribe Firestore directo —
+ * ver memoria `feedback_no_direct_firestore_writes`).
+ *
+ * Side-effects automáticos:
+ * - Cuando `theme()` cambia → `ThemeService.Theme = ...`
+ * - Cuando `language()` cambia → `I18nService.setLanguage(...)`
+ *
+ * Auto-bind al user actual via `AuthService.user()`. Sin user (logout) → unbind.
+ */
+export class PreferencesService {
+    constructor(config, firestore, auth, http, themeService, i18n) {
+        this.config = config;
+        this.firestore = firestore;
+        this.auth = auth;
+        this.http = http;
+        this.themeService = themeService;
+        this.i18n = i18n;
+        this._theme = signal('auto');
+        this._language = signal('es');
+        // Default `false` (opt-in). El user debe activar explícitamente las notificaciones;
+        // no asumimos consentimiento implícito. Backend debe coincidir.
+        this._notificationsMaster = signal(false);
+        /** `true` después del primer snapshot Firestore. Antes, defaults sin side-effects. */
+        this._synced = signal(false);
+        this.theme = this._theme.asReadonly();
+        this.language = this._language.asReadonly();
+        this.notificationsMaster = this._notificationsMaster.asReadonly();
+        this.synced = this._synced.asReadonly();
+        const destroyRef = inject(DestroyRef);
+        destroyRef.onDestroy(() => this.unbind());
+        // Auto-bind al user actual. effect() corre en injection context (constructor OK).
+        // allowSignalWrites: bindToUser/unbind escriben `_synced` (señal interna sin
+        // dependencias del propio effect) → seguro y necesario.
+        effect(() => {
+            const user = this.auth.user();
+            if (user?.userId) {
+                this.bindToUser(user.userId);
+            }
+            else {
+                this.unbind();
+            }
+        }, { allowSignalWrites: true });
+        // Side-effect: aplicar theme local cuando llega snapshot real.
+        // OJO: usar `toggleUserPreference()` y NO el setter `Theme =`. El setter
+        // solo persiste localStorage + emite el BehaviorSubject; no aplica las
+        // clases `body.dark`/`body.light` que el palette `dark.class.css` de
+        // Ionic necesita para conmutar el tema visible.
+        effect(() => {
+            if (!this._synced())
+                return;
+            const t = this._theme();
+            if (this.themeService) {
+                this.themeService.toggleUserPreference(t);
+            }
+        });
+        // Side-effect: aplicar language local cuando llega snapshot real.
+        effect(() => {
+            if (!this._synced())
+                return;
+            const l = this._language();
+            if (this.i18n && this.i18n.lang() !== l) {
+                this.i18n.setLanguage(l);
+            }
+        });
+    }
+    /** Actualiza preferencias via backend. Optimistic UI: aplica local, revierte si falla. */
+    async update(partial) {
+        const url = `${this.config.apiUrl}/v2/auth/preferences`;
+        const prev = {
+            theme: this._theme(),
+            language: this._language(),
+            master: this._notificationsMaster(),
+        };
+        if (partial.theme)
+            this._theme.set(partial.theme);
+        if (partial.language)
+            this._language.set(partial.language);
+        if (partial.notifications && typeof partial.notifications.master === 'boolean') {
+            this._notificationsMaster.set(partial.notifications.master);
+        }
+        try {
+            const res = await firstValueFrom(this.http.put(url, partial));
+            // El listener Firestore es la fuente final, pero alinear ya con la
+            // respuesta del backend acelera UX (especialmente si el listener
+            // tarda en propagar).
+            if (res.theme)
+                this._theme.set(res.theme);
+            if (res.language)
+                this._language.set(res.language);
+            if (typeof res.notifications?.master === 'boolean') {
+                this._notificationsMaster.set(res.notifications.master);
+            }
+            return res;
+        }
+        catch (err) {
+            // Revert optimistic.
+            this._theme.set(prev.theme);
+            this._language.set(prev.language);
+            this._notificationsMaster.set(prev.master);
+            throw err;
+        }
+    }
+    setTheme(theme) {
+        return this.update({ theme });
+    }
+    setLanguage(language) {
+        return this.update({ language });
+    }
+    setNotificationsMaster(enabled) {
+        return this.update({ notifications: { master: enabled } });
+    }
+    bindToUser(userId) {
+        if (this.currentUserId === userId && this.subscription)
+            return;
+        this.unbind();
+        this.currentUserId = userId;
+        // FirestoreService.docChanges prefija automáticamente `apps/{appId}/`
+        // cuando `config.appId` está seteado en ValtechAuthConfig.
+        this.subscription = this.firestore
+            .docChanges(`users/${userId}/preferences`, 'main')
+            .subscribe(doc => {
+            if (!doc) {
+                // Doc no existe aún (user nuevo, sin primer sync). Mantenemos
+                // defaults locales pero NO marcamos synced — los side-effects no
+                // pisan el theme/lang locales con valores arbitrarios.
+                return;
+            }
+            if (doc.theme)
+                this._theme.set(doc.theme);
+            if (doc.language)
+                this._language.set(doc.language);
+            if (doc.notifications && typeof doc.notifications.master === 'boolean') {
+                this._notificationsMaster.set(doc.notifications.master);
+            }
+            this._synced.set(true);
+        });
+    }
+    unbind() {
+        this.subscription?.unsubscribe();
+        this.subscription = undefined;
+        this.currentUserId = undefined;
+        this._synced.set(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PreferencesService, deps: [{ token: VALTECH_AUTH_CONFIG }, { token: i1.FirestoreService }, { token: i2.AuthService }, { token: i3.HttpClient }, { token: i4.ThemeService, optional: true }, { token: i5.I18nService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PreferencesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PreferencesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VALTECH_AUTH_CONFIG]
+                }] }, { type: i1.FirestoreService }, { type: i2.AuthService }, { type: i3.HttpClient }, { type: i4.ThemeService, decorators: [{
+                    type: Optional
+                }] }, { type: i5.I18nService, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preferences.service.js","sourceRoot":"","sources":["../../../../../../src/lib/services/preferences/preferences.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Inject, Injectable, Optional, effect, inject, signal } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Subscription, firstValueFrom } from 'rxjs';\n\nimport { AuthService } from '../auth/auth.service';\nimport { VALTECH_AUTH_CONFIG } from '../auth/config';\nimport { ValtechAuthConfig } from '../auth/types';\nimport { FirestoreService } from '../firebase/firestore.service';\nimport { I18nLang } from '../i18n/types';\nimport { I18nService } from '../i18n/i18n.service';\nimport { ThemeOption, ThemeService } from '../theme.service';\nimport {\n  PreferencesDocument,\n  PreferencesLanguage,\n  PreferencesTheme,\n  PreferencesUpdate,\n  PreferencesUpdateResponse,\n} from './preferences.types';\n\n/**\n * PreferencesService — preferencias del user en el doc canónico Firestore\n * `/apps/{appId}/users/{uid}/preferences/main`.\n *\n * Read reactivo (signals) via listener Firestore.\n * Write via `PUT /v2/auth/preferences` (cliente NUNCA escribe Firestore directo —\n * ver memoria `feedback_no_direct_firestore_writes`).\n *\n * Side-effects automáticos:\n * - Cuando `theme()` cambia → `ThemeService.Theme = ...`\n * - Cuando `language()` cambia → `I18nService.setLanguage(...)`\n *\n * Auto-bind al user actual via `AuthService.user()`. Sin user (logout) → unbind.\n */\n@Injectable({ providedIn: 'root' })\nexport class PreferencesService {\n  private readonly _theme = signal<PreferencesTheme>('auto');\n  private readonly _language = signal<PreferencesLanguage>('es');\n  // Default `false` (opt-in). El user debe activar explícitamente las notificaciones;\n  // no asumimos consentimiento implícito. Backend debe coincidir.\n  private readonly _notificationsMaster = signal<boolean>(false);\n  /** `true` después del primer snapshot Firestore. Antes, defaults sin side-effects. */\n  private readonly _synced = signal<boolean>(false);\n\n  readonly theme = this._theme.asReadonly();\n  readonly language = this._language.asReadonly();\n  readonly notificationsMaster = this._notificationsMaster.asReadonly();\n  readonly synced = this._synced.asReadonly();\n\n  private subscription?: Subscription;\n  private currentUserId?: string;\n\n  constructor(\n    @Inject(VALTECH_AUTH_CONFIG) private config: ValtechAuthConfig,\n    private firestore: FirestoreService,\n    private auth: AuthService,\n    private http: HttpClient,\n    @Optional() private themeService: ThemeService | null,\n    @Optional() private i18n: I18nService | null\n  ) {\n    const destroyRef = inject(DestroyRef);\n    destroyRef.onDestroy(() => this.unbind());\n\n    // Auto-bind al user actual. effect() corre en injection context (constructor OK).\n    // allowSignalWrites: bindToUser/unbind escriben `_synced` (señal interna sin\n    // dependencias del propio effect) → seguro y necesario.\n    effect(\n      () => {\n        const user = this.auth.user();\n        if (user?.userId) {\n          this.bindToUser(user.userId);\n        } else {\n          this.unbind();\n        }\n      },\n      { allowSignalWrites: true }\n    );\n\n    // Side-effect: aplicar theme local cuando llega snapshot real.\n    // OJO: usar `toggleUserPreference()` y NO el setter `Theme =`. El setter\n    // solo persiste localStorage + emite el BehaviorSubject; no aplica las\n    // clases `body.dark`/`body.light` que el palette `dark.class.css` de\n    // Ionic necesita para conmutar el tema visible.\n    effect(() => {\n      if (!this._synced()) return;\n      const t = this._theme();\n      if (this.themeService) {\n        this.themeService.toggleUserPreference(t as ThemeOption);\n      }\n    });\n\n    // Side-effect: aplicar language local cuando llega snapshot real.\n    effect(() => {\n      if (!this._synced()) return;\n      const l = this._language();\n      if (this.i18n && this.i18n.lang() !== l) {\n        this.i18n.setLanguage(l as I18nLang);\n      }\n    });\n  }\n\n  /** Actualiza preferencias via backend. Optimistic UI: aplica local, revierte si falla. */\n  async update(partial: PreferencesUpdate): Promise<PreferencesUpdateResponse> {\n    const url = `${this.config.apiUrl}/v2/auth/preferences`;\n\n    const prev = {\n      theme: this._theme(),\n      language: this._language(),\n      master: this._notificationsMaster(),\n    };\n\n    if (partial.theme) this._theme.set(partial.theme);\n    if (partial.language) this._language.set(partial.language);\n    if (partial.notifications && typeof partial.notifications.master === 'boolean') {\n      this._notificationsMaster.set(partial.notifications.master);\n    }\n\n    try {\n      const res = await firstValueFrom(this.http.put<PreferencesUpdateResponse>(url, partial));\n      // El listener Firestore es la fuente final, pero alinear ya con la\n      // respuesta del backend acelera UX (especialmente si el listener\n      // tarda en propagar).\n      if (res.theme) this._theme.set(res.theme as PreferencesTheme);\n      if (res.language) this._language.set(res.language as PreferencesLanguage);\n      if (typeof res.notifications?.master === 'boolean') {\n        this._notificationsMaster.set(res.notifications.master);\n      }\n      return res;\n    } catch (err) {\n      // Revert optimistic.\n      this._theme.set(prev.theme);\n      this._language.set(prev.language);\n      this._notificationsMaster.set(prev.master);\n      throw err;\n    }\n  }\n\n  setTheme(theme: PreferencesTheme): Promise<PreferencesUpdateResponse> {\n    return this.update({ theme });\n  }\n\n  setLanguage(language: PreferencesLanguage): Promise<PreferencesUpdateResponse> {\n    return this.update({ language });\n  }\n\n  setNotificationsMaster(enabled: boolean): Promise<PreferencesUpdateResponse> {\n    return this.update({ notifications: { master: enabled } });\n  }\n\n  private bindToUser(userId: string): void {\n    if (this.currentUserId === userId && this.subscription) return;\n    this.unbind();\n    this.currentUserId = userId;\n    // FirestoreService.docChanges prefija automáticamente `apps/{appId}/`\n    // cuando `config.appId` está seteado en ValtechAuthConfig.\n    this.subscription = this.firestore\n      .docChanges<PreferencesDocument & { id?: string }>(`users/${userId}/preferences`, 'main')\n      .subscribe(doc => {\n        if (!doc) {\n          // Doc no existe aún (user nuevo, sin primer sync). Mantenemos\n          // defaults locales pero NO marcamos synced — los side-effects no\n          // pisan el theme/lang locales con valores arbitrarios.\n          return;\n        }\n        if (doc.theme) this._theme.set(doc.theme);\n        if (doc.language) this._language.set(doc.language);\n        if (doc.notifications && typeof doc.notifications.master === 'boolean') {\n          this._notificationsMaster.set(doc.notifications.master);\n        }\n        this._synced.set(true);\n      });\n  }\n\n  private unbind(): void {\n    this.subscription?.unsubscribe();\n    this.subscription = undefined;\n    this.currentUserId = undefined;\n    this._synced.set(false);\n  }\n}\n"]}

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

@@ -0,0 +1,7 @@
+/**
+ * Preferences types — Fase 1 schema simple (theme + language + notifications.master).
+ * Doc canónico: /apps/{appId}/users/{uid}/preferences/main
+ * Cliente NUNCA escribe directo — todas las mutaciones via PUT /v2/auth/preferences.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlZmVyZW5jZXMudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3ByZWZlcmVuY2VzL3ByZWZlcmVuY2VzLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFByZWZlcmVuY2VzIHR5cGVzIOKAlCBGYXNlIDEgc2NoZW1hIHNpbXBsZSAodGhlbWUgKyBsYW5ndWFnZSArIG5vdGlmaWNhdGlvbnMubWFzdGVyKS5cbiAqIERvYyBjYW7Ds25pY286IC9hcHBzL3thcHBJZH0vdXNlcnMve3VpZH0vcHJlZmVyZW5jZXMvbWFpblxuICogQ2xpZW50ZSBOVU5DQSBlc2NyaWJlIGRpcmVjdG8g4oCUIHRvZGFzIGxhcyBtdXRhY2lvbmVzIHZpYSBQVVQgL3YyL2F1dGgvcHJlZmVyZW5jZXMuXG4gKi9cblxuZXhwb3J0IHR5cGUgUHJlZmVyZW5jZXNUaGVtZSA9ICdsaWdodCcgfCAnZGFyaycgfCAnYXV0byc7XG5leHBvcnQgdHlwZSBQcmVmZXJlbmNlc0xhbmd1YWdlID0gJ2VzJyB8ICdlbicgfCAncHQnO1xuXG4vKiogRm9ybWEgZGVsIGRvYyB0YWwgY29tbyBsbyBlc2NyaWJlIGVsIGJhY2tlbmQgKEFkbWluIFNESykuICovXG5leHBvcnQgaW50ZXJmYWNlIFByZWZlcmVuY2VzRG9jdW1lbnQge1xuICB0aGVtZT86IFByZWZlcmVuY2VzVGhlbWU7XG4gIGxhbmd1YWdlPzogUHJlZmVyZW5jZXNMYW5ndWFnZTtcbiAgbm90aWZpY2F0aW9ucz86IHtcbiAgICBtYXN0ZXI/OiBib29sZWFuO1xuICB9O1xuICAvKiogc2VydmVyVGltZXN0YW1wIGVzY3JpdG8gcG9yIGVsIGJhY2tlbmQgZW4gY2FkYSBzeW5jLiAqL1xuICBzeW5jZWRBdD86IHVua25vd247XG59XG5cbi8qKiBQYXlsb2FkIGFjZXB0YWRvIHBvciBgUFVUIC92Mi9hdXRoL3ByZWZlcmVuY2VzYCDigJQgcGFydGlhbCB1cGRhdGUuICovXG5leHBvcnQgaW50ZXJmYWNlIFByZWZlcmVuY2VzVXBkYXRlIHtcbiAgdGhlbWU/OiBQcmVmZXJlbmNlc1RoZW1lO1xuICBsYW5ndWFnZT86IFByZWZlcmVuY2VzTGFuZ3VhZ2U7XG4gIG5vdGlmaWNhdGlvbnM/OiB7XG4gICAgbWFzdGVyPzogYm9vbGVhbjtcbiAgfTtcbn1cblxuLyoqIFJlc3BvbnNlIGRlbCBiYWNrZW5kIHRyYXMgZWwgUFVULiAqL1xuZXhwb3J0IGludGVyZmFjZSBQcmVmZXJlbmNlc1VwZGF0ZVJlc3BvbnNlIHtcbiAgb3BlcmF0aW9uSWQ6IHN0cmluZztcbiAgdGhlbWU6IFByZWZlcmVuY2VzVGhlbWUgfCAnJztcbiAgbGFuZ3VhZ2U6IFByZWZlcmVuY2VzTGFuZ3VhZ2UgfCAnJztcbiAgbm90aWZpY2F0aW9uczogeyBtYXN0ZXI/OiBib29sZWFuIH07XG4gIHVwZGF0ZWQ6IGJvb2xlYW47XG59XG4iXX0=

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

@@ -0,0 +1,46 @@
+import { makeEnvironmentProviders, APP_INITIALIZER, } from '@angular/core';
+import { PresetService } from './preset.service';
+/**
+ * Configura el sistema de presets de Valtech Components.
+ *
+ * @param presets Configuración de presets por componente
+ * @returns Providers para agregar en app.config.ts
+ *
+ * @example
+ * // app.config.ts
+ * import { provideValtechPresets } from 'valtech-components';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideValtechPresets({
+ *       button: {
+ *         'primary-action': { size: 'large', color: 'primary', fill: 'solid' },
+ *         'secondary': { size: 'medium', color: 'secondary', fill: 'outline' },
+ *         'danger': { size: 'medium', color: 'danger', fill: 'solid' },
+ *       },
+ *       card: {
+ *         'feature': { variant: 'elevated', padding: 'large' },
+ *         'compact': { variant: 'flat', padding: 'small' },
+ *       },
+ *       input: {
+ *         'form-field': { size: 'medium', fill: 'outline', labelPosition: 'floating' },
+ *       }
+ *     }),
+ *   ]
+ * };
+ */
+export function provideValtechPresets(presets) {
+    return makeEnvironmentProviders([
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (presetService) => {
+                return () => {
+                    presetService.registerPresets(presets);
+                };
+            },
+            deps: [PresetService],
+            multi: true,
+        },
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+// Service
+export { PresetService } from './preset.service';
+// Config
+export { provideValtechPresets } from './config';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL3ByZXNldHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsVUFBVTtBQUNWLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVqRCxTQUFTO0FBQ1QsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVHlwZXNcbmV4cG9ydCB7IFByZXNldENvbmZpZywgQ29tcG9uZW50UHJlc2V0cywgUHJlc2V0c09wdGlvbnMgfSBmcm9tICcuL3R5cGVzJztcblxuLy8gU2VydmljZVxuZXhwb3J0IHsgUHJlc2V0U2VydmljZSB9IGZyb20gJy4vcHJlc2V0LnNlcnZpY2UnO1xuXG4vLyBDb25maWdcbmV4cG9ydCB7IHByb3ZpZGVWYWx0ZWNoUHJlc2V0cyB9IGZyb20gJy4vY29uZmlnJztcbiJdfQ==

package/esm2022/lib/services/presets/preset.service.mjs

@@ -0,0 +1,104 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para gestionar presets de componentes.
+ *
+ * Los presets permiten definir configuraciones reutilizables
+ * de componentes (tamaño, color, variante, etc.) que se pueden
+ * aplicar con un nombre semántico.
+ *
+ * @example
+ * // En un componente
+ * presets = inject(PresetService);
+ *
+ * // Obtener preset
+ * const buttonProps = this.presets.get<ButtonMetadata>('button', 'primary-action');
+ * // { size: 'large', color: 'primary', fill: 'solid' }
+ */
+export class PresetService {
+    constructor() {
+        this._presets = signal({});
+    }
+    /**
+     * Obtiene un preset específico para un componente
+     *
+     * @param component Tipo de componente (ej: 'button', 'card', 'input')
+     * @param presetName Nombre del preset (ej: 'primary-action', 'compact')
+     * @returns Propiedades del preset o objeto vacío si no existe
+     *
+     * @example
+     * // Obtener preset de botón
+     * const props = presets.get<ButtonMetadata>('button', 'primary-action');
+     *
+     * // Usar en componente
+     * <val-button [props]="props"></val-button>
+     */
+    get(component, presetName) {
+        const componentPresets = this._presets()[component];
+        if (!componentPresets) {
+            console.warn(`[presets] No presets registered for component: ${component}`);
+            return {};
+        }
+        const preset = componentPresets[presetName];
+        if (!preset) {
+            console.warn(`[presets] Preset '${presetName}' not found for component: ${component}`);
+            return {};
+        }
+        return preset;
+    }
+    /**
+     * Verifica si existe un preset
+     */
+    has(component, presetName) {
+        return !!this._presets()[component]?.[presetName];
+    }
+    /**
+     * Registra presets de la aplicación
+     *
+     * @param presets Configuración de presets
+     *
+     * @example
+     * presets.registerPresets({
+     *   button: {
+     *     'primary-action': { size: 'large', color: 'primary' },
+     *   },
+     *   card: {
+     *     'feature': { variant: 'elevated' },
+     *   }
+     * });
+     */
+    registerPresets(presets) {
+        this._presets.set(presets);
+    }
+    /**
+     * Agrega presets para un componente específico (merge con existentes)
+     */
+    registerComponentPresets(component, presets) {
+        this._presets.update((current) => ({
+            ...current,
+            [component]: {
+                ...current[component],
+                ...presets,
+            },
+        }));
+    }
+    /**
+     * Obtiene todos los nombres de presets para un componente
+     */
+    getPresetNames(component) {
+        return Object.keys(this._presets()[component] || {});
+    }
+    /**
+     * Obtiene todos los componentes con presets registrados
+     */
+    getRegisteredComponents() {
+        return Object.keys(this._presets());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PresetService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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