s4y-ui 5.2.1 → 5.3.1

package/fesm2022/s4y-ui.mjs

@@ -3351,6 +3351,25 @@ async function toMaybeBooleanPromise(value) {
         return await firstValueFrom(value);
     return value;
 }
+async function toHandlerResult(ret) {
+    if (ret instanceof Promise)
+        return await ret;
+    if (ret instanceof EventEmitter)
+        return await firstValueFrom(ret);
+    if (isObservable(ret))
+        return await firstValueFrom(ret);
+    return ret;
+}
+async function allow(canDismiss, reason) {
+    if (!canDismiss)
+        return true;
+    try {
+        return await Promise.resolve(canDismiss(reason));
+    }
+    catch {
+        return false;
+    }
+}
 
 class DynamicDialogRef {
     overlayRef;
@@ -3363,6 +3382,8 @@ class DynamicDialogRef {
     _afterClosed = new Subject();
     panelEl;
     isClosing = false;
+    _container;
+    _opts;
     constructor(overlayRef) {
         this.overlayRef = overlayRef;
         this.afterOpened$ = this._afterOpened.asObservable();
@@ -3445,6 +3466,63 @@ class DynamicDialogRef {
         }
         this.overlayRef.dispose();
     }
+    _attachForButtonUpdates(container, opts) {
+        this._container = container;
+        this._opts = opts;
+        // garantir objetos
+        this._opts.okBtnOptions ??= {};
+        this._opts.cancelBtnOptions ??= {};
+    }
+    updateButtons(patch) {
+        if (!this._opts)
+            return;
+        if (patch.ok)
+            Object.assign(this._opts.okBtnOptions, patch.ok);
+        if (patch.cancel)
+            Object.assign(this._opts.cancelBtnOptions, patch.cancel);
+        this._markForCheck();
+    }
+    // OK
+    setOkLoading(state) {
+        this._ensureBtn('ok').loading = state;
+        // se você usa okLoading interno como overlay, mantenha em sincronia:
+        this._container.okLoading = !!state;
+        this._markForCheck();
+    }
+    setOkDisabled(state) {
+        this._ensureBtn('ok').disabled = state;
+        this._markForCheck();
+    }
+    setOkText(text) {
+        this._ensureBtn('ok').text = text;
+        this._markForCheck();
+    }
+    // Cancel
+    setCancelLoading(state) {
+        this._ensureBtn('cancel').loading = state;
+        this._container.cancelLoading = !!state;
+        this._markForCheck();
+    }
+    setCancelDisabled(state) {
+        this._ensureBtn('cancel').disabled = state;
+        this._markForCheck();
+    }
+    setCancelText(text) {
+        this._ensureBtn('cancel').text = text;
+        this._markForCheck();
+    }
+    _ensureBtn(which) {
+        if (!this._opts)
+            throw new Error('Dialog options not attached.');
+        const key = which === 'ok' ? 'okBtnOptions' : 'cancelBtnOptions';
+        this._opts[key] ??= {};
+        return this._opts[key];
+    }
+    _markForCheck() {
+        const cdr = this._container?.cdr;
+        if (cdr?.markForCheck)
+            cdr.markForCheck();
+    }
 }
 
 class DynamicDialogComponent {
@@ -3472,10 +3550,11 @@ class DynamicDialogComponent {
             return;
         this.okLoading = true;
         try {
-            const res = await toMaybeBooleanPromise(this.dialogOptions?.onOk?.({ data: this.injectedData, ref: this.ref }));
-            if (res === false)
+            const out = await toHandlerResult(this.dialogOptions?.onOk?.({ data: this.injectedData, ref: this.ref }));
+            if (out === false)
                 return;
-            await this.ref.closeAnimated(undefined, 'ok');
+            const result = out === true || typeof out === 'undefined' ? undefined : out;
+            await this.ref.closeAnimated(result, 'ok');
         }
         finally {
             this.okLoading = false;
@@ -3485,15 +3564,16 @@ class DynamicDialogComponent {
     async onCancel() {
         if (this.cancelLoading)
             return;
-        this.cancelLoading = true;
+        // this.cancelLoading = true;
         try {
-            const res = await toMaybeBooleanPromise(this.dialogOptions?.onCancel?.({
+            const out = await toHandlerResult(this.dialogOptions?.onCancel?.({
                 data: this.injectedData,
                 ref: this.ref,
             }));
-            if (res === false)
-                return;
-            await this.ref.closeAnimated(undefined, 'cancel');
+            if (out === false)
+                return; // NÃO fecha
+            const result = out === true || typeof out === 'undefined' ? undefined : out;
+            await this.ref.closeAnimated(result, 'cancel');
         }
         finally {
             this.cancelLoading = false;
@@ -3546,19 +3626,26 @@ class DynamicDialogService {
             classes.forEach((c) => overlayRef.addPanelClass(c));
         }
         const dialogRef = new DynamicDialogRef(overlayRef);
+        const untilClosed$ = dialogRef.afterClosed$.pipe(take(1));
         if (opts.closeOnBackdrop) {
             overlayRef
                 .backdropClick()
-                .pipe(take(1))
-                .subscribe(() => {
+                .pipe(takeUntil(untilClosed$))
+                .subscribe(async () => {
+                if (!(await allow(opts.canDismiss, 'backdrop')))
+                    return;
                 dialogRef.closeAnimated(undefined, 'backdrop');
             });
         }
         if (opts.closeOnEsc !== false) {
             overlayRef
                 .keydownEvents()
-                .pipe(filter$1((e) => e.key === 'Escape' || e.key === 'Esc'), take(1))
-                .subscribe(() => dialogRef.closeAnimated(undefined, 'esc'));
+                .pipe(filter$1((e) => e.key === 'Escape' || e.key === 'Esc'), takeUntil(untilClosed$))
+                .subscribe(async () => {
+                if (!(await allow(opts.canDismiss, 'esc')))
+                    return;
+                dialogRef.closeAnimated(undefined, 'esc');
+            });
         }
         // injeta o ref + dados no componente container
         const injector = Injector.create({
@@ -3572,6 +3659,7 @@ class DynamicDialogService {
         // anexa o container
         const containerPortal = new ComponentPortal(DynamicDialogComponent, null, injector);
         const containerRef = overlayRef.attach(containerPortal);
+        dialogRef._attachForButtonUpdates(containerRef.instance, opts);
         const templateCtx = {
             $implicit: opts.data,
             data: opts.data,