@ktortu/aaa 0.1.0-beta.0

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

@@ -0,0 +1,171 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+/**
+ * `[ktMenu]` — marqueur de THÈME posé sur l'hôte `[ngMenu]` d'`@angular/aria`. Style UNIQUEMENT la
+ * SURFACE du menu (fond, bord, ombre, rayon, padding, positionnement en dropdown ancré). N'ajoute
+ * AUCUN rôle ni comportement : la sémantique (`role="menu"`), le clavier, le focus roving, le
+ * retour de focus au trigger, les sous-menus et le typeahead viennent intégralement d'aria
+ * (`[ngMenu]`). Même philosophie que `[ktCard]` : la lib thématise, aria gère l'accessibilité.
+ *
+ * La directive n'a pas de logique propre : tout vit dans `menu.css` via le sélecteur `[ktMenu]`,
+ * piloté par l'attribut `data-visible` qu'aria pose sur l'hôte (ouvert/fermé). Le positionnement
+ * (CSS Anchor Positioning) est câblé par `[ktMenuTrigger]` (menu racine) et par `[ktMenuItem]`
+ * (sous-menus) qui posent les `anchor-name` / `position-anchor`.
+ *
+ * @example
+ * ```html
+ * <button ngMenuTrigger ktMenuTrigger [menu]="m">Options</button>
+ * <div ngMenu ktMenu #m="ngMenu" (itemSelected)="onSelect($event)" aria-label="Options">
+ *   <button ngMenuItem ktMenuItem value="new">Nouveau</button>
+ * </div>
+ * ```
+ */
+declare class KtMenu {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KtMenu, "[ktMenu]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * `[ktMenuItem]` — marqueur de thème posé sur l'hôte `[ngMenuItem]`. Style la RANGÉE (hauteur de
+ * cible tactile ≥44px, focus, survol, désactivé, item de sous-menu avec chevron). Comme `[ktMenu]`,
+ * sans logique de sélection : l'état stylé est lu sur les attributs ARIA déjà posés par aria
+ * (`:focus-visible` pour l'item actif via focus roving, `[aria-disabled]`, `[aria-expanded]`,
+ * `[aria-haspopup]`, `[aria-checked]`).
+ *
+ * SEULE responsabilité technique : si l'item porte un sous-menu (`[submenu]` côté aria), on câble
+ * l'ancrage CSS du sous-menu sur cet item (anchor-name sur l'item, position-anchor sur la surface
+ * du sous-menu, marqueur `data-kt-submenu` pour l'ouvrir en latéral plutôt qu'en dropdown).
+ *
+ * EXIGENCE DE STRUCTURE (sous-menus) : le `[ngMenu]` d'un sous-menu DOIT être un DESCENDANT DOM du
+ * menu parent (et non un frère). aria décide de maintenir un menu ouvert via `element.contains()`
+ * sur la cible du focus/survol ; un sous-menu placé hors du sous-arbre du parent ferait croire à
+ * aria que le focus a quitté le menu et provoquerait sa fermeture dès qu'on survole le sous-menu.
+ * Le sous-menu reste rendu en place (top-layer non requis : `position: fixed` + ancrage CSS).
+ *
+ * @example
+ * ```html
+ * <button ngMenuItem ktMenuItem value="open">Ouvrir</button>
+ * ```
+ */
+declare class KtMenuItem {
+    private readonly host;
+    private readonly ariaItem;
+    private readonly platformId;
+    protected anchorName: string | undefined;
+    private readonly idGen;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KtMenuItem, "[ktMenuItem]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * `[ktMenuSeparator]` — filet de séparation entre groupes d'items. Pose `role="separator"`
+ * (sémantique standard d'un séparateur de menu) ; la ligne elle-même vit dans `menu.css`.
+ *
+ * @example
+ * ```html
+ * <hr ktMenuSeparator />
+ * ```
+ */
+declare class KtMenuSeparator {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtMenuSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KtMenuSeparator, "[ktMenuSeparator]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * `[ktMenuTrigger]` — sucre de POSITIONNEMENT pour le menu racine. À poser SUR le même élément
+ * qu'`[ngMenuTrigger]` (le bouton qui ouvre le menu). Il ne réimplémente RIEN du comportement :
+ * l'ouverture/fermeture, `aria-expanded`, Échap, le clic-dehors et le retour de focus sont gérés
+ * par aria (`[ngMenuTrigger]`). Sa seule tâche : poser un `anchor-name` sur le trigger et le
+ * `position-anchor` correspondant sur la surface du menu, pour que `menu.css` l'ancre en dropdown
+ * (CSS Anchor Positioning), comme le popup du Select — sans CDK Overlay (styles scopés conservés,
+ * et pas de coordination fragile avec le focus qu'aria pose à l'ouverture).
+ *
+ * Requiert `[ngMenuTrigger]` sur le même hôte (injecté en `self`).
+ *
+ * @example
+ * ```html
+ * <button ngMenuTrigger ktMenuTrigger [menu]="m">Fichier</button>
+ * ```
+ */
+declare class KtMenuTrigger {
+    private readonly host;
+    private readonly ariaTrigger;
+    private readonly platformId;
+    private readonly idGen;
+    protected readonly anchorName: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KtMenuTrigger, "[ktMenuTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * `[ktMenuItemCheckbox]` — case à cocher de menu (bascule indépendante). À poser sur un
+ * `[ngMenuItem] role="menuitemcheckbox"`. Bind `aria-checked` et bascule `checked` à l'activation.
+ *
+ * @example
+ * ```html
+ * <button ngMenuItem ktMenuItem ktMenuItemCheckbox role="menuitemcheckbox" [(checked)]="wrap">
+ *   Retour à la ligne
+ * </button>
+ * ```
+ */
+declare class KtMenuItemCheckbox {
+    private readonly ariaItem;
+    /** État coché, bidirectionnel : `[(checked)]`. */
+    readonly checked: i0.ModelSignal<boolean>;
+    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>;
+}
+/** Source de la valeur sélectionnée d'un groupe radio, exposée aux `[ktMenuItemRadio]` enfants. */
+declare const KT_MENU_RADIO_GROUP: InjectionToken<KtMenuRadioGroup<unknown>>;
+/**
+ * `[ktMenuRadioGroup]` — coordinateur d'un groupe d'items radio mutuellement exclusifs. À poser sur
+ * un conteneur englobant les `[ktMenuItemRadio]` (typiquement un `role="group"`). Détient la valeur
+ * sélectionnée ; chaque radio s'y compare pour son `aria-checked` et la met à jour à l'activation.
+ *
+ * @example
+ * ```html
+ * <div role="group" ktMenuRadioGroup [(value)]="sortBy" aria-label="Trier par">
+ *   <button ngMenuItem ktMenuItem ktMenuItemRadio role="menuitemradio" [value]="'name'">Nom</button>
+ *   <button ngMenuItem ktMenuItem ktMenuItemRadio role="menuitemradio" [value]="'date'">Date</button>
+ * </div>
+ * ```
+ */
+declare class KtMenuRadioGroup<V> {
+    /** Valeur sélectionnée du groupe, bidirectionnelle : `[(value)]`. */
+    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>;
+}
+/**
+ * `[ktMenuItemRadio]` — bouton radio de menu. À poser sur un `[ngMenuItem] role="menuitemradio"`
+ * dans un `[ktMenuRadioGroup]`. `aria-checked` reflète l'égalité avec la valeur du groupe ;
+ * l'activation sélectionne cette valeur.
+ *
+ * @example
+ * ```html
+ * <button ngMenuItem ktMenuItem ktMenuItemRadio role="menuitemradio" [value]="'name'">Trier par nom</button>
+ * ```
+ */
+declare class KtMenuItemRadio<V> {
+    private readonly ariaItem;
+    private readonly group;
+    /** Valeur portée par ce radio (comparée à celle du groupe). */
+    readonly value: i0.InputSignal<V>;
+    protected readonly checked: i0.Signal<boolean>;
+    constructor();
+    protected activate(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtMenuItemRadio<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KtMenuItemRadio<any>, "[ktMenuItemRadio]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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
+ * 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];
+
+export { KT_MENU, KT_MENU_RADIO_GROUP, KtMenu, KtMenuItem, KtMenuItemCheckbox, KtMenuItemRadio, KtMenuRadioGroup, KtMenuSeparator, KtMenuTrigger };

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

@@ -0,0 +1,27 @@
+import * as i0 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**.
+ *
+ * Opt-in, à poser sur `[ngTabList]` :
+ *
+ * @example
+ * ```html
+ * <ul ngTabList ktTabScroll [(selectedTab)]="tab"> … </ul>
+ * ```
+ *
+ * Intégrée réactivement avec `@angular/aria/tabs` via son `ModelSignal` `selectedTab`.
+ */
+declare class KtTabScroll {
+    private readonly list;
+    private readonly tabList;
+    constructor();
+    private scrollSelectedIntoView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KtTabScroll, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KtTabScroll, "[ngTabList][ktTabScroll]", never, {}, {}, never, never, true, never>;
+}
+
+export { KtTabScroll };

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

@@ -0,0 +1,90 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnDestroy, TemplateRef, Provider } from '@angular/core';
+
+type KtTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+interface KtTooltipConfig {
+    showDelay: number;
+    hideDelay: number;
+    position: KtTooltipPosition;
+}
+declare const KT_TOOLTIP_CONFIG: InjectionToken<Partial<KtTooltipConfig>>;
+/**
+ * Fournit des défauts d'infobulle (délais, position) pour un sous-arbre ou l'application entière.
+ *
+ * @example
+ * ```ts
+ * providers: [provideKtTooltip({ showDelay: 300, position: 'bottom' })]
+ * ```
+ */
+declare function provideKtTooltip(config: Partial<KtTooltipConfig>): Provider;
+/**
+ * Infobulle accessible posée sur n'importe quel élément focusable/survolable.
+ * Apparaît au survol et au focus, reste « hoverable » (WCAG 1.4.13) et se ferme
+ * par Échap. Le contenu peut être un texte simple ou un `TemplateRef` **non interactif**
+ * (un `role="tooltip"` ne doit pas contenir de lien/bouton/champ).
+ *
+ * @example
+ * ```html
+ * <button ktTooltip="Enregistrer le brouillon">Enregistrer</button>
+ * <span ktTooltip="Aide" tooltipPosition="right" [showDelay]="300">?</span>
+ * ```
+ */
+declare class KtTooltip implements OnDestroy {
+    private readonly config;
+    private readonly doc;
+    private readonly host;
+    private readonly renderer;
+    private readonly vcr;
+    private readonly ngZone;
+    private readonly platformId;
+    /** Contenu de l'infobulle : texte simple (injecté en `textContent`) ou `TemplateRef` non interactif. */
+    readonly ktTooltip: _angular_core.InputSignal<string | TemplateRef<unknown>>;
+    /** Position de l'infobulle autour de la cible. @default 'top' (ou KT_TOOLTIP_CONFIG.position) */
+    readonly tooltipPosition: _angular_core.InputSignal<KtTooltipPosition>;
+    /** Désactive l'affichage de l'infobulle. @default false */
+    readonly tooltipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Délai (ms) avant apparition au survol/focus. @default 150 (ou KT_TOOLTIP_CONFIG.showDelay) */
+    readonly showDelay: _angular_core.InputSignal<number>;
+    /** Délai (ms) avant masquage ; laisse le temps d'amener le pointeur sur l'infobulle (WCAG « hoverable »). @default 100 (ou KT_TOOLTIP_CONFIG.hideDelay) */
+    readonly hideDelay: _angular_core.InputSignal<number>;
+    private readonly idGen;
+    private readonly uid;
+    private readonly tooltipId;
+    readonly idForA11y: string;
+    private readonly anchorName;
+    /** Vrai quand l'infobulle est susceptible de s'afficher (contenu non vide et non désactivée).
+        Public : lu par `KtField` pour câbler `aria-describedby` du contrôle sur l'infobulle d'aide. */
+    readonly isActive: _angular_core.Signal<boolean>;
+    protected describedById: _angular_core.Signal<string | null>;
+    private tip;
+    private view;
+    private listeners;
+    private showTimer;
+    private hideTimer;
+    private readonly isShown;
+    private _supportsAnchor;
+    private get supportsAnchor();
+    private fallbackListeners;
+    private activeTemplate;
+    private escListener;
+    constructor();
+    ngOnDestroy(): void;
+    protected show(): void;
+    protected hide(): void;
+    protected onEscape(event: Event): void;
+    private dismiss;
+    private ensureTip;
+    private registerEscapeListener;
+    private syncContent;
+    private clearContent;
+    private warnIfInteractive;
+    private destroyTip;
+    private positionFallback;
+    private registerFallbackListeners;
+    private clearFallbackListeners;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KtTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KtTooltip, "[ktTooltip]", never, { "ktTooltip": { "alias": "ktTooltip"; "required": true; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { KT_TOOLTIP_CONFIG, KtTooltip, provideKtTooltip };
+export type { KtTooltipConfig, KtTooltipPosition };

package/types/ktortu-aaa.d.ts

@@ -0,0 +1,8 @@
+export * from '@ktortu/aaa/button';
+export * from '@ktortu/aaa/card';
+export * from '@ktortu/aaa/cdk';
+export * from '@ktortu/aaa/dialog';
+export * from '@ktortu/aaa/forms';
+export * from '@ktortu/aaa/menu';
+export * from '@ktortu/aaa/tabs';
+export * from '@ktortu/aaa/tooltip';