@starterlib/ui 0.9.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starterlib/ui",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Bibliotheque de composants st-* du socle frontal starter, sur CDK et Aria.",
   "license": "UNLICENSED",
   "sideEffects": false,
@@ -25,8 +25,8 @@
     "@angular/forms": "^22.2.0",
     "@angular/cdk": "^22.2.0",
     "@angular/aria": "^22.2.0",
-    "@starterlib/tokens": "^0.9.0",
-    "@starterlib/util": "^0.9.0"
+    "@starterlib/tokens": "^0.10.0",
+    "@starterlib/util": "^0.10.0"
   },
   "peerDependenciesMeta": {
     "@angular/cdk": {
@@ -57,10 +57,18 @@
       "types": "./types/starterlib-ui-donnees.d.ts",
       "default": "./fesm2022/starterlib-ui-donnees.mjs"
     },
+    "./etats": {
+      "types": "./types/starterlib-ui-etats.d.ts",
+      "default": "./fesm2022/starterlib-ui-etats.mjs"
+    },
     "./formulaires": {
       "types": "./types/starterlib-ui-formulaires.d.ts",
       "default": "./fesm2022/starterlib-ui-formulaires.mjs"
     },
+    "./indicateurs": {
+      "types": "./types/starterlib-ui-indicateurs.d.ts",
+      "default": "./fesm2022/starterlib-ui-indicateurs.mjs"
+    },
     "./libelles-en": {
       "types": "./types/starterlib-ui-libelles-en.d.ts",
       "default": "./fesm2022/starterlib-ui-libelles-en.mjs"
@@ -73,6 +81,10 @@
       "types": "./types/starterlib-ui-messagerie.d.ts",
       "default": "./fesm2022/starterlib-ui-messagerie.mjs"
     },
+    "./mise-en-page": {
+      "types": "./types/starterlib-ui-mise-en-page.d.ts",
+      "default": "./fesm2022/starterlib-ui-mise-en-page.mjs"
+    },
     "./navigation": {
       "types": "./types/starterlib-ui-navigation.d.ts",
       "default": "./fesm2022/starterlib-ui-navigation.mjs"

package/types/starterlib-ui-donnees.d.ts

@@ -1,6 +1,7 @@
 import { AnnonceLocale, Icone, TailleDAvatar, TailleDIconeFixe, TonDAvatar } from "@starterlib/ui";
 import * as i0 from "@angular/core";
-import { Montant, Ton, TonSemantique } from "@starterlib/util";
+import { Ton, TonSemantique } from "@starterlib/util";
+import { Montant } from "@starterlib/util/valeurs";
 export type TypeMasque = 'iban' | 'carte' | 'telephone' | 'reference';
 /**
  * `ligne` : dans le flux d'une phrase ou d'une cellule. `tuile` : la tuile de la planche 2
@@ -1485,5 +1486,98 @@ export declare class StRepartition {
     };
   }, {}, never, never, true, never>;
 }
+/**
+ * Valeur technique courte et copiable : identifiant de trace, reference
+ * d'operation, code d'erreur. Jamais un secret.
+ *
+ * ⚠️ Le `<code>` est lu par TOUT LE MONDE, technologies d'assistance comprises, precede
+ * de son etiquette (« Code : 7f3a-91c4 ») : la valeur se selectionne au curseur virtuel.
+ * Avant 0.9, un `<code aria-hidden>` doublait une copie masquee, et le curseur virtuel ne
+ * pouvait rien selectionner. `translate="no"` : une reference ne se traduit pas.
+ *
+ * ⚠️ Le bouton de copie porte un nom DISTINCT par valeur : « Copier : <etiquette> », ou
+ * « Copier : <valeur> » sans etiquette. Deux valeurs techniques d'une page ne proposent plus
+ * deux boutons « Copier » ; sans etiquette, « Copier : Code » se repetait a chaque valeur
+ * (revue E7). La valeur est courte par contrat : le nom reste lisible a l'oral.
+ *
+ * ⚠️ La confirmation de copie passe par une petite region vivante interne, et
+ * le NOM DU BOUTON NE CHANGE PAS. Le changer ferait annoncer un autre bouton que
+ * celui que l'utilisateur a sous le doigt.
+ *
+ * ⚠️ Le retour se VOIT aussi (03 §3.20, MV-7) : l'icone passe a la coche, en
+ * `succes`, pendant `rythme.tenue.confirmation`, d'un coup ; un refus laisse un
+ * message visible sous la valeur jusqu'a la tentative suivante. Meme regle que
+ * `st-copy-button`.
+ */
+export declare class StCode {
+  private readonly document;
+  private readonly libelles;
+  readonly valeur: import("@angular/core").InputSignal<string>;
+  readonly copiable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Nature de la valeur (« Identifiant de trace », « Reference de l'operation »), lue avant
+   * elle. `null` : « Code », le mot generique du dictionnaire.
+   */
+  readonly etiquette: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Nom du bouton de copie. `null` : « Copier : <etiquette> » (« Copier : Code » sans etiquette).
+   * Jamais la valeur : un secret (TOTP) devenait le nom du bouton, lu et journalise par les
+   * technologies d'assistance (audit du 2026-09-27, A-11).
+   */
+  readonly libelleCopier: import("@angular/core").InputSignal<string | null>;
+  readonly messageDeConfirmation: import("@angular/core").InputSignal<string | null>;
+  /**
+   * La valeur telle qu'elle s'affiche ET se copie : sans commande de direction, ce qu'on voit est
+   * ce qu'on colle (audit du 2026-09-27, A-2).
+   */
+  protected readonly valeurAffichee: import("@angular/core").Signal<string>;
+  protected readonly etiquetteLue: import("@angular/core").Signal<string>;
+  protected readonly libelleCopierLu: import("@angular/core").Signal<string>;
+  readonly copie: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly annonce: AnnonceLocale;
+  protected readonly copieConfirmee: import("@angular/core").WritableSignal<boolean>;
+  protected readonly copieRefusee: import("@angular/core").WritableSignal<boolean>;
+  protected readonly iconeDeCopie: import("@angular/core").Signal<"iban" | "chargement" | "message" | "devise" | "cle" | "accessibilite" | "appareils" | "arborescence" | "asterisque" | "badge-coche" | "banque" | "batiment" | "bifurcation" | "billets" | "billets-envoi" | "billets-pile" | "boite" | "boite-de-reception" | "bouclier" | "bouclier-alerte" | "bouclier-coche" | "bouclier-coeur" | "bouclier-croix" | "bouclier-moitie" | "bouclier-recherche" | "bouclier-utilisateur" | "boussole" | "bouton-curseur" | "bulle-question" | "cadenas" | "cadenas-horloge" | "cadenas-ouvert" | "cadre-pied" | "cadre-texte" | "calendrier" | "calendrier-evenement" | "calendrier-horloge" | "calendrier-jour" | "calques" | "carte-bancaire" | "carte-bancaire-barre" | "carte-bancaire-cadenas" | "carte-contact" | "carte-identite" | "cartes-empilees" | "case-cochee" | "casse" | "cercle" | "cercle-alerte" | "cercle-chevron-bas" | "cercle-coche" | "cercle-coche-ouvert" | "cercle-croix" | "cercle-info" | "cercle-moins" | "cercle-plus" | "cercle-question" | "certificat" | "chandelier" | "cheque" | "chevron-bas" | "chevron-droite" | "chevron-gauche" | "chevron-haut" | "chevrons-droite" | "chevrons-haut-bas" | "cloche" | "cloche-sonnerie" | "coche" | "code" | "code-qr" | "code-qr-scanner" | "coffre-fort" | "colonnes" | "connexion" | "contraste" | "copie" | "corbeille" | "corbeille-croix" | "courriel" | "crayon" | "croix" | "curseur-clic" | "deconnexion" | "disposition" | "dollar" | "dossier" | "dossier-barre" | "dossier-ouvert" | "double-coche" | "echange" | "eclair" | "empreinte-digitale" | "enregistrer" | "entree" | "envoyer" | "epaisseur-de-trait" | "epingle" | "etoile" | "euro" | "fichier" | "fichier-image" | "fichier-pdf" | "fichier-texte" | "filtre" | "filtre-barre" | "filtre-lignes" | "fleche-bas" | "fleche-bas-gauche" | "fleche-bas-ligne" | "fleche-droite" | "fleche-gauche" | "fleche-haut" | "fleche-haut-droite" | "fleche-haut-ligne" | "fleche-large-haut" | "fleches-gauche-droite" | "flocon" | "flou" | "formes" | "globe" | "graphique-anneau" | "graphique-barres" | "graphique-barres-cadre" | "graphique-camembert" | "graphique-ligne" | "graphique-lignes" | "grille" | "grille-lignes" | "hexagone" | "historique" | "horloge" | "horloge-fleche" | "imprimer" | "interdit" | "jalons" | "jauge" | "lien" | "lien-externe" | "lignes" | "lignes-crayon" | "liste" | "liste-coche" | "liste-controle" | "liste-numerotee" | "luminosite" | "lune" | "maillet" | "maison" | "marque-page" | "menu" | "menu-ouvert" | "minuteur" | "mise-au-point" | "mise-en-page-image" | "moins" | "nuage-barre" | "nuage-televerser" | "octogone-alerte" | "oeil" | "oeil-barre" | "panneau-gauche" | "parametres" | "parapluie" | "parchemin" | "pieces" | "plus" | "pointeur" | "points" | "points-verticaux" | "portefeuille" | "portefeuille-cartes" | "presse-papiers-coche" | "presse-papiers-horloge" | "priorite-haute" | "rafraichir" | "recherche" | "recherche-barre" | "recherche-texte" | "rectangle-points" | "recu" | "redemarrer" | "reglages" | "regle" | "reseau-jauge" | "rotation-arriere" | "routeur" | "sablier" | "sablier-bas" | "sablier-haut" | "sac-argent" | "sans-contact" | "serveur" | "soleil" | "style-de-trait" | "synchro" | "synchro-probleme" | "tableau" | "tableau-de-bord" | "tableau-de-bord-plus" | "tablette" | "tabulation" | "telecharger" | "telephone-mobile" | "televerser" | "tendance-baisse" | "tendance-hausse" | "terminal" | "tirelire" | "triangle-alerte" | "triangle-bas" | "triangle-haut" | "trombone" | "utilisateur" | "utilisateur-crayon" | "utilisateurs" | "wifi" | "wifi-barre">;
+  protected readonly messageDeRefus: import("@angular/core").Signal<string>;
+  private minuterieDeConfirmation;
+  constructor();
+  /**
+   * Le bouton n'apparait que si le navigateur sait copier. Sans presse-papiers,
+   * un bouton qui ne fait rien vaut moins que la selection manuelle, que la
+   * feuille garde possible (`user-select: all`).
+   */
+  protected readonly copiePossible: import("@angular/core").Signal<boolean>;
+  protected auClicDeCopie(): Promise<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StCode, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StCode, "st-code", never, {
+    "valeur": {
+      "alias": "valeur";
+      "required": true;
+      "isSignal": true;
+    };
+    "copiable": {
+      "alias": "copiable";
+      "required": false;
+      "isSignal": true;
+    };
+    "etiquette": {
+      "alias": "etiquette";
+      "required": false;
+      "isSignal": true;
+    };
+    "libelleCopier": {
+      "alias": "libelleCopier";
+      "required": false;
+      "isSignal": true;
+    };
+    "messageDeConfirmation": {
+      "alias": "messageDeConfirmation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "copie": "copie";
+  }, never, never, true, never>;
+}
 
 export {};

package/types/starterlib-ui-etats.d.ts

@@ -0,0 +1,486 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Resource, Signal, TemplateRef } from "@angular/core";
+import { ErreurDeBloc } from "@starterlib/ui";
+import { EtatDeBloc } from "@starterlib/util";
+/**
+ * Les gabarits des cinq etats, declares DANS `<st-state>`.
+ *
+ * ⚠️ Pourquoi des directives de contenu plutot que des entrees `TemplateRef` :
+ * un `<ng-template>` declare a l'exterieur du composant appartient a
+ * l'injecteur de l'endroit ou il est ECRIT, pas de celui qui le rend. Les
+ * fournisseurs de `st-state` — dont `REGION_VIVANTE_PARENTE`, qui fait taire
+ * les annonces en double — ne l'atteignaient donc pas, et l'erreur etait
+ * annoncee deux fois. Passer par le contenu rend la declaration a l'exterieur
+ * impossible : le defaut ne peut plus revenir.
+ */
+export declare class StSucces<T> {
+  readonly gabarit: TemplateRef<{
+    $implicit: Exclude<T, undefined>;
+  }>;
+  /**
+   * La ressource n'est lue nulle part : elle porte le TYPE de la valeur, pour
+   * que `let-valeur` soit type dans le gabarit au lieu d'etre `unknown`.
+   */
+  readonly stSucces: import("@angular/core").InputSignal<Resource<T> | undefined>;
+  /**
+   * `Exclude<T, undefined>` : une ressource sans valeur initiale se type
+   * `T | undefined`, mais st-state ne rend ce gabarit QUE lorsqu'une valeur
+   * existe. Sans cela, chaque gabarit de succes devrait ecrire `page?.length`
+   * pour un cas qui ne se produit pas.
+   */
+  static ngTemplateContextGuard<T>(_directive: StSucces<T>, _contexte: unknown): _contexte is {
+    $implicit: Exclude<T, undefined>;
+  };
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSucces<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StSucces<any>, "ng-template[stSucces]", never, {
+    "stSucces": {
+      "alias": "stSucces";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Erreur. Le contexte porte l'erreur DECRITE (`decrireLErreur`) : code machine, variante,
+ * rejouabilite, trace ; l'erreur brute reste dans `cause`. Les applications cessent de recopier
+ * leur « code de » et leur « est-ce rejouable ».
+ */
+export declare class StErreur {
+  readonly gabarit: TemplateRef<{
+    $implicit: ErreurDeBloc;
+  }>;
+  static ngTemplateContextGuard(_directive: StErreur, _contexte: unknown): _contexte is {
+    $implicit: ErreurDeBloc;
+  };
+  static ɵfac: i0.ɵɵFactoryDeclaration<StErreur, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StErreur, "ng-template[stErreur]", never, {}, {}, never, never, true, never>;
+}
+export declare class StVide {
+  readonly gabarit: TemplateRef<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StVide, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StVide, "ng-template[stVide]", never, {}, {}, never, never, true, never>;
+}
+export declare class StHorsLigne {
+  readonly gabarit: TemplateRef<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StHorsLigne, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StHorsLigne, "ng-template[stHorsLigne]", never, {}, {}, never, never, true, never>;
+}
+/** Chargement sur mesure. Sans lui, `st-state` rend sa silhouette par defaut. */
+export declare class StChargement {
+  readonly gabarit: TemplateRef<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StChargement, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<StChargement, "ng-template[stChargement]", never, {}, {}, never, never, true, never>;
+}
+/** Toutes les directives de gabarit, a importer d'un coup. */
+export declare const GABARITS_D_ETAT: readonly [typeof StSucces, typeof StErreur, typeof StVide, typeof StHorsLigne, typeof StChargement];
+/**
+ * Les silhouettes de la planche 9 de Claude Design (typologie des squelettes, lot 207) :
+ * - `texte` (defaut) : des lignes de texte, la derniere a 60 % ;
+ * - `tableau` : rangee d'en-tete courte, puis des rangees de cellules (la troisieme en pastille) ;
+ * - `liste` : des rangees disque de 40 px, deux lignes et un montant, en option sous une rangee
+ *   d'en-tete (`entete`, planche 2) ;
+ * - `carte` : en-tete, media 16/9 a pictogramme, pied ;
+ * - `formulaire` : des champs (libelle, champ de 44 px, aide sur un champ sur deux) ;
+ * - `indicateur` : le bloc d'un indicateur chiffre (libelle et pastille, valeur, deux lignes).
+ */
+export type VarianteDeSquelette = 'texte' | 'tableau' | 'liste' | 'carte' | 'formulaire' | 'indicateur';
+/**
+ * Silhouette du contenu en cours de chargement.
+ *
+ * Entierement masque aux technologies d'assistance : c'est `stState` qui
+ * annonce le chargement, une fois. Un squelette annonce ligne par ligne
+ * noierait le lecteur d'ecran. Pose hors de `st-state`, son conteneur porte
+ * `aria-busy="true"` pendant le chargement (recette).
+ *
+ * Il doit reproduire la BOITE du contenu reel, sinon l'arrivee des donnees
+ * fait sauter la mise en page.
+ */
+export declare class StSkeleton {
+  readonly variante: import("@angular/core").InputSignal<VarianteDeSquelette>;
+  /** Lignes de texte, rangees de tableau ou de liste, champs de formulaire. */
+  readonly lignes: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly colonnes: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly anime: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Pose la silhouette dans un creux (`surfaceConteneurBas`, 16 px de marge, coins de 8 px) :
+   * la planche 9 montre ainsi un bloc en attente au milieu d'une carte blanche.
+   */
+  readonly puits: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * Une rangee d'en-tete au-dessus de la liste : deux blocs de 24 px aux deux bouts (le titre et
+   * l'action d'une liste, planche 2). Sans effet hors de la variante `liste`.
+   */
+  readonly entete: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly avecEntete: import("@angular/core").Signal<boolean>;
+  protected readonly enteteDeListe: readonly [32, 20];
+  protected readonly indicesDeLigne: import("@angular/core").Signal<number[]>;
+  protected readonly indicesDeColonne: import("@angular/core").Signal<number[]>;
+  /** Pas des titres de colonne. */
+  protected readonly enteteDeTableau: import("@angular/core").Signal<(24 | 32 | 20)[]>;
+  /** Pour chaque rangee, le pas de chaque cellule et si elle est une pastille. */
+  protected readonly rangeesDeTableau: import("@angular/core").Signal<{
+    pas: 24 | 32 | 20 | 28 | 48 | 16 | 40 | 36 | 14;
+    pastille: boolean;
+  }[][]>;
+  protected readonly rangeesDeListe: import("@angular/core").Signal<{
+    titre: 28 | 36 | 44;
+    sousTitre: 32 | 48 | 40;
+    montant: 24 | 20 | 28;
+  }[]>;
+  protected readonly champsDeFormulaire: import("@angular/core").Signal<{
+    libelle: 28 | 36;
+    aide: boolean;
+  }[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSkeleton, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSkeleton, "st-skeleton", never, {
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "lignes": {
+      "alias": "lignes";
+      "required": false;
+      "isSignal": true;
+    };
+    "colonnes": {
+      "alias": "colonnes";
+      "required": false;
+      "isSignal": true;
+    };
+    "anime": {
+      "alias": "anime";
+      "required": false;
+      "isSignal": true;
+    };
+    "puits": {
+      "alias": "puits";
+      "required": false;
+      "isSignal": true;
+    };
+    "entete": {
+      "alias": "entete";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Presence du reseau, lue par `st-state` A L'INSTANT OU UNE ERREUR APPARAIT : une erreur survenue
+ * hors ligne se dit « hors ligne », pas « une erreur est survenue ». La lecture est figee avec
+ * l'erreur : une erreur deja affichee n'est jamais re-etiquetee quand la connectivite bascule.
+ *
+ * ⚠️ `ui` ne depend pas de `@starterlib/core` (ADR 0003) : c'est l'HOTE qui relie ce jeton a
+ * `StConnectivite` du noyau, qui fait d'un statut 0 la source d'autorite et se rouvre a la
+ * premiere reponse (lot 165) :
+ *
+ * ```ts
+ * { provide: ST_EN_LIGNE, useFactory: () => inject(StConnectivite).enLigne }
+ * ```
+ *
+ * ⚠️ Relie a `StConnectivite`, le jeton ne change le rendu d'AUCUNE reponse du serveur :
+ * l'intercepteur du noyau remet la connectivite en ligne sur toute reponse, avant que l'erreur
+ * n'atteigne la ressource. Seul le statut 0 fait alors autorite (predicat `estHorsLigne`). Le
+ * defaut, qui suit les evenements `online` / `offline` du navigateur, couvre en plus l'erreur
+ * rendue hors ligne sans reseau (un service worker qui repond a la place du serveur).
+ */
+export declare const ST_EN_LIGNE: InjectionToken<Signal<boolean>>;
+/** Ce qu'un etat degrade rend quand l'appelant n'a pas fourni son gabarit. */
+type GabaritParDefaut = 'vide' | 'erreur' | 'hors-ligne';
+/**
+ * Impose les cinq etats a un bloc qui consomme l'API, et centralise leur
+ * annonce.
+ *
+ * Deux usages. Le plus courant passe la ressource, et l'etat s'en deduit :
+ *
+ * ```html
+ * <st-state [ressource]="operations">
+ *   <ng-template [stSucces]="operations" let-page>…</ng-template>
+ *   <ng-template stErreur let-erreur><st-error [code]="erreur.code" … /></ng-template>
+ *   <ng-template stVide><st-empty … /></ng-template>
+ * </st-state>
+ * ```
+ *
+ * L'autre pose `[etat]` a la main, pour un bloc qui ne vient pas d'une
+ * ressource — une soumission de formulaire, par exemple.
+ *
+ * ⚠️ Un RECHARGEMENT garde le contenu affiche, sous une barre de 4 px en tete du bloc
+ * (planche 9). Revenir a la silhouette a chaque changement de filtre fait clignoter la
+ * page entiere et perd la position de lecture ; seul un chargement SANS valeur retenue
+ * (premier appel, ou rejeu apres une erreur) montre la silhouette — jamais l'etat vide.
+ *
+ * ⚠️ Anti-clignotement, a l'oeil ET a l'oreille : rien avant `rythme.delai.attente`, puis
+ * la silhouette au moins `rythme.tenue.affichageMinimal` ; « Chargement en cours » n'est
+ * dit que si la silhouette est montree. Un rechargement de plus de
+ * `rythme.tenue.rechargementAnnonce` s'annonce une fois (« Actualisation en cours »).
+ *
+ * ⚠️ L'hote ne porte PAS `role="status"`, contrairement a ce qu'on attendrait :
+ * un remplacement de contenu A L'INTERIEUR d'une region vivante fait relire
+ * tout le sous-arbre par le lecteur d'ecran a chaque bascule d'etat. Seule une
+ * petite zone masquee porte l'annonce, qui tient en quelques mots.
+ *
+ * ⚠️ `REGION_VIVANTE_PARENTE` ne vaut que pour les etats que st-state ANNONCE (chargement,
+ * erreur, vide, hors ligne) : il se tait en succes, et le contenu du gabarit `stSucces` se dit
+ * donc lui-meme — une erreur d'action y garde son `role="alert"`, une banniere hors ligne son
+ * `role="status"`. Fourni a tout le contenu, le jeton les faisait taire sans que personne ne
+ * parle a leur place (revue E8).
+ *
+ * ⚠️ Un gabarit d'etat degrade oublie rend le gabarit PAR DEFAUT du dictionnaire (« Aucun
+ * resultat », « Une erreur est survenue », « Hors connexion ») plutot qu'un bloc vide ; en
+ * developpement, un avertissement le signale.
+ */
+export declare class StState<T> {
+  private readonly libelles;
+  private readonly enLigne;
+  /** La ressource dont l'etat se deduit. */
+  readonly ressource: import("@angular/core").InputSignal<Resource<T> | null>;
+  /** Etat pose a la main. Il prime sur la ressource quand les deux existent. */
+  readonly etat: import("@angular/core").InputSignal<EtatDeBloc | null>;
+  /** Ce qui compte comme « vide » : par defaut, une collection sans element. */
+  readonly estVide: import("@angular/core").InputSignal<(valeur: T) => boolean>;
+  /**
+   * Ce qui compte comme une perte de reseau : par defaut, le statut 0. Une erreur APPARUE
+   * pendant que `ST_EN_LIGNE` disait hors ligne en est une aussi, quel que soit ce predicat.
+   */
+  readonly estHorsLigne: import("@angular/core").InputSignal<(erreur: unknown) => boolean>;
+  /** Silhouette par defaut du chargement. `null` : un indicateur tournant. */
+  readonly squelette: import("@angular/core").InputSignal<VarianteDeSquelette | null>;
+  readonly lignesDeSquelette: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /**
+   * Rien n'est montre avant ce delai, en millisecondes (`rythme.delai.attente`). Zero : la
+   * silhouette tout de suite, pour un bloc dont on SAIT qu'il sera long (un rapport).
+   */
+  readonly delaiAvantSilhouette: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** `null` : les annonces viennent du dictionnaire de l'application. `succes` se tait. */
+  readonly annonces: import("@angular/core").InputSignal<Readonly<Partial<Record<EtatDeBloc, string>>> | null>;
+  /**
+   * Hauteur reservee au bloc, longueur CSS (`'12rem'`, `'240px'`) : la silhouette, puis le contenu,
+   * y tiennent sans pousser ce qui suit — aucun decalage de mise en page au passage du chargement
+   * au succes (CLS 0, lot 211). Un contenu plus haut agrandit le bloc. `null` : rien de reserve.
+   */
+  readonly hauteurMinimale: import("@angular/core").InputSignal<string | null>;
+  private readonly gabaritSucces;
+  private readonly gabaritErreur;
+  private readonly gabaritVide;
+  private readonly gabaritHorsLigne;
+  private readonly gabaritChargement;
+  private readonly instantane;
+  /**
+   * La derniere valeur connue, gardee pendant qu'une autre se charge.
+   *
+   * ⚠️ Necessaire, et pas seulement confortable : un changement de PARAMETRE
+   * n'est pas un `reload`. Angular traite le premier comme une nouvelle
+   * requete — statut « loading », valeur videe. Sans cette memoire, changer un
+   * filtre ou tourner une page ferait donc disparaitre le tableau, clignoter la
+   * page, et perdre la position de lecture. Une erreur, elle, ne garde rien :
+   * afficher des donnees perimees sous un message d'erreur serait mentir.
+   */
+  private readonly valeurRetenue;
+  /**
+   * La connectivite a l'instant de l'erreur, figee avec elle : recalculee seulement quand une
+   * NOUVELLE erreur apparait. Lue en direct, une bascule du reseau re-etiquetait une erreur deja
+   * affichee (un 409 devenait « Hors connexion »), et la region polie la re-annoncait.
+   */
+  private readonly horsLigneALErreur;
+  /** Etat deduit de la ressource, valeur retenue comprise. */
+  private readonly etatDeLaRessource;
+  /**
+   * ⚠️ Un succes pose A LA MAIN sur une ressource qui n'a encore rien rendu passerait `undefined`
+   * au gabarit de succes, que son type promet defini (`let-page` : A1113) : c'est encore un
+   * chargement. Sans ressource, le succes pose a la main se rend tel quel.
+   */
+  protected readonly etatEffectif: Signal<EtatDeBloc>;
+  /**
+   * Une valeur est affichee, et une autre arrive — par rappel explicite ou par
+   * changement de parametre.
+   */
+  protected readonly enRechargement: Signal<boolean>;
+  /** Une ressource au repos (`idle`) n'attend rien : pas d'`aria-busy` perpetuel. */
+  protected readonly enAttente: Signal<boolean>;
+  /**
+   * La silhouette, une fois le delai anti-clignotement passe, et pour au moins la
+   * tenue minimale (`rythme.delai.attente`, `rythme.tenue.affichageMinimal`) : une
+   * reponse rapide n'a pas a clignoter, une reponse a 210 ms ne produit pas d'eclair.
+   * Le gabarit `stChargement` y est soumis aussi.
+   */
+  private readonly chargementVisible;
+  /** Un rechargement long s'annonce, une fois, passe `rythme.tenue.rechargementAnnonce`. */
+  private readonly rechargementLong;
+  /**
+   * La silhouette, une fois le delai anti-clignotement passe, et TENUE :
+   * elle reste le temps de la tenue minimale meme si la reponse arrive avant.
+   * ⚠️ Sans condition sur l'etat : exiger aussi « encore en chargement » faisait
+   * partir la silhouette des la reponse, et une reponse a 230 ms la montrait 30 ms
+   * — l'eclair que la tenue doit eviter (revue E5).
+   */
+  protected readonly montreLaSilhouette: Signal<boolean>;
+  /** Le gabarit `stChargement`, soumis au meme delai et a la meme tenue que la silhouette. */
+  protected readonly gabaritDeChargement: Signal<TemplateRef<void> | null>;
+  private readonly annoncesLues;
+  /**
+   * Ce qui se dit : l'etat, sauf le chargement tant que la silhouette n'est pas montree (une
+   * reponse a 100 ms ne dit rien), et « Actualisation en cours » pour un rechargement long.
+   */
+  protected readonly annonce: Signal<string>;
+  /**
+   * L'injecteur du gabarit de succes : il masque `REGION_VIVANTE_PARENTE`, que les fournisseurs
+   * de st-state posent pour les etats qu'il annonce. Le gabarit est declare dans le contenu de
+   * st-state : sans ce masque, il voyait le jeton.
+   */
+  private readonly injecteurDuSucces;
+  /** `null` : l'injecteur de declaration du gabarit, sous la region de st-state. */
+  protected readonly injecteurDuGabarit: Signal<import("@angular/core").DestroyableInjector | null>;
+  /** L'erreur de la ressource, decrite pour le gabarit (`let-erreur` : `ErreurDeBloc`). */
+  protected readonly erreurDecrite: Signal<ErreurDeBloc | null>;
+  /** Contexte passe au gabarit : la valeur en succes, l'erreur decrite en erreur. */
+  protected readonly contexte: Signal<{
+    $implicit: unknown;
+  }>;
+  /** Le gabarit de l'etat courant, ou `null` (silhouette, ou gabarit par defaut). */
+  protected readonly gabaritDeLEtat: Signal<TemplateRef<unknown> | null>;
+  /** L'etat degrade dont le gabarit manque, rendu par le gabarit du dictionnaire. */
+  protected readonly gabaritParDefaut: Signal<GabaritParDefaut | null>;
+  /** Les textes des gabarits par defaut : ceux du dictionnaire, jamais une phrase du serveur. */
+  protected readonly textesParDefaut: Signal<import("@starterlib/ui").LibellesUi>;
+  /**
+   * Ce qui est a l'ecran : la silhouette, ou le bloc de l'etat. Suivi pour le fondu
+   * d'arrivee, qui ne vaut qu'a la sortie d'un chargement MONTRE.
+   */
+  private readonly affiche;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<StState<any>, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StState<any>, "st-state", never, {
+    "ressource": {
+      "alias": "ressource";
+      "required": false;
+      "isSignal": true;
+    };
+    "etat": {
+      "alias": "etat";
+      "required": false;
+      "isSignal": true;
+    };
+    "estVide": {
+      "alias": "estVide";
+      "required": false;
+      "isSignal": true;
+    };
+    "estHorsLigne": {
+      "alias": "estHorsLigne";
+      "required": false;
+      "isSignal": true;
+    };
+    "squelette": {
+      "alias": "squelette";
+      "required": false;
+      "isSignal": true;
+    };
+    "lignesDeSquelette": {
+      "alias": "lignesDeSquelette";
+      "required": false;
+      "isSignal": true;
+    };
+    "delaiAvantSilhouette": {
+      "alias": "delaiAvantSilhouette";
+      "required": false;
+      "isSignal": true;
+    };
+    "annonces": {
+      "alias": "annonces";
+      "required": false;
+      "isSignal": true;
+    };
+    "hauteurMinimale": {
+      "alias": "hauteurMinimale";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["gabaritSucces", "gabaritErreur", "gabaritVide", "gabaritHorsLigne", "gabaritChargement"], never, true, never>;
+}
+/** `clair` : surface a liseret primaire. `marque` : ilot sombre de la marque, a halo. */
+export type VarianteDeDemarrage = 'clair' | 'marque';
+/**
+ * Ecran de demarrage : ce qu'on voit pendant que l'application se charge, APRES l'amorce statique
+ * (`@starterlib/ui/styles/amorce.css`, peinte avant le JavaScript) et avant le premier ecran.
+ *
+ * ```html
+ * <st-splash-screen variante="marque" nom="Banque Exemple" sousTitre="Tresorerie"
+ *                   statut="Synchronisation des ordres" version="Version 0.9.0">
+ *   <st-icon logo nom="banque" taille="28" />
+ *   <span surtitre>PORTAIL</span>
+ * </st-splash-screen>
+ * ```
+ *
+ * ⚠️ **Aucune retention artificielle** (D25) : l'application le retire des qu'elle est prete. Un
+ * ecran de demarrage qui se montre « au moins deux secondes » fait attendre pour rien.
+ *
+ * ⚠️ **Le statut n'apparait qu'apres `rythme.delai.attente`** (200 ms) : un demarrage rapide ne
+ * fait pas clignoter une phrase qu'on n'a pas le temps de lire. Il est lu par une region
+ * `status`, presente VIDE des la creation ; sans `statut`, elle lit le libelle par defaut
+ * (`chargementEnCours`, masque) : l'attente est un message d'etat (WCAG 4.1.3). L'indicateur et
+ * la barre, eux, se taisent (une seule annonce).
+ *
+ * ⚠️ **Aucun `aria-busy` sur l'ecran** : un sous-arbre `busy` peut etre ignore par les lecteurs
+ * d'ecran jusqu'a son retour a `false`, et l'ecran est retire, jamais rendu « pret ». Il ferait
+ * taire la region meme qu'il contient.
+ *
+ * ⚠️ **La version est un texte public** : un numero de version, jamais un numero de construction,
+ * une adresse ou un detail d'infrastructure (EA-15).
+ *
+ * Emplacements : `[logo]` (tuile de 48 px), `[surtitre]` (ligne du haut, micro-libelle de 11 px
+ * mis en capitales par le composant, D18, D41), contenu libre sous le statut (une mention),
+ * `[pied]` apres la version (12/16 ; un micro-libelle projete y pose ses capitales lui-meme).
+ */
+export declare class StSplashScreen {
+  private readonly libelles;
+  readonly variante: import("@angular/core").InputSignal<VarianteDeDemarrage>;
+  /** Nom de l'application ou de l'etablissement. */
+  readonly nom: import("@angular/core").InputSignal<string>;
+  readonly sousTitre: import("@angular/core").InputSignal<string | null>;
+  /** Ce qui se passe (« Synchronisation des ordres ») ; montre apres `rythme.delai.attente`. */
+  readonly statut: import("@angular/core").InputSignal<string | null>;
+  /** Version publiee (« Version 0.9.0 »), jamais un numero de construction. */
+  readonly version: import("@angular/core").InputSignal<string | null>;
+  /**
+   * Delai avant le statut, en millisecondes : `rythme.delai.attente` par defaut. Zero le montre
+   * tout de suite (une vignette de galerie, un test).
+   */
+  readonly delaiMs: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  protected readonly etiquetteLue: import("@angular/core").Signal<string>;
+  protected readonly statutVisible: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StSplashScreen, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StSplashScreen, "st-splash-screen", never, {
+    "variante": {
+      "alias": "variante";
+      "required": false;
+      "isSignal": true;
+    };
+    "nom": {
+      "alias": "nom";
+      "required": true;
+      "isSignal": true;
+    };
+    "sousTitre": {
+      "alias": "sousTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "statut": {
+      "alias": "statut";
+      "required": false;
+      "isSignal": true;
+    };
+    "version": {
+      "alias": "version";
+      "required": false;
+      "isSignal": true;
+    };
+    "delaiMs": {
+      "alias": "delaiMs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[surtitre]", "[logo]", "*", "[pied]"], true, never>;
+}
+
+export {};

package/types/starterlib-ui-formulaires.d.ts

@@ -3,7 +3,7 @@ import { AnneesDuCalendrier, ContratDeChamp, ContratDeChampABornes, ControleDeSa
 import * as i0 from "@angular/core";
 import { InjectionToken, Provider, Signal } from "@angular/core";
 import { AnnonceLocale, CatalogueDuPointDEntree, LibellesUi } from "@starterlib/ui";
-import { DateIso, FrequenceDeRecurrence, HeureIso, PlageDeDates, Recurrence } from "@starterlib/util";
+import { DateIso, FrequenceDeRecurrence, HeureIso, PlageDeDates, Recurrence } from "@starterlib/util/valeurs";
 /**
  * L'envoi d'un formulaire valide. Il rend les refus du serveur, que Signal Forms place sous leur
  * champ (`fieldTree`) et au recapitulatif, puis efface des que la valeur du champ change ; rien