@ktortu/aaa 0.1.0-beta.0 → 0.9.0

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

@@ -0,0 +1,74 @@
+import { EnvironmentProviders } from '@angular/core';
+import { KtFieldConfig, KtSelectConfigOptions, KtChipsConfig } from '@ktortu/aaa/forms';
+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 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-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,7 @@ 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/tabs';
 export * from '@ktortu/aaa/tooltip';