@starterlib/ui 0.14.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starterlib/ui",
-  "version": "0.14.0",
+  "version": "0.15.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.14.0",
-    "@starterlib/util": "^0.14.0",
+    "@starterlib/tokens": "^0.15.0",
+    "@starterlib/util": "^0.15.0",
     "@zxcvbn-ts/core": "^4.2.0",
     "@zxcvbn-ts/language-common": "^4.1.3",
     "@zxcvbn-ts/language-en": "^4.1.1",
@@ -93,6 +93,10 @@
       "types": "./types/starterlib-ui-indicateurs.d.ts",
       "default": "./fesm2022/starterlib-ui-indicateurs.mjs"
     },
+    "./journal": {
+      "types": "./types/starterlib-ui-journal.d.ts",
+      "default": "./fesm2022/starterlib-ui-journal.mjs"
+    },
     "./libelles-en": {
       "types": "./types/starterlib-ui-libelles-en.d.ts",
       "default": "./fesm2022/starterlib-ui-libelles-en.mjs"

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

@@ -0,0 +1,214 @@
+import { ApiError } from "@starterlib/util";
+import { OptionDeListe } from "@starterlib/ui/saisie";
+import * as i0 from "@angular/core";
+import { InjectionToken, Injector, Provider, Signal } from "@angular/core";
+import { CatalogueDuPointDEntree, NiveauDeTitre } from "@starterlib/ui";
+import { EnvoiDeFormulaire } from "@starterlib/ui/formulaires";
+/** Le motif libre d'une action journalisee : dix caracteres au moins, cinq cents au plus (bornes par defaut). */
+export declare const LONGUEUR_MINIMALE_DU_MOTIF = 10;
+export declare const LONGUEUR_MAXIMALE_DU_MOTIF = 500;
+/** L'adresse du journal filtre sur une reference : un chemin du routeur de l'application et ses parametres. */
+export interface AdresseDuJournal {
+  readonly chemin: string;
+  readonly parametres: Readonly<Record<string, string>>;
+}
+/**
+ * Ce que demande une ecriture journalisee (un geste d'exploitation qui entre au journal d'audit) : ses textes deja
+ * traduits par l'application, son motif, son envoi. Le socle ne porte aucun metier : l'application dit ce que fait le
+ * geste, le serveur juge.
+ */
+export interface DemandeDActionJournalisee {
+  /** Le titre du dialogue : le geste (« Retirer une exception »). */
+  readonly titre: string;
+  /** Ce que le geste fait, et ce qui suit. */
+  readonly consigne: string;
+  readonly libelleDuMotif: string;
+  /** L'aide du motif ; par defaut, celle du socle (dix caracteres au moins, le motif part avec l'action). */
+  readonly aideDuMotif?: string;
+  /** Le motif en liste fermee, la ou l'application l'exige ; sinon un texte libre. */
+  readonly motifs?: readonly OptionDeListe[];
+  /** Les bornes du motif libre ; par defaut 10 et 500 caracteres. */
+  readonly longueurMinimaleDuMotif?: number;
+  readonly longueurMaximaleDuMotif?: number;
+  readonly libelleDuBouton: string;
+  /** Ce qui vient d'etre fait (« Exception retiree ») ; par defaut, « Action journalisee ». */
+  readonly titreDeLaConfirmation?: string;
+  /**
+   * L'envoi : le motif part AVEC l'action, jamais apres ; la cle est celle de l'INTENTION, tiree une fois a
+   * l'ouverture du dialogue et rejouee a chaque renvoi (a poser en `CLE_D_IDEMPOTENCE`). Rend le corps de la reponse,
+   * ou la reference d'audit est lue (`lireLaReferenceDAudit`).
+   */
+  readonly executer: (motif: string, cle: string) => Promise<unknown>;
+  /**
+   * La lecture d'un refus d'`executer` : `versApiError` du noyau (`@starterlib/core`), que l'application passe telle
+   * quelle (`{ ..., versApiError }`). `ui` ne connait pas `core` : le refus se lit comme partout ailleurs, sans copie.
+   */
+  readonly versApiError: (erreur: unknown) => ApiError;
+  /**
+   * Le message d'un refus propre a ce geste, deja traduit ; `null` laisse le socle dire le refus (hors ligne, motif
+   * refuse, refus generiques des codes du socle backend, puis le message generique avec son code et sa trace).
+   */
+  readonly messageDuRefus?: (erreur: ApiError) => string | null;
+  /** Un refus ou un retrait (refuser, retirer, revoquer) : le bouton du geste en rouge avec son icone. */
+  readonly retrait?: boolean;
+  /** L'adresse du journal filtre sur la reference rendue ; sans elle, la confirmation ne montre aucun lien. */
+  readonly adresseDuJournal?: (reference: string) => AdresseDuJournal;
+  /** Ce qui precise la confirmation (« Validation unique », par exemple), deja traduit ; lu a la confirmation. */
+  readonly precisionDeLaConfirmation?: () => string | null;
+}
+/** Ce que rend le dialogue a sa fermeture apres l'action : la reference d'audit, `null` si le serveur n'en rend aucune. */
+export interface ResultatDActionJournalisee {
+  readonly referenceDAudit: string | null;
+}
+/**
+ * La reference d'audit d'une reponse (`{ "referenceDAudit": "..." }`), si elle a la forme du contrat ; `null` sinon :
+ * jamais une reference devinee.
+ */
+export declare function lireLaReferenceDAudit(corps: unknown): string | null;
+/**
+ * Le motif refuse par la validation de forme du serveur (`PLATFORM_VALIDATION_FAILED`, violation du champ `motif`) :
+ * aucun code propre au motif manquant, le socle backend le dit par sa validation.
+ */
+export declare function motifRefuse(erreur: ApiError): boolean;
+/**
+ * Les libelles de `@starterlib/ui/journal` (reste R-407 d'Aplomb) : le catalogue par point d'entree (AD-10, D154),
+ * comme ceux du parcours et de la messagerie. La langue suit celle du dictionnaire du tronc.
+ */
+export interface LibellesDuJournal {
+  /** L'aide du motif libre, sa longueur minimale ecrite. */
+  readonly aideDuMotif: (minimum: number) => string;
+  /** Le rappel sous le motif : le geste et son motif entrent au journal d'audit. */
+  readonly journal: string;
+  /** Quitter le dialogue sans agir. */
+  readonly annuler: string;
+  /** Fermer le dialogue apres la confirmation. */
+  readonly fermer: string;
+  /** Le titre de la confirmation, par defaut. */
+  readonly journalisee: string;
+  /** L'etiquette de la reference d'audit. */
+  readonly reference: string;
+  /** Le serveur n'a rendu aucune reference : jamais une reference devinee. */
+  readonly sansReference: string;
+  readonly voirAuJournal: string;
+  /** Le titre d'un refus. */
+  readonly titreDuRefus: string;
+  readonly horsLigne: string;
+  /** Le motif refuse par la validation de forme du serveur. */
+  readonly motifRequis: string;
+  /** Un refus sans message propre : son code et sa trace se montrent, copiables. */
+  readonly refusGenerique: string;
+  /** Les refus generiques des codes du socle backend (`PLATFORM_*`), par code. */
+  readonly refusDuSocle: Readonly<Record<string, string>>;
+}
+export declare const LIBELLES_DU_JOURNAL_FR: LibellesDuJournal;
+export declare const LIBELLES_DU_JOURNAL_EN: LibellesDuJournal;
+/**
+ * Les catalogues du journal par langue (sous-etiquette primaire : `fr`, `en`). Une application qui ajoute une langue
+ * au dictionnaire du tronc ajoute la sienne ici, par `fournirLibellesDuJournal({ de: ... })`.
+ */
+export declare const ST_LIBELLES_DU_JOURNAL: InjectionToken<Readonly<Record<string, LibellesDuJournal>>>;
+/** Ajoute (ou remplace) des catalogues du journal, par langue. */
+export declare function fournirLibellesDuJournal(catalogues: Readonly<Record<string, LibellesDuJournal>>): Provider;
+/** Le catalogue de la langue du dictionnaire du tronc. A appeler dans un contexte d'injection. */
+export declare function libellesDuJournal(): Signal<LibellesDuJournal>;
+/**
+ * Le catalogue du journal ET la langue de son repli (`catalogueDuPointDEntree`) : `lang` de ce qu'il ecrit seul (D-29).
+ * A appeler dans un contexte d'injection.
+ */
+export declare function catalogueDuJournal(): Signal<CatalogueDuPointDEntree<LibellesDuJournal>>;
+/**
+ * La confirmation d'une action journalisee (reste R-407 d'Aplomb, question P10-05-patrons ; patron monte de la coquille
+ * de la console) : « Action journalisee », la reference d'audit que le serveur a rendue et, quand l'application donne
+ * son adresse, le lien vers le journal filtre sur elle. Une reponse sans reference le dit : jamais une reference
+ * devinee. Ce qui precise l'issue (une validation unique, par exemple) vient de l'application, deja traduit.
+ *
+ * ```html
+ * <st-confirmation-journalisee [reference]="reference()" [adresse]="adresseDuJournal(reference())" />
+ * ```
+ */
+export declare class StConfirmationJournalisee {
+  protected readonly catalogue: import("@angular/core").Signal<import("@starterlib/ui").CatalogueDuPointDEntree<import("@starterlib/ui/journal").LibellesDuJournal>>;
+  /** La reference d'audit que le serveur a rendue ; `null` s'il n'en a pas rendu. */
+  readonly reference: import("@angular/core").InputSignal<string | null>;
+  /** Ce qui vient d'etre fait (« Exception retiree »), deja traduit ; par defaut, « Action journalisee ». */
+  readonly titre: import("@angular/core").InputSignal<string | null>;
+  readonly niveauDuTitre: import("@angular/core").InputSignal<NiveauDeTitre>;
+  /** L'adresse du journal filtre sur la reference ; sans elle (ou sans reference), aucun lien. */
+  readonly adresse: import("@angular/core").InputSignal<AdresseDuJournal | null>;
+  /** Ce qui precise l'issue, deja traduit (« Validation unique »), apres la mention d'une reference absente. */
+  readonly precision: import("@angular/core").InputSignal<string | null>;
+  protected readonly lien: import("@angular/core").Signal<AdresseDuJournal | null>;
+  protected readonly phrase: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StConfirmationJournalisee, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StConfirmationJournalisee, "st-confirmation-journalisee", never, {
+    "reference": {
+      "alias": "reference";
+      "required": true;
+      "isSignal": true;
+    };
+    "titre": {
+      "alias": "titre";
+      "required": false;
+      "isSignal": true;
+    };
+    "niveauDuTitre": {
+      "alias": "niveauDuTitre";
+      "required": false;
+      "isSignal": true;
+    };
+    "adresse": {
+      "alias": "adresse";
+      "required": false;
+      "isSignal": true;
+    };
+    "precision": {
+      "alias": "precision";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+interface Motif {
+  motif: string;
+}
+/**
+ * Le dialogue d'une action journalisee (reste R-407 d'Aplomb, question P10-05-patrons ; patron monte de la coquille de
+ * la console) : le motif (texte libre de dix caracteres au moins, ou liste fermee), envoye AVEC l'action ; la cle
+ * d'idempotence de l'intention (tiree une fois a l'ouverture : un double envoi ne fait qu'une action) ; le bouton
+ * occupe pendant l'envoi ; un refus dit depuis son code (`st-refusal` : le message propre du geste, sinon ceux du
+ * socle, decompte d'un `429`, code et trace copiables pour un refus inconnu) ; hors ligne, rien n'est mis en file. Apres
+ * l'action, sa confirmation dans le meme dialogue (`st-confirmation-journalisee`), puis « Fermer » rend la reference.
+ * « Annuler » quitte sans agir : rouge, comme tout abandon d'un geste.
+ *
+ * S'ouvre par `ouvrirUneActionJournalisee(injecteur, demande)` ; jamais un second dialogue par-dessus.
+ */
+export declare class StActionJournalisee {
+  protected readonly demande: DemandeDActionJournalisee;
+  protected readonly catalogue: import("@angular/core").Signal<import("@starterlib/ui").CatalogueDuPointDEntree<import("@starterlib/ui/journal").LibellesDuJournal>>;
+  /** La cle de l'INTENTION : tiree une fois, rejouee a chaque renvoi (jamais une cle par requete). */
+  private readonly cle;
+  protected readonly minimum: number;
+  private readonly maximum;
+  protected readonly refus: import("@angular/core").WritableSignal<ApiError | null>;
+  protected readonly attente: import("@angular/core").WritableSignal<boolean>;
+  protected readonly resultat: import("@angular/core").WritableSignal<ResultatDActionJournalisee | null>;
+  protected readonly action: import("@angular/forms/signals").FieldTree<Motif, string | number, "writable">;
+  /** L'adresse du journal filtre sur la reference rendue, si l'application la donne. */
+  protected readonly adresse: import("@angular/core").Signal<import("@starterlib/ui/journal").AdresseDuJournal | null>;
+  /** Ce qui precise la confirmation, lu a la confirmation seulement. */
+  protected readonly precision: import("@angular/core").Signal<string | null>;
+  protected readonly envoyer: EnvoiDeFormulaire<Motif>;
+  /** Le message d'un refus : hors ligne, le motif refuse, le message propre du geste, ceux du socle, le generique. */
+  protected message(erreur: ApiError): string;
+  /** Vrai quand le refus a un message ; sinon `st-refusal` montre le code et la trace, copiables. */
+  protected connu(erreur: ApiError): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StActionJournalisee, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StActionJournalisee, "st-action-journalisee", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Ouvre le dialogue d'une action journalisee ; resout a sa fermeture : le resultat apres l'action, `undefined` si la
+ * personne l'a quitte sans agir. A charger au geste (import dynamique du point d'entree), hors du premier ecran.
+ */
+export declare function ouvrirUneActionJournalisee(injecteur: Injector, demande: DemandeDActionJournalisee): Promise<ResultatDActionJournalisee | undefined>;
+
+export {};

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

@@ -1159,6 +1159,17 @@ export interface LibellesParcours {
   readonly annuler: string;
   /** L'annonce d'un changement d'etat (« Demande : programmee »). */
   readonly etatDeLaDemande: (etat: string) => string;
+  /** L'annulation motivee, dans la meme fenetre (reste R-498 d'Aplomb) : ce qu'elle fait. */
+  readonly consigneDAnnulation: string;
+  readonly motifDAnnulation: string;
+  /** L'aide du motif d'annulation, sa longueur minimale citee. */
+  readonly aideDuMotifDAnnulation: (minimum: number) => string;
+  readonly motifDAnnulationRequis: string;
+  /** Le motif trop court, sa longueur minimale citee. */
+  readonly motifDAnnulationTropCourt: (minimum: number) => string;
+  readonly confirmerLAnnulation: string;
+  /** Quitter l'annulation sans annuler : « Annuler », comme tout abandon d'un geste. */
+  readonly abandonnerLAnnulation: string;
 }
 export declare const LIBELLES_PARCOURS_FR: LibellesParcours;
 export declare const LIBELLES_PARCOURS_EN: LibellesParcours;
@@ -1210,7 +1221,9 @@ export declare function catalogueDuParcours(): Signal<CatalogueDuPointDEntree<Li
  *   « Soumettre la demande » une fois l'effet montre ; `envoyerAvec` fait l'appel selon l'etat. Le
  *   double clic est avale (`chargement`), la cle d'idempotence posee par l'intercepteur du socle.
  * - Apres la previsualisation, la saisie se fige (« Modifier la demande » la rouvre : `modification`)
- *   ; envoyee, elle ne change plus, et « Annuler la demande » reste (`annulation`).
+ *   ; envoyee, elle ne change plus, et « Annuler la demande » reste (`annulation`). Avec `annulationMotivee`, le
+ *   motif de l'annulation s'ecrit sous la demande, dans la meme fenetre, jamais dans un dialogue par-dessus (reste
+ *   R-498 d'Aplomb) ; `annulation` le rend, `annulationEnCours` et `refusDAnnulation` disent la suite.
  * - Un changement d'etat s'annonce ; un refus prend le focus (`st-refusal`).
  */
 export declare class StChangeRequest {
@@ -1230,15 +1243,45 @@ export declare class StChangeRequest {
   readonly plage: import("@angular/core").InputSignal<PlageDeDemande | null>;
   /** Le refus du serveur, montre a l'etat `refuse`. */
   readonly refus: import("@angular/core").InputSignal<RefusDeDemande | null>;
+  /**
+   * L'annulation demande son motif DANS la meme fenetre (reste R-498 d'Aplomb : jamais deux fenetres l'une sur
+   * l'autre) : « Annuler la demande » ouvre le motif sous la demande, puis « Confirmer l'annulation » l'emet. Faux, le
+   * bouton emet aussitot, sans motif.
+   */
+  readonly annulationMotivee: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** La longueur minimale du motif d'annulation : dix caracteres par defaut. */
+  readonly longueurMinimaleDuMotifDAnnulation: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** L'annulation part : la confirmation est occupee, le motif fige (un double clic est avale). */
+  readonly annulationEnCours: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Le refus de l'annulation, deja traduit par l'application : dit dans l'etape, qui reste ouverte. */
+  readonly refusDAnnulation: import("@angular/core").InputSignal<string | null>;
   /** « Modifier la demande » : apres une previsualisation ou un refus, la saisie se rouvre. */
   readonly modification: import("@angular/core").OutputEmitterRef<void>;
-  /** « Annuler la demande » : une demande envoyee, encore en attente ou programmee. */
-  readonly annulation: import("@angular/core").OutputEmitterRef<void>;
+  /**
+   * « Annuler la demande » : une demande envoyee, encore en attente ou programmee. Rend le motif quand l'annulation est
+   * motivee (`annulationMotivee`), sinon une chaine vide.
+   */
+  readonly annulation: import("@angular/core").OutputEmitterRef<string>;
   protected readonly identifiants: {
     readonly titre: `${string}-titre`;
     readonly gel: `${string}-gel`;
     readonly previsualisation: `${string}-previsualisation`;
+    readonly annulation: `${string}-annulation`;
   };
+  private readonly injecteur;
+  private readonly boutonDAnnulation;
+  private readonly champDuMotif;
+  /** L'etape du motif d'annulation, ouverte tant que la demande reste envoyee. */
+  private readonly etapeDAnnulation;
+  protected readonly annulationOuverte: import("@angular/core").Signal<boolean>;
+  protected readonly motifDAnnulation: import("@angular/core").WritableSignal<string>;
+  /** Une confirmation a ete tentee : les erreurs du motif se montrent des lors. */
+  protected readonly tentative: import("@angular/core").WritableSignal<boolean>;
+  /** Le motif d'annulation tel que le juge le composant : obligatoire, et sa longueur minimale. */
+  protected readonly erreursDuMotif: import("@angular/core").Signal<{
+    kind: string;
+    message: string;
+  }[]>;
   protected readonly pastille: import("@angular/core").Signal<{
     readonly ton: TonDeStatut;
     readonly icone: NomDIcone;
@@ -1254,6 +1297,12 @@ export declare class StChangeRequest {
   protected readonly enCours: import("@angular/core").Signal<boolean>;
   /** Le recapitulatif sous le titre : un niveau de plus, 4 au plus. */
   protected readonly niveauDuRecapitulatif: import("@angular/core").Signal<3 | 4>;
+  /** « Annuler la demande » : sans motif, l'annulation part ; motivee, son motif s'ecrit sous la demande. */
+  protected demanderLAnnulation(): void;
+  /** « Confirmer l'annulation » : le motif valide part ; sinon le champ dit pourquoi et reprend le focus. */
+  protected confirmerLAnnulation(): void;
+  /** « Annuler » : l'annulation est abandonnee, rien ne part ; le focus revient au bouton qui l'avait ouverte. */
+  protected abandonnerLAnnulation(): void;
   constructor();
   static ɵfac: i0.ɵɵFactoryDeclaration<StChangeRequest, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<StChangeRequest, "st-change-request", never, {
@@ -1287,6 +1336,26 @@ export declare class StChangeRequest {
       "required": false;
       "isSignal": true;
     };
+    "annulationMotivee": {
+      "alias": "annulationMotivee";
+      "required": false;
+      "isSignal": true;
+    };
+    "longueurMinimaleDuMotifDAnnulation": {
+      "alias": "longueurMinimaleDuMotifDAnnulation";
+      "required": false;
+      "isSignal": true;
+    };
+    "annulationEnCours": {
+      "alias": "annulationEnCours";
+      "required": false;
+      "isSignal": true;
+    };
+    "refusDAnnulation": {
+      "alias": "refusDAnnulation";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "modification": "modification";
     "annulation": "annulation";