@dflat-core/web 1.0.49 → 1.0.51

package/fesm2022/dflat-core-web.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"dflat-core-web.mjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/*\r\n * Point d'entrée principal de @dflat-core/web.\r\n * Les librairies sont exposées par des points d'entrée secondaires :\r\n *   @dflat-core/web/core, @dflat-core/web/core-model, @dflat-core/web/core-services, @dflat-core/web/core-data,\r\n *   @dflat-core/web/core-ux, @dflat-core/web/system-model, @dflat-core/web/system-data,\r\n *   @dflat-core/web/system-root, @dflat-core/web/system-ux\r\n */\r\nexport const DFLAT_WEB_ENTRY_POINTS = [\r\n    'core', 'core-model', 'core-services', 'core-data', 'core-ux',\r\n    'system-model', 'system-data', 'system-root', 'system-ux'\r\n] as const;\r\n"],"mappings":"AAOA,MAAa,yBAAyB;CAClC;CAAQ;CAAc;CAAiB;CAAa;CACpD;CAAgB;CAAe;CAAe;AACxC"}
+{"version":3,"file":"dflat-core-web.mjs","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/*\r\n * Point d'entrée principal de @dflat-core/web.\r\n * Les librairies sont exposées par des points d'entrée secondaires :\r\n *   @dflat-core/web/core, @dflat-core/web/core-model, @dflat-core/web/core-services, @dflat-core/web/core-data,\r\n *   @dflat-core/web/core-ux, @dflat-core/web/system-model, @dflat-core/web/system-data,\r\n *   @dflat-core/web/system-root, @dflat-core/web/system-ux\r\n * et, pour les fichiers de test seulement, @dflat-core/web/core-ux/testing.\r\n */\r\nexport const DFLAT_WEB_ENTRY_POINTS = [\r\n    'core', 'core-model', 'core-services', 'core-data', 'core-ux',\r\n    'system-model', 'system-data', 'system-root', 'system-ux'\r\n] as const;\r\n"],"mappings":"AAQA,MAAa,yBAAyB;CAClC;CAAQ;CAAc;CAAiB;CAAa;CACpD;CAAgB;CAAe;CAAe;AACxC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dflat-core/web",
-  "version": "1.0.49",
+  "version": "1.0.51",
   "description": "Librairies Angular Dflat (core, core-*, system-*) et assets partagés, empaquetées en un module npm unique.",
   "license": "MIT",
   "peerDependencies": {
@@ -66,6 +66,10 @@
       "types": "./types/dflat-core-web-core-ux.d.ts",
       "default": "./fesm2022/dflat-core-web-core-ux.mjs"
     },
+    "./core-ux/testing": {
+      "types": "./types/dflat-core-web-core-ux-testing.d.ts",
+      "default": "./fesm2022/dflat-core-web-core-ux-testing.mjs"
+    },
     "./system-data": {
       "types": "./types/dflat-core-web-system-data.d.ts",
       "default": "./fesm2022/dflat-core-web-system-data.mjs"

package/types/dflat-core-web-core-data.d.ts

@@ -27,6 +27,13 @@ export declare class DataService {
    * vidé au redémarrage de l'API (horodatage du jeton d'accès) et au changement d'utilisateur.
    */
   getCached<T>(entityKey: string, action: string): Observable<T>;
+  /**
+   * Valeur d'initialisation d'une entité calculée par le front (ex. définition de ses onglets,
+   * voir EntitySections), gardée dans le même cache que les appels de getCached et sous la même
+   * portée (clé de l'entité) : `factory` n'est appelée qu'une fois, jusqu'à ce que le cache soit
+   * vidé (clearCached, redémarrage de l'API, changement d'utilisateur).
+   */
+  getCachedValue<T>(entityKey: string, name: string, factory: () => T): Observable<T>;
   /** Vide le cache d'initialisation d'une entité, ou tout le cache. */
   clearCached(entityKey?: string): void;
   getViewFilterDescriptors(entityKey: string): Observable<FilterDescriptor[]>;

package/types/dflat-core-web-core-ux-testing.d.ts

@@ -0,0 +1,246 @@
+import { Provider, Type } from "@angular/core";
+import { ActivatedRoute, NavigationExtras, Router, Routes, UrlCreationOptions, UrlTree } from "@angular/router";
+import { ActionDescriptor, ColumnDescriptor, EntityViewModel, EntityViewModelWithFields, FilterDescriptor, FilterViewModel, PagedList } from "@dflat-core/web/core-model";
+import { ApplicationService, BaseComponent, EntityFacade, EntityFacadeRegistryService, EntitySectionProvider, EntitySelector } from "@dflat-core/web/core-ux";
+import { BreadcrumbService, MenuItem, NotificationMqService } from "@dflat-core/web/core-services";
+import { DataService } from "@dflat-core/web/core-data";
+import { Observable } from "rxjs";
+import { Guid } from "guid-typescript";
+import { Title } from "@angular/platform-browser";
+/** Valeurs attendues d'un composant dérivé de BaseComponent (voir describeBaseComponent). */
+export interface BaseComponentExpectations {
+  /** Clé de l'entité (getEntityKey), ex. country. */
+  entityKey: string;
+  /** Lien du composant (getPath), ex. /sys/country. */
+  path: string;
+  /** Titre du composant (getTitle). */
+  title: string;
+  /** Clé de permission du composant (PermissionKey), ex. system.country. */
+  permissionKey: string;
+  /**
+   * Titres des onglets enregistrés par le composant après ngOnInit (facade.sections), dans
+   * l'ordre ; non vérifiés si absent.
+   */
+  sections?: string[];
+  /**
+   * Le composant demande (true) ou non (false) les onglets de son entité au registre du socle
+   * (EntitySections.registerSections) après ngOnInit ; non vérifié si absent. Les onglets
+   * eux-mêmes sont vérifiés avec le module (describeGeneratedModule).
+   */
+  requestsSections?: boolean;
+  /** Fournisseurs ajoutés au module de test (ex. PP_SERVICE). */
+  providers?: Provider[];
+}
+/**
+ * Fabrique du composant à tester : appelée dans un contexte d'injection, avec les services de
+ * test (voir BaseComponentTestContext). Ex. `(app, route) => new TestCountryComponent(app, route)`.
+ */
+export type BaseComponentFactory<TFilter extends FilterViewModel, TData extends EntityViewModel> = (app: ApplicationService, route: ActivatedRoute) => BaseComponent<TFilter, TData>;
+/** Fil d'Ariane publié par BreadcrumbService (setCurrent). */
+export interface BreadcrumbData {
+  /** Description de la page. */
+  description: string;
+  /** Le fil d'Ariane est affiché. */
+  display: boolean;
+  /** En-tête de la page. */
+  header: string;
+  /** Niveaux du fil d'Ariane : icône, lien et libellé. */
+  levels: {
+    icon: string;
+    link: string[];
+    title: string;
+  }[];
+}
+/** Compteur des appels d'une méthode (voir countCalls). */
+export interface CallCounter {
+  /** Nombre d'appels depuis la pose du compteur. */
+  count: number;
+}
+/** Éléments générés d'un module (dflat -g ts) dont describeGeneratedModule vérifie la cohérence. */
+export interface GeneratedModuleExpectations {
+  /** Composants des entités ([Module]GeneratedComponents). */
+  components: Type<unknown>[];
+  /** Routes des composants ([Module]GeneratedRoutes). */
+  routes: Routes;
+  /** Sélecteurs d'entité ([Module]GeneratedSelectors). */
+  selectors: EntitySelector[];
+  /** Classe des clés d'entité générées (Base[Module]EntityKeys) : une propriété statique par entité. */
+  entityKeys: object;
+  /** Lien d'une entité à partir de sa clé (Base[Module]MenuItemProvider.GetLink). */
+  getLink: (entityKey: string) => string;
+  /** Éléments de menu générés des entités du menu dont la route est générée. */
+  menuItems: MenuItem[];
+  /** Service des onglets des entités ([Module]GeneratedSectionService) ; onglets non vérifiés si absent. */
+  sectionProvider?: EntitySectionProvider;
+  /** Titres attendus des onglets, par clé d'entité et dans l'ordre ; titres non vérifiés si absent. */
+  sections?: {
+    [entityKey: string]: string[];
+  };
+  /** Classe des permissions du module ([Module]Permissions) ; permissions non vérifiées si absente. */
+  permissions?: object;
+}
+/**
+ * Vérifications communes aux outils de test (Vitest, Jest, Jasmine) utilisées par les suites
+ * standard : seul ce sous-ensemble est appelé, pour ne dépendre d'aucun outil.
+ */
+export interface TestMatchers {
+  /** Égalité stricte (===). */
+  toBe(expected: unknown): void;
+  /** Égalité de structure (objets et tableaux comparés en profondeur). */
+  toEqual(expected: unknown): void;
+  /** Valeur considérée comme vraie. */
+  toBeTruthy(): void;
+  /** Valeur considérée comme fausse. */
+  toBeFalsy(): void;
+}
+/**
+ * Fonctions globales de l'outil de test (Vitest, Jest, Jasmine) utilisées par les suites
+ * standard, lues sur globalThis (voir getTestRunner).
+ */
+export interface TestRunner {
+  /** Déclare un groupe de tests. */
+  describe(name: string, body: () => void): void;
+  /** Déclare un test, synchrone ou asynchrone. */
+  it(name: string, body: () => void | Promise<void>): void;
+  /** Code exécuté avant chaque test du groupe. */
+  beforeEach(body: () => void | Promise<void>): void;
+  /** Vérifications sur une valeur. */
+  expect(actual: unknown): TestMatchers;
+}
+/**
+ * Doublure de DataService : aucune requête HTTP. Fournit les données d'initialisation d'une
+ * façade (colonnes, filtre vide, formulaire, actions) et enregistre les recherches et lectures
+ * de détail demandées par le composant testé.
+ */
+export declare class DataServiceDouble {
+  /** Recherches demandées (search), dans l'ordre. */
+  readonly searchCalls: {
+    entityKey: string;
+    filter: FilterViewModel;
+  }[];
+  /** Lectures de détail demandées (getDetails), dans l'ordre. */
+  readonly detailsCalls: {
+    entityKey: string;
+    id: number;
+  }[];
+  /** Résultat renvoyé par search. */
+  searchResult: PagedList<EntityViewModel>;
+  /** Entité renvoyée par getDetails. */
+  details: EntityViewModel;
+  /** Enregistre la recherche et renvoie searchResult. */
+  search<TData>(entityKey: string, filter: FilterViewModel): Observable<PagedList<TData>>;
+  /** Enregistre la lecture et renvoie details. */
+  getDetails<TData>(entityKey: string, id: number): Observable<TData>;
+  /** Paramètres d'URL d'un filtre : copie du filtre, sans mise en forme. */
+  getFormattedParams(params: object): object;
+  /** Colonnes de la grille : aucune. */
+  getViewColumns(): Observable<ColumnDescriptor[]>;
+  /** Critères du filtre : aucun. */
+  getViewFilterDescriptors(): Observable<FilterDescriptor[]>;
+  /** Filtre vide : première page de 25 lignes. */
+  getEmptyFilter<TFilter>(): Observable<TFilter>;
+  /** Formulaire vide, sans champ. */
+  getEntityViewModel<TData>(): Observable<EntityViewModelWithFields<TData>>;
+  /** Actions étendues : aucune. */
+  getExtendedActions(): Observable<ActionDescriptor[]>;
+  /** Valeur d'initialisation calculée par le front : calculée à chaque appel, sans cache. */
+  getCachedValue<T>(entityKey: string, name: string, factory: () => T): Observable<T>;
+  /** La doublure, vue comme le DataService qu'elle remplace. */
+  asDataService(): DataService;
+}
+/** Registre de façades du socle (vraies façades), qui enregistre les façades demandées. */
+export declare class EntityFacadeRegistrySpy extends EntityFacadeRegistryService {
+  /** Façades demandées (getFacade), dans l'ordre : clé d'entité, identifiant et façade renvoyée. */
+  readonly requests: {
+    key: string;
+    id: Guid;
+    facade: EntityFacade<EntityViewModel>;
+  }[];
+  /** Enregistre la demande et renvoie la façade du registre. */
+  getFacade<TData extends EntityViewModel>(key: string, id: Guid): EntityFacade<TData>;
+}
+/**
+ * Doublure de Router : URL courante, construction d'URL (chemin et paramètres) et navigations
+ * enregistrées. Une navigation réussit toujours et devient l'URL courante.
+ */
+export declare class RouterDouble {
+  /** URL courante. */
+  url: string;
+  /** Navigations demandées (navigate), dans l'ordre. */
+  readonly navigations: {
+    commands: unknown[];
+    extras?: NavigationExtras;
+  }[];
+  constructor(url: string);
+  /** URL formée des segments `commands` et des paramètres `extras.queryParams`. */
+  createUrlTree(commands: unknown[], extras?: UrlCreationOptions): UrlTree;
+  /** Enregistre la navigation, qui devient l'URL courante. */
+  navigate(commands: unknown[], extras?: NavigationExtras): Promise<boolean>;
+  /** La doublure, vue comme le Router qu'elle remplace. */
+  asRouter(): Router;
+  /** URL d'un chemin et de ses paramètres. */
+  private static format;
+}
+/**
+ * Services donnés à un composant dérivé de BaseComponent pendant un test : vraies classes du
+ * socle quand elles s'instancient sans dépendance (ApplicationService, registre de façades et
+ * façades, fil d'Ariane, file de messages), doublures pour le service de données, le routeur et
+ * la route. Les services que BaseComponent n'utilise pas (authentification, fenêtres modales,
+ * alertes, mise en page...) ne sont pas fournis.
+ */
+export declare class BaseComponentTestContext {
+  /** Doublure du service de données. */
+  readonly dataService: DataServiceDouble;
+  /** Doublure du routeur. */
+  readonly router: RouterDouble;
+  /** Route active, sans paramètre. */
+  readonly route: ActivatedRoute;
+  /** Fil d'Ariane du socle. */
+  readonly breadcrumb: BreadcrumbService;
+  /** File de messages (notifications d'entité) du socle. */
+  readonly notifications: NotificationMqService;
+  /** Registre de façades du socle, qui enregistre les façades demandées. */
+  readonly registry: EntityFacadeRegistrySpy;
+  /** ApplicationService du socle, construit sur les services ci-dessus. */
+  readonly app: ApplicationService;
+  /**
+   * @param url URL courante du routeur.
+   * @param title Service du titre de la page (TestBed.inject(Title)), utilisé par le fil d'Ariane.
+   */
+  constructor(url: string, title: Title);
+  /** Fil d'Ariane courant (dernière valeur publiée). */
+  get currentBreadcrumb(): BreadcrumbData;
+}
+/**
+ * Compte les appels de la méthode `method` de `target`, qui reste exécutée : équivalent, sans
+ * outil de test, d'un espion transparent.
+ */
+export declare function countCalls<T extends object, K extends keyof T>(target: T, method: K): CallCounter;
+/**
+ * Fonctions globales de l'outil de test (describe, it, beforeEach, expect), lues sur globalThis
+ * pour ne dépendre d'aucun outil ni de ses types.
+ */
+export declare function getTestRunner(): TestRunner;
+/**
+ * Suite de test standard d'un composant dérivé de BaseComponent : vérifie, sans rendre son
+ * gabarit, le contrat de BaseComponent (création, clé d'entité, lien, titre, permission, façade,
+ * ngOnInit, demande des onglets, Search / refresh, notifications, ngOnDestroy). À appeler au premier niveau d'un
+ * fichier de test :
+ * `describeBaseComponent('CountryComponent', (app, route) => new TestCountryComponent(app, route), { ... })`.
+ * La suite n'utilise que les fonctions globales de l'outil de test (describe, it, beforeEach,
+ * expect) et TestBed.
+ *
+ * @param name Nom du composant, repris dans le titre de la suite.
+ * @param factory Fabrique du composant, appelée dans un contexte d'injection avant chaque test.
+ * @param expectations Valeurs attendues du composant.
+ */
+export declare function describeBaseComponent<TFilter extends FilterViewModel, TData extends EntityViewModel>(name: string, factory: BaseComponentFactory<TFilter, TData>, expectations: BaseComponentExpectations): void;
+/**
+ * Suite de test standard d'un module généré (dflat -g ts) : cohérence de ses composants, routes,
+ * sélecteurs, clés d'entité, onglets, éléments de menu et permissions. Chaque test compare à une liste
+ * vide la liste des éléments en défaut, que l'outil de test affiche en cas d'échec.
+ *
+ * @param name Nom du module (ex. System), repris dans le titre de la suite.
+ * @param module Éléments générés du module.
+ */
+export declare function describeGeneratedModule(name: string, module: GeneratedModuleExpectations): void;

package/types/dflat-core-web-core-ux.d.ts

@@ -448,6 +448,14 @@ export declare class LayoutService {
   static ɵfac: i0.ɵɵFactoryDeclaration<LayoutService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
+/**
+ * Dépendances racines d'ApplicationService et du registre de façades. Le jeton est déclaré dans son
+ * propre fichier, sans import d'exécution : ApplicationService et EntityFacadeRegistryService
+ * s'importent l'un l'autre, et un jeton déclaré avec ApplicationService serait lu avant son
+ * initialisation par le registre quand le package est chargé sans édition de liens Angular
+ * (tests unitaires d'une application : "Cannot access 'ROOT_DEPS' before initialization").
+ */
+export declare const ROOT_DEPS: InjectionToken<RootDeps>;
 declare namespace dynamic_form_component_d_exports {
   export { DynamicFormComponent };
 }
@@ -1891,9 +1899,10 @@ export declare class SectionContext<P extends EntityViewModel> {
   private defaultLayoutOverride;
   registerSection<F extends FilterViewModel, T extends EntityViewModel>(name: string, template: Type<ISectionComponent<T>>, config?: ISectionConfig<T, F, P>): ISpecificSectionContext<T, F, P>;
   /**
-   * Onglet d'une entité liée (relation 1..*), décrit par une section du formulaire par défaut et
-   * enregistré par le composant généré (Base[X]Component.registerFormSections) : liste des
-   * enregistrements de l'entité dont le critère `filterProperty` vaut l'Id de l'enregistrement
+   * Onglet d'une entité liée (relation 1..*), décrit par une section du formulaire par défaut,
+   * déclaré par le service généré du module ([Module]GeneratedSectionService) et enregistré à
+   * la demande du composant généré (Base[X]Component.registerFormSections, voir EntitySections) :
+   * liste des enregistrements de l'entité dont le critère `filterProperty` vaut l'Id de l'enregistrement
    * sélectionné. Ignoré si le composant spécifique a déjà enregistré un onglet du même titre ou
    * de la même entité (clé d'entité du composant, ex. variante dérivée du composant généré).
    */
@@ -2707,7 +2716,6 @@ export interface RootDeps {
   selection: SelectionService<EntityViewModel>;
   readonly test: TestService;
 }
-export declare const ROOT_DEPS: InjectionToken<RootDeps>;
 export declare class ApplicationService {
   deps: RootDeps;
   MQService: NotificationMqService;
@@ -5537,6 +5545,65 @@ export declare class EntitySelectors {
     injector?: Injector;
   } | undefined;
 }
+/**
+ * Définition d'un onglet d'entité liée (relation 1..*) du formulaire d'une entité : liste des
+ * enregistrements de l'entité du composant dont le critère `filterProperty` vaut l'Id de
+ * l'enregistrement sélectionné. L'ordre des onglets est celui de la liste qui les porte.
+ */
+export interface EntitySection {
+  /** Libellé de l'onglet. */
+  title: string;
+  /** Composant de recherche de l'entité listée dans l'onglet. */
+  component: Type<ISectionComponent<any>>;
+  /** Critère du filtre de l'entité listée qui reçoit l'Id de l'enregistrement sélectionné (clé étrangère). */
+  filterProperty: string;
+}
+/**
+ * Service d'un module qui déclare les onglets d'entités liées de ses entités (service généré
+ * [Module]GeneratedSectionService, voir EntitySections).
+ */
+export interface EntitySectionProvider {
+  /** Clés des entités du module qui ont des onglets. */
+  getEntityKeys(): string[];
+  /** Onglets de l'entité de clé `entityKey`, dans l'ordre d'affichage ; liste vide si elle n'en a pas. */
+  getSections(entityKey: string): EntitySection[];
+}
+/**
+ * Onglets d'entités liées (relation 1..*) des entités des modules de l'application. Chaque
+ * librairie [module]-ux enregistre le service qui déclare ceux de ses entités, généré par
+ * codegenerator (dflat -g ts) dans [module]-sections.generated.ts, dans le constructeur de son
+ * module Angular :
+ * `constructor(injector: Injector) { EntitySections.register(injector.get(<Module>GeneratedSectionService)); }`.
+ * Un composant généré (Base[X]Component.registerFormSections) demande ses onglets par la clé de
+ * son entité, sans importer ni ce service ni les composants des onglets : pas de dépendance
+ * circulaire entre composants.
+ *
+ * Le service n'est interrogé qu'une fois par entité : la définition des onglets est gardée dans le
+ * cache d'initialisation des écrans (InitCacheService, par DataService.getCachedValue), avec les
+ * descripteurs de filtre et le filtre vide de l'entité, et vidée avec eux. L'enregistrement des
+ * onglets sur la façade, propre à l'instance du composant, est fait à chaque initialisation.
+ */
+export declare class EntitySections {
+  /** Nom de la définition des onglets d'une entité dans le cache d'initialisation ([clé d'entité]/FormSections). */
+  static readonly CACHE_NAME = "FormSections";
+  private static readonly providers;
+  /** Enregistre le service des onglets d'un module (le dernier enregistré l'emporte pour une même clé d'entité). */
+  static register(provider: EntitySectionProvider): void;
+  /** Service qui déclare les onglets de l'entité de clé `entityKey` (insensible à la casse), sinon undefined. */
+  static find(entityKey: string): EntitySectionProvider | undefined;
+  /**
+   * Définition d'un onglet d'entité liée : `filterProperty` est vérifié à la compilation parmi
+   * les critères du filtre `F` de l'entité listée par `component`.
+   */
+  static related<F extends FilterViewModel, T extends EntityViewModel>(title: string, component: Type<ISectionComponent<T>>, filterProperty: keyof F & string): EntitySection;
+  /**
+   * Ajoute à la façade `facade` les onglets de l'entité de clé `entityKey`, dans l'ordre déclaré
+   * par le service de son module (demandé une seule fois, puis lu dans le cache d'initialisation).
+   * Un onglet du même titre ou de la même entité déjà enregistré sur la façade n'est pas dupliqué
+   * (voir SectionContext.registerRelatedSection). Sans service enregistré pour l'entité, rien n'est ajouté.
+   */
+  static registerSections<T extends EntityViewModel>(entityKey: string, facade: EntityFacade<T>): void;
+}
 export declare class SortableColumnComponent implements OnInit, OnDestroy {
   constructor();
   columnName: string;