@ktortu/aaa 0.9.9 → 0.10.1

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, Provider } from '@angular/core';
+import { OnInit, OnDestroy, InjectionToken, Provider } from '@angular/core';
 import { DialogConfig, DialogRef, CdkDialogContainer } from '@angular/cdk/dialog';
 import { ComponentType } from '@angular/cdk/portal';
 import * as _ktortu_aaa_dialog from '@ktortu/aaa/dialog';
@@ -105,6 +105,10 @@ declare class KtDialogClose {
  * aria-labelledby). En usage simple — titre nu sans header — [ktDialogTitle] conserve son propre
  * padding : ce header n'est à utiliser que pour les en-têtes composés (icône, close top-right…).
  *
+ * ⚠️ Ne rend RIEN par lui-même — pas de bouton de fermeture implicite : c'est vous qui posez la
+ * croix (cf. exemple). En présentation `sheet`, l'option `sheetCloseButton` en rend une
+ * automatiquement, hors flux ; les deux ensemble feraient doublon (le conteneur avertit en dev).
+ *
  * @example
  * ```html
  * <header ktDialogHeader>
@@ -163,7 +167,7 @@ declare class KtDialogFocusInitial {
 }
 /**
  * @deprecated ADR-0005 — la poignée est désormais RENDUE AUTOMATIQUEMENT par `KtDialogContainer`
- * en présentation `sheet` (opt-out : panelClass additionnel `kt-dialog--no-handle`), et le
+ * en présentation `sheet` (opt-out : option typée `sheetHandle: false`), et le
  * drag-to-dismiss s'attrape sur TOUTE la surface de la sheet (scroll-snap natif). Cette
  * directive est INERTE et son hôte est masqué (évite une double poignée) : retirez-la de vos
  * templates. Sera supprimée dans une prochaine version majeure.
@@ -207,6 +211,63 @@ declare const KT_DIALOG_AAA_DEFAULTS: DialogConfig;
  * @returns Un `Provider` pour le token `DEFAULT_DIALOG_CONFIG`.
  */
 declare function provideKtDialogDefaults(overrides?: Partial<DialogConfig>): Provider;
+/**
+ * Options MAISON du dialog (≠ {@link KT_DIALOG_AAA_DEFAULTS}, qui porte la config du CDK).
+ * Conforme à l'ADR-0003 : un token `KT_*_CONFIG` par entry-point, défauts anglais neutres,
+ * cascade `option d'ouverture ?? token ?? défaut`.
+ *
+ * Toutes les clés actuelles ne concernent que la présentation `sheet` (préfixe `sheet*`) : sur les
+ * présentations `centered` / `fullscreen`, la place d'un bouton de fermeture est un
+ * `[ktDialogHeader]`, où on le POSE soi-même, dans le flux. Un usage hors sheet déclenche un
+ * avertissement en mode dev.
+ */
+interface KtDialogConfig {
+    /**
+     * Bouton de fermeture AUTO-RENDU en haut de la carte, en présentation `sheet`.
+     *
+     * Désactivé par défaut, pour une raison de COMPATIBILITÉ, pas d'ergonomie : `[ktDialogHeader]`
+     * ne rend aucune croix (c'est une simple rangée flex), mais un dialog qui en compose un y place
+     * généralement la sienne à la main. Activer l'option par défaut ferait donc apparaître une
+     * DEUXIÈME croix chez ces consommateurs-là sans qu'ils aient rien changé.
+     *
+     * Recommandé sur toute sheet qui ne pose pas déjà son propre bouton de fermeture en tête.
+     * @default false
+     */
+    sheetCloseButton: boolean;
+    /** Nom accessible du bouton de fermeture auto-rendu (WCAG 4.1.2). @default 'Close' */
+    sheetCloseLabel: string;
+    /** Poignée décorative auto-rendue en présentation `sheet` (ADR-0005). @default true */
+    sheetHandle: boolean;
+}
+/**
+ * Défauts effectifs des options maison du dialog. Objet `Required` figé : c'est la SOURCE des
+ * valeurs de repli, lue à la fois par l'ouvreur (résolution) et par le conteneur (fusion
+ * idempotente), et énumérée par la garde de complétude i18n.
+ */
+declare const DEFAULT_KT_DIALOG_CONFIG: Required<KtDialogConfig>;
+/**
+ * Token des options maison du dialog. Deux usages, un seul chemin de résolution :
+ * - **application** : fourni via {@link provideKtDialog} (valeur partielle) ;
+ * - **par ouverture** : `injectKtDialogOpener` REFOURNIT ce même token, déjà RÉSOLU, dans
+ *   l'injecteur du conteneur (canal `container.providers` du CDK). Le conteneur fusionne
+ *   toujours par-dessus {@link DEFAULT_KT_DIALOG_CONFIG} : l'opération est idempotente sur une
+ *   valeur déjà résolue, et reste correcte si le conteneur est monté sans passer par l'ouvreur.
+ */
+declare const KT_DIALOG_CONFIG: InjectionToken<Partial<KtDialogConfig>>;
+/**
+ * Enregistre les options maison du dialog pour l'application (ou un sous-arbre).
+ * Complémentaire de {@link provideKtDialogDefaults}, qui porte la config du CDK : les deux
+ * coexistent et ne se recouvrent pas.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts — bouton de fermeture sur toutes les bottom-sheets
+ * providers: [provideKtDialog({ sheetCloseButton: true })];
+ * ```
+ * @param config Options partielles fusionnées par-dessus `DEFAULT_KT_DIALOG_CONFIG`.
+ * @returns Un `Provider` pour le token `KT_DIALOG_CONFIG`.
+ */
+declare function provideKtDialog(config: Partial<KtDialogConfig>): Provider;
 /**
  * Présentation du dialog, CHOISIE EXPLICITEMENT PAR LE DÉVELOPPEUR à l'ouverture (option
  * `presentation` de `injectKtDialogOpener`). Aucune bascule CSS automatique : le dev décide.
@@ -236,8 +297,11 @@ type KtDialogPresentation = 'centered' | 'fullscreen' | 'sheet' | 'centered-full
  */
 declare function resolveKtDialogPanelClass(presentation?: KtDialogPresentation, compact?: boolean): string[];
 
-/** Config d'ouverture sans le champ `data` (fourni séparément, typé), enrichie de `presentation`. */
-type KtDialogOpenerConfig<D, R, C> = Omit<DialogConfig<D, DialogRef<R, C>>, 'data'> & {
+/**
+ * Config d'ouverture sans le champ `data` (fourni séparément, typé), enrichie de `presentation` et
+ * des options maison de {@link KtDialogConfig} (surcharge par ouverture de `KT_DIALOG_CONFIG`).
+ */
+type KtDialogOpenerConfig<D, R, C> = Omit<DialogConfig<D, DialogRef<R, C>>, 'data'> & Partial<KtDialogConfig> & {
     /** Présentation du dialog (cf. `KtDialogPresentation`) — choisie par le dev. Résolue à CHAQUE
         ouverture : les variantes responsive lisent le signal d'écran compact. Défaut : `'centered'`.
         Combinée à un éventuel `panelClass` additionnel. */
@@ -343,6 +407,11 @@ declare class KtDialogContainer extends CdkDialogContainer {
     private readonly platformId;
     private readonly destroyRef;
     private readonly bodyScrollLock;
+    /** Options maison RÉSOLUES. `injectKtDialogOpener` refournit `KT_DIALOG_CONFIG` déjà résolu dans
+        l'injecteur du conteneur : la fusion ci-dessous est alors un no-op. Elle reste indispensable
+        quand le conteneur est monté sans l'ouvreur (`dialog.open` brut), où le token remonte à
+        l'application et n'est que partiel. Un seul chemin de code, idempotent. */
+    protected readonly ktConfig: Required<KtDialogConfig>;
     protected readonly isClosing: i0.WritableSignal<boolean>;
     /** Armé quand l'ouverture a dépassé 50px : un repos à ~0 est alors forcément le snap « fermé ». */
     private sheetArmed;
@@ -355,9 +424,25 @@ declare class KtDialogContainer extends CdkDialogContainer {
         renomme ce membre, on dégrade proprement vers `null` au lieu de casser le rendu du conteneur. */
     protected get ariaLabelledBy(): string | null;
     constructor();
+    /** Garde-fous dev sur la config maison : usage hors sheet, double bouton de fermeture, opt-out
+        déprécié de la poignée. On AVERTIT sans jamais corriger en silence — un masquage automatique
+        dépendrait de l'ordre de rendu du portail et serait indébogable. */
+    private warnOnConfigMisuse;
     protected isSheet(): boolean;
-    /** Poignée décorative auto-rendue en présentation sheet. Opt-out : panelClass `kt-dialog--no-handle`. */
+    /** panelClass d'opt-out historique de la poignée — repli DÉPRÉCIÉ, remplacé par `sheetHandle`. */
+    private hasLegacyNoHandleClass;
+    /** Poignée décorative auto-rendue en présentation sheet (ADR-0005). Opt-out : option `sheetHandle`
+        (le panelClass historique reste honoré, en déprécié). */
     protected showSheetHandle(): boolean;
+    /** Bouton de fermeture auto-rendu : opt-in `sheetCloseButton`, et UNIQUEMENT en présentation sheet
+        (ailleurs, la croix se pose à la main dans un `[ktDialogHeader]` — cf. `KtDialogConfig`). */
+    protected showSheetClose(): boolean;
+    /** Clic sur le bouton de fermeture auto-rendu. Ne consulte VOLONTAIREMENT pas `disableClose` :
+        contrairement au tap-extérieur et à Échap (fermetures « par inadvertance » que `disableClose`
+        protège), ce bouton est une sortie EXPLICITEMENT demandée par le dev via `sheetCloseButton` —
+        le combiner à `disableClose` est le patron « une seule sortie contrôlée ». Le drapeau
+        `isClosing` garde l'idempotence face à un geste de glissement simultané. */
+    protected onSheetCloseClick(): void;
     /** Tap sur le spacer (zone extérieure à la carte) = fermeture, façon backdrop. Le conteneur
         captant désormais le tactile (pointer-events auto, requis pour le drag iOS), le clic ne
         traverse plus vers le backdrop CDK : on porte donc ICI la fermeture au tap-extérieur, en
@@ -531,5 +616,5 @@ declare class KtQuickDialog {
     static ɵprov: i0.ɵɵInjectableDeclaration<KtQuickDialog>;
 }
 
-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, KtAlertDialogVariant, KtAlertOptions, KtConfirmConfig, KtConfirmResult, KtDecideConfig, KtDialogColor, KtDialogContract, KtDialogOpenerConfig, KtDialogPresentation };
+export { DEFAULT_KT_DIALOG_CONFIG, KT_DIALOG_AAA_DEFAULTS, KT_DIALOG_CONFIG, KtAlertDialog, KtConfirmDialog, KtDialogActions, KtDialogClose, KtDialogContainer, KtDialogContent, KtDialogDescription, KtDialogFocusInitial, KtDialogHeader, KtDialogImports, KtDialogSheetHandle, KtDialogTitle, KtQuickDialog, defineKtDialog, injectAlertDialog, injectConfirmDialog, injectKtDialogOpener, provideKtDialog, provideKtDialogDefaults, resolveKtDialogPanelClass };
+export type { KtAlertData, KtAlertDialogVariant, KtAlertOptions, KtConfirmConfig, KtConfirmResult, KtDecideConfig, KtDialogColor, KtDialogConfig, KtDialogContract, KtDialogOpenerConfig, KtDialogPresentation };

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

@@ -1284,6 +1284,8 @@ interface KtSelectConfigOptions {
     truncatedResultsText: (max: number, total: number) => string;
     /** Annonce de la troncature des résultats (live region). Défaut : `'X results displayed out of Y...'`. */
     truncatedResultsAnnouncement: (max: number, total: number) => string;
+    /** Libellé du bouton de validation en bas de la sheet mobile (opt-in, multi-select). Défaut : `''` (aucun bouton). */
+    validationButtonLabel: string;
 }
 declare const KT_SELECT_CONFIG: InjectionToken<Partial<KtSelectConfigOptions>>;
 /**
@@ -1432,10 +1434,13 @@ declare class KtMultiSelect<T, V = T> extends KtBaseSelect<T, V> implements Form
     readonly selectionActions: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Nombre maximal de chips affichés avant repli derrière un bouton « +N more ». Défaut : illimité. */
     readonly maxVisibleChips: _angular_core.InputSignal<number | undefined>;
+    /** Libellé du bouton de validation affiché en bas de la sheet mobile. Défaut : `KT_SELECT_CONFIG.validationButtonLabel` ou vide. */
+    readonly validationButtonLabel: _angular_core.InputSignal<string | undefined>;
     protected readonly optionDef: _angular_core.Signal<KtMultiSelectOptionDef<any> | undefined>;
     protected readonly triggerDef: _angular_core.Signal<KtMultiSelectTriggerDef<any> | undefined>;
     protected readonly chipDef: _angular_core.Signal<KtMultiSelectChipDef<any> | undefined>;
     private readonly chipList;
+    protected readonly resolvedValidationButtonLabel: _angular_core.Signal<string>;
     protected readonly resolvedRemoveItemLabel: _angular_core.Signal<(itemLabel: string) => string>;
     protected readonly resolvedSelectedItemsLabel: _angular_core.Signal<string>;
     private readonly resolvedSelectionSummaryText;
@@ -1487,8 +1492,10 @@ declare class KtMultiSelect<T, V = T> extends KtBaseSelect<T, V> implements Form
     protected clearAllFiltered(): void;
     /** Annonce immédiate (action ponctuelle, pas de débounce) du total sélectionné. */
     private announceSelectionCount;
+    /** Valide la sélection depuis la sheet mobile (ferme le popup, marque le champ comme visité et replace le focus sur le trigger). */
+    protected validateSheet(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtMultiSelect<any, any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtMultiSelect<any, any>, "kt-multi-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionActions": { "alias": "selectionActions"; "required": false; "isSignal": true; }; "maxVisibleChips": { "alias": "maxVisibleChips"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selectionChange": "selectionChange"; }, ["optionDef", "triggerDef", "chipDef"], ["[ktFieldHelp]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtMultiSelect<any, any>, "kt-multi-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionActions": { "alias": "selectionActions"; "required": false; "isSignal": true; }; "maxVisibleChips": { "alias": "maxVisibleChips"; "required": false; "isSignal": true; }; "validationButtonLabel": { "alias": "validationButtonLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selectionChange": "selectionChange"; }, ["optionDef", "triggerDef", "chipDef"], ["[ktFieldHelp]"], true, never>;
 }
 
 /** Portée de transition des chips. Fourni par `ChipList` (via `useExisting`) ; injecté en

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

@@ -2,6 +2,7 @@ import { EnvironmentProviders } from '@angular/core';
 import { KtFieldConfig, KtSelectConfigOptions, KtChipsConfig } from '@ktortu/aaa/forms';
 import { KtSnackbarConfig } from '@ktortu/aaa/snackbar';
 import { KtTabsConfig } from '@ktortu/aaa/tabs';
+import { KtDialogConfig } from '@ktortu/aaa/dialog';
 
 /**
  * Agrégat de TOUS les libellés traduisibles de la lib, groupés par famille de composants.
@@ -23,6 +24,8 @@ interface KtTranslations {
     snackbar?: Partial<KtSnackbarConfig>;
     /** Libellés de la pagination des onglets → {@link KT_TABS_CONFIG}. */
     tabs?: Partial<KtTabsConfig>;
+    /** Libellés du dialog (`sheetCloseLabel`) → {@link KT_DIALOG_CONFIG}. */
+    dialog?: Partial<KtDialogConfig>;
 }
 /**
  * Enregistre, en un seul appel, les libellés fournis sur les tokens de config de la lib.

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

@@ -0,0 +1,158 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
+
+/**
+ * Définition d'une police d'icônes **à ligatures** enregistrée dans le registre (cf.
+ * {@link KtIconConfig}). Le registre ne charge AUCUNE police : il se contente d'associer un alias
+ * court à la famille CSS réelle (à vous de charger le fichier de police, façon « apportez la vôtre »).
+ */
+interface KtIconFont {
+    /** Famille de police CSS réelle (ex. `'Material Symbols Rounded'`). Valeur `font-family` brute :
+        si elle commence par un chiffre ou contient des caractères spéciaux, la citer vous-même. */
+    family: string;
+    /** Graisse par défaut de cette police (ex. `300` ou `'normal'`). @default hérité de `--kt-icon-font-weight` */
+    weight?: string | number;
+    /** `font-variation-settings` par défaut (polices variables, ex. `"'FILL' 0, 'wght' 300"`). @default `normal` */
+    variationSettings?: string;
+}
+/**
+ * Défauts applicables à toutes les icônes `[ktIcon]` (registre de polices + police par défaut),
+ * fournis via {@link provideKtIcon}. Fourni en `Partial` : on ne déclare que ce qu'on veut.
+ */
+interface KtIconConfig {
+    /** Registre `alias → police`. L'alias est ensuite choisi sur la primitive via `[font]`. */
+    fonts: Record<string, KtIconFont>;
+    /** Alias utilisé quand aucune police n'est précisée sur la primitive (`[font]` absent). */
+    defaultFont: string;
+}
+/**
+ * Interface d'**enregistrement des alias de POLICE** à augmenter côté application pour typer l'input
+ * `[font]` et obtenir son **autocomplétion** dans les templates. Vide par défaut : sans augmentation,
+ * `[font]` accepte n'importe quelle chaîne (dégradation gracieuse, zéro config).
+ *
+ * Nommée `KtIconFontRegistry` (et non `KtIconRegistry`) à dessein : le nom générique reste réservé à
+ * un futur registre de **noms d'icônes** (SVG), qui bénéficiera du même mécanisme.
+ *
+ * @example Recette à source unique (le même objet type ET fournit le registre) :
+ * ```ts
+ * // app-icons.ts
+ * export const APP_ICON_FONTS = {
+ *   material: { family: 'Material Symbols Outlined' },
+ *   rounded: { family: 'Material Symbols Rounded', variationSettings: "'FILL' 0, 'wght' 300" },
+ * } as const;
+ *
+ * declare module '@ktortu/aaa/icon' {
+ *   // Injecte les clés de APP_ICON_FONTS comme alias connus → autocomplétion de [font].
+ *   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+ *   interface KtIconFontRegistry extends Record<keyof typeof APP_ICON_FONTS, unknown> {}
+ * }
+ *
+ * // app.config.ts
+ * providers: [provideKtIcon({ fonts: APP_ICON_FONTS, defaultFont: 'material' })];
+ * ```
+ */
+interface KtIconFontRegistry {
+}
+/**
+ * Alias de police connus : l'union des clés de {@link KtIconFontRegistry} une fois augmentée, sinon
+ * `string` (registre vide → chaîne libre). Le tuple `[…] extends […]` évite la distribution du
+ * conditionnel sur l'union.
+ */
+type KtIconFontAlias = [keyof KtIconFontRegistry] extends [never] ? string : keyof KtIconFontRegistry;
+declare const KT_ICON_CONFIG: InjectionToken<Partial<KtIconConfig>>;
+/**
+ * Fournit un registre de polices d'icônes (alias → famille) et l'alias par défaut, pour un
+ * sous-arbre ou l'application entière. Combiné à l'augmentation de {@link KtIconFontRegistry}, il
+ * offre l'autocomplétion typée de l'input `[font]`.
+ *
+ * `defaultFont` est **contraint aux clés de `fonts`** passées dans le même appel : un typo devient
+ * une erreur de compilation (pas de repli silencieux de toutes les icônes sur la police globale).
+ *
+ * @example
+ * ```ts
+ * providers: [
+ *   provideKtIcon({
+ *     fonts: {
+ *       material: { family: 'Material Symbols Outlined' },
+ *       rounded: { family: 'Material Symbols Rounded' },
+ *     },
+ *     defaultFont: 'material', // 'rouded' → erreur TS
+ *   }),
+ * ];
+ * ```
+ */
+declare function provideKtIcon<F extends Record<string, KtIconFont>>(config: {
+    fonts?: F;
+    defaultFont?: keyof F & string;
+}): Provider;
+/**
+ * Primitive d'icône **autonome** : pose une icône seule (en-tête, item de liste, badge d'état…),
+ * là où le bouton et les champs ne suffisent pas. Directive présentationnelle — **jamais focusable
+ * ni cliquable** (pour une icône cliquable, utilisez `ktButton iconOnly`).
+ *
+ * Sélecteur d'attribut `[ktIcon]` (camelCase) ; l'hôte reçoit la classe stable `.kt-icon` (cible du
+ * style et du harness). Ne pas confondre avec le slot de projection `[kt-icon]` (kebab) de
+ * `kt-nav-item`, qui est un autre mécanisme.
+ *
+ * Deux régimes, comme dans le reste de la lib :
+ * - **Ligature** (`[ktIcon]="nom"`) : le nom devient un glyphe via une police d'icônes à ligatures
+ *   (défaut `--kt-icon-font` → Material Symbols Outlined). Choisissez une autre police enregistrée
+ *   via `[font]`.
+ * - **Projection** (set à classes, ex. Font Awesome, ou SVG en ligne) : laissez `ktIcon` vide et
+ *   projetez votre markup dans l'élément ; la primitive ne fait que l'habiller (taille, couleur
+ *   héritée, alignement). Le contenu projeté **ne doit jamais être focusable** (l'hôte décoratif
+ *   porte `aria-hidden` : un descendant focusable violerait WCAG 4.1.2).
+ *
+ * Accessibilité : **décorative par défaut** (`aria-hidden`). Fournissez `[ariaLabel]` (ou un
+ * `aria-label` natif) pour une icône **porteuse de sens** (bascule en `role="img"`).
+ *
+ * @example
+ * ```html
+ * <!-- Ligature autonome, taille et couleur héritées du contexte ; `fill` = version remplie -->
+ * <span ktIcon="home"></span>
+ * <span ktIcon="favorite" fill size="2rem" style="color: var(--kt-primary)"></span>
+ *
+ * <!-- Set à classes (Font Awesome) : projection, ktIcon reste vide -->
+ * <span ktIcon><i class="fa-solid fa-user"></i></span>
+ *
+ * <!-- Icône porteuse de sens (nommée pour les lecteurs d'écran) -->
+ * <span ktIcon="error" ariaLabel="Erreur" style="color: var(--kt-danger)"></span>
+ * ```
+ */
+declare class KtIcon {
+    private readonly config;
+    private readonly auditEnabled;
+    private readonly platformId;
+    private readonly host;
+    private readonly nativeAriaLabel;
+    /** Nom de l'icône (ligature). Laisser vide pour projeter un set à classes / un SVG. @default '' */
+    readonly ktIcon: _angular_core.InputSignal<string>;
+    /** Alias de police d'icônes du registre (cf. {@link provideKtIcon}). @default `KtIconConfig.defaultFont` */
+    readonly font: _angular_core.InputSignal<string | undefined>;
+    /** Nom accessible : le fournir rend l'icône **porteuse de sens** (`role="img"`). Aligné sur `ktButton`.
+        @default undefined (icône décorative ; un `aria-label` natif reste toutefois préservé) */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Taille de l'icône (longueur CSS, ex. `'24px'`, `'2rem'`, `'1.5em'`). @default `1.25em` (héritée du contexte) */
+    readonly size: _angular_core.InputSignal<string | undefined>;
+    /** Version **remplie** plutôt que contour, pour les polices variables à axe `FILL` (Material Symbols).
+        Force `FILL` à 1 en préservant les autres axes (graisse…) ; sans effet sur une police sans cet axe.
+        Nécessite une police chargée **avec l'axe FILL ajustable** (ex. Google Fonts :
+        `…Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200`).
+        @default false (contour) */
+    readonly fill: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Nom rendu en ligature : coupé, `null` si vide (aucun `::before`, laisse place à la projection). */
+    protected readonly renderedName: _angular_core.Signal<string | null>;
+    /** Libellé accessible résolu : input prioritaire, sinon `aria-label` natif préservé, sinon `null` (décorative). */
+    protected readonly accessibleLabel: _angular_core.Signal<string | null>;
+    /** Police résolue depuis le registre : alias explicite, sinon police par défaut du provider. */
+    private readonly resolvedFont;
+    protected readonly resolvedFamily: _angular_core.Signal<string | null>;
+    protected readonly resolvedWeight: _angular_core.Signal<string | null>;
+    protected readonly resolvedVariation: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtIcon, "[ktIcon]", never, { "ktIcon": { "alias": "ktIcon"; "required": false; "isSignal": true; }; "font": { "alias": "font"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { KT_ICON_CONFIG, KtIcon, provideKtIcon };
+export type { KtIconConfig, KtIconFont, KtIconFontAlias, KtIconFontRegistry };

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

@@ -77,11 +77,21 @@ declare class KtToolbarComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtToolbarComponent, "kt-toolbar", never, {}, {}, never, ["*"], true, never>;
 }
 
+/**
+ * Item de navigation : projette une icône dans son slot dédié + un libellé.
+ *
+ * Le slot d'icône accepte :
+ * - la directive `[ktIcon]` (primitive d'icône `@ktortu/aaa/icon`), forme canonique.
+ * - l'attribut de projection `kt-icon` (historique/legacy).
+ *
+ * Note : la classe `.kt-icon` (posée à l'exécution par la directive) n'est PAS un critère de
+ * projection valable (ng-content matche la forme statique du template) — d'où le sélecteur d'attribut.
+ */
 declare class KtNavItemComponent {
     label: _angular_core.InputSignal<string>;
     protected readonly layout: KtLayoutService;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtNavItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtNavItemComponent, "kt-nav-item", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["[kt-icon]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtNavItemComponent, "kt-nav-item", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["[ktIcon], [kt-icon]", "*"], true, never>;
 }
 
 /**

package/types/ktortu-aaa.d.ts

@@ -5,6 +5,7 @@ export * from '@ktortu/aaa/dialog';
 export * from '@ktortu/aaa/disclosure';
 export * from '@ktortu/aaa/forms';
 export * from '@ktortu/aaa/i18n';
+export * from '@ktortu/aaa/icon';
 export * from '@ktortu/aaa/menu';
 export * from '@ktortu/aaa/snackbar';
 export * from '@ktortu/aaa/tabs';