@dflat-core/web 1.0.41 → 1.0.43

package/core-services/index.d.ts

@@ -18,6 +18,8 @@ export * from './lib/services/server-url';
 export * from './lib/services/string.function';
 export * from './lib/services/user.service';
 export * from './lib/services/menu.service';
+export * from './lib/services/module-menu-services.token';
+export * from './lib/services/application-menu.service';
 export * from './lib/services/filter.service';
 export * from './lib/services/screen.service';
 export * from './lib/model/model';

package/core-services/lib/services/application-menu.service.d.ts

@@ -0,0 +1,22 @@
+import { MenuItem } from '../model/model';
+import { MenuService } from './menu.service';
+import { PermissionService } from './permission.service';
+import * as i0 from "@angular/core";
+/**
+ * Menu de l'application : réunion des menus de tous ses modules (déclarés sous
+ * MODULE_MENU_SERVICES), dans l'ordre de déclaration. Les thèmes de même libellé sont fusionnés
+ * et leurs éléments réunis sans doublon (même lien). Chaque module filtre ses éléments selon les
+ * permissions de l'utilisateur connecté.
+ *
+ * Fourni sous MenuService par DflatAppModule.
+ */
+export declare class ApplicationMenuService extends MenuService {
+    private moduleMenus;
+    constructor(permissionService: PermissionService, moduleMenus: MenuService[] | null);
+    getAllMenuItems(isAdmin: boolean): MenuItem[];
+    getAccessGrantedMenuItems(): MenuItem[];
+    /** Éléments sans doublon : le premier élément de chaque lien est gardé. */
+    private distinctItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationMenuService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationMenuService>;
+}

package/core-services/lib/services/module-menu-services.token.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+import { MenuService } from './menu.service';
+/**
+ * Menus des modules de l'application : chaque module racine ([module]-root) y déclare le sien,
+ * `{ provide: MODULE_MENU_SERVICES, useExisting: <Module>MenuService, multi: true }`.
+ * ApplicationMenuService les réunit en un seul menu.
+ */
+export declare const MODULE_MENU_SERVICES: InjectionToken<MenuService[]>;

package/core-ux/index.d.ts

@@ -25,6 +25,7 @@ export * from './lib/services/modal.service';
 export * from './lib/services/application.service';
 export * from './lib/services/presentation-profile.token';
 export * from './lib/services/selectorMapperBase.service';
+export * from './lib/services/entity-selectors';
 export * from './lib/services/action.service';
 export * from './lib/components/actions/actions.component';
 export * from './lib/components/actions/actions-content.component';

package/core-ux/lib/services/entity-selectors.d.ts

@@ -0,0 +1,37 @@
+import { Injector, Type } from '@angular/core';
+import { EntityDataService } from '@dflat-core/web/core-data';
+/**
+ * Sélecteur d'une entité (champ de formulaire FilterType Custom, dont ModalEntityKey désigne
+ * l'entité) : composant de recherche ouvert en fenêtre modale et service de données dont la
+ * recherche alimente la liste du sélecteur.
+ */
+export interface EntitySelector {
+    /** Clé de l'entité : route de son contrôleur, en minuscule (ex. country). */
+    key: string;
+    /** Composant de recherche de l'entité. */
+    component: Type<any>;
+    /** Libellé de l'entité (titre de la fenêtre de sélection). */
+    title?: string;
+    /** Service de données de l'entité (recherche). */
+    dataService?: Type<EntityDataService<any, any>>;
+}
+/**
+ * Sélecteurs d'entité des modules de l'application. Chaque librairie [module]-ux enregistre ceux
+ * de ses entités, générés par codegenerator (dflat -g ts) dans [module]-components.generated.ts,
+ * dans le constructeur de son module Angular :
+ * `constructor(injector: Injector) { EntitySelectors.register(<Module>GeneratedSelectors, injector); }`.
+ * Le registre est global et garde l'injecteur du module : il sert aussi aux modules chargés à la
+ * demande (loadChildren), dont les services de données ne sont pas visibles de l'injecteur
+ * racine. SelectorMapperServiceBase s'en sert pour toute clé que l'application ne traite pas
+ * elle-même.
+ */
+export declare class EntitySelectors {
+    private static readonly selectors;
+    /** Enregistre des sélecteurs et l'injecteur de leur module (le dernier enregistré l'emporte pour une même clé). */
+    static register(selectors: EntitySelector[], injector?: Injector): void;
+    /** Sélecteur de l'entité de clé `key` (insensible à la casse) et injecteur de son module, sinon undefined. */
+    static find(key: string): {
+        selector: EntitySelector;
+        injector?: Injector;
+    } | undefined;
+}

package/core-ux/lib/services/selectorMapperBase.service.d.ts

@@ -16,9 +16,15 @@ export interface ModalConfig {
 }
 export declare abstract class SelectorMapperServiceBase {
     protected modalService: ModalService;
+    private readonly injector;
     constructor(modalService: ModalService);
     getInputSelectorContext(key: string, title: string, filter?: FilterViewModel, params?: any): IInputSelectorContext;
-    abstract getComponentParams(key: string, params?: any): {
+    /**
+     * Composants et recherche du sélecteur de l'entité de clé `key` : par défaut, le sélecteur
+     * généré de l'entité (EntitySelectors, enregistrés par les librairies [module]-ux). Une
+     * application dérivée traite ses propres clés, puis appelle super.getComponentParams.
+     */
+    getComponentParams(key: string, params?: any): {
         selectionCompType: Type<any>;
         selectionModalTitle?: string;
         creationComType: Type<any>;

package/core-ux/lib/v2/models/contexts/section-context.d.ts

@@ -48,6 +48,18 @@ export declare class SectionContext<P extends EntityViewModel> {
     registerDynamicContainers(containers: ViewContainerRef[]): void;
     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
+     * 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é).
+     */
+    registerRelatedSection<F extends FilterViewModel, T extends EntityViewModel>(name: string, template: Type<ISectionComponent<T>>, filterProperty: keyof F): void;
+    /** Onglets d'entités liées enregistrés par registerRelatedSection (une entité peut en avoir plusieurs, un par clé). */
+    private relatedSections;
+    /** Clé d'entité d'un composant (getEntityKey sans instance, valeur constante), sinon null. */
+    private static getEntityKey;
     getActiveTab(): number;
     renderSection(section: ISpecificSectionContext<any, any, P>, container: ViewContainerRef): void;
     private attachComponentOverrides;

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

@@ -5,7 +5,7 @@ import { CommonModule } from '@angular/common';
 import * as i3 from '@angular/common/http';
 import { HttpHeaders, provideHttpClient, withInterceptorsFromDi, HttpErrorResponse } from '@angular/common/http';
 import * as i0 from '@angular/core';
-import { Injectable, EventEmitter, Optional, SkipSelf, NgModule } from '@angular/core';
+import { Injectable, EventEmitter, Optional, SkipSelf, NgModule, InjectionToken, Inject } from '@angular/core';
 import * as i1 from '@angular/router';
 import jwt_decode from 'jwt-decode';
 import { Subject, ReplaySubject, timer, throwError, BehaviorSubject, empty } from 'rxjs';
@@ -1548,6 +1548,13 @@ function trimChar(str, c) {
     return str.replace(new RegExp(`^[${c}]+|[${c}]+$`, "g"), "");
 }
 
+/**
+ * Menus des modules de l'application : chaque module racine ([module]-root) y déclare le sien,
+ * `{ provide: MODULE_MENU_SERVICES, useExisting: <Module>MenuService, multi: true }`.
+ * ApplicationMenuService les réunit en un seul menu.
+ */
+const MODULE_MENU_SERVICES = new InjectionToken('MODULE_MENU_SERVICES');
+
 class MenuItem {
     constructor(title, link, icon, sublinks, permissionKey) {
         this.external = false;
@@ -1560,9 +1567,56 @@ class MenuItem {
     }
 }
 
+/**
+ * Menu de l'application : réunion des menus de tous ses modules (déclarés sous
+ * MODULE_MENU_SERVICES), dans l'ordre de déclaration. Les thèmes de même libellé sont fusionnés
+ * et leurs éléments réunis sans doublon (même lien). Chaque module filtre ses éléments selon les
+ * permissions de l'utilisateur connecté.
+ *
+ * Fourni sous MenuService par DflatAppModule.
+ */
+class ApplicationMenuService extends MenuService {
+    constructor(permissionService, moduleMenus) {
+        super(permissionService);
+        this.moduleMenus = moduleMenus;
+    }
+    getAllMenuItems(isAdmin) {
+        // Copies : merge complète les éléments de son premier thème de chaque libellé.
+        const themes = (this.moduleMenus ?? [])
+            .reduce((all, menu) => all.concat(menu.getAllMenuItems(isAdmin)), new Array())
+            .map(theme => new MenuItem(theme.title, theme.link, theme.icon, [...(theme.sublinks ?? [])], theme.permissionKey));
+        return this.merge(themes)
+            .map(theme => new MenuItem(theme.title, theme.link, theme.icon, this.distinctItems(theme.sublinks), theme.permissionKey));
+    }
+    getAccessGrantedMenuItems() {
+        return (this.moduleMenus ?? [])
+            .reduce((all, menu) => all.concat(menu.getAccessGrantedMenuItems() ?? []), new Array());
+    }
+    /** Éléments sans doublon : le premier élément de chaque lien est gardé. */
+    distinctItems(items) {
+        const links = new Set();
+        return (items ?? []).filter(item => {
+            if (item.link !== undefined && links.has(item.link))
+                return false;
+            links.add(item.link);
+            return true;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ApplicationMenuService, deps: [{ token: PermissionService }, { token: MODULE_MENU_SERVICES, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ApplicationMenuService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ApplicationMenuService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: PermissionService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MODULE_MENU_SERVICES]
+                }] }] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AppConfiguration, AppKeys, AuthGuard, AuthInterceptor, AuthService, AuthTokenType, BreadcrumbService, BusMessageService, CanActivateGuard, CoreServicesModule, FilterService, GeolocationService, HeadersService, HubService, LocalStoreManager, MenuItem, MenuService, MessagesService, NotificationMqService, NotificationsService, PermissionService, ScreenService, ServerUrl, UserService, trimChar };
+export { AppConfiguration, AppKeys, ApplicationMenuService, AuthGuard, AuthInterceptor, AuthService, AuthTokenType, BreadcrumbService, BusMessageService, CanActivateGuard, CoreServicesModule, FilterService, GeolocationService, HeadersService, HubService, LocalStoreManager, MODULE_MENU_SERVICES, MenuItem, MenuService, MessagesService, NotificationMqService, NotificationsService, PermissionService, ScreenService, ServerUrl, UserService, trimChar };
 //# sourceMappingURL=dflat-core-web-core-services.mjs.map