valtech-components 2.0.971 → 2.0.972

package/esm2022/lib/components/organisms/preferences-view/preferences-view.component.mjs

@@ -0,0 +1,263 @@
+import { CommonModule } from '@angular/common';
+import { Component, computed, inject, Input, signal } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TextComponent } from '../../atoms/text/text.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { LanguageSelectorComponent } from '../../molecules/language-selector/language-selector.component';
+import { SegmentControlComponent } from '../../molecules/segment-control/segment-control.component';
+import { I18nService } from '../../../services/i18n';
+import { NavigationService } from '../../../services/navigation/navigation.service';
+import { PreferencesService } from '../../../services/preferences/preferences.service';
+import { ValtechErrorService } from '../../../services/errors/valtech-error.service';
+import { PREFERENCES_VIEW_I18N } from './preferences-view.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'Settings.General';
+const DEFAULT_LANGUAGES = ['es', 'en'];
+/**
+ * `val-preferences-view` — vista de preferencias de UI cross-app (tema +
+ * idioma) full-feature autocontenida (organism). Promovida desde `showcase`
+ * bajo el proceso de ADR-021.
+ *
+ * Backend integration 100% en `PreferencesService`:
+ *  - Read: listener Firestore reactivo (`prefs.theme()` / `prefs.language()`).
+ *  - Write: `PUT /v2/auth/preferences` (`prefs.setTheme` / `prefs.setLanguage`).
+ *    El cliente NUNCA escribe Firestore directo.
+ *
+ * NO renderiza ion-content — vive dentro de val-page-wrapper.
+ *
+ * Auto-registra sus defaults i18n (es/en) en el constructor si el consumer no
+ * proveyó el namespace configurado (default `Settings.General`).
+ */
+export class PreferencesViewComponent {
+    /** Namespace i18n resuelto (capturado para llamadas no-reactivas). */
+    get ns() {
+        return this.resolvedConfig().i18nNamespace;
+    }
+    constructor() {
+        this.nav = inject(NavigationService);
+        this.prefs = inject(PreferencesService);
+        this.i18n = inject(I18nService);
+        this.errors = inject(ValtechErrorService);
+        this.route = inject(ActivatedRoute, { optional: true });
+        /** Config mergeada con defaults. @Input gana sobre route data. */
+        this.resolvedConfig = computed(() => {
+            const fromRoute = (this.route?.snapshot.data['preferencesConfig'] ?? {});
+            const merged = { ...fromRoute, ...(this.config ?? {}) };
+            return {
+                showTheme: merged.showTheme ?? true,
+                showLanguage: merged.showLanguage ?? true,
+                supportedLanguages: merged.supportedLanguages ?? DEFAULT_LANGUAGES,
+                i18nNamespace: merged.i18nNamespace ?? DEFAULT_NAMESPACE,
+                onThemeChanged: merged.onThemeChanged,
+                onLanguageChanged: merged.onLanguageChanged,
+            };
+        });
+        this.saving = signal(false);
+        this.pageTitle = computed(() => this.t('pageTitle'));
+        this.pageDescription = computed(() => this.t('pageDescription'));
+        this.themeTitle = computed(() => this.t('themeTitle'));
+        this.themeHint = computed(() => this.t('themeHint'));
+        this.langTitle = computed(() => this.t('languageTitle'));
+        this.langHint = computed(() => this.t('languageHint'));
+        this.themeProps = computed(() => ({
+            value: this.prefs.theme(),
+            disabled: this.saving(),
+            options: [
+                { value: 'light', label: this.t('themeLight') },
+                { value: 'dark', label: this.t('themeDark') },
+                { value: 'auto', label: this.t('themeAuto') },
+            ],
+        }));
+        this.langProps = computed(() => ({
+            currentLanguage: this.prefs.language(),
+            availableLanguages: this.resolvedConfig().supportedLanguages,
+            showLabel: false,
+            disabled: this.saving(),
+            expand: 'block',
+            fill: 'outline',
+        }));
+        // Auto-registro i18n — respeta override del consumer. El namespace puede
+        // venir de @Input.config o del route data; lo resolvemos acá.
+        const ns = this.ns;
+        if (!this.i18n.hasNamespace(ns)) {
+            this.i18n.registerContent(ns, PREFERENCES_VIEW_I18N);
+        }
+        this.nav.setBackHeader('pageTitle', ns, { withMenu: true });
+    }
+    async onThemeChange(value) {
+        if (this.saving() || value === this.prefs.theme())
+            return;
+        const theme = value;
+        await this.dispatch(() => this.prefs.setTheme(theme), () => this.resolvedConfig().onThemeChanged?.(theme));
+    }
+    async onLanguageChange(value) {
+        const lang = value;
+        if (!this.resolvedConfig().supportedLanguages.includes(lang))
+            return;
+        if (this.saving() || value === this.prefs.language())
+            return;
+        await this.dispatch(() => this.prefs.setLanguage(lang), () => this.resolvedConfig().onLanguageChanged?.(lang));
+    }
+    async dispatch(fn, onSuccess) {
+        this.saving.set(true);
+        try {
+            await fn();
+            onSuccess?.();
+        }
+        catch (err) {
+            this.errors.handle(err, {
+                context: 'settings.preferences.save',
+                fallbackKey: 'saveError',
+                i18nNamespace: this.ns,
+            });
+        }
+        finally {
+            this.saving.set(false);
+        }
+    }
+    /** Lee del namespace configurado. */
+    t(key) {
+        return this.i18n.t(key, this.ns);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PreferencesViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: PreferencesViewComponent, isStandalone: true, selector: "val-preferences-view", inputs: { config: "config" }, ngImport: i0, template: `
+    <div class="page">
+      <header class="page-header">
+        <val-display [props]="{ size: 'small', color: 'dark', content: pageTitle() }" />
+        <val-title
+          [props]="{
+            size: 'large',
+            color: 'dark',
+            bold: false,
+            content: pageDescription(),
+          }"
+        />
+      </header>
+
+      @if (resolvedConfig().showTheme) {
+        <section class="settings-section">
+          <val-title
+            [props]="{
+              size: 'medium',
+              color: 'dark',
+              bold: true,
+              content: themeTitle(),
+            }"
+          />
+          <div class="section-body">
+            <val-text
+              [props]="{
+                size: 'medium',
+                color: 'dark',
+                bold: false,
+                content: themeHint(),
+              }"
+            />
+            <val-segment-control [props]="themeProps()" (segmentChange)="onThemeChange($event)" />
+          </div>
+        </section>
+      }
+
+      @if (resolvedConfig().showLanguage) {
+        <section class="settings-section">
+          <val-title
+            [props]="{
+              size: 'medium',
+              color: 'dark',
+              bold: true,
+              content: langTitle(),
+            }"
+          />
+          <div class="section-body">
+            <val-text
+              [props]="{
+                size: 'medium',
+                color: 'dark',
+                bold: false,
+                content: langHint(),
+              }"
+            />
+            <val-language-selector [props]="langProps()" (languageChange)="onLanguageChange($event)" />
+          </div>
+        </section>
+      }
+    </div>
+  `, isInline: true, styles: [".page{padding:16px 0;max-width:720px;margin:0 auto}.settings-section{padding:16px 0}.settings-section+.settings-section{border-top:1px solid var(--val-border-color, rgba(0, 0, 0, .08))}.section-body{display:flex;flex-direction:column;gap:10px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: SegmentControlComponent, selector: "val-segment-control", inputs: ["preset", "props"], outputs: ["segmentChange"] }, { kind: "component", type: LanguageSelectorComponent, selector: "val-language-selector", inputs: ["props"], outputs: ["languageChange"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }, { kind: "component", type: TextComponent, selector: "val-text", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PreferencesViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-preferences-view', standalone: true, imports: [
+                        CommonModule,
+                        SegmentControlComponent,
+                        LanguageSelectorComponent,
+                        DisplayComponent,
+                        TitleComponent,
+                        TextComponent,
+                    ], template: `
+    <div class="page">
+      <header class="page-header">
+        <val-display [props]="{ size: 'small', color: 'dark', content: pageTitle() }" />
+        <val-title
+          [props]="{
+            size: 'large',
+            color: 'dark',
+            bold: false,
+            content: pageDescription(),
+          }"
+        />
+      </header>
+
+      @if (resolvedConfig().showTheme) {
+        <section class="settings-section">
+          <val-title
+            [props]="{
+              size: 'medium',
+              color: 'dark',
+              bold: true,
+              content: themeTitle(),
+            }"
+          />
+          <div class="section-body">
+            <val-text
+              [props]="{
+                size: 'medium',
+                color: 'dark',
+                bold: false,
+                content: themeHint(),
+              }"
+            />
+            <val-segment-control [props]="themeProps()" (segmentChange)="onThemeChange($event)" />
+          </div>
+        </section>
+      }
+
+      @if (resolvedConfig().showLanguage) {
+        <section class="settings-section">
+          <val-title
+            [props]="{
+              size: 'medium',
+              color: 'dark',
+              bold: true,
+              content: langTitle(),
+            }"
+          />
+          <div class="section-body">
+            <val-text
+              [props]="{
+                size: 'medium',
+                color: 'dark',
+                bold: false,
+                content: langHint(),
+              }"
+            />
+            <val-language-selector [props]="langProps()" (languageChange)="onLanguageChange($event)" />
+          </div>
+        </section>
+      }
+    </div>
+  `, styles: [".page{padding:16px 0;max-width:720px;margin:0 auto}.settings-section{padding:16px 0}.settings-section+.settings-section{border-top:1px solid var(--val-border-color, rgba(0, 0, 0, .08))}.section-body{display:flex;flex-direction:column;gap:10px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preferences-view.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/preferences-view/preferences-view.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, computed, inject, Input, signal } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\n\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TextComponent } from '../../atoms/text/text.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\nimport { LanguageSelectorComponent } from '../../molecules/language-selector/language-selector.component';\nimport { LanguageSelectorMetadata } from '../../molecules/language-selector/types';\nimport { SegmentControlComponent } from '../../molecules/segment-control/segment-control.component';\nimport { SegmentControlMetadata } from '../../molecules/segment-control/types';\n\nimport { I18nService } from '../../../services/i18n';\nimport { NavigationService } from '../../../services/navigation/navigation.service';\nimport { PreferencesService } from '../../../services/preferences/preferences.service';\nimport { PreferencesLanguage, PreferencesTheme } from '../../../services/preferences/preferences.types';\nimport { ValtechErrorService } from '../../../services/errors/valtech-error.service';\n\nimport { PreferencesViewConfig } from './types';\nimport { PREFERENCES_VIEW_I18N } from './preferences-view.i18n';\n\nconst DEFAULT_NAMESPACE = 'Settings.General';\nconst DEFAULT_LANGUAGES: PreferencesLanguage[] = ['es', 'en'];\n\n/**\n * `val-preferences-view` — vista de preferencias de UI cross-app (tema +\n * idioma) full-feature autocontenida (organism). Promovida desde `showcase`\n * bajo el proceso de ADR-021.\n *\n * Backend integration 100% en `PreferencesService`:\n *  - Read: listener Firestore reactivo (`prefs.theme()` / `prefs.language()`).\n *  - Write: `PUT /v2/auth/preferences` (`prefs.setTheme` / `prefs.setLanguage`).\n *    El cliente NUNCA escribe Firestore directo.\n *\n * NO renderiza ion-content — vive dentro de val-page-wrapper.\n *\n * Auto-registra sus defaults i18n (es/en) en el constructor si el consumer no\n * proveyó el namespace configurado (default `Settings.General`).\n */\n@Component({\n  selector: 'val-preferences-view',\n  standalone: true,\n  imports: [\n    CommonModule,\n    SegmentControlComponent,\n    LanguageSelectorComponent,\n    DisplayComponent,\n    TitleComponent,\n    TextComponent,\n  ],\n  template: `\n    <div class=\"page\">\n      <header class=\"page-header\">\n        <val-display [props]=\"{ size: 'small', color: 'dark', content: pageTitle() }\" />\n        <val-title\n          [props]=\"{\n            size: 'large',\n            color: 'dark',\n            bold: false,\n            content: pageDescription(),\n          }\"\n        />\n      </header>\n\n      @if (resolvedConfig().showTheme) {\n        <section class=\"settings-section\">\n          <val-title\n            [props]=\"{\n              size: 'medium',\n              color: 'dark',\n              bold: true,\n              content: themeTitle(),\n            }\"\n          />\n          <div class=\"section-body\">\n            <val-text\n              [props]=\"{\n                size: 'medium',\n                color: 'dark',\n                bold: false,\n                content: themeHint(),\n              }\"\n            />\n            <val-segment-control [props]=\"themeProps()\" (segmentChange)=\"onThemeChange($event)\" />\n          </div>\n        </section>\n      }\n\n      @if (resolvedConfig().showLanguage) {\n        <section class=\"settings-section\">\n          <val-title\n            [props]=\"{\n              size: 'medium',\n              color: 'dark',\n              bold: true,\n              content: langTitle(),\n            }\"\n          />\n          <div class=\"section-body\">\n            <val-text\n              [props]=\"{\n                size: 'medium',\n                color: 'dark',\n                bold: false,\n                content: langHint(),\n              }\"\n            />\n            <val-language-selector [props]=\"langProps()\" (languageChange)=\"onLanguageChange($event)\" />\n          </div>\n        </section>\n      }\n    </div>\n  `,\n  styles: [\n    `\n      .page {\n        padding: 16px 0;\n        max-width: 720px;\n        margin: 0 auto;\n      }\n      .settings-section {\n        padding: 16px 0;\n      }\n      .settings-section + .settings-section {\n        border-top: 1px solid var(--val-border-color, rgba(0, 0, 0, 0.08));\n      }\n      .section-body {\n        display: flex;\n        flex-direction: column;\n        gap: 10px;\n      }\n    `,\n  ],\n})\nexport class PreferencesViewComponent {\n  private nav = inject(NavigationService);\n  private prefs = inject(PreferencesService);\n  private i18n = inject(I18nService);\n  private errors = inject(ValtechErrorService);\n  private route = inject(ActivatedRoute, { optional: true });\n\n  /**\n   * Config vía @Input (object-first). Si no se pasa, se cae al route data\n   * `preferencesConfig` (poblado por `provideValtechPreferencesRoutes`).\n   * `resolvedConfig` mergea con los defaults.\n   */\n  @Input() config?: PreferencesViewConfig;\n\n  /** Config mergeada con defaults. @Input gana sobre route data. */\n  readonly resolvedConfig = computed<\n    Required<Omit<PreferencesViewConfig, 'onThemeChanged' | 'onLanguageChanged'>> &\n      Pick<PreferencesViewConfig, 'onThemeChanged' | 'onLanguageChanged'>\n  >(() => {\n    const fromRoute = (this.route?.snapshot.data['preferencesConfig'] ?? {}) as PreferencesViewConfig;\n    const merged: PreferencesViewConfig = { ...fromRoute, ...(this.config ?? {}) };\n    return {\n      showTheme: merged.showTheme ?? true,\n      showLanguage: merged.showLanguage ?? true,\n      supportedLanguages: merged.supportedLanguages ?? DEFAULT_LANGUAGES,\n      i18nNamespace: merged.i18nNamespace ?? DEFAULT_NAMESPACE,\n      onThemeChanged: merged.onThemeChanged,\n      onLanguageChanged: merged.onLanguageChanged,\n    };\n  });\n\n  /** Namespace i18n resuelto (capturado para llamadas no-reactivas). */\n  private get ns(): string {\n    return this.resolvedConfig().i18nNamespace;\n  }\n\n  readonly saving = signal(false);\n\n  readonly pageTitle = computed(() => this.t('pageTitle'));\n  readonly pageDescription = computed(() => this.t('pageDescription'));\n  readonly themeTitle = computed(() => this.t('themeTitle'));\n  readonly themeHint = computed(() => this.t('themeHint'));\n  readonly langTitle = computed(() => this.t('languageTitle'));\n  readonly langHint = computed(() => this.t('languageHint'));\n\n  readonly themeProps = computed<Partial<SegmentControlMetadata>>(() => ({\n    value: this.prefs.theme(),\n    disabled: this.saving(),\n    options: [\n      { value: 'light', label: this.t('themeLight') },\n      { value: 'dark', label: this.t('themeDark') },\n      { value: 'auto', label: this.t('themeAuto') },\n    ],\n  }));\n\n  readonly langProps = computed<Partial<LanguageSelectorMetadata>>(() => ({\n    currentLanguage: this.prefs.language(),\n    availableLanguages: this.resolvedConfig().supportedLanguages,\n    showLabel: false,\n    disabled: this.saving(),\n    expand: 'block',\n    fill: 'outline',\n  }));\n\n  constructor() {\n    // Auto-registro i18n — respeta override del consumer. El namespace puede\n    // venir de @Input.config o del route data; lo resolvemos acá.\n    const ns = this.ns;\n    if (!this.i18n.hasNamespace(ns)) {\n      this.i18n.registerContent(ns, PREFERENCES_VIEW_I18N);\n    }\n\n    this.nav.setBackHeader('pageTitle', ns, { withMenu: true });\n  }\n\n  async onThemeChange(value: string): Promise<void> {\n    if (this.saving() || value === this.prefs.theme()) return;\n    const theme = value as PreferencesTheme;\n    await this.dispatch(\n      () => this.prefs.setTheme(theme),\n      () => this.resolvedConfig().onThemeChanged?.(theme)\n    );\n  }\n\n  async onLanguageChange(value: string): Promise<void> {\n    const lang = value as PreferencesLanguage;\n    if (!this.resolvedConfig().supportedLanguages.includes(lang)) return;\n    if (this.saving() || value === this.prefs.language()) return;\n    await this.dispatch(\n      () => this.prefs.setLanguage(lang),\n      () => this.resolvedConfig().onLanguageChanged?.(lang)\n    );\n  }\n\n  private async dispatch(fn: () => Promise<unknown>, onSuccess?: () => void): Promise<void> {\n    this.saving.set(true);\n    try {\n      await fn();\n      onSuccess?.();\n    } catch (err) {\n      this.errors.handle(err, {\n        context: 'settings.preferences.save',\n        fallbackKey: 'saveError',\n        i18nNamespace: this.ns,\n      });\n    } finally {\n      this.saving.set(false);\n    }\n  }\n\n  /** Lee del namespace configurado. */\n  protected t(key: string): string {\n    return this.i18n.t(key, this.ns);\n  }\n}\n"]}

package/esm2022/lib/components/organisms/preferences-view/preferences-view.i18n.mjs

@@ -0,0 +1,37 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-preferences-view`. Auto-registrados
+ * en el constructor del componente si el consumer no proveyó el namespace
+ * (`Settings.General` por default). Garantiza que nunca haya una key faltante
+ * evaluada por cada change-detection (ver nota en valtech-components/CLAUDE.md
+ * sobre el storm de CD con `val-debug-console`). El consumer puede override
+ * registrando el mismo namespace antes de que el componente monte.
+ *
+ * SOLO incluye las keys que la vista realmente usa.
+ */
+export const PREFERENCES_VIEW_I18N = {
+    es: {
+        pageTitle: 'General',
+        pageDescription: 'Apariencia e idioma',
+        themeTitle: 'Tema',
+        themeHint: 'Cómo se ve la app: claro, oscuro o según tu sistema.',
+        themeLight: 'Claro',
+        themeDark: 'Oscuro',
+        themeAuto: 'Auto',
+        languageTitle: 'Idioma',
+        languageHint: 'Idioma de la interfaz y de los correos que recibes.',
+        saveError: 'No se pudo guardar la preferencia.',
+    },
+    en: {
+        pageTitle: 'General',
+        pageDescription: 'Appearance and language',
+        themeTitle: 'Theme',
+        themeHint: 'How the app looks: light, dark, or matching your system.',
+        themeLight: 'Light',
+        themeDark: 'Dark',
+        themeAuto: 'Auto',
+        languageTitle: 'Language',
+        languageHint: 'Language of the interface and of the emails you receive.',
+        saveError: 'Could not save preference.',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/preferences-view/preferences.routes.mjs

@@ -0,0 +1,29 @@
+import { PreferencesViewComponent } from './preferences-view.component';
+/**
+ * Helper para montar la vista de preferencias (`val-preferences-view`) como
+ * ruta en una app del factory. El `config` se pasa por route `data`
+ * (`preferencesConfig`) y el componente lo lee como fallback de su
+ * `@Input() config`.
+ *
+ * @example
+ * ```ts
+ * // settings.routes.ts
+ * export const settingsRoutes: Routes = [
+ *   ...provideValtechPreferencesRoutes(),
+ *   { path: 'profile', loadComponent: () => ... },
+ * ];
+ *
+ * // con config acotada:
+ * ...provideValtechPreferencesRoutes({ config: { showLanguage: false } }),
+ * ```
+ */
+export function provideValtechPreferencesRoutes(opts) {
+    return [
+        {
+            path: opts?.path ?? 'preferences',
+            component: PreferencesViewComponent,
+            data: { preferencesConfig: opts?.config },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlZmVyZW5jZXMucm91dGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb21wb25lbnRzL29yZ2FuaXNtcy9wcmVmZXJlbmNlcy12aWV3L3ByZWZlcmVuY2VzLnJvdXRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUd4RTs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLFVBQVUsK0JBQStCLENBQUMsSUFHL0M7SUFDQyxPQUFPO1FBQ0w7WUFDRSxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksSUFBSSxhQUFhO1lBQ2pDLFNBQVMsRUFBRSx3QkFBd0I7WUFDbkMsSUFBSSxFQUFFLEVBQUUsaUJBQWlCLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRTtTQUMxQztLQUNGLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUm91dGVzIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuaW1wb3J0IHsgUHJlZmVyZW5jZXNWaWV3Q29tcG9uZW50IH0gZnJvbSAnLi9wcmVmZXJlbmNlcy12aWV3LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBQcmVmZXJlbmNlc1ZpZXdDb25maWcgfSBmcm9tICcuL3R5cGVzJztcblxuLyoqXG4gKiBIZWxwZXIgcGFyYSBtb250YXIgbGEgdmlzdGEgZGUgcHJlZmVyZW5jaWFzIChgdmFsLXByZWZlcmVuY2VzLXZpZXdgKSBjb21vXG4gKiBydXRhIGVuIHVuYSBhcHAgZGVsIGZhY3RvcnkuIEVsIGBjb25maWdgIHNlIHBhc2EgcG9yIHJvdXRlIGBkYXRhYFxuICogKGBwcmVmZXJlbmNlc0NvbmZpZ2ApIHkgZWwgY29tcG9uZW50ZSBsbyBsZWUgY29tbyBmYWxsYmFjayBkZSBzdVxuICogYEBJbnB1dCgpIGNvbmZpZ2AuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiAvLyBzZXR0aW5ncy5yb3V0ZXMudHNcbiAqIGV4cG9ydCBjb25zdCBzZXR0aW5nc1JvdXRlczogUm91dGVzID0gW1xuICogICAuLi5wcm92aWRlVmFsdGVjaFByZWZlcmVuY2VzUm91dGVzKCksXG4gKiAgIHsgcGF0aDogJ3Byb2ZpbGUnLCBsb2FkQ29tcG9uZW50OiAoKSA9PiAuLi4gfSxcbiAqIF07XG4gKlxuICogLy8gY29uIGNvbmZpZyBhY290YWRhOlxuICogLi4ucHJvdmlkZVZhbHRlY2hQcmVmZXJlbmNlc1JvdXRlcyh7IGNvbmZpZzogeyBzaG93TGFuZ3VhZ2U6IGZhbHNlIH0gfSksXG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVWYWx0ZWNoUHJlZmVyZW5jZXNSb3V0ZXMob3B0cz86IHtcbiAgcGF0aD86IHN0cmluZztcbiAgY29uZmlnPzogUHJlZmVyZW5jZXNWaWV3Q29uZmlnO1xufSk6IFJvdXRlcyB7XG4gIHJldHVybiBbXG4gICAge1xuICAgICAgcGF0aDogb3B0cz8ucGF0aCA/PyAncHJlZmVyZW5jZXMnLFxuICAgICAgY29tcG9uZW50OiBQcmVmZXJlbmNlc1ZpZXdDb21wb25lbnQsXG4gICAgICBkYXRhOiB7IHByZWZlcmVuY2VzQ29uZmlnOiBvcHRzPy5jb25maWcgfSxcbiAgICB9LFxuICBdO1xufVxuIl19

package/esm2022/lib/components/organisms/preferences-view/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/types.mjs

@@ -58,4 +58,4 @@ export var ToolbarActionType;
     ToolbarActionType["IMAGE"] = "IMAGE";
     ToolbarActionType["BUTTON"] = "BUTTON";
 })(ToolbarActionType || (ToolbarActionType = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/components/types.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,QAAQ,GAAmB,UAAU,CAAC;AAC5C,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,KAAK,GAAmB,OAAO,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,CAAN,IAAY,UAMX;AAND,WAAY,UAAU;IACpB,iEAAe,CAAA;IACf,mEAAgB,CAAA;IAChB,iEAAe,CAAA;IACf,+DAAc,CAAA;IACd,uEAAkB,CAAA;AACpB,CAAC,EANW,UAAU,KAAV,UAAU,QAMrB;AAcD;;GAEG;AACH,MAAM,CAAN,IAAY,SA0BX;AA1BD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,iDAAQ,CAAA;IACR,2CAAK,CAAA;IACL,iDAAQ,CAAA;IACR,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6DAAc,CAAA;IACd,iDAAQ,CAAA;IACR,yCAAI,CAAA;IACJ,qDAAU,CAAA;IACV,0CAAI,CAAA;IACJ,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,8CAAM,CAAA;IACN,4DAAa,CAAA;IACb,0DAAY,CAAA;IACZ,wEAAmB,CAAA;IACnB,0CAAI,CAAA;IACJ,8CAAM,CAAA;IACN,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,kDAAQ,CAAA;IACR,8DAAc,CAAA;IACd,8CAAM,CAAA;IACN,sDAAU,CAAA;AACZ,CAAC,EA1BW,SAAS,KAAT,SAAS,QA0BpB;AAwJD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B","sourcesContent":["import { FormControl, ValidatorFn } from '@angular/forms';\nimport { Color } from '@ionic/core';\nimport { ImageMetadata } from './atoms/image/types';\n\n/**\n * Possible states for an interactive component.\n */\nexport type ComponentState = 'ENABLED' | 'DISABLED' | 'WORKING' | 'ERROR';\nconst ENABLED: ComponentState = 'ENABLED';\nconst DISABLED: ComponentState = 'DISABLED';\nconst WORKING: ComponentState = 'WORKING';\nconst ERROR: ComponentState = 'ERROR';\n\n/**\n * Object containing all possible component states.\n */\nexport const ComponentStates = { ENABLED, DISABLED, WORKING, ERROR };\n\n/**\n * Types of actions that a button or link can perform.\n */\nexport enum ActionType {\n  BROWSER_NEW_TAB, // Open in a new browser tab\n  BROWSER_DOWNLOAD, // Download via browser\n  NATIVE_DOWNLOAD, // Download using native capabilities\n  APP_NAVIGATION, // Internal app navigation\n  BROWSER_NAVIGATION, // Navigation in the browser\n}\n\n/**\n * Represents an executable action for a button or link.\n */\nexport type Action = {\n  /** Action description */\n  description: string;\n  /** Action type */\n  type: ActionType;\n  /** Action source or destination */\n  source: string;\n};\n\n/**\n * Supported input types for forms.\n */\nexport enum InputType {\n  TEXT,\n  TEXTAREA,\n  EMAIL,\n  PASSWORD,\n  COMMENT,\n  NUMBER,\n  NUMBER_FROM_TO,\n  PIN_CODE,\n  DATE,\n  DATE_RANGE,\n  HOUR,\n  CHECK,\n  RADIO,\n  SELECT,\n  SEARCH_SELECT,\n  MULTI_SELECT,\n  MULTI_SELECT_SIMPLE,\n  FILE,\n  TOGGLE,\n  RANGE,\n  PHONE,\n  CURRENCY,\n  CHECKBOX_RADIO,\n  HANDLE,\n  ATTACHMENT,\n}\n\n/**\n * Option for select, radio, etc. inputs.\n */\nexport type InputOption = {\n  /** Unique option identifier */\n  id: string;\n  /** Display name */\n  name: string;\n  /** Whether the option is selected by default */\n  selected?: boolean;\n  /** Display order */\n  order: number;\n};\n\n/**\n * Metadata for a form field.\n */\nexport type InputMetadata = {\n  /** Associated form control (optional, created internally by val-form) */\n  control?: FormControl;\n  /** From control (only for NUMBER_FROM_TO type) */\n  fromControl?: FormControl;\n  /** To control (only for NUMBER_FROM_TO type) */\n  toControl?: FormControl;\n  /** Unique token for the input */\n  token: string;\n  /** Display label */\n  label: string;\n  /** Field name */\n  name: string;\n  /** Help text (shown below input, for validation hints) */\n  hint: string;\n  /** Description text (shown below label, explains the field purpose) */\n  description?: string;\n  /** Input placeholder */\n  placeholder: string;\n  /** Input type */\n  type: InputType;\n  /** Display order */\n  order: number;\n  /** Associated validators */\n  validators: ValidatorFn[];\n  /** Options (for select, radio, etc.) */\n  options?: InputOption[];\n  /** Allowed range (for number, date, etc.) */\n  range?: {\n    min: number;\n    max: number;\n  };\n  /** Custom error messages */\n  errors: {\n    [key: string]: string;\n  };\n  /** Initial value for the field */\n  value?: string;\n  /** Default value configuration - string for custom defaults, true for auto defaults */\n  withDefault?: string | boolean;\n  /** Field state */\n  state: ComponentState;\n  /** Label for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromLabel?: string;\n  /** Label for \"to\" field (only for NUMBER_FROM_TO type) */\n  toLabel?: string;\n  /** Placeholder for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromPlaceholder?: string;\n  /** Placeholder for \"to\" field (only for NUMBER_FROM_TO type) */\n  toPlaceholder?: string;\n\n  // i18n support properties\n  /** Key for content lookup */\n  contentKey?: string;\n  /** Component class name for content lookup */\n  contentClass?: string;\n  /** Fallback text if content key is not found */\n  contentFallback?: string;\n\n  // select-input specific i18n properties\n  /** Custom header text for select modal */\n  modalHeader?: string;\n  /** Custom cancel button text for select modal */\n  cancelText?: string;\n  /** Custom OK button text for select modal */\n  okText?: string;\n  /** Interface del ion-select (default: 'popover'). 'modal' para listas largas. */\n  selectInterface?: 'popover' | 'modal' | 'action-sheet' | 'alert';\n\n  // check-input specific properties\n  /** Position of label for checkbox ('start' | 'end') */\n  labelPlacement?: 'start' | 'end';\n\n  // PIN_CODE specific properties\n  /** Number of digits in PIN (default: 5, only for PIN_CODE type) */\n  length?: number;\n  /** Size of the input boxes: 'small' | 'medium' | 'large' (default: 'medium', only for PIN_CODE type) */\n  size?: 'small' | 'medium' | 'large';\n  /** Allow only numbers (default: true, only for PIN_CODE type) */\n  allowNumbersOnly?: boolean;\n  /** Mask input - show dots instead of characters (only for PIN_CODE type) */\n  mask?: boolean;\n  /** Auto focus first input (only for PIN_CODE type) */\n  autoFocus?: boolean;\n  /** Custom input styles (only for PIN_CODE type) */\n  inputStyles?: Record<string, string>;\n\n  /** Upload function (only for ATTACHMENT type). Receives a File, must resolve to the uploaded URL. */\n  uploadFn?: (file: File) => Promise<string>;\n};\n\n/**\n * A section in a form, grouping multiple fields.\n */\nexport type FormSection = {\n  /** Section name */\n  name: string;\n  /** Display order */\n  order: number;\n  /** Fields included in the section */\n  fields: InputMetadata[];\n};\n\n/**\n * Data sent when submitting a form.\n */\nexport type FormSubmit = {\n  /** Form field values as key-value pairs */\n  fields: Record<string, any>;\n  /** Optional token for the operation */\n  token?: string;\n};\n\n/**\n * Metadata for a complete form.\n */\nexport type FormMetadata = {\n  /** Form name */\n  name: string;\n  /** Form sections */\n  sections: FormSection[];\n  /** Action buttons configuration */\n  actions: ButtonMetadata;\n  /** Global form state */\n  state: ComponentState;\n  /**\n   * Espacio vertical entre campos, en px. Si se omite, usa el default\n   * responsivo de la lib (8px mobile / 12px desktop). Útil para formularios\n   * densos o más aireados sin tocar CSS del consumer.\n   */\n  fieldSpacing?: number;\n};\n\n/**\n * Possible action types for a toolbar.\n */\nexport enum ToolbarActionType {\n  AVATAR = 'AVATAR',\n  ICON = 'ICON',\n  IMAGE = 'IMAGE',\n  BUTTON = 'BUTTON',\n}\n\n/**\n * Toolbar action definition.\n */\nexport type ToolbarAction = {\n  /** Action type */\n  type: 'AVATAR' | 'ICON' | 'IMAGE' | 'BUTTON';\n  /** Optional token identifier */\n  token?: string;\n  /** Toolbar position */\n  position: 'left' | 'right' | 'center';\n  /** Optional description */\n  description?: string;\n  /** Associated image (if any) */\n  image?: ImageMetadata;\n  /**\n   * User shape para el modo `AVATAR` — habilita fallback inteligente:\n   * foto → iniciales (de `name`/`email`) → icono persona. Si se omite, el\n   * toolbar solo muestra la imagen pasada en `description`.\n   */\n  user?: { name?: string; email?: string; avatarUrl?: string; handle?: string } | null;\n  /** Controls avatar size when type is AVATAR. Defaults to 'small'. */\n  avatarSize?: 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';\n};\n\n/**\n * Metadata for an icon.\n */\nexport interface IconMetada {\n  /** Icon name */\n  name: string;\n  /** Icon slot position */\n  slot: 'start' | 'end';\n}\n\n/**\n * Button configuration object.\n * Supports both static and reactive content.\n * @type {ButtonMetadata}\n * @property text - Static button label (takes precedence over textConfig).\n * @property textConfig - Reactive content configuration for button text.\n * @property color - The button color (Ionic color string).\n * @property icon - Icon to display (optional).\n * @property state - Button state (enabled, disabled, working, etc.).\n * @property expand, fill, size, shape, href, target, download, handler, etc. - See ButtonMetadata for all options.\n */\nexport interface ButtonMetadata {\n  /** Associated action type */\n  actionType?: ActionType;\n  /** Button expansion */\n  expand?: 'full' | 'block';\n  /** Associated link */\n  link?: string;\n  /** Associated href link */\n  href?: string;\n  /** Link target */\n  target?: '_blank' | '_self' | '_parent' | '_top';\n  /** Download file name */\n  download?: string;\n  /** Button color */\n  color: Color;\n  /** Button state */\n  state: ComponentState;\n  /** Static display text (takes precedence over reactive content) */\n  text?: string;\n  /** Reactive content configuration for button text */\n  contentKey?: string;\n  /** Component class name for content lookup (required with contentKey) */\n  contentClass?: string;\n  /** Fallback text if contentKey is not found */\n  contentFallback?: string;\n  /** Values to interpolate into the content string */\n  contentInterpolation?: Record<string, string | number>;\n  /** Associated icon */\n  icon?: IconMetada;\n  /** Button shape */\n  shape?: 'round';\n  /** Button size */\n  size?: 'small' | 'default' | 'large';\n  /** Button fill */\n  fill?: 'clear' | 'outline' | 'solid' | 'default';\n  /** Button type */\n  type: 'button' | 'submit' | 'reset';\n  /** Optional token identifier */\n  token?: string;\n  /** Optional reference */\n  ref?: any;\n  /** Action handler */\n  handler?: (value: any) => any | Promise<any>;\n}\n\n/**\n * Configuration for reactive content in val-button component.\n * Use this interface when you only need to specify content-related properties.\n * This follows the same pattern as TextContentConfig for consistency.\n */\nexport interface ButtonContentConfig {\n  contentKey: string;\n  contentClass: string;\n  contentFallback?: string;\n  contentInterpolation?: Record<string, string | number>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/components/types.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,QAAQ,GAAmB,UAAU,CAAC;AAC5C,MAAM,OAAO,GAAmB,SAAS,CAAC;AAC1C,MAAM,KAAK,GAAmB,OAAO,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,CAAN,IAAY,UAMX;AAND,WAAY,UAAU;IACpB,iEAAe,CAAA;IACf,mEAAgB,CAAA;IAChB,iEAAe,CAAA;IACf,+DAAc,CAAA;IACd,uEAAkB,CAAA;AACpB,CAAC,EANW,UAAU,KAAV,UAAU,QAMrB;AAcD;;GAEG;AACH,MAAM,CAAN,IAAY,SA0BX;AA1BD,WAAY,SAAS;IACnB,yCAAI,CAAA;IACJ,iDAAQ,CAAA;IACR,2CAAK,CAAA;IACL,iDAAQ,CAAA;IACR,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6DAAc,CAAA;IACd,iDAAQ,CAAA;IACR,yCAAI,CAAA;IACJ,qDAAU,CAAA;IACV,0CAAI,CAAA;IACJ,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,8CAAM,CAAA;IACN,4DAAa,CAAA;IACb,0DAAY,CAAA;IACZ,wEAAmB,CAAA;IACnB,0CAAI,CAAA;IACJ,8CAAM,CAAA;IACN,4CAAK,CAAA;IACL,4CAAK,CAAA;IACL,kDAAQ,CAAA;IACR,8DAAc,CAAA;IACd,8CAAM,CAAA;IACN,sDAAU,CAAA;AACZ,CAAC,EA1BW,SAAS,KAAT,SAAS,QA0BpB;AAsKD;;GAEG;AACH,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,kCAAa,CAAA;IACb,oCAAe,CAAA;IACf,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B","sourcesContent":["import { FormControl, ValidatorFn } from '@angular/forms';\nimport { Color } from '@ionic/core';\nimport { ImageMetadata } from './atoms/image/types';\n\n/**\n * Possible states for an interactive component.\n */\nexport type ComponentState = 'ENABLED' | 'DISABLED' | 'WORKING' | 'ERROR';\nconst ENABLED: ComponentState = 'ENABLED';\nconst DISABLED: ComponentState = 'DISABLED';\nconst WORKING: ComponentState = 'WORKING';\nconst ERROR: ComponentState = 'ERROR';\n\n/**\n * Object containing all possible component states.\n */\nexport const ComponentStates = { ENABLED, DISABLED, WORKING, ERROR };\n\n/**\n * Types of actions that a button or link can perform.\n */\nexport enum ActionType {\n  BROWSER_NEW_TAB, // Open in a new browser tab\n  BROWSER_DOWNLOAD, // Download via browser\n  NATIVE_DOWNLOAD, // Download using native capabilities\n  APP_NAVIGATION, // Internal app navigation\n  BROWSER_NAVIGATION, // Navigation in the browser\n}\n\n/**\n * Represents an executable action for a button or link.\n */\nexport type Action = {\n  /** Action description */\n  description: string;\n  /** Action type */\n  type: ActionType;\n  /** Action source or destination */\n  source: string;\n};\n\n/**\n * Supported input types for forms.\n */\nexport enum InputType {\n  TEXT,\n  TEXTAREA,\n  EMAIL,\n  PASSWORD,\n  COMMENT,\n  NUMBER,\n  NUMBER_FROM_TO,\n  PIN_CODE,\n  DATE,\n  DATE_RANGE,\n  HOUR,\n  CHECK,\n  RADIO,\n  SELECT,\n  SEARCH_SELECT,\n  MULTI_SELECT,\n  MULTI_SELECT_SIMPLE,\n  FILE,\n  TOGGLE,\n  RANGE,\n  PHONE,\n  CURRENCY,\n  CHECKBOX_RADIO,\n  HANDLE,\n  ATTACHMENT,\n}\n\n/**\n * Option for select, radio, etc. inputs.\n */\nexport type InputOption = {\n  /** Unique option identifier */\n  id: string;\n  /** Display name */\n  name: string;\n  /** Whether the option is selected by default */\n  selected?: boolean;\n  /** Display order */\n  order: number;\n};\n\n/**\n * Metadata for a form field.\n */\nexport type InputMetadata = {\n  /** Associated form control (optional, created internally by val-form) */\n  control?: FormControl;\n  /** From control (only for NUMBER_FROM_TO type) */\n  fromControl?: FormControl;\n  /** To control (only for NUMBER_FROM_TO type) */\n  toControl?: FormControl;\n  /** Unique token for the input */\n  token: string;\n  /** Display label */\n  label: string;\n  /** Field name */\n  name: string;\n  /** Help text (shown below input, for validation hints) */\n  hint: string;\n  /** Description text (shown below label, explains the field purpose) */\n  description?: string;\n  /** Input placeholder */\n  placeholder: string;\n  /** Input type */\n  type: InputType;\n  /** Display order */\n  order: number;\n  /** Associated validators */\n  validators: ValidatorFn[];\n  /** Options (for select, radio, etc.) */\n  options?: InputOption[];\n  /** Allowed range (for number, date, etc.) */\n  range?: {\n    min: number;\n    max: number;\n  };\n  /** Custom error messages */\n  errors: {\n    [key: string]: string;\n  };\n  /** Initial value for the field */\n  value?: string;\n  /** Default value configuration - string for custom defaults, true for auto defaults */\n  withDefault?: string | boolean;\n  /** Field state */\n  state: ComponentState;\n  /** Label for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromLabel?: string;\n  /** Label for \"to\" field (only for NUMBER_FROM_TO type) */\n  toLabel?: string;\n  /** Placeholder for \"from\" field (only for NUMBER_FROM_TO type) */\n  fromPlaceholder?: string;\n  /** Placeholder for \"to\" field (only for NUMBER_FROM_TO type) */\n  toPlaceholder?: string;\n\n  // i18n support properties\n  /** Key for content lookup */\n  contentKey?: string;\n  /** Component class name for content lookup */\n  contentClass?: string;\n  /** Fallback text if content key is not found */\n  contentFallback?: string;\n\n  // select-input specific i18n properties\n  /** Custom header text for select modal */\n  modalHeader?: string;\n  /** Custom cancel button text for select modal */\n  cancelText?: string;\n  /** Custom OK button text for select modal */\n  okText?: string;\n  /** Interface del ion-select (default: 'popover'). 'modal' para listas largas. */\n  selectInterface?: 'popover' | 'modal' | 'action-sheet' | 'alert';\n\n  // check-input specific properties\n  /** Position of label for checkbox ('start' | 'end') */\n  labelPlacement?: 'start' | 'end';\n\n  // PIN_CODE specific properties\n  /** Number of digits in PIN (default: 5, only for PIN_CODE type) */\n  length?: number;\n  /** Size of the input boxes: 'small' | 'medium' | 'large' (default: 'medium', only for PIN_CODE type) */\n  size?: 'small' | 'medium' | 'large';\n  /** Allow only numbers (default: true, only for PIN_CODE type) */\n  allowNumbersOnly?: boolean;\n  /** Mask input - show dots instead of characters (only for PIN_CODE type) */\n  mask?: boolean;\n  /** Auto focus first input (only for PIN_CODE type) */\n  autoFocus?: boolean;\n  /** Custom input styles (only for PIN_CODE type) */\n  inputStyles?: Record<string, string>;\n\n  /** Upload function (only for ATTACHMENT type). Receives a File, must resolve to the uploaded URL. */\n  uploadFn?: (file: File) => Promise<string>;\n};\n\n/**\n * A section in a form, grouping multiple fields.\n */\nexport type FormSection = {\n  /** Section name */\n  name: string;\n  /** Display order */\n  order: number;\n  /** Fields included in the section */\n  fields: InputMetadata[];\n};\n\n/**\n * Data sent when submitting a form.\n */\nexport type FormSubmit = {\n  /** Form field values as key-value pairs */\n  fields: Record<string, any>;\n  /** Optional token for the operation */\n  token?: string;\n};\n\n/**\n * Metadata for a complete form.\n */\nexport type FormMetadata = {\n  /** Form name */\n  name: string;\n  /** Form sections */\n  sections: FormSection[];\n  /** Action buttons configuration */\n  actions: ButtonMetadata;\n  /** Global form state */\n  state: ComponentState;\n  /**\n   * Espacio vertical entre campos, en px. Si se omite, usa el default\n   * responsivo de la lib (8px mobile / 12px desktop). Útil para formularios\n   * densos o más aireados sin tocar CSS del consumer.\n   */\n  fieldSpacing?: number;\n  /**\n   * Modo embebido: el form NO renderiza su button-group/footer de submit.\n   * Solo campos + validación. Para wizards/hosts que controlan la navegación\n   * y leen el estado del form vía `@ViewChild(FormComponent)` (signals públicos\n   * `value`/`valid` + método `validate()`/`markAllTouched()`).\n   * Cuando es `true`, ignora `stickyFooter`.\n   */\n  controlled?: boolean;\n  /**\n   * Fija el button-group de submit al fondo (`position: sticky; bottom: 0`)\n   * para modales largos con scroll. Solo aplica si NO es `controlled`.\n   * Por defecto (sin flags) el submit es inline al final del form.\n   */\n  stickyFooter?: boolean;\n};\n\n/**\n * Possible action types for a toolbar.\n */\nexport enum ToolbarActionType {\n  AVATAR = 'AVATAR',\n  ICON = 'ICON',\n  IMAGE = 'IMAGE',\n  BUTTON = 'BUTTON',\n}\n\n/**\n * Toolbar action definition.\n */\nexport type ToolbarAction = {\n  /** Action type */\n  type: 'AVATAR' | 'ICON' | 'IMAGE' | 'BUTTON';\n  /** Optional token identifier */\n  token?: string;\n  /** Toolbar position */\n  position: 'left' | 'right' | 'center';\n  /** Optional description */\n  description?: string;\n  /** Associated image (if any) */\n  image?: ImageMetadata;\n  /**\n   * User shape para el modo `AVATAR` — habilita fallback inteligente:\n   * foto → iniciales (de `name`/`email`) → icono persona. Si se omite, el\n   * toolbar solo muestra la imagen pasada en `description`.\n   */\n  user?: { name?: string; email?: string; avatarUrl?: string; handle?: string } | null;\n  /** Controls avatar size when type is AVATAR. Defaults to 'small'. */\n  avatarSize?: 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';\n};\n\n/**\n * Metadata for an icon.\n */\nexport interface IconMetada {\n  /** Icon name */\n  name: string;\n  /** Icon slot position */\n  slot: 'start' | 'end';\n}\n\n/**\n * Button configuration object.\n * Supports both static and reactive content.\n * @type {ButtonMetadata}\n * @property text - Static button label (takes precedence over textConfig).\n * @property textConfig - Reactive content configuration for button text.\n * @property color - The button color (Ionic color string).\n * @property icon - Icon to display (optional).\n * @property state - Button state (enabled, disabled, working, etc.).\n * @property expand, fill, size, shape, href, target, download, handler, etc. - See ButtonMetadata for all options.\n */\nexport interface ButtonMetadata {\n  /** Associated action type */\n  actionType?: ActionType;\n  /** Button expansion */\n  expand?: 'full' | 'block';\n  /** Associated link */\n  link?: string;\n  /** Associated href link */\n  href?: string;\n  /** Link target */\n  target?: '_blank' | '_self' | '_parent' | '_top';\n  /** Download file name */\n  download?: string;\n  /** Button color */\n  color: Color;\n  /** Button state */\n  state: ComponentState;\n  /** Static display text (takes precedence over reactive content) */\n  text?: string;\n  /** Reactive content configuration for button text */\n  contentKey?: string;\n  /** Component class name for content lookup (required with contentKey) */\n  contentClass?: string;\n  /** Fallback text if contentKey is not found */\n  contentFallback?: string;\n  /** Values to interpolate into the content string */\n  contentInterpolation?: Record<string, string | number>;\n  /** Associated icon */\n  icon?: IconMetada;\n  /** Button shape */\n  shape?: 'round';\n  /** Button size */\n  size?: 'small' | 'default' | 'large';\n  /** Button fill */\n  fill?: 'clear' | 'outline' | 'solid' | 'default';\n  /** Button type */\n  type: 'button' | 'submit' | 'reset';\n  /** Optional token identifier */\n  token?: string;\n  /** Optional reference */\n  ref?: any;\n  /** Action handler */\n  handler?: (value: any) => any | Promise<any>;\n}\n\n/**\n * Configuration for reactive content in val-button component.\n * Use this interface when you only need to specify content-related properties.\n * This follows the same pattern as TextContentConfig for consistency.\n */\nexport interface ButtonContentConfig {\n  contentKey: string;\n  contentClass: string;\n  contentFallback?: string;\n  contentInterpolation?: Record<string, string | number>;\n}\n"]}

package/esm2022/lib/version.mjs

@@ -2,5 +2,5 @@
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-export const VERSION = '2.0.971';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45NzEnO1xuIl19
+export const VERSION = '2.0.972';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45NzInO1xuIl19