@ktortu/aaa 0.1.0-beta.0 → 0.9.1

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

@@ -0,0 +1,77 @@
+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';
+
+/**
+ * Agrégat de TOUS les libellés traduisibles de la lib, groupés par famille de composants.
+ * Chaque clé reprend la config du token correspondant (`Partial` : tout est optionnel — on ne
+ * fournit que ce qu'on veut traduire). C'est l'« interface de traduction » unique de la lib :
+ * un point d'entrée pour brancher une langue d'un coup.
+ *
+ * @see provideKtTranslations pour enregistrer un jeu de libellés.
+ * @see provideKtDefaultFR pour partir des libellés français.
+ */
+interface KtTranslations {
+    /** Libellés des champs (`clearLabel`, `helpLabel`) → {@link KT_FIELD_CONFIG}. */
+    field?: Partial<KtFieldConfig>;
+    /** Libellés des selects / multi-selects → {@link KT_SELECT_CONFIG}. */
+    select?: Partial<KtSelectConfigOptions>;
+    /** Libellés des listes de chips → {@link KT_CHIPS_CONFIG}. */
+    chips?: Partial<KtChipsConfig>;
+    /** Libellés de la snackbar (`closeLabel`) → {@link KT_SNACKBAR_CONFIG}. */
+    snackbar?: Partial<KtSnackbarConfig>;
+    /** Libellés de la pagination des onglets → {@link KT_TABS_CONFIG}. */
+    tabs?: Partial<KtTabsConfig>;
+}
+/**
+ * Enregistre, en un seul appel, les libellés fournis sur les tokens de config de la lib.
+ * Base = défauts anglais de chaque composant ; seules les familles **présentes** dans `t` sont
+ * fournies (les autres gardent leur défaut anglais et restent surchargeables ailleurs).
+ *
+ * À placer dans les `providers` de `app.config.ts` (ou de tout injecteur).
+ *
+ * @param t Libellés à fournir, groupés par famille ; seules les familles présentes sont enregistrées.
+ * @returns Les `EnvironmentProviders` liant chaque famille présente à son token de config.
+ * @example
+ * ```ts
+ * provideKtTranslations({ tabs: { nextLabel: 'Suivant', previousLabel: 'Précédent' } })
+ * ```
+ */
+declare function provideKtTranslations(t: KtTranslations): EnvironmentProviders;
+/**
+ * Fusion par famille de deux {@link KtTranslations} : `over` écrase `base`, clé par clé.
+ * @param base Libellés de référence (ex. un dictionnaire de langue complet).
+ * @param over Libellés prioritaires venant écraser `base`.
+ * @returns Un nouveau {@link KtTranslations} fusionné, famille par famille.
+ * @example mergeKtTranslations(KT_FR_TRANSLATIONS, { tabs: { nextLabel: 'Suivant' } })
+ */
+declare function mergeKtTranslations(base: KtTranslations, over: KtTranslations): KtTranslations;
+
+/**
+ * Dictionnaire **français** complet de tous les libellés de la lib. Figé et réutilisable :
+ * importable tel quel (ex. pour le composer avec d'autres réglages) ou via {@link provideKtDefaultFR}.
+ * Les libellés à pluriels sont des fonctions, pour laisser la grammaire au consommateur.
+ */
+declare const KT_FR_TRANSLATIONS: KtTranslations;
+/**
+ * Enregistre les libellés **français** par défaut sur toute la lib, en un seul appel.
+ * `overrides` permet d'ajuster ponctuellement sans tout réécrire (fusion par famille,
+ * cf. {@link mergeKtTranslations}). À placer dans les `providers` de `app.config.ts`.
+ *
+ * @param overrides Libellés à ajuster par-dessus le français (fusion par famille). Défaut : `{}`.
+ * @returns Les `EnvironmentProviders` enregistrant le français (fusionné aux `overrides`).
+ * @example
+ * ```ts
+ * // app.config.ts
+ * providers: [
+ *   provideKtDefaultFR(),                                // tout en français
+ *   // ou en ajustant un libellé précis :
+ *   provideKtDefaultFR({ tabs: { nextLabel: 'Suivant' } }),
+ * ]
+ * ```
+ */
+declare function provideKtDefaultFR(overrides?: KtTranslations): EnvironmentProviders;
+
+export { KT_FR_TRANSLATIONS, mergeKtTranslations, provideKtDefaultFR, provideKtTranslations };
+export type { KtTranslations };

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

@@ -48,7 +48,6 @@ declare class KtMenu {
  * ```
  */
 declare class KtMenuItem {
-    private readonly host;
     private readonly ariaItem;
     private readonly platformId;
     protected anchorName: string | undefined;
@@ -88,7 +87,6 @@ declare class KtMenuSeparator {
  * ```
  */
 declare class KtMenuTrigger {
-    private readonly host;
     private readonly ariaTrigger;
     private readonly platformId;
     private readonly idGen;
@@ -111,8 +109,13 @@ declare class KtMenuTrigger {
  */
 declare class KtMenuItemCheckbox {
     private readonly ariaItem;
-    /** État coché, bidirectionnel : `[(checked)]`. */
+    private readonly host;
+    /**
+     * État coché, bidirectionnel : `[(checked)]`.
+     * @default false
+     */
     readonly checked: i0.ModelSignal<boolean>;
+    constructor();
     protected activate(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<KtMenuItemCheckbox, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<KtMenuItemCheckbox, "[ktMenuItemCheckbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
@@ -133,7 +136,10 @@ declare const KT_MENU_RADIO_GROUP: InjectionToken<KtMenuRadioGroup<unknown>>;
  * ```
  */
 declare class KtMenuRadioGroup<V> {
-    /** Valeur sélectionnée du groupe, bidirectionnelle : `[(value)]`. */
+    /**
+     * Valeur sélectionnée du groupe, bidirectionnelle : `[(value)]`.
+     * @default null
+     */
     readonly value: i0.ModelSignal<V | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<KtMenuRadioGroup<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<KtMenuRadioGroup<any>, "[ktMenuRadioGroup]", ["ktMenuRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
@@ -151,7 +157,8 @@ declare class KtMenuRadioGroup<V> {
 declare class KtMenuItemRadio<V> {
     private readonly ariaItem;
     private readonly group;
-    /** Valeur portée par ce radio (comparée à celle du groupe). */
+    private readonly host;
+    /** Valeur portée par ce radio (comparée à celle du groupe). @default (requis) */
     readonly value: i0.InputSignal<V>;
     protected readonly checked: i0.Signal<boolean>;
     constructor();
@@ -162,10 +169,10 @@ declare class KtMenuItemRadio<V> {
 
 /**
  * Import ergonomique de toute la famille menu (couche de THÈME ktortu) en une fois :
- * `imports: [KT_MENU]` au lieu d'énumérer chaque directive. À composer avec les directives
+ * `imports: [KtMenuImports]` au lieu d'énumérer chaque directive. À composer avec les directives
  * d'`@angular/aria/menu` (`Menu`, `MenuItem`, `MenuTrigger`, `MenuContent`), qui apportent le
  * comportement accessible.
  */
-declare const KT_MENU: readonly [typeof KtMenu, typeof KtMenuItem, typeof KtMenuSeparator, typeof KtMenuTrigger, typeof KtMenuItemCheckbox, typeof KtMenuItemRadio, typeof KtMenuRadioGroup];
+declare const KtMenuImports: readonly [typeof KtMenu, typeof KtMenuItem, typeof KtMenuSeparator, typeof KtMenuTrigger, typeof KtMenuItemCheckbox, typeof KtMenuItemRadio, typeof KtMenuRadioGroup];
 
-export { KT_MENU, KT_MENU_RADIO_GROUP, KtMenu, KtMenuItem, KtMenuItemCheckbox, KtMenuItemRadio, KtMenuRadioGroup, KtMenuSeparator, KtMenuTrigger };
+export { KT_MENU_RADIO_GROUP, KtMenu, KtMenuImports, KtMenuItem, KtMenuItemCheckbox, KtMenuItemRadio, KtMenuRadioGroup, KtMenuSeparator, KtMenuTrigger };

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

@@ -0,0 +1,275 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/** Politesse de l'annonce au lecteur d'écran (relayée à `LiveAnnouncer`). */
+type KtSnackbarPoliteness = 'polite' | 'assertive';
+/** Bord d'ancrage de la snackbar dans le viewport. */
+type KtSnackbarPosition = 'top' | 'bottom';
+/**
+ * Régime temporel de la snackbar :
+ * - `'auto'` : disparition automatique après `duration`, **mise en pause au survol et au focus**
+ *   clavier (WCAG 1.4.13 / 2.2.1). Conforme **AA**. C'est le défaut.
+ * - `'manual'` : **aucune** minuterie, la snackbar reste jusqu'à fermeture explicite
+ *   (bouton de fermeture ou `ref.dismiss()`). Conforme **2.2.3 (AAA)** au sens strict.
+ *
+ * Conformément aux recommandations d'accessibilité (Roselli/Soueidan), la snackbar ne porte **pas
+ * d'action interactive** (ex. « Annuler ») : une action auto-disparaissante n'est pas atteignable et
+ * une live region n'expose pas ses boutons. Pour un undo, préférez un mécanisme atteignable côté app
+ * (Ctrl+Z, bannière persistante).
+ */
+type KtSnackbarTiming = 'auto' | 'manual';
+/**
+ * Variante sémantique de la snackbar. Pilote uniquement l'**apparence** (couleur d'accent + icône),
+ * via l'attribut `data-variant` et les tokens CSS `--snackbar-*` — donc entièrement gérée par le
+ * thème, sans logique TypeScript. Découplée de la `politeness` (une « erreur » n'est pas forcément
+ * une urgence assertive). La couleur n'est jamais le seul indice : chaque variante porte une **icône**
+ * de forme distincte (WCAG 1.4.1).
+ * - `'neutral'` : pastille neutre, sans icône (défaut) ;
+ * - `'info' | 'success' | 'warning' | 'error'` : accent + icône dédiés.
+ */
+type KtSnackbarVariant = 'neutral' | 'info' | 'success' | 'warning' | 'error';
+/**
+ * Défauts de la snackbar, injectables via `provideKtSnackbar` / `KT_SNACKBAR_CONFIG`.
+ * Tous les champs sont surchargeables **par appel** via les options de `KtSnackbar.open()`.
+ *
+ * Résolution en cascade (convention de la lib) : `option d'open ?? KT_SNACKBAR_CONFIG ?? défaut`.
+ */
+interface KtSnackbarConfig {
+    /**
+     * Durée d'affichage en régime `'auto'`. Soit un **nombre fixe** (ms), soit le sentinel
+     * **`'reading-time'`** (DÉFAUT) qui **calcule** la durée d'après la longueur du message :
+     * `clamp(longueur × readingTimePerChar, readingTimeMin, readingTimeMax)`. Passer un nombre à
+     * `open()` force donc une durée fixe pour cet appel.
+     *
+     * ⚠️ Gardez le message **court** : une snackbar est un message transitoire (pas un paragraphe).
+     * Un message long fait grimper la durée jusqu'au plafond `readingTimeMax`.
+     * @default 'reading-time'
+     */
+    duration: number | 'reading-time';
+    /** Plancher (ms) de la durée calculée (`'reading-time'`) — laisse le temps de lire un message court. @default 4000 */
+    readingTimeMin: number;
+    /** Plafond (ms) de la durée calculée (`'reading-time'`) — borne un message long. @default 10000 */
+    readingTimeMax: number;
+    /** Coefficient de lecture : millisecondes ajoutées par caractère du message. @default 60 (~200 mots/min) */
+    readingTimePerChar: number;
+    /** Régime temporel (cf. {@link KtSnackbarTiming}). @default 'auto' (AA + pause) */
+    timing: KtSnackbarTiming;
+    /** Bord d'ancrage dans le viewport. @default 'bottom' */
+    position: KtSnackbarPosition;
+    /** Politesse de l'annonce lecteur d'écran. @default 'polite' */
+    politeness: KtSnackbarPoliteness;
+    /** Variante sémantique (apparence seule, cf. {@link KtSnackbarVariant}). @default 'neutral' */
+    variant: KtSnackbarVariant;
+    /** Affiche un bouton de fermeture (cible 44px, AAA). @default true */
+    closable: boolean;
+    /** Nom accessible du bouton de fermeture. @default 'Close' (FR fourni en lot L3) */
+    closeLabel: string;
+    /**
+     * Taille maximale de la file FIFO (snackbar affichée + en attente). Au-delà, les **plus anciennes
+     * en attente** sont retirées silencieusement. Une seule snackbar est visible à la fois. @default 3
+     */
+    max: number;
+}
+/** Défauts AAA-orientés de la snackbar (anglais neutre). */
+declare const KT_SNACKBAR_DEFAULTS: KtSnackbarConfig;
+declare const KT_SNACKBAR_CONFIG: InjectionToken<Partial<KtSnackbarConfig>>;
+/**
+ * Options ponctuelles d'ouverture d'une snackbar : un sous-ensemble (toutes facultatives) de la
+ * config, prioritaire sur `KT_SNACKBAR_CONFIG` et sur les défauts.
+ */
+type KtSnackbarOptions = Partial<KtSnackbarConfig>;
+/**
+ * Fournit des défauts de snackbar pour un sous-arbre ou l'application entière.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts — bascule TOUTE l'app en AAA strict (aucune disparition automatique)
+ * providers: [provideKtSnackbar({ timing: 'manual' })]
+ * ```
+ * @example
+ * ```ts
+ * providers: [provideKtSnackbar({ duration: 8000, position: 'top' })]
+ * ```
+ */
+declare function provideKtSnackbar(config: Partial<KtSnackbarConfig>): Provider;
+
+/**
+ * Raison de fermeture d'une snackbar, transmise par {@link KtSnackbarRef.afterDismissed}.
+ * - `'timeout'` : la minuterie (régime `'auto'`) est arrivée à échéance ;
+ * - `'dismiss'` : fermeture explicite (bouton de fermeture, `Échap`, ou `ref.dismiss()`) ;
+ * - `'replaced'` : la snackbar a été retirée de la file sans être affichée (file pleine — cf. `max`).
+ */
+type KtSnackbarDismissReason = 'timeout' | 'dismiss' | 'replaced';
+/**
+ * Référence d'une snackbar ouverte, renvoyée par `KtSnackbar.open()`. Permet de fermer la
+ * snackbar par programmation et d'observer sa fermeture.
+ *
+ * Le débutant peut l'ignorer (`snackbar.open('…')`) ; le code avancé s'en sert pour piloter la
+ * fermeture et réagir à la raison de fin.
+ *
+ * @example
+ * ```ts
+ * const ref = snackbar.open('Brouillon enregistré');
+ * ref.afterDismissed().subscribe((reason) => console.log(reason)); // 'timeout' | 'dismiss' | 'replaced'
+ * // plus tard : ref.dismiss();
+ * ```
+ */
+declare class KtSnackbarRef {
+    private readonly onDismiss;
+    private readonly _afterDismissed;
+    private settled;
+    /**
+     * @param onDismiss Rappel exécuté une fois à la fermeture (animation de sortie + démontage de
+     *   l'overlay + avance de la file), fourni par le service.
+     * @internal Construit par `KtSnackbar` — n'instanciez pas `KtSnackbarRef` directement.
+     */
+    constructor(onDismiss: (reason: KtSnackbarDismissReason) => void);
+    /**
+     * Ferme la snackbar (idempotent). Déclenche la sortie/démontage puis émet la raison sur
+     * `afterDismissed()`.
+     * @param reason Raison de fermeture. @default 'dismiss'
+     */
+    dismiss(reason?: KtSnackbarDismissReason): void;
+    /** Émet une fois (puis complète) à la fermeture, avec la {@link KtSnackbarDismissReason}. */
+    afterDismissed(): Observable<KtSnackbarDismissReason>;
+}
+
+/**
+ * Service d'ouverture des snackbars `@ktortu/aaa` — feedback **non bloquant** qui confirme une
+ * action ou signale un événement transitoire sans interrompre la tâche (n'utilisez PAS de snackbar
+ * pour une information critique à acquitter : préférez le dialog).
+ *
+ * Architecture a11y :
+ * - **CDK Overlay** pour le panneau visuel, **CDK LiveAnnouncer** pour l'annonce — **un seul canal**
+ *   d'annonce (le panneau n'est pas une live region) ;
+ * - **le focus n'est jamais déplacé** vers la snackbar (RGAA « message de statut » / WCAG 4.1.3) ;
+ * - disparition automatique **en pause au survol et au focus** (régime `'auto'`, défaut AA), ou
+ *   persistante (`timing: 'manual'`, AAA) ;
+ * - **file FIFO** : une seule snackbar visible, les suivantes patientent (live region non saturée).
+ *   La file est bornée par `max` (défaut 3) ; les messages **identiques** sont fusionnés (coalescing) ;
+ * - **Échap** ferme la snackbar affichée (la plus récente).
+ *
+ * Requiert côté hôte les styles `@angular/cdk/overlay-prebuilt.css` **et**
+ * `@angular/cdk/a11y-prebuilt.css` (ce dernier masque l'élément du LiveAnnouncer).
+ *
+ * @example
+ * ```ts
+ * private readonly snackbar = inject(KtSnackbar);
+ * this.snackbar.open('Brouillon enregistré');                       // disparaît, annonce polie
+ * this.snackbar.open('Fichier supprimé', { variant: 'success' });   // variante (couleur + icône)
+ * this.snackbar.open('Hors ligne', { timing: 'manual' });           // reste jusqu'à fermeture (AAA)
+ * ```
+ */
+declare class KtSnackbar implements OnDestroy {
+    private readonly overlay;
+    private readonly injector;
+    private readonly liveAnnouncer;
+    private readonly config;
+    private readonly platformId;
+    private readonly doc;
+    /** File FIFO : `queue[0]` est la snackbar affichée dès qu'elle est attachée. */
+    private readonly queue;
+    private active;
+    private escapeRegistered;
+    /**
+     * Ouvre une snackbar affichant `message`. Les `options` priment sur `KT_SNACKBAR_CONFIG`, qui
+     * prime sur les défauts. Renvoie une {@link KtSnackbarRef} (ignorable dans le cas simple).
+     *
+     * Une seule snackbar est visible : si une autre est affichée, celle-ci patiente en file (FIFO).
+     * Un `message` identique à une snackbar déjà affichée ou en attente est **fusionné** : on renvoie
+     * alors la référence existante sans rien ré-empiler.
+     *
+     * @param message Texte affiché et annoncé au lecteur d'écran.
+     * @param options Surcharges ponctuelles (durée, régime, position, politesse, variante, fermeture).
+     * @returns La référence de la snackbar (existante en cas de fusion).
+     */
+    open(message: string, options?: KtSnackbarOptions): KtSnackbarRef;
+    ngOnDestroy(): void;
+    /** Borne la file (affichée + en attente) : retire les plus ANCIENNES en attente au-delà de `max`. */
+    private enforceMax;
+    /** Affiche la tête de file si rien n'est actuellement visible. */
+    private showHead;
+    /** Retire l'élément de la file ; s'il est affiché, joue la sortie puis démonte et avance la file. */
+    private handleDismiss;
+    private readonly onDocumentKeydown;
+    private registerEscape;
+    private unregisterEscape;
+    /**
+     * Durée effective (ms) en régime `'auto'`. Un nombre est pris tel quel (durée fixe) ; le sentinel
+     * `'reading-time'` calcule `clamp(longueur × perChar, min, max)`.
+     */
+    private computeDuration;
+    /** Résolution en cascade `option ?? KT_SNACKBAR_CONFIG ?? défaut`, champ par champ. */
+    private resolve;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtSnackbar, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KtSnackbar>;
+}
+
+/**
+ * Données résolues passées au conteneur visuel à l'ouverture (injectées via {@link KT_SNACKBAR_CONTEXT}).
+ * Produites par `KtSnackbar` après résolution `option ?? config ?? défaut`.
+ */
+interface KtSnackbarContext {
+    /** Message affiché et annoncé. */
+    readonly message: string;
+    /** Variante sémantique (apparence : accent + icône). */
+    readonly variant: KtSnackbarVariant;
+    /** Affiche le bouton de fermeture. */
+    readonly closable: boolean;
+    /** Nom accessible du bouton de fermeture. */
+    readonly closeLabel: string;
+    /** Régime temporel (la minuterie n'existe qu'en `'auto'`). */
+    readonly timing: KtSnackbarTiming;
+    /** Durée (ms) avant disparition automatique en régime `'auto'`. */
+    readonly duration: number;
+}
+declare const KT_SNACKBAR_CONTEXT: InjectionToken<KtSnackbarContext>;
+/**
+ * Conteneur visuel d'une snackbar. **Volontairement pas une live region** (aucun `role`/`aria-live`
+ * sur l'hôte) : l'annonce passe par un canal UNIQUE, le `LiveAnnouncer` du service. On évite ainsi
+ * la double-annonce et l'écrasement de politesse observés sur d'autres libs.
+ *
+ * En régime `'auto'`, la minuterie de disparition se met **en pause au survol et au focus** clavier
+ * (WCAG 1.4.13 / 2.2.1) et reprend quand ni le pointeur ni le focus ne sont sur la snackbar.
+ * L'icône de variante est **décorative** (`aria-hidden`) : la forme distincte sert d'indice non
+ * coloré (WCAG 1.4.1), le sens reste porté par le texte.
+ *
+ * @internal Monté par `KtSnackbar` via un `ComponentPortal`.
+ */
+declare class KtSnackbarContainer {
+    protected readonly context: KtSnackbarContext;
+    private readonly ref;
+    private readonly platformId;
+    private readonly host;
+    /** Vrai pendant l'animation de sortie (déclenche la classe `kt-snackbar--leaving`). */
+    protected readonly leaving: i0.WritableSignal<boolean>;
+    private timer;
+    private remaining;
+    private deadline;
+    private hovered;
+    private focused;
+    constructor();
+    protected close(): void;
+    /**
+     * Joue l'animation de sortie puis invoque `done` (démontage de l'overlay côté service). Appelé par
+     * le service à la fermeture. Sans animation (durée nulle, `prefers-reduced-motion`, ou SSR), `done`
+     * est invoqué immédiatement. Filet de sécurité par `setTimeout` si `transitionend` ne se déclenche pas.
+     */
+    playExit(done: () => void): void;
+    protected onPointerEnter(): void;
+    protected onPointerLeave(): void;
+    protected onFocusEnter(): void;
+    protected onFocusLeave(): void;
+    private maybeResume;
+    private startTimer;
+    private pauseTimer;
+    private clearTimer;
+    /** Durée (ms) de la transition de sortie, lue sur l'hôte (0 si aucune — ex. reduced-motion). */
+    private exitDurationMs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtSnackbarContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KtSnackbarContainer, "kt-snackbar-container", never, {}, {}, never, never, true, never>;
+}
+
+export { KT_SNACKBAR_CONFIG, KT_SNACKBAR_CONTEXT, KT_SNACKBAR_DEFAULTS, KtSnackbar, KtSnackbarContainer, KtSnackbarRef, provideKtSnackbar };
+export type { KtSnackbarConfig, KtSnackbarContext, KtSnackbarDismissReason, KtSnackbarOptions, KtSnackbarPoliteness, KtSnackbarPosition, KtSnackbarTiming, KtSnackbarVariant };

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

@@ -1,27 +1,144 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
 
 /**
- * Amène l'onglet sélectionné dans la zone visible quand la liste d'onglets déborde et défile
- * (cf. tabs.css). Le focus clavier d'`@angular/aria` scrolle déjà l'onglet focalisé ; cette
- * directive couvre ce que le CSS seul ne peut pas faire de façon fiable : l'onglet actif
- * **hors-champ au montage** et lors d'un **changement de sélection programmatique**.
+ * Pilote le **débordement** d'une liste d'onglets `@angular/aria/tabs` (cf. tabs.css). Deux rôles :
+ *
+ * 1. **Scroll-into-view** : amène l'onglet sélectionné dans la vue au montage et lors d'un changement
+ *    de sélection programmatique (ce que le CSS seul ne fait pas), en respectant `prefers-reduced-motion`.
+ * 2. **Pagination** : expose un état réactif (`canScrollStart()`, `canScrollEnd()`, `overflowing()`,
+ *    `orientation()`) et une méthode `scrollByPage()`, pour brancher des boutons chevrons (cf. le
+ *    composant clé-en-main `KtTabScrollerPager`, ou des boutons custom via `exportAs: 'ktTabScroller'`).
  *
  * Opt-in, à poser sur `[ngTabList]` :
  *
  * @example
  * ```html
- * <ul ngTabList ktTabScroll [(selectedTab)]="tab"> … </ul>
+ * <ul ngTabList ktTabScroller #s="ktTabScroller" [(selectedTab)]="tab"> … </ul>
+ * <button (click)="s.scrollByPage('start')" [disabled]="!s.canScrollStart()">‹</button>
  * ```
- *
- * Intégrée réactivement avec `@angular/aria/tabs` via son `ModelSignal` `selectedTab`.
  */
-declare class KtTabScroll {
+declare class KtTabScroller {
     private readonly list;
     private readonly tabList;
+    private readonly doc;
+    private readonly destroyRef;
+    /** Préférence « réduire les animations », lue à chaud (absente possible en SSR/jsdom). */
+    private readonly reducedMotion;
+    /**
+     * Métriques de débordement. Mises à jour UNIQUEMENT depuis des callbacks navigateur
+     * (`afterNextRender`, `scroll`, `ResizeObserver`, `MutationObserver`) — jamais depuis le corps
+     * d'un effet réactif, pour rester conforme (pas d'écriture de signal dans un effet).
+     */
+    private readonly metrics;
+    /** Reste-t-il du contenu hors-champ côté début (à brancher sur le bouton « précédent ») ? */
+    readonly canScrollStart: _angular_core.Signal<boolean>;
+    /** Reste-t-il du contenu hors-champ côté fin (à brancher sur le bouton « suivant ») ? */
+    readonly canScrollEnd: _angular_core.Signal<boolean>;
+    /** La liste déborde-t-elle ? (utile pour masquer toute la barre de pagination). */
+    readonly overflowing: _angular_core.Signal<boolean>;
+    /** Axe courant, dérivé de l'orientation `@angular/aria`. */
+    readonly orientation: _angular_core.Signal<"horizontal" | "vertical">;
+    constructor();
+    /**
+     * Fait défiler d'environ une « page » (≈ {@link PAGE_RATIO} de la zone visible) vers le début ou la
+     * fin. `behavior` respecte `prefers-reduced-motion`. Le navigateur sature au min/max ; les boutons
+     * câblés sont `disabled` aux extrémités, donc l'appel n'a pas lieu à vide.
+     */
+    scrollByPage(dir: 'start' | 'end'): void;
+    /** Met à jour le signal de métriques. Appelé depuis des callbacks navigateur (jamais un effet). */
+    private remeasure;
+    /** Mesure le débordement (lecture pure de géométrie, n'écrit rien). */
+    private measure;
+    private isVertical;
+    private isRtl;
+    /**
+     * `auto` si l'utilisateur a demandé à réduire les animations (WCAG 2.3.3 AAA), `smooth` sinon.
+     * Passer un `behavior` explicite à `scrollTo`/`scrollBy` écrase la propriété CSS `scroll-behavior`,
+     * d'où la nécessité de répliquer ici la décision que le CSS prend via `prefers-reduced-motion`.
+     */
+    private scrollBehavior;
+    /**
+     * Calcule l'offset à atteindre pour amener l'onglet actif dans la vue, ou `null` s'il est déjà
+     * visible (ou s'il n'y a aucun onglet sélectionné). Lit `selectedTab()` → dépendance réactive.
+     */
+    private computeScrollTarget;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTabScroller, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtTabScroller, "[ngTabList][ktTabScroller]", ["ktTabScroller"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Composant clé-en-main : enveloppe une liste d'onglets `@angular/aria/tabs` débordante de deux
+ * **chevrons de pagination** accessibles (style Material). Il ne contient aucune logique propre :
+ * il lit l'état réactif de la directive headless {@link KtTabScroller} (à poser sur le `ngTabList`
+ * projeté) et câble deux boutons {@link KtButton}.
+ *
+ * @example
+ * ```html
+ * <kt-tab-scroller>
+ *   <ul ngTabList ktTabScroller [(selectedTab)]="tab">
+ *     @for (t of tabs; track t) { <li ngTab [value]="t">…</li> }
+ *   </ul>
+ * </kt-tab-scroller>
+ * ```
+ */
+declare class KtTabScrollerPager {
+    private readonly host;
+    private readonly doc;
+    /** Défauts d'app (provider global `KT_TABS_CONFIG`) ; les inputs ci-dessous priment dessus. */
+    private readonly config;
+    /** La directive headless posée sur le `ngTabList` projeté (`descendants` car dans le viewport). */
+    protected readonly scroller: _angular_core.Signal<KtTabScroller>;
+    /** Sens de lecture (figé au montage : le RTL inverse les chevrons gauche/droite). */
+    private readonly dir;
+    protected readonly startIcon: _angular_core.Signal<"expand_less" | "chevron_right" | "chevron_left">;
+    protected readonly endIcon: _angular_core.Signal<"chevron_right" | "chevron_left" | "expand_more">;
+    /**
+     * Noms accessibles des chevrons (`aria-label`). Résolution `input ?? KT_TABS_CONFIG ?? défaut`,
+     * comme partout dans la lib (cf. `KT_FIELD_CONFIG`/`KT_CHIPS_CONFIG`). Défauts en anglais : lib
+     * neutre i18n, les textes sont fournis par le consommateur (provider global ou binding).
+     */
+    /**
+     * `aria-label` du chevron « onglets précédents ».
+     * @default config.previousLabel ?? 'Previous tabs'
+     */
+    readonly previousLabel: _angular_core.InputSignal<string>;
+    /**
+     * `aria-label` du chevron « onglets suivants ».
+     * @default config.nextLabel ?? 'Next tabs'
+     */
+    readonly nextLabel: _angular_core.InputSignal<string>;
     constructor();
-    private scrollSelectedIntoView;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KtTabScroll, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KtTabScroll, "[ngTabList][ktTabScroll]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTabScrollerPager, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KtTabScrollerPager, "kt-tab-scroller", never, { "previousLabel": { "alias": "previousLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; }, {}, ["scroller"], ["[ngTabList]"], true, never>;
+}
+
+/**
+ * @deprecated Utilisez {@link KtTabScroller} (sélecteur `[ktTabScroller]`) : même défilement de
+ * l'onglet sélectionné dans la vue, plus la pagination par chevrons. `ktTabScroll` reste un **alias
+ * fonctionnel** (il applique `KtTabScroller` comme directive hôte) et sera retiré dans une version
+ * majeure ultérieure.
+ *
+ * Note : depuis cette version, une liste pilotée par `ktTabScroll`/`ktTabScroller` masque sa
+ * scrollbar native par défaut (les chevrons / ombres prennent le relais). Réafficher la barre via
+ * `--tab-scroller-scrollbar: thin`.
+ */
+declare class KtTabScroll {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTabScroll, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtTabScroll, "[ngTabList][ktTabScroll]", ["ktTabScroll"], {}, {}, never, never, true, [{ directive: typeof KtTabScroller; inputs: {}; outputs: {}; }]>;
+}
+
+/** Défauts applicables à tous les `kt-tab-scroller` (surchargeables par instance via les inputs).
+    Lib neutre i18n : les textes sont fournis par le consommateur (ici en une fois).
+    Fourni en `Partial` : un consommateur n'override que ce qu'il veut.
+    Calqué sur `KT_FIELD_CONFIG`/`KT_CHIPS_CONFIG`. */
+interface KtTabsConfig {
+    /** `aria-label` du chevron de pagination « onglets précédents ». Défaut : `'Previous tabs'`. */
+    previousLabel: string;
+    /** `aria-label` du chevron de pagination « onglets suivants ». Défaut : `'Next tabs'`. */
+    nextLabel: string;
 }
+declare const KT_TABS_CONFIG: InjectionToken<Partial<KtTabsConfig>>;
 
-export { KtTabScroll };
+export { KT_TABS_CONFIG, KtTabScroll, KtTabScroller, KtTabScrollerPager };
+export type { KtTabsConfig };

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

@@ -2,9 +2,13 @@ import * as _angular_core from '@angular/core';
 import { InjectionToken, OnDestroy, TemplateRef, Provider } from '@angular/core';
 
 type KtTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+/** Défauts d'infobulle (délais, position) injectables via `provideKtTooltip` / `KT_TOOLTIP_CONFIG`. */
 interface KtTooltipConfig {
+    /** Délai (ms) avant apparition au survol/focus. */
     showDelay: number;
+    /** Délai (ms) avant masquage (laisse le temps d'atteindre l'infobulle, WCAG « hoverable »). */
     hideDelay: number;
+    /** Position de l'infobulle autour de la cible. */
     position: KtTooltipPosition;
 }
 declare const KT_TOOLTIP_CONFIG: InjectionToken<Partial<KtTooltipConfig>>;
@@ -50,6 +54,7 @@ declare class KtTooltip implements OnDestroy {
     private readonly idGen;
     private readonly uid;
     private readonly tooltipId;
+    /** Id du noeud `role="tooltip"`. Public : sert aux liaisons d'accessibilité (`aria-describedby`) du déclencheur. */
     readonly idForA11y: string;
     private readonly anchorName;
     /** Vrai quand l'infobulle est susceptible de s'afficher (contenu non vide et non désactivée).

package/types/ktortu-aaa.d.ts

@@ -3,6 +3,8 @@ export * from '@ktortu/aaa/card';
 export * from '@ktortu/aaa/cdk';
 export * from '@ktortu/aaa/dialog';
 export * from '@ktortu/aaa/forms';
+export * from '@ktortu/aaa/i18n';
 export * from '@ktortu/aaa/menu';
+export * from '@ktortu/aaa/snackbar';
 export * from '@ktortu/aaa/tabs';
 export * from '@ktortu/aaa/tooltip';