valtech-components 2.0.985 → 2.0.987

package/esm2022/lib/components/organisms/switch-org-modal/switch-org-modal.component.mjs

@@ -0,0 +1,280 @@
+import { Component, computed, inject, Input, signal } from '@angular/core';
+import { take } from 'rxjs/operators';
+import { IonButton, IonButtons, IonContent, IonHeader, IonIcon, IonSpinner, IonToolbar, } from '@ionic/angular/standalone';
+import { addIcons } from 'ionicons';
+import { businessOutline, checkmarkCircleOutline } from 'ionicons/icons';
+import { DisplayComponent } from '../../atoms/display/display.component';
+import { TitleComponent } from '../../atoms/title/title.component';
+import { EmptyStateComponent } from '../../molecules/empty-state/empty-state.component';
+import { SearchbarComponent } from '../../molecules/searchbar/searchbar.component';
+import { AuthService } from '../../../services/auth/auth.service';
+import { I18nService } from '../../../services/i18n';
+import { OrgService } from '../../../services/org/org.service';
+import { OrgSwitchService } from '../../../services/auth/org-switch.service';
+import { ValtechErrorService } from '../../../services/errors/valtech-error.service';
+import { SWITCH_ORG_MODAL_I18N } from './switch-org-modal.i18n';
+import * as i0 from "@angular/core";
+const DEFAULT_NAMESPACE = 'Settings.SwitchOrg';
+addIcons({ businessOutline, checkmarkCircleOutline });
+/**
+ * `val-switch-org-modal` — modal de cambio de organización activa (organism
+ * compartido). Promovido desde `showcase` bajo el proceso de ADR-021. Reusado por
+ * la vista Cuenta (y futuras vistas org-aware).
+ *
+ * Lista las organizaciones del user (vía `OrgService.listMyOrgs`), permite buscar
+ * por nombre, y cambia la org activa con `OrgSwitchService.switchTo`. La org
+ * actual queda primera y deshabilitada.
+ *
+ * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback
+ * `onSuccess`. Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en
+ * `slot=end`, título/subtítulo en el body con `val-display`/`val-title`.
+ *
+ * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace
+ * `Settings.SwitchOrg`.
+ */
+export class SwitchOrgModalComponent {
+    constructor() {
+        this.i18n = inject(I18nService);
+        this.auth = inject(AuthService);
+        this.orgService = inject(OrgService);
+        this.orgSwitch = inject(OrgSwitchService);
+        this.errors = inject(ValtechErrorService);
+        /** Namespace i18n con que la vista resuelve sus textos. */
+        this.i18nNamespace = DEFAULT_NAMESPACE;
+        this.orgs = signal([]);
+        this.loading = signal(false);
+        this.query = signal('');
+        this.switchingId = signal(null);
+        this.activeOrgId = computed(() => {
+            const u = this.auth.user();
+            return u?.activeOrgId ?? u?.activeOrg ?? '';
+        });
+        this.filteredOrgs = computed(() => {
+            const q = this.query().trim().toLowerCase();
+            const list = this.orgs();
+            if (!q)
+                return list;
+            return list.filter(o => o.name.toLowerCase().includes(q));
+        });
+        if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {
+            this.i18n.registerContent(DEFAULT_NAMESPACE, SWITCH_ORG_MODAL_I18N);
+        }
+        this.loadOrgs();
+    }
+    onQueryChange(value) {
+        this.query.set(value ?? '');
+    }
+    async onSelect(org) {
+        if (this.switchingId() || org.id === this.activeOrgId())
+            return;
+        this.switchingId.set(org.id);
+        try {
+            await this.orgSwitch.switchTo(org.id);
+            this.onSuccess?.();
+            this.dismiss();
+        }
+        catch (err) {
+            this.errors.handle(err, {
+                context: 'account.switchOrg',
+                fallbackKey: 'switchError',
+                i18nNamespace: this.i18nNamespace,
+            });
+            this.switchingId.set(null);
+        }
+    }
+    loadOrgs() {
+        this.loading.set(true);
+        this.orgService
+            .listMyOrgs()
+            .pipe(take(1))
+            .subscribe({
+            next: orgs => {
+                const activeId = this.activeOrgId();
+                this.orgs.set([...orgs].sort((a, b) => (a.id === activeId ? -1 : b.id === activeId ? 1 : 0)));
+                this.loading.set(false);
+            },
+            error: () => this.loading.set(false),
+        });
+    }
+    dismiss() {
+        this._modalRef?.dismiss(null, 'cancel');
+    }
+    t(key) {
+        return this.i18n.t(key, this.i18nNamespace);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SwitchOrgModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SwitchOrgModalComponent, isStandalone: true, selector: "val-switch-org-modal", inputs: { _modalRef: "_modalRef", onSuccess: "onSuccess", i18nNamespace: "i18nNamespace" }, ngImport: i0, template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: t('title'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('subtitle'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+
+      <div class="switch-section">
+        <val-searchbar
+          [props]="{
+            placeholder: t('searchPlaceholder'),
+            debounce: 200,
+            showCancelButton: 'never',
+          }"
+          (filterEvent)="onQueryChange($event)"
+        />
+
+        @if (loading()) {
+          <div class="switch-state">
+            <ion-spinner name="crescent" />
+          </div>
+        } @else if (filteredOrgs().length === 0) {
+          <val-empty-state
+            [props]="{
+              variant: 'empty',
+              title: t('noResults'),
+              icon: 'business-outline',
+            }"
+          />
+        } @else {
+          <div class="orgs-list">
+            @for (org of filteredOrgs(); track org.id) {
+              <button
+                type="button"
+                class="org-row"
+                [class.org-row--active]="org.id === activeOrgId()"
+                [disabled]="!!switchingId() || org.id === activeOrgId()"
+                (click)="onSelect(org)"
+              >
+                <div class="org-row__icon">
+                  <ion-icon name="business-outline" />
+                </div>
+                <div class="org-row__body">
+                  <span class="org-row__name">{{ org.name }}</span>
+                  <span class="org-row__type">{{ org.type }}</span>
+                </div>
+                <div class="org-row__end">
+                  @if (switchingId() === org.id) {
+                    <ion-spinner name="crescent" class="org-row__spinner" />
+                  } @else if (org.id === activeOrgId()) {
+                    <span class="org-row__current">{{ t('current') }}</span>
+                    <ion-icon name="checkmark-circle-outline" class="org-row__check" />
+                  }
+                </div>
+              </button>
+            }
+          </div>
+        }
+      </div>
+    </ion-content>
+  `, isInline: true, styles: [".switch-section{margin-top:16px;display:flex;flex-direction:column;gap:12px}.switch-state{display:flex;justify-content:center;padding:24px 0}.orgs-list{display:flex;flex-direction:column;gap:8px}.org-row{display:flex;align-items:center;gap:12px;width:100%;padding:12px 14px;border:1px solid rgba(var(--ion-color-dark-rgb),.14);border-radius:12px;background:var(--ion-card-background, var(--ion-background-color));cursor:pointer;text-align:left;transition:border-color .15s ease,opacity .15s ease}.org-row:not(:disabled):active{opacity:.7}.org-row:disabled{cursor:default}.org-row--active{border-color:var(--ion-color-dark)}.org-row__icon{width:36px;height:36px;border-radius:50%;flex-shrink:0;display:flex;align-items:center;justify-content:center;font-size:18px;color:var(--ion-color-dark);background:rgba(var(--ion-color-dark-rgb),.08)}.org-row__body{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}.org-row__name{font-weight:600;font-size:.95rem;color:var(--ion-color-dark);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.org-row__type{font-size:.8rem;color:rgba(var(--ion-color-dark-rgb),.7)}.org-row__end{display:flex;align-items:center;gap:6px;flex-shrink:0}.org-row__current{font-size:.74rem;font-weight:600;text-transform:uppercase;letter-spacing:.04em;color:rgba(var(--ion-color-dark-rgb),.7)}.org-row__check{font-size:1.1rem;color:var(--ion-color-dark)}.org-row__spinner{width:18px;height:18px;color:var(--ion-color-dark)}\n"], dependencies: [{ kind: "component", type: IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: DisplayComponent, selector: "val-display", inputs: ["props"] }, { kind: "component", type: EmptyStateComponent, selector: "val-empty-state", inputs: ["props"] }, { kind: "component", type: SearchbarComponent, selector: "val-searchbar", inputs: ["preset", "props"], outputs: ["filterEvent", "focusEvent", "blurEvent"] }, { kind: "component", type: TitleComponent, selector: "val-title", inputs: ["props"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SwitchOrgModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'val-switch-org-modal', standalone: true, imports: [
+                        IonHeader,
+                        IonToolbar,
+                        IonButtons,
+                        IonButton,
+                        IonContent,
+                        IonSpinner,
+                        IonIcon,
+                        DisplayComponent,
+                        EmptyStateComponent,
+                        SearchbarComponent,
+                        TitleComponent,
+                    ], template: `
+    <ion-header>
+      <ion-toolbar>
+        <ion-buttons slot="end">
+          <ion-button fill="clear" color="dark" (click)="dismiss()">
+            <strong>{{ t('close') }}</strong>
+          </ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+
+    <ion-content class="ion-padding">
+      <val-display [props]="{ content: t('title'), size: 'small', color: 'dark' }" />
+      <val-title
+        [props]="{
+          content: t('subtitle'),
+          size: 'large',
+          color: '',
+          bold: false,
+        }"
+      />
+
+      <div class="switch-section">
+        <val-searchbar
+          [props]="{
+            placeholder: t('searchPlaceholder'),
+            debounce: 200,
+            showCancelButton: 'never',
+          }"
+          (filterEvent)="onQueryChange($event)"
+        />
+
+        @if (loading()) {
+          <div class="switch-state">
+            <ion-spinner name="crescent" />
+          </div>
+        } @else if (filteredOrgs().length === 0) {
+          <val-empty-state
+            [props]="{
+              variant: 'empty',
+              title: t('noResults'),
+              icon: 'business-outline',
+            }"
+          />
+        } @else {
+          <div class="orgs-list">
+            @for (org of filteredOrgs(); track org.id) {
+              <button
+                type="button"
+                class="org-row"
+                [class.org-row--active]="org.id === activeOrgId()"
+                [disabled]="!!switchingId() || org.id === activeOrgId()"
+                (click)="onSelect(org)"
+              >
+                <div class="org-row__icon">
+                  <ion-icon name="business-outline" />
+                </div>
+                <div class="org-row__body">
+                  <span class="org-row__name">{{ org.name }}</span>
+                  <span class="org-row__type">{{ org.type }}</span>
+                </div>
+                <div class="org-row__end">
+                  @if (switchingId() === org.id) {
+                    <ion-spinner name="crescent" class="org-row__spinner" />
+                  } @else if (org.id === activeOrgId()) {
+                    <span class="org-row__current">{{ t('current') }}</span>
+                    <ion-icon name="checkmark-circle-outline" class="org-row__check" />
+                  }
+                </div>
+              </button>
+            }
+          </div>
+        }
+      </div>
+    </ion-content>
+  `, styles: [".switch-section{margin-top:16px;display:flex;flex-direction:column;gap:12px}.switch-state{display:flex;justify-content:center;padding:24px 0}.orgs-list{display:flex;flex-direction:column;gap:8px}.org-row{display:flex;align-items:center;gap:12px;width:100%;padding:12px 14px;border:1px solid rgba(var(--ion-color-dark-rgb),.14);border-radius:12px;background:var(--ion-card-background, var(--ion-background-color));cursor:pointer;text-align:left;transition:border-color .15s ease,opacity .15s ease}.org-row:not(:disabled):active{opacity:.7}.org-row:disabled{cursor:default}.org-row--active{border-color:var(--ion-color-dark)}.org-row__icon{width:36px;height:36px;border-radius:50%;flex-shrink:0;display:flex;align-items:center;justify-content:center;font-size:18px;color:var(--ion-color-dark);background:rgba(var(--ion-color-dark-rgb),.08)}.org-row__body{flex:1;min-width:0;display:flex;flex-direction:column;gap:2px}.org-row__name{font-weight:600;font-size:.95rem;color:var(--ion-color-dark);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.org-row__type{font-size:.8rem;color:rgba(var(--ion-color-dark-rgb),.7)}.org-row__end{display:flex;align-items:center;gap:6px;flex-shrink:0}.org-row__current{font-size:.74rem;font-weight:600;text-transform:uppercase;letter-spacing:.04em;color:rgba(var(--ion-color-dark-rgb),.7)}.org-row__check{font-size:1.1rem;color:var(--ion-color-dark)}.org-row__spinner{width:18px;height:18px;color:var(--ion-color-dark)}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { _modalRef: [{
+                type: Input
+            }], onSuccess: [{
+                type: Input
+            }], i18nNamespace: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch-org-modal.component.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/switch-org-modal/switch-org-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, inject, Input, signal } from '@angular/core';\nimport { take } from 'rxjs/operators';\nimport {\n  IonButton,\n  IonButtons,\n  IonContent,\n  IonHeader,\n  IonIcon,\n  IonSpinner,\n  IonToolbar,\n} from '@ionic/angular/standalone';\nimport { addIcons } from 'ionicons';\nimport { businessOutline, checkmarkCircleOutline } from 'ionicons/icons';\n\nimport { DisplayComponent } from '../../atoms/display/display.component';\nimport { TitleComponent } from '../../atoms/title/title.component';\nimport { EmptyStateComponent } from '../../molecules/empty-state/empty-state.component';\nimport { SearchbarComponent } from '../../molecules/searchbar/searchbar.component';\n\nimport { AuthService } from '../../../services/auth/auth.service';\nimport { I18nService } from '../../../services/i18n';\nimport { OrgService } from '../../../services/org/org.service';\nimport { Organization } from '../../../services/org/types';\nimport { OrgSwitchService } from '../../../services/auth/org-switch.service';\nimport { ValtechErrorService } from '../../../services/errors/valtech-error.service';\n\nimport { SWITCH_ORG_MODAL_I18N } from './switch-org-modal.i18n';\n\nconst DEFAULT_NAMESPACE = 'Settings.SwitchOrg';\n\naddIcons({ businessOutline, checkmarkCircleOutline });\n\n/**\n * `val-switch-org-modal` — modal de cambio de organización activa (organism\n * compartido). Promovido desde `showcase` bajo el proceso de ADR-021. Reusado por\n * la vista Cuenta (y futuras vistas org-aware).\n *\n * Lista las organizaciones del user (vía `OrgService.listMyOrgs`), permite buscar\n * por nombre, y cambia la org activa con `OrgSwitchService.switchTo`. La org\n * actual queda primera y deshabilitada.\n *\n * Abierto vía `ModalService` — recibe `_modalRef` por `componentProps` + callback\n * `onSuccess`. Header canónico (Regla #5): sin `ion-title`, botón Cerrar texto en\n * `slot=end`, título/subtítulo en el body con `val-display`/`val-title`.\n *\n * Auto-registra sus defaults i18n (es/en) si el consumer no proveyó el namespace\n * `Settings.SwitchOrg`.\n */\n@Component({\n  selector: 'val-switch-org-modal',\n  standalone: true,\n  imports: [\n    IonHeader,\n    IonToolbar,\n    IonButtons,\n    IonButton,\n    IonContent,\n    IonSpinner,\n    IonIcon,\n    DisplayComponent,\n    EmptyStateComponent,\n    SearchbarComponent,\n    TitleComponent,\n  ],\n  template: `\n    <ion-header>\n      <ion-toolbar>\n        <ion-buttons slot=\"end\">\n          <ion-button fill=\"clear\" color=\"dark\" (click)=\"dismiss()\">\n            <strong>{{ t('close') }}</strong>\n          </ion-button>\n        </ion-buttons>\n      </ion-toolbar>\n    </ion-header>\n\n    <ion-content class=\"ion-padding\">\n      <val-display [props]=\"{ content: t('title'), size: 'small', color: 'dark' }\" />\n      <val-title\n        [props]=\"{\n          content: t('subtitle'),\n          size: 'large',\n          color: '',\n          bold: false,\n        }\"\n      />\n\n      <div class=\"switch-section\">\n        <val-searchbar\n          [props]=\"{\n            placeholder: t('searchPlaceholder'),\n            debounce: 200,\n            showCancelButton: 'never',\n          }\"\n          (filterEvent)=\"onQueryChange($event)\"\n        />\n\n        @if (loading()) {\n          <div class=\"switch-state\">\n            <ion-spinner name=\"crescent\" />\n          </div>\n        } @else if (filteredOrgs().length === 0) {\n          <val-empty-state\n            [props]=\"{\n              variant: 'empty',\n              title: t('noResults'),\n              icon: 'business-outline',\n            }\"\n          />\n        } @else {\n          <div class=\"orgs-list\">\n            @for (org of filteredOrgs(); track org.id) {\n              <button\n                type=\"button\"\n                class=\"org-row\"\n                [class.org-row--active]=\"org.id === activeOrgId()\"\n                [disabled]=\"!!switchingId() || org.id === activeOrgId()\"\n                (click)=\"onSelect(org)\"\n              >\n                <div class=\"org-row__icon\">\n                  <ion-icon name=\"business-outline\" />\n                </div>\n                <div class=\"org-row__body\">\n                  <span class=\"org-row__name\">{{ org.name }}</span>\n                  <span class=\"org-row__type\">{{ org.type }}</span>\n                </div>\n                <div class=\"org-row__end\">\n                  @if (switchingId() === org.id) {\n                    <ion-spinner name=\"crescent\" class=\"org-row__spinner\" />\n                  } @else if (org.id === activeOrgId()) {\n                    <span class=\"org-row__current\">{{ t('current') }}</span>\n                    <ion-icon name=\"checkmark-circle-outline\" class=\"org-row__check\" />\n                  }\n                </div>\n              </button>\n            }\n          </div>\n        }\n      </div>\n    </ion-content>\n  `,\n  styles: [\n    `\n      .switch-section {\n        margin-top: 16px;\n        display: flex;\n        flex-direction: column;\n        gap: 12px;\n      }\n      .switch-state {\n        display: flex;\n        justify-content: center;\n        padding: 24px 0;\n      }\n      .orgs-list {\n        display: flex;\n        flex-direction: column;\n        gap: 8px;\n      }\n      .org-row {\n        display: flex;\n        align-items: center;\n        gap: 12px;\n        width: 100%;\n        padding: 12px 14px;\n        border: 1px solid rgba(var(--ion-color-dark-rgb), 0.14);\n        border-radius: 12px;\n        background: var(--ion-card-background, var(--ion-background-color));\n        cursor: pointer;\n        text-align: left;\n        transition:\n          border-color 0.15s ease,\n          opacity 0.15s ease;\n      }\n      .org-row:not(:disabled):active {\n        opacity: 0.7;\n      }\n      .org-row:disabled {\n        cursor: default;\n      }\n      .org-row--active {\n        border-color: var(--ion-color-dark);\n      }\n      .org-row__icon {\n        width: 36px;\n        height: 36px;\n        border-radius: 50%;\n        flex-shrink: 0;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        font-size: 18px;\n        color: var(--ion-color-dark);\n        background: rgba(var(--ion-color-dark-rgb), 0.08);\n      }\n      .org-row__body {\n        flex: 1;\n        min-width: 0;\n        display: flex;\n        flex-direction: column;\n        gap: 2px;\n      }\n      .org-row__name {\n        font-weight: 600;\n        font-size: 0.95rem;\n        color: var(--ion-color-dark);\n        white-space: nowrap;\n        overflow: hidden;\n        text-overflow: ellipsis;\n      }\n      .org-row__type {\n        font-size: 0.8rem;\n        color: rgba(var(--ion-color-dark-rgb), 0.7);\n      }\n      .org-row__end {\n        display: flex;\n        align-items: center;\n        gap: 6px;\n        flex-shrink: 0;\n      }\n      .org-row__current {\n        font-size: 0.74rem;\n        font-weight: 600;\n        text-transform: uppercase;\n        letter-spacing: 0.04em;\n        color: rgba(var(--ion-color-dark-rgb), 0.7);\n      }\n      .org-row__check {\n        font-size: 1.1rem;\n        color: var(--ion-color-dark);\n      }\n      .org-row__spinner {\n        width: 18px;\n        height: 18px;\n        color: var(--ion-color-dark);\n      }\n    `,\n  ],\n})\nexport class SwitchOrgModalComponent {\n  private i18n = inject(I18nService);\n  private auth = inject(AuthService);\n  private orgService = inject(OrgService);\n  private orgSwitch = inject(OrgSwitchService);\n  private errors = inject(ValtechErrorService);\n\n  /** Inyectado por `ModalService.open` — referencia para cerrar desde dentro. */\n  @Input() _modalRef?: { dismiss: (data?: unknown, role?: string) => void };\n\n  /** Callback tras un switch exitoso (pasado por `componentProps`). */\n  @Input() onSuccess?: () => void;\n\n  /** Namespace i18n con que la vista resuelve sus textos. */\n  @Input() i18nNamespace = DEFAULT_NAMESPACE;\n\n  readonly orgs = signal<Organization[]>([]);\n  readonly loading = signal(false);\n  readonly query = signal('');\n  readonly switchingId = signal<string | null>(null);\n\n  readonly activeOrgId = computed(() => {\n    const u = this.auth.user() as {\n      activeOrgId?: string;\n      activeOrg?: string;\n    } | null;\n    return u?.activeOrgId ?? u?.activeOrg ?? '';\n  });\n\n  readonly filteredOrgs = computed(() => {\n    const q = this.query().trim().toLowerCase();\n    const list = this.orgs();\n    if (!q) return list;\n    return list.filter(o => o.name.toLowerCase().includes(q));\n  });\n\n  constructor() {\n    if (!this.i18n.hasNamespace(DEFAULT_NAMESPACE)) {\n      this.i18n.registerContent(DEFAULT_NAMESPACE, SWITCH_ORG_MODAL_I18N);\n    }\n    this.loadOrgs();\n  }\n\n  onQueryChange(value: string): void {\n    this.query.set(value ?? '');\n  }\n\n  async onSelect(org: Organization): Promise<void> {\n    if (this.switchingId() || org.id === this.activeOrgId()) return;\n    this.switchingId.set(org.id);\n    try {\n      await this.orgSwitch.switchTo(org.id);\n      this.onSuccess?.();\n      this.dismiss();\n    } catch (err) {\n      this.errors.handle(err, {\n        context: 'account.switchOrg',\n        fallbackKey: 'switchError',\n        i18nNamespace: this.i18nNamespace,\n      });\n      this.switchingId.set(null);\n    }\n  }\n\n  private loadOrgs(): void {\n    this.loading.set(true);\n    this.orgService\n      .listMyOrgs()\n      .pipe(take(1))\n      .subscribe({\n        next: orgs => {\n          const activeId = this.activeOrgId();\n          this.orgs.set([...orgs].sort((a, b) => (a.id === activeId ? -1 : b.id === activeId ? 1 : 0)));\n          this.loading.set(false);\n        },\n        error: () => this.loading.set(false),\n      });\n  }\n\n  dismiss(): void {\n    this._modalRef?.dismiss(null, 'cancel');\n  }\n\n  t(key: string): string {\n    return this.i18n.t(key, this.i18nNamespace);\n  }\n}\n"]}

package/esm2022/lib/components/organisms/switch-org-modal/switch-org-modal.i18n.mjs

@@ -0,0 +1,26 @@
+/**
+ * Defaults i18n (es/en) embebidos en `val-switch-org-modal`. Auto-registrados en
+ * el constructor del componente si el consumer no proveyó el namespace
+ * (`Settings.SwitchOrg` por default). SOLO incluye las keys que el modal usa.
+ */
+export const SWITCH_ORG_MODAL_I18N = {
+    es: {
+        title: 'Cambiar de cuenta',
+        subtitle: 'Selecciona la organización a la que quieres cambiar.',
+        searchPlaceholder: 'Buscar organización...',
+        noResults: 'No se encontraron organizaciones.',
+        current: 'Actual',
+        close: 'Cerrar',
+        switchError: 'No se pudo cambiar de organización.',
+    },
+    en: {
+        title: 'Switch account',
+        subtitle: 'Select the organization you want to switch to.',
+        searchPlaceholder: 'Search organization...',
+        noResults: 'No organizations found.',
+        current: 'Active',
+        close: 'Close',
+        switchError: 'Could not switch organization.',
+    },
+};
+//# 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;AAyKD;;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  /**\n   * Configuración del botón de submit. Opcional: en modo `controlled` el form\n   * no renderiza submit propio (lo maneja el host) y `actions` se ignora.\n   */\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"]}
+//# 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;AAyKD;;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  /**\n   * Configuración del botón de submit. Opcional: en modo `controlled` el form\n   * no renderiza submit propio (lo maneja el host) y `actions` se ignora.\n   */\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  /** Angular router link (SPA navigation, no reload) */\n  routerLink?: string | any[];\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.985';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45ODUnO1xuIl19
+export const VERSION = '2.0.987';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDdXJyZW50IHZlcnNpb24gb2YgdmFsdGVjaC1jb21wb25lbnRzLlxuICogVGhpcyBpcyBhdXRvbWF0aWNhbGx5IHVwZGF0ZWQgZHVyaW5nIHRoZSBwdWJsaXNoIHByb2Nlc3MuXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gJzIuMC45ODcnO1xuIl19