@ktortu/aaa 0.9.2 → 0.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ktortu/aaa",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Bibliothèque de composants Angular headless + thémés par tokens CSS.",
   "keywords": [
     "angular",

package/types/ktortu-aaa-card.d.ts

@@ -1,6 +1,70 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Provider } from '@angular/core';
+import { InjectionToken, AfterContentInit, AfterViewInit, Provider } from '@angular/core';
 
+/** Axe "apparence" de la surface. */
+type KtCardVariant = 'elevated' | 'outlined' | 'filled';
+/** Défauts applicables à toutes les `[ktCard]` (surchargeables par carte via les inputs). */
+interface KtCardConfig {
+    /** Apparence par défaut de la surface. */
+    variant: KtCardVariant;
+}
+declare const KT_CARD_CONFIG: InjectionToken<Partial<KtCardConfig>>;
+/**
+ * Fournit des défauts de carte (apparence de surface) pour un sous-arbre ou l'application entière.
+ *
+ * @example
+ * ```ts
+ * providers: [provideKtCard({ variant: 'outlined' })]
+ * ```
+ */
+declare function provideKtCard(config: Partial<KtCardConfig>): Provider;
+/**
+ * Carte : SURFACE de contenu. Directive (pas de composant) posée sur l'élément SÉMANTIQUE choisi
+ * par le consommateur (`<article>`, `<section>`, `<li>`, `<a>`…) — la lib n'impose jamais de
+ * wrapper non sémantique ni de rôle (cf. précédent Dialog : la sémantique appartient à l'hôte).
+ *
+ * Trois axes pilotés en `data-*` (même contrat que ktButton) :
+ *   - variant      : data-variant = elevated | outlined | filled (apparence)
+ *   - interactive  : data-interactive (affordance hover/focus — PAS un rôle ; la cible cliquable
+ *                    est un [ktCardLink], lien/bouton primaire au lien étiré)
+ *   - disabled     : data-disabled (surface inerte)
+ *
+ * La mise en forme (layout des marqueurs, lien étiré, états) vit dans `card.css` ; les couleurs
+ * et la géométrie dérivent du socle `--kt-*` via `card-tokens.css`.
+ *
+ * @example
+ * ```html
+ * <article ktCard variant="outlined" interactive>
+ *   <div ktCardContent>
+ *     <h3 id="t1">Titre</h3>
+ *     <a ktCardLink routerLink="/detail" aria-labelledby="t1">Voir le détail</a>
+ *   </div>
+ * </article>
+ * ```
+ */
+declare class KtCard implements AfterContentInit {
+    private readonly config;
+    private readonly host;
+    private readonly platformId;
+    private readonly auditEnabled;
+    /** Référence réactive sur le lien primaire de la carte */
+    readonly cardLink: i0.Signal<KtCardLink | undefined>;
+    /** Apparence de la surface : `elevated` | `outlined` | `filled`. @default 'elevated' (ou `KT_CARD_CONFIG.variant`) */
+    readonly variant: i0.InputSignal<KtCardVariant>;
+    /**
+     * Affordance visuelle d'élément cliquable (hover/focus). N'AJOUTE pas de rôle : un lien/bouton
+     * primaire ([ktCardLink]) porte l'interaction et le nom accessible. @default false
+     */
+    readonly interactive: i0.InputSignalWithTransform<boolean, unknown>;
+    /** Rend la surface inerte (état `data-disabled`). @default false */
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    private isDestroyed;
+    private readonly contentInitialized;
+    constructor();
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtCard, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KtCard, "[ktCard]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["cardLink"], never, true, never>;
+}
 /**
  * En-tête de la carte (rangée flex : média/avatar + titre + éventuelle action). Marqueur
  * structurel sans logique — la mise en forme vit dans `card.css` via `[ktCardHeader]`.
@@ -58,7 +122,7 @@ declare class KtCardActions {
 }
 /**
  * Lien (ou bouton) PRIMAIRE d'une carte interactive : pattern « lien étiré » (Inclusive
- * Components). Un pseudo-élément `::after` couvre toute la carte (cf. `card.css`) → toute la
+ * Components). Un pseudo-élément `::after` covers toute la carte (cf. `card.css`) → toute la
  * surface est cliquable, SANS imbriquer de contrôles interactifs (anti-pattern WCAG 4.1.2). Les
  * actions secondaires de la carte repassent au-dessus du lien (z-index dans `card.css`).
  *
@@ -78,7 +142,7 @@ declare class KtCardActions {
  * </article>
  * ```
  */
-declare class KtCardLink {
+declare class KtCardLink implements AfterViewInit {
     private readonly host;
     private readonly auditEnabled;
     /**
@@ -88,74 +152,11 @@ declare class KtCardLink {
      */
     protected readonly card: KtCard | null;
     handleClick(event: Event): void;
-    constructor();
+    ngAfterViewInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<KtCardLink, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<KtCardLink, "a[ktCardLink], button[ktCardLink]", never, {}, {}, never, never, true, never>;
 }
 
-/** Axe "apparence" de la surface. */
-type KtCardVariant = 'elevated' | 'outlined' | 'filled';
-/** Défauts applicables à toutes les `[ktCard]` (surchargeables par carte via les inputs). */
-interface KtCardConfig {
-    /** Apparence par défaut de la surface. */
-    variant: KtCardVariant;
-}
-declare const KT_CARD_CONFIG: InjectionToken<Partial<KtCardConfig>>;
-/**
- * Fournit des défauts de carte (apparence de surface) pour un sous-arbre ou l'application entière.
- *
- * @example
- * ```ts
- * providers: [provideKtCard({ variant: 'outlined' })]
- * ```
- */
-declare function provideKtCard(config: Partial<KtCardConfig>): Provider;
-/**
- * Carte : SURFACE de contenu. Directive (pas de composant) posée sur l'élément SÉMANTIQUE choisi
- * par le consommateur (`<article>`, `<section>`, `<li>`, `<a>`…) — la lib n'impose jamais de
- * wrapper non sémantique ni de rôle (cf. précédent Dialog : la sémantique appartient à l'hôte).
- *
- * Trois axes pilotés en `data-*` (même contrat que ktButton) :
- *   - variant      : data-variant = elevated | outlined | filled (apparence)
- *   - interactive  : data-interactive (affordance hover/focus — PAS un rôle ; la cible cliquable
- *                    est un [ktCardLink], lien/bouton primaire au lien étiré)
- *   - disabled     : data-disabled (surface inerte)
- *
- * La mise en forme (layout des marqueurs, lien étiré, états) vit dans `card.css` ; les couleurs
- * et la géométrie dérivent du socle `--kt-*` via `card-tokens.css`.
- *
- * @example
- * ```html
- * <article ktCard variant="outlined" interactive>
- *   <div ktCardContent>
- *     <h3 id="t1">Titre</h3>
- *     <a ktCardLink routerLink="/detail" aria-labelledby="t1">Voir le détail</a>
- *   </div>
- * </article>
- * ```
- */
-declare class KtCard {
-    private readonly config;
-    private readonly host;
-    private readonly platformId;
-    private readonly auditEnabled;
-    /** Référence réactive sur le lien primaire de la carte */
-    readonly cardLink: i0.Signal<KtCardLink | undefined>;
-    /** Apparence de la surface : `elevated` | `outlined` | `filled`. @default 'elevated' (ou `KT_CARD_CONFIG.variant`) */
-    readonly variant: i0.InputSignal<KtCardVariant>;
-    /**
-     * Affordance visuelle d'élément cliquable (hover/focus). N'AJOUTE pas de rôle : un lien/bouton
-     * primaire ([ktCardLink]) porte l'interaction et le nom accessible. @default false
-     */
-    readonly interactive: i0.InputSignalWithTransform<boolean, unknown>;
-    /** Rend la surface inerte (état `data-disabled`). @default false */
-    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
-    private isDestroyed;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<KtCard, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KtCard, "[ktCard]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["cardLink"], never, true, never>;
-}
-
 /**
  * Import ergonomique de toute la famille card en une fois :
  * `imports: [KtCardImports]` au lieu d'énumérer chaque directive.

package/types/ktortu-aaa-dialog.d.ts

@@ -1,6 +1,9 @@
 import * as i0 from '@angular/core';
 import { OnInit, OnDestroy, Provider } from '@angular/core';
 import { DialogConfig, DialogRef, CdkDialogContainer } from '@angular/cdk/dialog';
+import * as _ktortu_aaa_dialog from '@ktortu/aaa/dialog';
+import { Observable } from 'rxjs';
+import { KtButtonColor } from '@ktortu/aaa/button';
 import { ComponentType } from '@angular/cdk/portal';
 
 /**
@@ -367,11 +370,134 @@ declare class KtDialogContainer extends CdkDialogContainer {
     static ɵcmp: i0.ɵɵComponentDeclaration<KtDialogContainer, "kt-dialog-container", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Configuration pour l'ouverture d'une boîte de dialogue d'alerte simple.
+ */
+interface KtAlertData {
+    /** Titre de la boîte de dialogue. */
+    title: string;
+    /**
+     * Message explicatif. Peut être une simple chaîne de caractères
+     * ou un tableau de chaînes pour composer plusieurs paragraphes.
+     * Supporte le HTML (balises sécurisées) désinfecté à l'affichage.
+     */
+    message: string | string[];
+    /** Libellé du bouton de fermeture. Par défaut: 'Fermer'. */
+    closeLabel?: string;
+}
+/**
+ * Composant interne d'alerte générique.
+ * Affiche un titre, un message (simple ou multiligne HTML) et un bouton de fermeture.
+ */
+declare class KtAlertDialog {
+    protected readonly data: KtAlertData;
+    protected isMessageArray(): boolean;
+    protected messageArray(): string[];
+    protected messageString(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtAlertDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KtAlertDialog, "kt-alert-dialog", never, {}, {}, never, never, true, never>;
+}
+/** Ouvreur co-localisé officiel pour l'alerte. Utilise la présentation responsive par défaut. */
+declare const injectAlertDialog: () => (data: KtAlertData, config?: _ktortu_aaa_dialog.KtDialogOpenerConfig<KtAlertData, void, KtAlertDialog> | undefined) => DialogRef<void, KtAlertDialog>;
+/** Option de variante visuelle pour le bouton d'action principal. */
+type KtDialogColor = KtButtonColor;
+/**
+ * Configuration pour l'ouverture d'une boîte de dialogue de confirmation binaire (Oui/Non).
+ */
+interface KtConfirmConfig {
+    /** Titre de la boîte de dialogue. */
+    title: string;
+    /**
+     * Message explicatif. Peut être une simple chaîne ou un tableau
+     * de chaînes de caractères pour composer plusieurs paragraphes.
+     * Supporte le HTML désinfecté à l'affichage.
+     */
+    message: string | string[];
+    /** Libellé du bouton de validation. Par défaut: 'Oui'. */
+    confirmLabel?: string;
+    /** Libellé du bouton de rejet. Par défaut: 'Non'. */
+    rejectLabel?: string;
+    /**
+     * Variante de couleur du bouton principal.
+     * Utile pour marquer une action destructive ou critique.
+     * Par défaut: 'primary'.
+     */
+    color?: KtDialogColor;
+}
+/**
+ * Configuration pour une décision ternaire (inclut obligatoirement un bouton d'annulation).
+ */
+interface KtDecideConfig extends KtConfirmConfig {
+    /** Libellé du bouton d'annulation. Requis. */
+    cancelLabel: string;
+}
+/**
+ * Type de retour d'une boîte de dialogue de confirmation ou de décision.
+ * - 'confirm' : Choix de validation (Oui / Enregistrer)
+ * - 'reject' : Choix de rejet (Non / Ignorer)
+ * - 'cancel' : Choix d'annulation (Annuler)
+ */
+type KtConfirmResult = 'confirm' | 'reject' | 'cancel';
+/**
+ * Composant interne de confirmation/décision générique.
+ * Supporte le mode binaire (Oui/Non) et le mode ternaire (Oui/Non/Annuler).
+ * Gère l'empilement vertical des boutons et les messages HTML multi-lignes.
+ */
+declare class KtConfirmDialog {
+    protected readonly data: KtDecideConfig;
+    private readonly ref;
+    protected isMessageArray(): boolean;
+    protected messageArray(): string[];
+    protected messageString(): string;
+    protected confirm(): void;
+    protected reject(): void;
+    protected cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtConfirmDialog, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KtConfirmDialog, "kt-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+/** Ouvreur co-localisé officiel pour la confirmation/décision. Utilise la présentation responsive par défaut. */
+declare const injectConfirmDialog: () => (data: KtDecideConfig, config?: _ktortu_aaa_dialog.KtDialogOpenerConfig<KtDecideConfig, KtConfirmResult, KtConfirmDialog> | undefined) => DialogRef<KtConfirmResult, KtConfirmDialog>;
+/**
+ * Service d'aide global pour l'ouverture simplifiée de boîtes de dialogue d'alerte et de confirmation.
+ * S'appuie sur les ouvreurs de dialogues officiels co-localisés.
+ * Propose une présentation adaptative (centrée sur grand écran, bottom-sheet sur mobile).
+ */
+declare class KtQuickDialog {
+    private readonly openAlert;
+    private readonly openConfirm;
+    /**
+     * Ouvre une boîte de dialogue d'alerte simple.
+     *
+     * @param title Titre de l'alerte.
+     * @param message Message d'explication (string simple ou tableau de strings pour du multi-lignes HTML).
+     * @param closeLabel Libellé du bouton de fermeture.
+     * @returns La référence DialogRef de la modale ouverte.
+     */
+    alert(title: string, message: string | string[], closeLabel?: string): DialogRef<void, KtAlertDialog>;
+    /**
+     * Ouvre une boîte de dialogue de confirmation binaire (Oui/Non).
+     *
+     * @param config Options de configuration (titre, message, libellés de boutons, couleur).
+     * @returns Un Observable émettant true si l'utilisateur valide (Oui),
+     *          false s'il rejette (Non), et undefined si la boîte est fermée en cliquant en dehors ou via Échap.
+     */
+    confirm(config: KtConfirmConfig): Observable<boolean | undefined>;
+    /**
+     * Ouvre une boîte de dialogue de décision ternaire (Oui/Non/Annuler).
+     *
+     * @param config Options de configuration (titre, message, libellés de boutons dont cancelLabel obligatoire).
+     * @returns Un Observable émettant 'confirm', 'reject', 'cancel' ou undefined si fermeture externe.
+     */
+    decide(config: KtDecideConfig): Observable<KtConfirmResult | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtQuickDialog, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KtQuickDialog>;
+}
+
 /**
  * Import ergonomique de toute la famille dialog en une fois :
  * `imports: [KtDialogImports]` au lieu d'énumérer chaque directive structurelle.
  */
 declare const KtDialogImports: readonly [typeof KtDialogHeader, typeof KtDialogTitle, typeof KtDialogDescription, typeof KtDialogContent, typeof KtDialogActions, typeof KtDialogClose, typeof KtDialogFocusInitial, typeof KtDialogSheetHandle];
 
-export { KT_DIALOG_AAA_DEFAULTS, KtDialogActions, KtDialogClose, KtDialogContainer, KtDialogContent, KtDialogDescription, KtDialogFocusInitial, KtDialogHeader, KtDialogImports, KtDialogSheetHandle, KtDialogTitle, defineKtDialog, injectKtDialogOpener, provideKtDialogDefaults, resolveKtDialogPanelClass };
-export type { KtDialogContract, KtDialogOpenerConfig, KtDialogPresentation };
+export { KT_DIALOG_AAA_DEFAULTS, KtAlertDialog, KtConfirmDialog, KtDialogActions, KtDialogClose, KtDialogContainer, KtDialogContent, KtDialogDescription, KtDialogFocusInitial, KtDialogHeader, KtDialogImports, KtDialogSheetHandle, KtDialogTitle, KtQuickDialog, defineKtDialog, injectAlertDialog, injectConfirmDialog, injectKtDialogOpener, provideKtDialogDefaults, resolveKtDialogPanelClass };
+export type { KtAlertData, KtConfirmConfig, KtConfirmResult, KtDecideConfig, KtDialogColor, KtDialogContract, KtDialogOpenerConfig, KtDialogPresentation };

package/types/ktortu-aaa-disclosure.d.ts

@@ -1,4 +1,6 @@
 import * as i0 from '@angular/core';
+import { AfterViewInit, AfterContentInit, InjectionToken } from '@angular/core';
+import * as _ktortu_aaa_disclosure from '@ktortu/aaa/disclosure';
 
 /**
  * Déclencheur d'un [ktDisclosure] : posé sur un **vrai `<button>`** (clavier Entrée/Espace
@@ -16,14 +18,14 @@ import * as i0 from '@angular/core';
  * <button ktDisclosureToggle [chevron]="false">Détails</button>  <!-- sans chevron -->
  * ```
  */
-declare class KtDisclosureToggle {
-    readonly disclosure: KtDisclosure;
+declare class KtDisclosureToggle implements AfterViewInit {
+    readonly disclosure: _ktortu_aaa_disclosure.KtDisclosureInterface;
     private readonly host;
     private readonly auditEnabled;
-    private isDestroyed;
     /** Affiche le chevron décoratif (qui pivote selon l'état). @default true */
     readonly chevron: i0.InputSignalWithTransform<boolean, unknown>;
     constructor();
+    ngAfterViewInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<KtDisclosureToggle, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<KtDisclosureToggle, "button[ktDisclosureToggle]", never, { "chevron": { "alias": "chevron"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -31,7 +33,7 @@ declare class KtDisclosureToggle {
 /**
  * Panneau repliable d'un [ktDisclosure]. **Composant** (et non directive) car l'animation grid
  * `0fr ↔ 1fr` exige un **unique enfant `overflow:hidden`** autour du contenu projeté — ce wrapper
- * (`.kt-disclosure-content__inner`) est fourni par le template, le consommateur reste libre d'y
+ * (`.kt-disclosure-content__inner`) est fourni by le template, le consommateur reste libre d'y
  * mettre autant de blocs qu'il veut.
  *
  * Porte l'`id` (cible de `aria-controls`) et passe **`inert`** quand c'est fermé : le contenu
@@ -47,7 +49,7 @@ declare class KtDisclosureToggle {
  * ```
  */
 declare class KtDisclosureContent {
-    readonly disclosure: KtDisclosure;
+    readonly disclosure: _ktortu_aaa_disclosure.KtDisclosureInterface;
     static ɵfac: i0.ɵɵFactoryDeclaration<KtDisclosureContent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<KtDisclosureContent, "kt-disclosure-content", never, {}, {}, never, ["*"], true, never>;
 }
@@ -76,10 +78,9 @@ declare class KtDisclosureContent {
  * </div>
  * ```
  */
-declare class KtDisclosure {
+declare class KtDisclosure implements AfterContentInit {
     private readonly idGen;
     private readonly host;
-    private isDestroyed;
     /** Identifiant stable du panneau contrôlé : cible de l'`aria-controls` du déclencheur. */
     readonly contentId: string;
     /**
@@ -92,7 +93,7 @@ declare class KtDisclosure {
     private readonly auditEnabled;
     readonly toggles: i0.Signal<readonly KtDisclosureToggle[]>;
     readonly contents: i0.Signal<readonly KtDisclosureContent[]>;
-    constructor();
+    ngAfterContentInit(): void;
     /** Bascule l'état. */
     toggle(): void;
     /** Ouvre le panneau. */
@@ -103,10 +104,18 @@ declare class KtDisclosure {
     static ɵdir: i0.ɵɵDirectiveDeclaration<KtDisclosure, "[ktDisclosure]", ["ktDisclosure"], { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, ["toggles", "contents"], never, true, never>;
 }
 
+interface KtDisclosureInterface {
+    readonly contentId: string;
+    readonly expanded: () => boolean;
+    toggle(): void;
+}
+declare const KT_DISCLOSURE: InjectionToken<KtDisclosureInterface>;
+
 /**
  * Import ergonomique de toute la famille disclosure en une fois :
  * `imports: [KtDisclosureImports]` au lieu d'énumérer chaque marqueur.
  */
 declare const KtDisclosureImports: readonly [typeof KtDisclosure, typeof KtDisclosureToggle, typeof KtDisclosureContent];
 
-export { KtDisclosure, KtDisclosureContent, KtDisclosureImports, KtDisclosureToggle };
+export { KT_DISCLOSURE, KtDisclosure, KtDisclosureContent, KtDisclosureImports, KtDisclosureToggle };
+export type { KtDisclosureInterface };

package/types/ktortu-aaa-forms.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Signal, Provider, TemplateRef, ModelSignal, ElementRef, PipeTransform } from '@angular/core';
+import { InjectionToken, Signal, Provider, TemplateRef, ModelSignal, ElementRef, AfterViewInit, PipeTransform } from '@angular/core';
 import * as _angular_forms_signals from '@angular/forms/signals';
 import { ValidationError, WithOptionalFieldTree, FormValueControl } from '@angular/forms/signals';
 import * as _ktortu_aaa_forms from '@ktortu/aaa/forms';
@@ -703,7 +703,7 @@ declare class KtCheckboxGroup<V> implements FormValueControl<V[]> {
  * </kt-checkbox-group>
  * ```
  */
-declare class KtCheckbox<V = unknown> implements FormValueControl<boolean> {
+declare class KtCheckbox<V = unknown> implements FormValueControl<boolean>, AfterViewInit {
     private readonly config;
     /** Groupe parent optionnel : présent ⇒ la case appartient à un `kt-checkbox-group`. */
     protected readonly group: KtCheckboxGroup<V> | null;
@@ -766,6 +766,7 @@ declare class KtCheckbox<V = unknown> implements FormValueControl<boolean> {
     protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
     protected readonly describedBy: _angular_core.Signal<string | null>;
     constructor();
+    ngAfterViewInit(): void;
     /** Focus la case native (utilisé par Signal Forms `focusBoundControl`). */
     focus(options?: FocusOptions): void;
     protected onChange(event: Event): void;