valtech-components 2.0.974 → 2.0.975

package/esm2022/lib/components/organisms/settings-hub/settings-hub.component.mjs

@@ -0,0 +1,152 @@
+import { Component, computed, inject, Input } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { IonCol, IonGrid, IonRow } from '@ionic/angular/standalone';
+import { ActionCardComponent } from '../../molecules/action-card/action-card.component';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { I18nService } from '../../../services/i18n';
+import { NavigationService } from '../../../services/navigation/navigation.service';
+import { buildSettingsCards } from './settings-sections';
+import { SETTINGS_HUB_LABELS_I18N, SETTINGS_HUB_PAGE_I18N } from './settings-hub.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_LABELS_NS = 'Dashboard';
+const DEFAULT_PAGE_NS = 'Settings.Preferences';
+/**
+ * `val-settings-hub` — portada de la sección Settings (organism). Renderiza un
+ * header (título + descripción) + un grid de `val-action-card` que navega a las
+ * sub-vistas. Promovido desde `showcase` (`pages/settings/pages/preferences`)
+ * bajo el proceso de ADR-021.
+ *
+ * Las cards salen de `buildSettingsCards` sobre el catálogo default
+ * (`SETTINGS_SECTIONS_CATALOG`), filtrado/extendido/reordenado por la config.
+ *
+ * Navegación: cards con `routerLink` navegan vía `Router`; la card de logout
+ * (sin ruta) invoca `config.onLogout`. Cada click emite `config.onSectionClick`.
+ *
+ * NO renderiza ion-content — vive dentro de val-page-wrapper.
+ *
+ * Auto-registra sus dos sets de defaults i18n (labels + header) en sus
+ * respectivos namespaces si el consumer no los proveyó.
+ */
+export class SettingsHubComponent {
+    get labelsNs() {
+        return this.resolvedConfig().i18nNamespace;
+    }
+    get pageNs() {
+        return this.resolvedConfig().pageI18nNamespace;
+    }
+    constructor() {
+        this.nav = inject(NavigationService);
+        this.i18n = inject(I18nService);
+        this.router = inject(Router);
+        this.route = inject(ActivatedRoute, { optional: true });
+        this.resolvedConfig = computed(() => {
+            const fromRoute = (this.route?.snapshot.data['settingsHubConfig'] ?? {});
+            const merged = { ...fromRoute, ...(this.config ?? {}) };
+            return {
+                ...merged,
+                i18nNamespace: merged.i18nNamespace ?? DEFAULT_LABELS_NS,
+                pageI18nNamespace: merged.pageI18nNamespace ?? DEFAULT_PAGE_NS,
+            };
+        });
+        this.pageTitle = computed(() => {
+            this.i18n.lang();
+            return this.i18n.t('pageTitle', this.pageNs);
+        });
+        this.pageDescription = computed(() => {
+            this.i18n.lang();
+            return this.i18n.t('pageDescription', this.pageNs);
+        });
+        /** Cards del HUB, resueltas desde la config. */
+        this.actionCards = computed(() => {
+            this.i18n.lang();
+            const cfg = this.resolvedConfig();
+            return buildSettingsCards(k => this.i18n.t(k, cfg.i18nNamespace), {
+                exclude: cfg.exclude,
+                include: cfg.include,
+                order: cfg.order,
+                includeLogout: cfg.includeLogout,
+                basePath: cfg.basePath,
+            });
+        });
+        // Auto-registro i18n — respeta override del consumer. Los namespaces pueden
+        // venir de @Input.config o del route data; los resolvemos acá.
+        const labelsNs = this.labelsNs;
+        if (!this.i18n.hasNamespace(labelsNs)) {
+            this.i18n.registerContent(labelsNs, SETTINGS_HUB_LABELS_I18N);
+        }
+        const pageNs = this.pageNs;
+        if (!this.i18n.hasNamespace(pageNs)) {
+            this.i18n.registerContent(pageNs, SETTINGS_HUB_PAGE_I18N);
+        }
+        this.nav.setBackHeader('pageTitle', pageNs, { withMenu: true });
+    }
+    onActionClick(action) {
+        const token = action.token;
+        this.resolvedConfig().onSectionClick?.(token ?? '');
+        if (token === 'action-logout') {
+            this.resolvedConfig().onLogout?.();
+            return;
+        }
+        if (action.routerLink) {
+            this.router.navigate(Array.isArray(action.routerLink) ? action.routerLink : [action.routerLink]);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SettingsHubComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SettingsHubComponent, isStandalone: true, selector: "val-settings-hub", 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>
+
+      <ion-grid class="cards-grid">
+        <ion-row>
+          @for (action of actionCards(); track action.token) {
+            <ion-col size="12" size-sm="6">
+              <val-action-card [props]="action" (onClick)="onActionClick(action)" />
+            </ion-col>
+          }
+        </ion-row>
+      </ion-grid>
+    </div>
+  `, isInline: true, styles: [".page{padding:16px 0;max-width:720px;margin:0 auto}.page-header{margin-bottom:16px}.cards-grid{margin:0 -4px;padding:0}.cards-grid ion-col{padding:4px}\n"], dependencies: [{ kind: "component", type: IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { kind: "component", type: IonRow, selector: "ion-row" }, { kind: "component", type: IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { kind: "component", type: ActionCardComponent, selector: "val-action-card", inputs: ["props"], outputs: ["onClick"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SettingsHubComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-settings-hub', standalone: true, imports: [IonGrid, IonRow, IonCol, ActionCardComponent, DisplayComponent, TitleComponent], 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>
+
+      <ion-grid class="cards-grid">
+        <ion-row>
+          @for (action of actionCards(); track action.token) {
+            <ion-col size="12" size-sm="6">
+              <val-action-card [props]="action" (onClick)="onActionClick(action)" />
+            </ion-col>
+          }
+        </ion-row>
+      </ion-grid>
+    </div>
+  `, styles: [".page{padding:16px 0;max-width:720px;margin:0 auto}.page-header{margin-bottom:16px}.cards-grid{margin:0 -4px;padding:0}.cards-grid ion-col{padding:4px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings-hub.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/settings-hub/settings-hub.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { IonCol, IonGrid, IonRow } from '@ionic/angular/standalone';\n\nimport { ActionCardComponent } from '../../molecules/action-card/action-card.component';\nimport { ActionCardMetadata } from '../../molecules/action-card/types';\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\n\nimport { I18nService } from '../../../services/i18n';\nimport { NavigationService } from '../../../services/navigation/navigation.service';\n\nimport { SettingsHubConfig } from './types';\nimport { buildSettingsCards } from './settings-sections';\nimport { SETTINGS_HUB_LABELS_I18N, SETTINGS_HUB_PAGE_I18N } from './settings-hub.i18n';\n\nconst DEFAULT_LABELS_NS = 'Dashboard';\nconst DEFAULT_PAGE_NS = 'Settings.Preferences';\n\n/**\n * `val-settings-hub` — portada de la sección Settings (organism). Renderiza un\n * header (título + descripción) + un grid de `val-action-card` que navega a las\n * sub-vistas. Promovido desde `showcase` (`pages/settings/pages/preferences`)\n * bajo el proceso de ADR-021.\n *\n * Las cards salen de `buildSettingsCards` sobre el catálogo default\n * (`SETTINGS_SECTIONS_CATALOG`), filtrado/extendido/reordenado por la config.\n *\n * Navegación: cards con `routerLink` navegan vía `Router`; la card de logout\n * (sin ruta) invoca `config.onLogout`. Cada click emite `config.onSectionClick`.\n *\n * NO renderiza ion-content — vive dentro de val-page-wrapper.\n *\n * Auto-registra sus dos sets de defaults i18n (labels + header) en sus\n * respectivos namespaces si el consumer no los proveyó.\n */\n@Component({\n  selector: 'val-settings-hub',\n  standalone: true,\n  imports: [IonGrid, IonRow, IonCol, ActionCardComponent, DisplayComponent, TitleComponent],\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      <ion-grid class=\"cards-grid\">\n        <ion-row>\n          @for (action of actionCards(); track action.token) {\n            <ion-col size=\"12\" size-sm=\"6\">\n              <val-action-card [props]=\"action\" (onClick)=\"onActionClick(action)\" />\n            </ion-col>\n          }\n        </ion-row>\n      </ion-grid>\n    </div>\n  `,\n  styles: [\n    `\n      .page {\n        padding: 16px 0;\n        max-width: 720px;\n        margin: 0 auto;\n      }\n      .page-header {\n        margin-bottom: 16px;\n      }\n      .cards-grid {\n        margin: 0 -4px;\n        padding: 0;\n      }\n      .cards-grid ion-col {\n        padding: 4px;\n      }\n    `,\n  ],\n})\nexport class SettingsHubComponent {\n  private nav = inject(NavigationService);\n  private i18n = inject(I18nService);\n  private router = inject(Router);\n  private route = inject(ActivatedRoute, { optional: true });\n\n  /**\n   * Config vía @Input (object-first). Si no se pasa, cae al route data\n   * `settingsHubConfig` (poblado por `provideValtechSettingsRoutes`).\n   * `resolvedConfig` mergea con defaults — @Input gana sobre route data.\n   */\n  @Input() config?: SettingsHubConfig;\n\n  readonly resolvedConfig = computed<\n    Required<Pick<SettingsHubConfig, 'i18nNamespace' | 'pageI18nNamespace'>> & SettingsHubConfig\n  >(() => {\n    const fromRoute = (this.route?.snapshot.data['settingsHubConfig'] ?? {}) as SettingsHubConfig;\n    const merged: SettingsHubConfig = { ...fromRoute, ...(this.config ?? {}) };\n    return {\n      ...merged,\n      i18nNamespace: merged.i18nNamespace ?? DEFAULT_LABELS_NS,\n      pageI18nNamespace: merged.pageI18nNamespace ?? DEFAULT_PAGE_NS,\n    };\n  });\n\n  private get labelsNs(): string {\n    return this.resolvedConfig().i18nNamespace;\n  }\n  private get pageNs(): string {\n    return this.resolvedConfig().pageI18nNamespace;\n  }\n\n  readonly pageTitle = computed(() => {\n    this.i18n.lang();\n    return this.i18n.t('pageTitle', this.pageNs);\n  });\n  readonly pageDescription = computed(() => {\n    this.i18n.lang();\n    return this.i18n.t('pageDescription', this.pageNs);\n  });\n\n  /** Cards del HUB, resueltas desde la config. */\n  readonly actionCards = computed<ActionCardMetadata[]>(() => {\n    this.i18n.lang();\n    const cfg = this.resolvedConfig();\n    return buildSettingsCards(k => this.i18n.t(k, cfg.i18nNamespace), {\n      exclude: cfg.exclude,\n      include: cfg.include,\n      order: cfg.order,\n      includeLogout: cfg.includeLogout,\n      basePath: cfg.basePath,\n    });\n  });\n\n  constructor() {\n    // Auto-registro i18n — respeta override del consumer. Los namespaces pueden\n    // venir de @Input.config o del route data; los resolvemos acá.\n    const labelsNs = this.labelsNs;\n    if (!this.i18n.hasNamespace(labelsNs)) {\n      this.i18n.registerContent(labelsNs, SETTINGS_HUB_LABELS_I18N);\n    }\n    const pageNs = this.pageNs;\n    if (!this.i18n.hasNamespace(pageNs)) {\n      this.i18n.registerContent(pageNs, SETTINGS_HUB_PAGE_I18N);\n    }\n\n    this.nav.setBackHeader('pageTitle', pageNs, { withMenu: true });\n  }\n\n  onActionClick(action: ActionCardMetadata): void {\n    const token = action.token;\n    this.resolvedConfig().onSectionClick?.(token ?? '');\n    if (token === 'action-logout') {\n      this.resolvedConfig().onLogout?.();\n      return;\n    }\n    if (action.routerLink) {\n      this.router.navigate(Array.isArray(action.routerLink) ? action.routerLink : [action.routerLink]);\n    }\n  }\n}\n"]}

package/esm2022/lib/components/organisms/settings-hub/settings-hub.i18n.mjs

@@ -0,0 +1,57 @@
+/**
+ * Defaults i18n embebidos en `val-settings-hub`. Dos sets, uno por namespace
+ * (ver `SettingsHubConfig.i18nNamespace` / `.pageI18nNamespace`). Auto-registrados
+ * en el constructor SOLO si el namespace no existe (respeta override del consumer).
+ *
+ * `SETTINGS_HUB_LABELS_I18N` — labels de cada sección (namespace `Dashboard` por
+ * default). Mismo set que showcase mantiene en `src/i18n/index.ts` (queda como
+ * override). `SETTINGS_HUB_PAGE_I18N` — header del HUB (namespace
+ * `Settings.Preferences` por default), tomado de la page Preferencias original.
+ */
+export const SETTINGS_HUB_LABELS_I18N = {
+    es: {
+        general: 'General',
+        generalDesc: 'Apariencia e idioma',
+        account: 'Cuenta',
+        accountDesc: 'Organizaciones y sesión',
+        editProfile: 'Editar perfil',
+        editProfileDesc: 'Actualiza tu información personal',
+        preferences: 'Preferencias',
+        preferencesDesc: 'Tema, idioma y otras opciones',
+        notifications: 'Notificaciones',
+        notificationsDesc: 'Configura tus preferencias',
+        security: 'Seguridad',
+        securityDesc: 'Gestiona contraseñas y MFA',
+        about: 'Acerca de',
+        aboutDesc: 'Versión, feedback y enlaces útiles',
+        logout: 'Cerrar sesión',
+    },
+    en: {
+        general: 'General',
+        generalDesc: 'Appearance and language',
+        account: 'Account',
+        accountDesc: 'Organizations and session',
+        editProfile: 'Edit profile',
+        editProfileDesc: 'Update your personal information',
+        preferences: 'Preferences',
+        preferencesDesc: 'Theme, language and other options',
+        notifications: 'Notifications',
+        notificationsDesc: 'Configure your preferences',
+        security: 'Security',
+        securityDesc: 'Manage passwords and MFA',
+        about: 'About',
+        aboutDesc: 'Version, feedback and useful links',
+        logout: 'Sign out',
+    },
+};
+export const SETTINGS_HUB_PAGE_I18N = {
+    es: {
+        pageTitle: 'Preferencias',
+        pageDescription: 'Ajusta tu cuenta y la app',
+    },
+    en: {
+        pageTitle: 'Preferences',
+        pageDescription: 'Tune your account and the app',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/settings-hub/settings-sections.mjs

@@ -0,0 +1,137 @@
+/**
+ * Catálogo default de secciones del HUB de settings (8 entradas). `logout` va
+ * incluida pero sin `routerLink` (la maneja un callback). Mismo set, mismos
+ * tokens/iconos/rutas que el builder original de showcase
+ * (`shared/settings-action-cards.ts`) que esta promoción reemplaza.
+ */
+export const SETTINGS_SECTIONS_CATALOG = [
+    {
+        token: 'action-general',
+        titleKey: 'general',
+        descKey: 'generalDesc',
+        ionicon: 'options-outline',
+        routerLink: '/app/settings/general',
+        showChevron: true,
+        shadowed: true,
+    },
+    {
+        token: 'action-account',
+        titleKey: 'account',
+        descKey: 'accountDesc',
+        ionicon: 'business-outline',
+        routerLink: '/app/settings/account',
+        showChevron: true,
+        shadowed: true,
+    },
+    {
+        token: 'action-profile',
+        titleKey: 'editProfile',
+        descKey: 'editProfileDesc',
+        ionicon: 'person-outline',
+        routerLink: '/app/settings/profile',
+        showChevron: true,
+        shadowed: true,
+    },
+    {
+        token: 'action-preferences',
+        titleKey: 'preferences',
+        descKey: 'preferencesDesc',
+        ionicon: 'options-outline',
+        routerLink: '/app/settings/preferences',
+        showChevron: true,
+        shadowed: true,
+    },
+    {
+        token: 'action-notifications',
+        titleKey: 'notifications',
+        descKey: 'notificationsDesc',
+        ionicon: 'notifications-outline',
+        routerLink: '/app/settings/notifications',
+        showChevron: true,
+        shadowed: true,
+    },
+    {
+        token: 'action-security',
+        titleKey: 'security',
+        descKey: 'securityDesc',
+        ionicon: 'shield-checkmark-outline',
+        routerLink: '/app/settings/security',
+        showChevron: true,
+        shadowed: true,
+    },
+    {
+        token: 'action-about',
+        titleKey: 'about',
+        descKey: 'aboutDesc',
+        ionicon: 'information-circle-outline',
+        routerLink: '/app/about',
+        showChevron: true,
+        shadowed: true,
+    },
+    {
+        token: 'action-logout',
+        titleKey: 'logout',
+        ionicon: 'log-out-outline',
+        showChevron: false,
+        shadowed: true,
+    },
+];
+const CATALOG_BASE = '/app/settings';
+/**
+ * Construye el grid de cards de navegación del HUB de settings (versión
+ * promovida del `buildSettingsActionCards` de showcase). Usa el catálogo
+ * default + las `include` del consumer, filtra `exclude`, gatea logout por
+ * `includeLogout`, reordena por `order` y reescribe las rutas por `basePath`.
+ *
+ * El `t` resuelve los `titleKey`/`descKey` contra el namespace de labels
+ * (default del componente: `Dashboard`). `logout` NO tiene `routerLink` — el
+ * consumer maneja el flujo de cierre de sesión por token / callback.
+ */
+export function buildSettingsCards(t, options = {}) {
+    const exclude = new Set(options.exclude ?? []);
+    const includeLogout = options.includeLogout ?? false;
+    const basePath = options.basePath;
+    const sections = [...SETTINGS_SECTIONS_CATALOG, ...(options.include ?? [])];
+    let resolved = sections.filter(s => {
+        if (exclude.has(s.token))
+            return false;
+        if (s.token === 'action-logout' && !includeLogout)
+            return false;
+        return true;
+    });
+    if (options.order && options.order.length > 0) {
+        const rank = new Map(options.order.map((token, i) => [token, i]));
+        resolved = [...resolved].sort((a, b) => {
+            const ra = rank.has(a.token) ? rank.get(a.token) : Number.MAX_SAFE_INTEGER;
+            const rb = rank.has(b.token) ? rank.get(b.token) : Number.MAX_SAFE_INTEGER;
+            return ra - rb;
+        });
+    }
+    return resolved.map(s => {
+        const card = {
+            token: s.token,
+            title: t(s.titleKey),
+            icon: {
+                ionicon: s.ionicon,
+                color: 'dark',
+                backgroundColor: 'light',
+            },
+            showChevron: s.showChevron ?? true,
+            shadowed: s.shadowed ?? true,
+        };
+        if (s.descKey)
+            card.description = t(s.descKey);
+        if (s.routerLink) {
+            card.routerLink = basePath ? rewriteBasePath(s.routerLink, basePath) : s.routerLink;
+        }
+        return card;
+    });
+}
+/** Reescribe el prefijo `/app/settings` de una ruta del catálogo por `basePath`. */
+function rewriteBasePath(routerLink, basePath) {
+    if (routerLink.startsWith(CATALOG_BASE)) {
+        return basePath + routerLink.slice(CATALOG_BASE.length);
+    }
+    return routerLink;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settings-sections.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/settings-hub/settings-sections.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActionCardMetadata } from '../../molecules/action-card/types';\n\n/**\n * Modelo de una sección del HUB de settings. Cada sección se proyecta a un\n * `val-action-card` (vía `buildSettingsCards`). El catálogo default\n * (`SETTINGS_SECTIONS_CATALOG`) cubre las secciones estándar del factory;\n * el consumer puede filtrar (`exclude`), reordenar (`order`), reescribir las\n * rutas base (`basePath`) o sumar las suyas (`include`).\n */\nexport interface SettingsSection {\n  /** Identificador estable de la sección (dispatch de click + filtrado). */\n  token: string;\n  /** i18n key del título de la card (resuelto contra el namespace de labels). */\n  titleKey: string;\n  /** i18n key de la descripción (opcional — logout no la tiene). */\n  descKey?: string;\n  /** Ionicon de la card. */\n  ionicon: string;\n  /**\n   * Ruta de navegación. Las secciones bajo `/app/settings` se reescriben si el\n   * consumer pasa `basePath`. `action-logout` no tiene ruta (callback).\n   */\n  routerLink?: string;\n  /** Muestra el chevron a la derecha. Default `true`. */\n  showChevron?: boolean;\n  /** Card con sombra. Default `true`. */\n  shadowed?: boolean;\n}\n\n/**\n * Catálogo default de secciones del HUB de settings (8 entradas). `logout` va\n * incluida pero sin `routerLink` (la maneja un callback). Mismo set, mismos\n * tokens/iconos/rutas que el builder original de showcase\n * (`shared/settings-action-cards.ts`) que esta promoción reemplaza.\n */\nexport const SETTINGS_SECTIONS_CATALOG: SettingsSection[] = [\n  {\n    token: 'action-general',\n    titleKey: 'general',\n    descKey: 'generalDesc',\n    ionicon: 'options-outline',\n    routerLink: '/app/settings/general',\n    showChevron: true,\n    shadowed: true,\n  },\n  {\n    token: 'action-account',\n    titleKey: 'account',\n    descKey: 'accountDesc',\n    ionicon: 'business-outline',\n    routerLink: '/app/settings/account',\n    showChevron: true,\n    shadowed: true,\n  },\n  {\n    token: 'action-profile',\n    titleKey: 'editProfile',\n    descKey: 'editProfileDesc',\n    ionicon: 'person-outline',\n    routerLink: '/app/settings/profile',\n    showChevron: true,\n    shadowed: true,\n  },\n  {\n    token: 'action-preferences',\n    titleKey: 'preferences',\n    descKey: 'preferencesDesc',\n    ionicon: 'options-outline',\n    routerLink: '/app/settings/preferences',\n    showChevron: true,\n    shadowed: true,\n  },\n  {\n    token: 'action-notifications',\n    titleKey: 'notifications',\n    descKey: 'notificationsDesc',\n    ionicon: 'notifications-outline',\n    routerLink: '/app/settings/notifications',\n    showChevron: true,\n    shadowed: true,\n  },\n  {\n    token: 'action-security',\n    titleKey: 'security',\n    descKey: 'securityDesc',\n    ionicon: 'shield-checkmark-outline',\n    routerLink: '/app/settings/security',\n    showChevron: true,\n    shadowed: true,\n  },\n  {\n    token: 'action-about',\n    titleKey: 'about',\n    descKey: 'aboutDesc',\n    ionicon: 'information-circle-outline',\n    routerLink: '/app/about',\n    showChevron: true,\n    shadowed: true,\n  },\n  {\n    token: 'action-logout',\n    titleKey: 'logout',\n    ionicon: 'log-out-outline',\n    showChevron: false,\n    shadowed: true,\n  },\n];\n\n/** Opciones del builder `buildSettingsCards`. */\nexport interface SettingsCardsOptions {\n  /** Oculta secciones por token (típicamente la entrada de la página actual). */\n  exclude?: string[];\n  /** Secciones extra a sumar al catálogo (las de la app aún no promovidas). */\n  include?: SettingsSection[];\n  /** Orden explícito por token. Las no listadas quedan al final, en su orden. */\n  order?: string[];\n  /** Incluye la card de logout (sin ruta). Default `false`. */\n  includeLogout?: boolean;\n  /**\n   * Reescribe el prefijo `/app/settings` de las rutas del catálogo. Ej.\n   * `basePath: '/app/config'` → `/app/config/general`. Si se omite, las rutas\n   * quedan tal cual el catálogo.\n   */\n  basePath?: string;\n}\n\nconst CATALOG_BASE = '/app/settings';\n\n/**\n * Construye el grid de cards de navegación del HUB de settings (versión\n * promovida del `buildSettingsActionCards` de showcase). Usa el catálogo\n * default + las `include` del consumer, filtra `exclude`, gatea logout por\n * `includeLogout`, reordena por `order` y reescribe las rutas por `basePath`.\n *\n * El `t` resuelve los `titleKey`/`descKey` contra el namespace de labels\n * (default del componente: `Dashboard`). `logout` NO tiene `routerLink` — el\n * consumer maneja el flujo de cierre de sesión por token / callback.\n */\nexport function buildSettingsCards(\n  t: (key: string) => string,\n  options: SettingsCardsOptions = {}\n): ActionCardMetadata[] {\n  const exclude = new Set<string>(options.exclude ?? []);\n  const includeLogout = options.includeLogout ?? false;\n  const basePath = options.basePath;\n\n  const sections: SettingsSection[] = [...SETTINGS_SECTIONS_CATALOG, ...(options.include ?? [])];\n\n  let resolved = sections.filter(s => {\n    if (exclude.has(s.token)) return false;\n    if (s.token === 'action-logout' && !includeLogout) return false;\n    return true;\n  });\n\n  if (options.order && options.order.length > 0) {\n    const rank = new Map(options.order.map((token, i) => [token, i]));\n    resolved = [...resolved].sort((a, b) => {\n      const ra = rank.has(a.token) ? rank.get(a.token)! : Number.MAX_SAFE_INTEGER;\n      const rb = rank.has(b.token) ? rank.get(b.token)! : Number.MAX_SAFE_INTEGER;\n      return ra - rb;\n    });\n  }\n\n  return resolved.map(s => {\n    const card: ActionCardMetadata = {\n      token: s.token,\n      title: t(s.titleKey),\n      icon: {\n        ionicon: s.ionicon,\n        color: 'dark',\n        backgroundColor: 'light',\n      },\n      showChevron: s.showChevron ?? true,\n      shadowed: s.shadowed ?? true,\n    };\n    if (s.descKey) card.description = t(s.descKey);\n    if (s.routerLink) {\n      card.routerLink = basePath ? rewriteBasePath(s.routerLink, basePath) : s.routerLink;\n    }\n    return card;\n  });\n}\n\n/** Reescribe el prefijo `/app/settings` de una ruta del catálogo por `basePath`. */\nfunction rewriteBasePath(routerLink: string, basePath: string): string {\n  if (routerLink.startsWith(CATALOG_BASE)) {\n    return basePath + routerLink.slice(CATALOG_BASE.length);\n  }\n  return routerLink;\n}\n"]}

package/esm2022/lib/components/organisms/settings-hub/settings.routes.mjs

@@ -0,0 +1,59 @@
+import { provideValtechProfileRoutes } from '../profile-view/profile.routes';
+import { provideValtechPreferencesRoutes } from '../preferences-view/preferences.routes';
+import { SettingsHubComponent } from './settings-hub.component';
+/**
+ * Helper para montar el bloque completo de Settings en una app del factory: el
+ * HUB de navegación (`val-settings-hub`) en el index + las vistas promovidas
+ * (Perfil, Preferencias) + las rutas propias de la app (`extraRoutes`).
+ *
+ * Pensado para apps nuevas (greenfield) que adoptan el set entero. showcase NO
+ * lo usa hoy (preserva su `settings.routes.ts` por la semántica de sus muchas
+ * secciones no promovidas — ver guía de promoción), pero el provider debe
+ * existir y compilar para el resto de apps.
+ *
+ * @example
+ * ```ts
+ * // app.routes.ts
+ * import { provideValtechSettingsRoutes } from 'valtech-components';
+ *
+ * export const routes: Routes = [
+ *   {
+ *     path: 'app',
+ *     children: [
+ *       ...provideValtechSettingsRoutes({
+ *         hubConfig: { onLogout: () => auth.logoutWithConfirmation() },
+ *         extraRoutes: [
+ *           { path: 'security', loadComponent: () => ... },
+ *         ],
+ *       }),
+ *     ],
+ *   },
+ * ];
+ * ```
+ */
+export function provideValtechSettingsRoutes(opts) {
+    const basePath = opts?.basePath ?? 'settings';
+    const includeProfile = opts?.includeProfile ?? true;
+    const includePreferences = opts?.includePreferences ?? true;
+    return [
+        {
+            path: basePath,
+            children: [
+                {
+                    path: '',
+                    component: SettingsHubComponent,
+                    data: { settingsHubConfig: opts?.hubConfig },
+                },
+                ...(includeProfile ? provideValtechProfileRoutes({ config: opts?.profileConfig }) : []),
+                ...(includePreferences
+                    ? provideValtechPreferencesRoutes({
+                        path: opts?.preferencesPath ?? 'preferences',
+                        config: opts?.preferencesConfig,
+                    })
+                    : []),
+                ...(opts?.extraRoutes ?? []),
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/organisms/settings-hub/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvb3JnYW5pc21zL3NldHRpbmdzLWh1Yi90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2V0dGluZ3NTZWN0aW9uIH0gZnJvbSAnLi9zZXR0aW5ncy1zZWN0aW9ucyc7XG5cbi8qKlxuICogQ29uZmlndXJhY2nDs24gYWNvdGFkYSBkZSBgdmFsLXNldHRpbmdzLWh1YmAgKG9iamVjdC1maXJzdCkuIEVsIEhVQiBlcyBsYVxuICogcG9ydGFkYSBkZSBsYSBzZWNjacOzbiBTZXR0aW5nczogdW4gaGVhZGVyICh0w610dWxvICsgZGVzY3JpcGNpw7NuKSArIHVuIGdyaWQgZGVcbiAqIGB2YWwtYWN0aW9uLWNhcmRgIHF1ZSBuYXZlZ2EgYSBsYXMgc3ViLXZpc3Rhcy5cbiAqXG4gKiBEb2JsZSBuYW1lc3BhY2UgaTE4bjpcbiAqICAtIGBpMThuTmFtZXNwYWNlYCAoZGVmYXVsdCBgJ0Rhc2hib2FyZCdgKSDigJQgbGFiZWxzIGRlIGNhZGEgc2VjY2nDs25cbiAqICAgIChgZ2VuZXJhbGAsIGBhY2NvdW50YCwg4oCmKS4gRXMgZWwgc2V0IHF1ZSBjb21wYXJ0ZW4gZGFzaGJvYXJkIC8gaHViLlxuICogIC0gYHBhZ2VJMThuTmFtZXNwYWNlYCAoZGVmYXVsdCBgJ1NldHRpbmdzLlByZWZlcmVuY2VzJ2ApIOKAlCBgcGFnZVRpdGxlYCAvXG4gKiAgICBgcGFnZURlc2NyaXB0aW9uYCBkZWwgaGVhZGVyIGRlbCBIVUIuXG4gKlxuICogRWwgY2F0w6Fsb2dvIGRlIHNlY2Npb25lcyBlcyBlbCBkZWZhdWx0IChgU0VUVElOR1NfU0VDVElPTlNfQ0FUQUxPR2ApOyBzZVxuICogZmlsdHJhIChgZXhjbHVkZWApLCByZW9yZGVuYSAoYG9yZGVyYCksIGV4dGllbmRlIChgaW5jbHVkZWApIG8gcmVlc2NyaWJlIHN1c1xuICogcnV0YXMgKGBiYXNlUGF0aGApLiBgaW5jbHVkZUxvZ291dGAgYWdyZWdhIGxhIGNhcmQgZGUgY2llcnJlIGRlIHNlc2nDs24gKHNpblxuICogcnV0YSkg4oCUIHN1IGNsaWNrIHNlIGRlbGVnYSBhIGBvbkxvZ291dGAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2V0dGluZ3NIdWJDb25maWcge1xuICAvKiogT2N1bHRhIHNlY2Npb25lcyBwb3IgdG9rZW4gKGVqLiBsYSBwcm9waWEgZW50cmFkYSBkZWwgSFVCKS4gKi9cbiAgZXhjbHVkZT86IHN0cmluZ1tdO1xuICAvKiogU2VjY2lvbmVzIGV4dHJhIGEgc3VtYXIgYWwgY2F0w6Fsb2dvIChsYXMgZGUgbGEgYXBwIGHDum4gbm8gcHJvbW92aWRhcykuICovXG4gIGluY2x1ZGU/OiBTZXR0aW5nc1NlY3Rpb25bXTtcbiAgLyoqIE9yZGVuIGV4cGzDrWNpdG8gcG9yIHRva2VuLiBMYXMgbm8gbGlzdGFkYXMgcXVlZGFuIGFsIGZpbmFsLiAqL1xuICBvcmRlcj86IHN0cmluZ1tdO1xuICAvKiogSW5jbHV5ZSBsYSBjYXJkIGRlIGxvZ291dCAoc2luIHJ1dGEpLiBEZWZhdWx0IGBmYWxzZWAuICovXG4gIGluY2x1ZGVMb2dvdXQ/OiBib29sZWFuO1xuICAvKiogUmVlc2NyaWJlIGVsIHByZWZpam8gYC9hcHAvc2V0dGluZ3NgIGRlIGxhcyBydXRhcyBkZWwgY2F0w6Fsb2dvLiAqL1xuICBiYXNlUGF0aD86IHN0cmluZztcblxuICAvKiogTmFtZXNwYWNlIGkxOG4gZGUgbG9zIGxhYmVscyBkZSBzZWNjacOzbi4gRGVmYXVsdCBgJ0Rhc2hib2FyZCdgLiAqL1xuICBpMThuTmFtZXNwYWNlPzogc3RyaW5nO1xuICAvKiogTmFtZXNwYWNlIGkxOG4gZGVsIGhlYWRlciAocGFnZVRpdGxlL3BhZ2VEZXNjcmlwdGlvbikuIERlZmF1bHQgYCdTZXR0aW5ncy5QcmVmZXJlbmNlcydgLiAqL1xuICBwYWdlSTE4bk5hbWVzcGFjZT86IHN0cmluZztcblxuICAvKiogQ2FsbGJhY2sgYWwgY2xpY2sgZGUgbGEgY2FyZCBkZSBsb2dvdXQgKHNpbiBydXRhKS4gKi9cbiAgb25Mb2dvdXQ/OiAoKSA9PiB2b2lkO1xuICAvKiogQ2FsbGJhY2sgYWwgY2xpY2sgZGUgY3VhbHF1aWVyIGNhcmQsIGNvbiBzdSB0b2tlbi4gKi9cbiAgb25TZWN0aW9uQ2xpY2s/OiAodG9rZW46IHN0cmluZykgPT4gdm9pZDtcbn1cbiJdfQ==

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.974';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45NzQnO1xuIl19
+export const VERSION = '2.0.975';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45NzUnO1xuIl19