@elasticias/screens 1.0.39 → 1.0.41

package/fesm2022/elasticias-screens.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { Input, Component, signal, InjectionToken, inject, ChangeDetectorRef, ViewChild, Injector, computed, DestroyRef } from '@angular/core';
 import { PersistedState, StorageUtils, AppUtils, CsvUtils } from '@elasticias/utils';
-import { Subject, combineLatest, take } from 'rxjs';
+import { Subject, combineLatest, take, merge, map, distinctUntilChanged } from 'rxjs';
 import { Permissions } from '@elasticias/types';
 import { Router, ActivatedRoute } from '@angular/router';
 import { CacheService, ToastService, ConfirmDialogService, EfShortcutService } from '@elasticias/core';
@@ -86,6 +86,15 @@ class ScreenContext extends AbstractEntity {
     entity;
     grants;
     duplicateMode = false;
+    /**
+     * Whether the screen may write the record it shows, for its current mode.
+     * Set by `AbstractDetailScreenV2` to its own `canWrite` signal, so shared
+     * components bound to `[context]` (ef-detail-toolbar's Save and its
+     * `requiresWrite` custom actions) follow the same rule without each
+     * screen passing it again. Undefined on screens that have no write mode
+     * (search, report), where those components keep their default behaviour.
+     */
+    canWrite;
     constructor(state, group, entity, refDataProvider, bundles, grants, screenName = '', language = 'fr') {
         super();
         this.state = state;
@@ -175,6 +184,12 @@ const SCREEN_REF_DATA_SERVICE = new InjectionToken('SCREEN_REF_DATA_SERVICE');
 class AbstractScreenComponent extends AbstractComponent {
     context;
     connectedUser;
+    /** V1 only: the NgForm a V1 detail template declares as `#entityForm`.
+     *  V2 templates bind `[value]` / `(valueChangeEvent)` with no NgForm, so
+     *  this stays undefined there and everything below that walks it
+     *  (`disableAllControls`, `setFormErrors`, `isFormValid`) does nothing.
+     *  V2 screens use `AbstractDetailScreenV2.readOnlyMode()` bound as
+     *  `[efReadOnly]` on the form container, and `canWrite()` for saving. */
     entityForm;
     serverErrors = signal({}, ...(ngDevMode ? [{ debugName: "serverErrors" }] : /* istanbul ignore next */ []));
     refDataLoaded$ = new Subject();
@@ -196,6 +211,10 @@ class AbstractScreenComponent extends AbstractComponent {
         this.context.screenName = this.getBundleName();
         this.processGrants();
     }
+    /** The `isReadOnly()` branch below is the V1 read-only path. It never
+     *  fires usefully on a V2 screen (see `entityForm`), and its predicate
+     *  ignores the mode: Read+Create on an existing record counts as
+     *  writable. V2 detail screens rely on `readOnlyMode()` instead. */
     ngAfterViewInit() {
         this.changeDetector.detectChanges();
         if (this.context && this.context.isReadOnly()) {
@@ -454,6 +473,8 @@ class AbstractScreenComponent extends AbstractComponent {
     clearServerErrors() {
         this.serverErrors.set({});
     }
+    /** V1 only: disables the controls of `entityForm`. A no-op on V2
+     *  screens, which use `readOnlyMode()` + `[efReadOnly]`. */
     disableAllControls() {
         setTimeout(() => {
             if (this.entityForm && Object.keys(this.entityForm.controls).length > 0) {
@@ -1487,7 +1508,13 @@ class AbstractSearchScreenV2 extends AbstractScreenComponent {
     }
     /* ── Convenience criteria mutators ───────────────────────────── */
     setSearchText(text) {
-        this.criteria.update((c) => this.cloneCriteria(c, { searchText: text || undefined, page: 1 }));
+        // Templates bind this to ef-smart-bar's (search), and that binding has
+        // received the native DOM 'search' Event, which reached the API as
+        // {"isTrusted":true} and failed. ef-smart-bar now stops the event, but
+        // whatever arrives that is not text, the field's own value is the
+        // search the user meant.
+        const value = typeof text === 'string' ? text : this.searchQuery();
+        this.criteria.update((c) => this.cloneCriteria(c, { searchText: value || undefined, page: 1 }));
         this.search();
     }
     setPage(pageNumber, pageSize) {
@@ -1826,6 +1853,12 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
     destroyRef = inject(DestroyRef);
     auditHistoryService = inject(AUDIT_HISTORY_SERVICE, { optional: true });
     shortcuts = inject(EfShortcutService);
+    /** The in-flight entity / history requests. A newer load drops the
+     *  older one, so a slow response for an id the screen has moved off
+     *  can never overwrite the record it now shows, and destroying the
+     *  screen drops both. */
+    loadSub;
+    auditSub;
     /** Distinguishes this instance's registration from any other detail
      *  screen alive at once (the outgoing and incoming routed component
      *  can briefly coexist), the same convention ef-row-actions uses:
@@ -1836,6 +1869,12 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
     serviceInstance;
     constructor() {
         super();
+        // A response landing after the screen is gone would still run
+        // afterLoad() and start a history request for a screen nobody sees.
+        this.destroyRef.onDestroy(() => {
+            this.loadSub?.unsubscribe();
+            this.auditSub?.unsubscribe();
+        });
         // Every detail screen inherits mod+s with no per-screen wiring, and
         // it doubles as the fix for the browser's own Save Page dialog
         // otherwise popping up on top of it.
@@ -1844,7 +1883,13 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
             keys: 'mod+s',
             labelKey: 'common_save',
             group: 'shortcut_group_screen',
-            handler: () => this.save(),
+            // Gated here as well as inside save(): a subclass that overrides
+            // save() without calling super must still not be reachable from
+            // the keyboard by a user who cannot write.
+            handler: () => {
+                if (this.canWrite())
+                    this.save();
+            },
         });
     }
     /**
@@ -1866,6 +1911,36 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
      * the `?mode=duplicate` query param.
      */
     duplicateMode = signal(false, ...(ngDevMode ? [{ debugName: "duplicateMode" }] : /* istanbul ignore next */ []));
+    /**
+     * Bumped every time `processGrants()` (re)reads the user's grants.
+     * `context` is a plain object, not a signal, so without this a
+     * `canWrite()` read before the grants arrive would memoize `false`
+     * and the route subscription re-setting `editionState(false)` to the
+     * same value would never invalidate it.
+     */
+    grantsVersion = signal(0, ...(ngDevMode ? [{ debugName: "grantsVersion" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether the user may write the record on screen, for the mode it is
+     * in: an existing record (edit mode, not duplicating) needs Edit; a new
+     * record or a duplicate needs Create. Read is not enough for either,
+     * which is how a Read-only user got a fully editable, savable form.
+     *
+     * Bind its negation on the form container to disable every ef-* control:
+     * `<div class="form" [efReadOnly]="readOnlyMode()">`. ef-detail-toolbar
+     * reads it through `context.canWrite` to hide Save, so screens pass
+     * nothing for that. The backend still enforces the same grants; this is
+     * the UI agreeing with it.
+     */
+    canWrite = computed(() => {
+        this.grantsVersion();
+        const ctx = this.context;
+        if (!ctx)
+            return false;
+        const editingExisting = this.editionState() && !this.duplicateMode();
+        return editingExisting ? ctx.hasEditPermission : ctx.hasCreatePermission;
+    }, ...(ngDevMode ? [{ debugName: "canWrite" }] : /* istanbul ignore next */ []));
+    /** `!canWrite()`, named for the `[efReadOnly]` binding it feeds. */
+    readOnlyMode = computed(() => !this.canWrite(), ...(ngDevMode ? [{ debugName: "readOnlyMode" }] : /* istanbul ignore next */ []));
     /** True while service.get / create / update / delete is in flight. */
     loading = signal(false, ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
     /** Last load / save error message — empty string when none. */
@@ -1923,11 +1998,21 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
                 this.loadReferenceData(cfg.REF_DATA_OPTIONS);
         }
         // Wire route params → load (or reset to empty on /details).
-        combineLatest([this.route.paramMap, this.route.queryParamMap])
-            .pipe(takeUntilDestroyed(this.destroyRef))
-            .subscribe(([params, queryParams]) => {
-            const id = params.get('id');
-            const isDuplicate = queryParams.get('mode') === 'duplicate';
+        //
+        // One navigation can emit on both maps: the router pushes
+        // queryParams first, then params. Combining the two emissions saw
+        // a half-updated route on details/SRC?mode=duplicate → details/NEW
+        // (the old id without the mode) and loaded SRC on a screen that
+        // was moving to NEW. The router sets `snapshot` to the next one
+        // before either emits, so each emission reads id and mode together
+        // from it, and the second emission of the same navigation (same
+        // snapshot object) is dropped. Any navigation that changes params
+        // or query still gets a new snapshot, so it still reloads once.
+        merge(this.route.paramMap, this.route.queryParamMap)
+            .pipe(map(() => this.route.snapshot), distinctUntilChanged(), takeUntilDestroyed(this.destroyRef))
+            .subscribe(snapshot => {
+            const id = snapshot.paramMap.get('id');
+            const isDuplicate = snapshot.queryParamMap.get('mode') === 'duplicate';
             this.entityId.set(id);
             this.duplicateMode.set(isDuplicate);
             this.context.duplicateMode = isDuplicate;
@@ -1937,12 +2022,30 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
             }
             else {
                 // New mode — reset to a fresh empty entity, no history yet.
+                // A load still in flight for the previous id is dropped.
+                if (this.loadSub && !this.loadSub.closed) {
+                    this.loadSub.unsubscribe();
+                    this.loading.set(false);
+                }
+                this.auditSub?.unsubscribe();
                 this.entity.set({});
                 this.auditEntries.set([]);
                 this.afterLoad();
             }
         });
     }
+    processGrants() {
+        // Stamp before super: it ends in detectChanges(), which renders an
+        // ef-detail-toolbar bound to this context. A toolbar that first sees
+        // the context without canWrite memoizes "unknown" (Save shown) and,
+        // the context being the same object, never re-reads it.
+        this.context.canWrite = this.canWrite;
+        // Bumped before super too, so the render inside it recomputes
+        // canWrite from the grants super is about to set rather than from a
+        // value memoized on an earlier read.
+        this.grantsVersion.update(v => v + 1);
+        super.processGrants();
+    }
     /**
      * Merge a partial patch into the `entity` signal — the canonical
      * way for form inputs to write back. Spread-immutably so OnPush
@@ -1966,7 +2069,15 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
             return;
         this.loading.set(true);
         this.errorMsg.set(null);
-        this.serviceInstance.get(id).subscribe({
+        // Moving to another record: the previous one's history must not
+        // land under it while this load is in flight.
+        const showsAnotherRecord = this.entity()?.id !== id;
+        if (showsAnotherRecord) {
+            this.auditSub?.unsubscribe();
+            this.auditEntries.set([]);
+        }
+        this.loadSub?.unsubscribe();
+        this.loadSub = this.serviceInstance.get(id).subscribe({
             next: (result) => {
                 const vm = new ViewModelEntity(result);
                 vm.id = id;
@@ -1979,6 +2090,13 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
                 console.error('AbstractDetailScreenV2.loadData failed', err);
                 this.errorMsg.set(err?.message ?? 'Erreur de chargement');
                 this.loading.set(false);
+                // Save and the status actions target entityId(). Leaving the
+                // previous record on screen would have them act on a record
+                // other than the one shown. A failed reload of the same
+                // record keeps it: what is shown is still what is targeted.
+                if (showsAnotherRecord) {
+                    this.entity.set({});
+                }
             },
         });
     }
@@ -1986,8 +2104,14 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
      * Persist the entity. Routes to `service.create()` when in new
      * or duplicate mode, `service.update(id, entity)` when editing.
      * Subclass `beforeSave()` can return `false` to cancel.
+     *
+     * A no-op when `canWrite()` is false, checked before `beforeSave()` so
+     * a screen's validation never toasts at a user who could not save
+     * anyway.
      */
     save() {
+        if (!this.canWrite())
+            return;
         const proceed = this.beforeSave();
         if (proceed === false)
             return;
@@ -2039,6 +2163,8 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
         return undefined;
     }
     delete() {
+        if (!this.context?.hasDeletePermission)
+            return;
         const id = this.entityId();
         if (!id) {
             this.recordNotFound();
@@ -2069,8 +2195,12 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
      *  via `service.create()` after the user hits Save.
      *  Without the id, the duplicate route would have nothing to
      *  fetch — `entity` would be empty and the clone-as-template
-     *  flow would fall back to creating a blank record. */
+     *  flow would fall back to creating a blank record.
+     *  Needs Create: a duplicate is saved through `service.create()`, so
+     *  opening one without Create would only lead to a read-only form. */
     duplicate() {
+        if (!this.context?.hasCreatePermission)
+            return;
         const id = this.entityId();
         const base = this.detailsBaseUrl();
         if (id == null) {
@@ -2120,6 +2250,7 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
      * an empty history rather than blocking the screen.
      */
     loadAuditHistory() {
+        this.auditSub?.unsubscribe();
         this.auditEntries.set([]);
         const entityType = this.getConfig()?.AUDIT_ENTITY_TYPE;
         const id = this.entityId();
@@ -2135,7 +2266,7 @@ class AbstractDetailScreenV2 extends AbstractScreenComponent {
             if (!result$ || typeof result$.subscribe !== 'function') {
                 return;
             }
-            result$.subscribe({
+            this.auditSub = result$.subscribe({
                 next: (entries) => this.auditEntries.set(entries ?? []),
                 error: () => this.auditEntries.set([]),
             });