@elasticias/screens 1.0.48 → 1.0.49

package/fesm2022/elasticias-screens.mjs

@@ -1,13 +1,13 @@
 import * as i0 from '@angular/core';
-import { Input, Component, signal, InjectionToken, inject, ChangeDetectorRef, ViewChild, Injector, computed, DestroyRef } from '@angular/core';
+import { Input, Component, signal, InjectionToken, inject, ChangeDetectorRef, ViewChild, Injector, DestroyRef, computed } from '@angular/core';
 import { PersistedState, StorageUtils, AppUtils, CsvUtils } from '@elasticias/utils';
-import { Subject, combineLatest, take, merge, map, distinctUntilChanged } from 'rxjs';
+import { Subject, combineLatest, take, from, merge, map, distinctUntilChanged } from 'rxjs';
 import { Permissions } from '@elasticias/types';
 import { Router, ActivatedRoute } from '@angular/router';
 import { CacheService, ToastService, ConfirmDialogService, EfShortcutService } from '@elasticias/core';
 import { Location } from '@angular/common';
-import { TranslateService } from '@ngx-translate/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { TranslateService } from '@ngx-translate/core';
 
 class AbstractEntity {
     clone(entity) {
@@ -1054,6 +1054,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
 class AbstractSearchScreenV2 extends AbstractScreenComponent {
     screenState = ScreenStateEnum.SEARCH;
     injector = inject(Injector);
+    destroyRef = inject(DestroyRef);
+    /**
+     * A delete confirm is loading or open. A second click (or the row
+     * shortcut) meanwhile is ignored, so one gesture cannot start two impact
+     * reads or stack two confirms. Cleared when the confirm is answered
+     * (PrimeNG calls reject on close and Escape too) or when the read
+     * yields no confirm.
+     */
+    deleteConfirmBusy = false;
     serviceInstance;
     /**
      * Translate lazily, through the injector.
@@ -1818,29 +1827,93 @@ class AbstractSearchScreenV2 extends AbstractScreenComponent {
     getDeleteConfirmName(_id) {
         return undefined;
     }
+    /**
+     * Async details for the delete confirmation, read before it opens. Use
+     * it when the confirm has to say what the delete will take with it, such
+     * as how many products lose a collection:
+     *
+     * ```ts
+     * protected override getDeleteConfirmOptions(id: any) {
+     *   return this.collectionsClient.deleteImpact(id).pipe(
+     *     map(impact => ({
+     *       messageKey: impact.onHome ? 'x_delete_message_home' : 'x_delete_message',
+     *       messageParams: { count: impact.productCount ?? 0 },
+     *     })),
+     *   );
+     * }
+     * ```
+     *
+     * The returned options are merged over `{ intent: 'delete', name:
+     * getDeleteConfirmName(id) }`. Only the first value of an Observable is
+     * used. If the read fails (the HTTP interceptor toasts it) or completes
+     * without a value, no confirm opens and nothing is deleted. Return
+     * `undefined`, the default, to open the confirm at once. While the read
+     * is in flight or the confirm is open, another delete is ignored, and a
+     * screen destroyed during the read opens nothing.
+     */
+    getDeleteConfirmOptions(_id) {
+        return undefined;
+    }
     delete(id) {
         if (!id) {
             this.recordNotFound();
             return;
         }
+        if (this.deleteConfirmBusy)
+            return;
+        this.deleteConfirmBusy = true;
+        const details = this.getDeleteConfirmOptions(id);
+        if (!details) {
+            this.openDeleteConfirm(id, {});
+            return;
+        }
+        let opened = false;
+        from(details)
+            // A screen left while the read was in flight opens nothing.
+            .pipe(take(1), takeUntilDestroyed(this.destroyRef))
+            .subscribe({
+            next: (extra) => {
+                opened = true;
+                this.openDeleteConfirm(id, extra ?? {});
+            },
+            // A failed read is the interceptor's to report; without its details
+            // the confirm would understate what the delete takes with it.
+            error: () => {
+                this.deleteConfirmBusy = false;
+            },
+            complete: () => {
+                if (!opened)
+                    this.deleteConfirmBusy = false;
+            },
+        });
+    }
+    openDeleteConfirm(id, extra) {
+        const { accept: _a, reject: _r, intent: _i, ...details } = extra;
         this.confirmDialogService.confirm({
             intent: 'delete',
             name: this.getDeleteConfirmName(id),
-            accept: () => this.serviceInstance.delete(id).subscribe({
-                next: (result) => {
-                    if (result?.errors?.length) {
-                        this.handleErrors(result.errors);
-                    }
-                    else {
-                        this.search();
-                        this.toastService.showSuccess();
-                    }
-                },
-                // The HTTP error interceptor surfaces the message (toast). Swallow
-                // here so a rejected delete (e.g. a 422 business-rule violation)
-                // doesn't bubble up as an unhandled error.
-                error: () => undefined,
-            }),
+            ...details,
+            reject: () => {
+                this.deleteConfirmBusy = false;
+            },
+            accept: () => {
+                this.deleteConfirmBusy = false;
+                this.serviceInstance.delete(id).subscribe({
+                    next: (result) => {
+                        if (result?.errors?.length) {
+                            this.handleErrors(result.errors);
+                        }
+                        else {
+                            this.search();
+                            this.toastService.showSuccess();
+                        }
+                    },
+                    // The HTTP error interceptor surfaces the message (toast). Swallow
+                    // here so a rejected delete (e.g. a 422 business-rule violation)
+                    // doesn't bubble up as an unhandled error.
+                    error: () => undefined,
+                });
+            },
         });
     }
     duplicate(id) {