@acorex/platform 21.0.0-next.70 → 21.0.0-next.71

package/fesm2022/acorex-platform-layout-builder.mjs

@@ -1,28 +1,171 @@
 import * as i5 from '@angular/common';
-import { CommonModule } from '@angular/common';
+import { CommonModule, DOCUMENT } from '@angular/common';
 import * as i0 from '@angular/core';
-import { Injectable, inject, input, model, signal, computed, effect, output, viewChild, ChangeDetectionStrategy, Component, NgModule, EventEmitter, Output } from '@angular/core';
+import { Injectable, inject, input, model, signal, computed, effect, output, viewChild, ChangeDetectionStrategy, Component, NgModule, EventEmitter, ElementRef, DestroyRef, Output } from '@angular/core';
 import { provideCommandSetups, AXPCommandService } from '@acorex/platform/runtime';
 import { AXPopupService } from '@acorex/components/popup';
 import * as i4 from '@acorex/platform/core';
-import { AXPHookService, AXPExpressionEvaluatorService, AXPComponentSlotModule, AXPContextStore } from '@acorex/platform/core';
+import { AXPHookService, AXPExpressionEvaluatorService, captureFormContextBaseline, isFormContextDirty, AXPComponentSlotModule, AXPContextStore } from '@acorex/platform/core';
 import * as i1 from '@acorex/platform/layout/widget-core';
 import { AXPWidgetSerializationHelper, AXPWidgetContainerComponent, AXPPageStatus, AXPWidgetCoreModule, AXPWidgetRegistryService } from '@acorex/platform/layout/widget-core';
 import { cloneDeep, isNil, set, isEqual, merge } from 'lodash-es';
 import * as i2 from '@acorex/components/form';
 import { AXFormComponent, AXFormModule } from '@acorex/components/form';
 import { Subject, debounceTime, distinctUntilChanged, startWith } from 'rxjs';
+import { AXOverlayService } from '@acorex/cdk/overlay';
 import * as i1$1 from '@acorex/components/button';
 import { AXButtonModule } from '@acorex/components/button';
+import { AXDialogService } from '@acorex/components/dialog';
 import * as i2$1 from '@acorex/components/decorators';
 import { AXDecoratorModule } from '@acorex/components/decorators';
 import * as i3 from '@acorex/components/loading';
 import { AXLoadingModule } from '@acorex/components/loading';
 import { AXBasePageComponent } from '@acorex/components/page';
 import * as i6 from '@acorex/core/translation';
-import { AXTranslationModule, AXTranslationService } from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
 import { AXP_ENTITY_DEFINITION_CRUD_SERVICE } from '@acorex/platform/domain';
 
+//#region ----   Dialog Action Shortcut Utilities   ----
+const DEFAULT_CANCEL_DIALOG_ACTION_SHORTCUTS = ['Esc'];
+const DEFAULT_SUBMIT_DIALOG_ACTION_SHORTCUTS = ['Enter', 'ctrl+s'];
+const PRIMARY_DIALOG_ACTION_COMMANDS = new Set(['submit', 'create', 'entity-form-done']);
+/**
+ * Parses a shortcut string such as `Enter`, `Escape`, or `ctrl+shift+s`.
+ */
+function parseDialogActionShortcut(shortcut) {
+    const parts = shortcut
+        .trim()
+        .toLowerCase()
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    const key = normalizeShortcutToken(parts.pop() ?? '');
+    return {
+        ctrl: parts.includes('ctrl') || parts.includes('control'),
+        shift: parts.includes('shift'),
+        alt: parts.includes('alt') || parts.includes('option'),
+        meta: parts.includes('meta') || parts.includes('cmd') || parts.includes('command'),
+        key,
+    };
+}
+/**
+ * Returns true when the keyboard event matches the given shortcut definition.
+ */
+function matchesDialogActionShortcut(event, shortcut) {
+    const parsed = parseDialogActionShortcut(shortcut);
+    if (parsed.ctrl !== event.ctrlKey) {
+        return false;
+    }
+    if (parsed.shift !== event.shiftKey) {
+        return false;
+    }
+    if (parsed.alt !== event.altKey) {
+        return false;
+    }
+    if (parsed.meta !== event.metaKey) {
+        return false;
+    }
+    return normalizeShortcutKey(event) === normalizeShortcutToken(parsed.key);
+}
+/**
+ * Resolves footer action shortcuts: defaults when omitted, merge when extras are provided, none when `[]`.
+ */
+function resolveDialogActionShortcuts(defaults, overrides) {
+    if (overrides !== undefined) {
+        if (overrides.length === 0) {
+            return undefined;
+        }
+        return dedupeDialogActionShortcuts([...defaults, ...overrides]);
+    }
+    return defaults.length ? [...defaults] : undefined;
+}
+/**
+ * Applies built-in footer shortcuts when actions are declared without `shortcuts`
+ * (e.g. workflow `show-layout-popup` raw action config).
+ */
+function resolveConfiguredFooterActionShortcuts(command, explicit) {
+    if (explicit !== undefined) {
+        return resolveDialogActionShortcuts([], explicit);
+    }
+    if (command === 'cancel') {
+        return resolveDialogActionShortcuts(DEFAULT_CANCEL_DIALOG_ACTION_SHORTCUTS, undefined);
+    }
+    if (command && PRIMARY_DIALOG_ACTION_COMMANDS.has(command)) {
+        return resolveDialogActionShortcuts(DEFAULT_SUBMIT_DIALOG_ACTION_SHORTCUTS, undefined);
+    }
+    return undefined;
+}
+function dedupeDialogActionShortcuts(shortcuts) {
+    const seen = new Set();
+    const result = [];
+    for (const shortcut of shortcuts) {
+        const token = normalizeShortcutToken(shortcut);
+        if (!token || seen.has(token)) {
+            continue;
+        }
+        seen.add(token);
+        result.push(shortcut.trim());
+    }
+    return result;
+}
+function normalizeShortcutToken(key) {
+    const normalized = key.trim().toLowerCase();
+    if (normalized === 'esc') {
+        return 'escape';
+    }
+    return normalized;
+}
+/**
+ * Whether a shortcut should fire given the current focus target.
+ * Enter without modifiers is suppressed in multiline / rich-text fields.
+ */
+function shouldTriggerDialogActionShortcut(event, shortcut) {
+    const parsed = parseDialogActionShortcut(shortcut);
+    const isPlainEnter = parsed.key === 'enter' && !parsed.ctrl && !parsed.shift && !parsed.alt && !parsed.meta;
+    if (!isPlainEnter) {
+        return true;
+    }
+    return !isKeyboardTargetMultilineEditable(event.target);
+}
+function normalizeShortcutKey(event) {
+    if (event.key === 'Enter') {
+        return 'enter';
+    }
+    if (event.key === 'Escape') {
+        return 'escape';
+    }
+    if (event.key === ' ') {
+        return 'space';
+    }
+    if (event.key.length === 1) {
+        return event.key.toLowerCase();
+    }
+    const codeMatch = event.code.match(/^Key([A-Z])$/);
+    if (codeMatch) {
+        return codeMatch[1].toLowerCase();
+    }
+    const digitMatch = event.code.match(/^Digit([0-9])$/);
+    if (digitMatch) {
+        return digitMatch[1];
+    }
+    return event.key.toLowerCase();
+}
+function isKeyboardTargetMultilineEditable(target) {
+    if (!(target instanceof HTMLElement)) {
+        return false;
+    }
+    if (target.isContentEditable) {
+        return true;
+    }
+    const textarea = target.closest('textarea');
+    if (textarea && !textarea.readOnly && !textarea.disabled) {
+        return true;
+    }
+    const richText = target.closest('[contenteditable="true"]');
+    return richText instanceof HTMLElement;
+}
+//#endregion
+
 /** Fallback {@link AXPDialogRef} when the popup is dismissed without a footer action (e.g. header close). */
 function createDismissedDialogRef(context = () => ({})) {
     return {
@@ -347,6 +490,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+//#region ----   Dialog Close Confirmation Utilities   ----
+function normalizeDialogCloseConfirmation(value) {
+    if (value === undefined || value === false) {
+        return undefined;
+    }
+    if (value === true) {
+        return { enabled: true };
+    }
+    if (value.enabled === false) {
+        return undefined;
+    }
+    return { enabled: true, ...value };
+}
+//#endregion
+
 //#region ----   Inheritance Utilities   ----
 /**
  * Resolves inherited properties from context and local values
@@ -1636,6 +1794,9 @@ class DialogContainerBuilder {
         this.dialogState.dialogOptions.onAction = handler;
         return this;
     }
+    confirmCloseWhenDirty(options) {
+        return this.setOptions({ confirmCloseWhenDirty: options ?? true });
+    }
     addCustomAction(action) {
         // Add to actions based on position
         const position = action.position || 'suffix';
@@ -1699,6 +1860,7 @@ class DialogContainerBuilder {
             };
             await hookService.runAsync(AXP_LAYOUT_BUILDER_DIALOG_BEFORE_OPEN_HOOK_KEY, beforePayload);
         }
+        const confirmCloseWhenDirty = normalizeDialogCloseConfirmation(this.dialogState.dialogOptions?.confirmCloseWhenDirty);
         // Create dialog configuration
         const dialogConfig = {
             title: this.dialogState.dialogOptions?.title || '',
@@ -1709,6 +1871,7 @@ class DialogContainerBuilder {
             metadata: this.dialogState.dialogOptions.metadata,
             actions: this.dialogState.actions,
             onAction: this.dialogState.dialogOptions?.onAction,
+            confirmCloseWhenDirty,
         };
         // 
         if (hookService) {
@@ -1912,7 +2075,7 @@ class ActionBuilder {
     constructor(dialogBuilder) {
         this.dialogBuilder = dialogBuilder;
     }
-    cancel(text) {
+    cancel(text, options) {
         if (!this.dialogBuilder['dialogState'].actions.footer.suffix) {
             this.dialogBuilder['dialogState'].actions.footer.suffix = [];
         }
@@ -1920,10 +2083,11 @@ class ActionBuilder {
             title: text || '@general:actions.cancel.title',
             color: 'default',
             command: { name: 'cancel' },
+            shortcuts: resolveDialogActionShortcuts(DEFAULT_CANCEL_DIALOG_ACTION_SHORTCUTS, options?.shortcuts),
         });
         return this;
     }
-    submit(text) {
+    submit(text, options) {
         if (!this.dialogBuilder['dialogState'].actions.footer.suffix) {
             this.dialogBuilder['dialogState'].actions.footer.suffix = [];
         }
@@ -1931,22 +2095,27 @@ class ActionBuilder {
             title: text || '@general:actions.submit.title',
             color: 'primary',
             command: { name: 'submit', options: { validate: true } },
+            shortcuts: resolveDialogActionShortcuts(DEFAULT_SUBMIT_DIALOG_ACTION_SHORTCUTS, options?.shortcuts),
         });
         return this;
     }
-    custom(action) {
-        const position = action.position ?? 'suffix';
+    custom(action, options) {
+        const item = {
+            ...action,
+            shortcuts: resolveDialogActionShortcuts(action.shortcuts ?? [], options?.shortcuts),
+        };
+        const position = item.position ?? 'suffix';
         if (position === 'prefix') {
             if (!this.dialogBuilder['dialogState'].actions.footer.prefix) {
                 this.dialogBuilder['dialogState'].actions.footer.prefix = [];
             }
-            this.dialogBuilder['dialogState'].actions.footer.prefix.push(action);
+            this.dialogBuilder['dialogState'].actions.footer.prefix.push(item);
         }
         else {
             if (!this.dialogBuilder['dialogState'].actions.footer.suffix) {
                 this.dialogBuilder['dialogState'].actions.footer.suffix = [];
             }
-            this.dialogBuilder['dialogState'].actions.footer.suffix.push(action);
+            this.dialogBuilder['dialogState'].actions.footer.suffix.push(item);
         }
         return this;
     }
@@ -2386,6 +2555,144 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+const OVERLAY_CONTAINER_SELECTOR = '.ax-overlay-container';
+const OVERLAY_PANE_SELECTOR = '.ax-overlay-pane';
+/**
+ * Returns true when a nested overlay is open and Esc should close it first.
+ * Returns false when only the dialog shell is on top.
+ * Returns null when the Acorex overlay service does not expose open-state queries yet.
+ */
+function hasOpenNestedOverlayFromAcorexService(overlayService, dialogOverlay) {
+    const service = overlayService;
+    if (typeof service.hasOpenAnchoredOverlay === 'function') {
+        if (!service.hasOpenAnchoredOverlay()) {
+            return false;
+        }
+        if (typeof service.hasOverlayAbove === 'function') {
+            return service.hasOverlayAbove(dialogOverlay);
+        }
+        return true;
+    }
+    if (typeof service.hasOverlayAbove === 'function') {
+        return service.hasOverlayAbove(dialogOverlay);
+    }
+    return null;
+}
+/**
+ * Returns true when the overlay element is rendered and visible in the viewport.
+ */
+function isVisibleOverlayElement(element) {
+    if (!(element instanceof HTMLElement)) {
+        return false;
+    }
+    const style = getComputedStyle(element);
+    if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity) === 0) {
+        return false;
+    }
+    const rect = element.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+}
+/**
+ * Collects visible overlay containers in stacking order (later / higher z-index wins).
+ */
+function getVisibleOverlayContainers(document) {
+    return Array.from(document.querySelectorAll(OVERLAY_CONTAINER_SELECTOR))
+        .filter(isVisibleOverlayElement)
+        .sort(compareOverlayStackOrder);
+}
+/**
+ * Compares two overlay containers by z-index, then DOM order.
+ */
+function compareOverlayStackOrder(a, b) {
+    const za = Number(getComputedStyle(a).zIndex) || 0;
+    const zb = Number(getComputedStyle(b).zIndex) || 0;
+    if (za !== zb) {
+        return za - zb;
+    }
+    const position = a.compareDocumentPosition(b);
+    if (position & Node.DOCUMENT_POSITION_FOLLOWING) {
+        return -1;
+    }
+    if (position & Node.DOCUMENT_POSITION_PRECEDING) {
+        return 1;
+    }
+    return 0;
+}
+/**
+ * Returns visible anchored overlay panes that belong to widget popovers, not the dialog shell.
+ */
+function getNestedOverlayPanes(document, dialogOverlay) {
+    return Array.from(document.querySelectorAll(OVERLAY_PANE_SELECTOR)).filter((pane) => isVisibleOverlayElement(pane) && !dialogOverlay?.contains(pane));
+}
+/**
+ * DOM fallback until {@link AXOverlayService} exposes open-overlay queries.
+ *
+ * Dialog popups use a centered `.ax-overlay-container` without `.ax-overlay-pane`.
+ * Widget popovers (select, datetime, dropdown) use anchored containers with `.ax-overlay-pane`.
+ */
+function shouldDeferEscapeToNestedOverlayFromDom(document, dialogHost) {
+    const dialogOverlay = dialogHost.closest(OVERLAY_CONTAINER_SELECTOR);
+    if (getNestedOverlayPanes(document, dialogOverlay).length > 0) {
+        return true;
+    }
+    const visibleContainers = getVisibleOverlayContainers(document);
+    if (!visibleContainers.length) {
+        return false;
+    }
+    const topContainer = visibleContainers[visibleContainers.length - 1];
+    if (!dialogOverlay) {
+        return topContainer.contains(dialogHost) === false;
+    }
+    return topContainer !== dialogOverlay;
+}
+/**
+ * When a nested overlay is above this dialog (widget popover, confirm box, etc.), footer shortcuts
+ * should not run on the parent dialog.
+ */
+function shouldDeferDialogShortcutsToNestedOverlay(document, dialogHost, overlayService) {
+    const dialogOverlay = dialogHost.closest(OVERLAY_CONTAINER_SELECTOR);
+    if (overlayService) {
+        const fromService = hasOpenNestedOverlayFromAcorexService(overlayService, dialogOverlay);
+        if (fromService !== null) {
+            return fromService;
+        }
+    }
+    return shouldDeferEscapeToNestedOverlayFromDom(document, dialogHost);
+}
+
+/**
+ * Builds the `show()` resolve payload for layout-builder custom footer commands (fallback path).
+ */
+function buildLayoutBuilderCustomActionRef(createDialogRef, command) {
+    return {
+        ...createDialogRef(command),
+        action: () => command,
+    };
+}
+/**
+ * Keeps legacy popup `data.context` / `data.action` side fields in sync for custom footer commands.
+ */
+function syncLegacyDialogDataSideFields(data, context, action) {
+    if (!data) {
+        return;
+    }
+    data.context = context;
+    data.action = action;
+}
+/**
+ * Cancel from an `onAction` handler should route through the dirty-close gate only when configured.
+ * Otherwise preserve the original resolve-then-close sequence.
+ */
+function shouldRouteOnActionCancelThroughDismissGate(confirmCloseWhenDirtyEnabled) {
+    return confirmCloseWhenDirtyEnabled === true;
+}
+
+/** Idle period after the last context change before capturing the clean baseline. */
+const DIALOG_DIRTY_BASELINE_IDLE_MS = 500;
+/** Hard fallback when idle detection never settles. */
+const DIALOG_DIRTY_BASELINE_FALLBACK_DELAY_MS = 2000;
+/** Debounce after widget count stabilizes before re-evaluating footer actions. */
+const DIALOG_WIDGET_COUNT_STABLE_DELAY_MS = 350;
 class AXPDialogRendererComponent extends AXBasePageComponent {
     constructor() {
         super(...arguments);
@@ -2393,8 +2700,18 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
         this.commandService = inject(AXPCommandService);
         this.hookService = inject(AXPHookService, { optional: true });
+        this.dialogService = inject(AXDialogService);
+        this.overlayService = inject(AXOverlayService);
+        this.translationService = inject(AXTranslationService);
+        this.document = inject(DOCUMENT);
+        this.host = inject((ElementRef));
         /** Ensures `show()` resolves once when the dialog closes (footer action or header close). */
         this.callbackInvoked = false;
+        /** True after the post-init baseline snapshot has been captured. */
+        this.dirtyBaselineCaptured = false;
+        /** Skips dirty confirmation on the next {@link onClosing} (successful submit / programmatic close). */
+        this.skipNextOnClosingDirtyCheck = false;
+        this.destroyRef = inject(DestroyRef);
         this.context = signal({}, ...(ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []));
         // This will be set by the popup service automatically - same as dynamic-dialog
         this.callBack = () => { };
@@ -2408,39 +2725,191 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
         this.contextChangedHooksSessionKey = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
             ? crypto.randomUUID()
             : `layout-dialog-ctx-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        /**
+         * Capture-phase footer shortcuts — runs before widget editors (select, date, text) that stop keydown bubbling.
+         */
+        this.onDialogShortcutCapture = (event) => {
+            if (this.isDialogLoading()) {
+                return;
+            }
+            // Unsaved-changes confirm is modal — parent footer shortcuts must not run underneath it.
+            if (this.dismissConfirmPromise) {
+                return;
+            }
+            if (shouldDeferDialogShortcutsToNestedOverlay(this.document, this.host.nativeElement, this.overlayService)) {
+                return;
+            }
+            if (event.key === 'Escape' && this.config?.confirmCloseWhenDirty?.enabled) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                this.requestDismiss();
+                return;
+            }
+            const actions = [...this.footerPrefixActions(), ...this.footerSuffixActions()];
+            for (const action of actions) {
+                if (action.disabled || action.hidden || !action.shortcuts?.length) {
+                    continue;
+                }
+                for (const shortcut of action.shortcuts) {
+                    if (event.key === 'Escape' && this.config?.confirmCloseWhenDirty?.enabled) {
+                        continue;
+                    }
+                    if (!matchesDialogActionShortcut(event, shortcut) || !shouldTriggerDialogActionShortcut(event, shortcut)) {
+                        continue;
+                    }
+                    event.preventDefault();
+                    event.stopImmediatePropagation();
+                    void this.executeAction(action);
+                    return;
+                }
+            }
+        };
         //#endregion
         //#region ----   View Accessors   ----
         // Access the internal layout renderer to reach the widgets container injector
         this.layoutRenderer = viewChild(AXPLayoutRendererComponent, ...(ngDevMode ? [{ debugName: "layoutRenderer" }] : /* istanbul ignore next */ []));
-        this.#eff = effect(() => {
-            let count = 0;
+        this.#widgetActionsEffect = effect(() => {
             this.aggregateAndEvaluateActions();
             if (!this.widgetCoreService) {
                 const renderer = this.layoutRenderer();
                 const container = renderer?.getContainer();
                 this.widgetCoreService = container?.builderService ?? null;
-                count = this.widgetCoreService?.registeredWidgetsCount();
+                return;
             }
-            else {
-                count = this.widgetCoreService?.registeredWidgetsCount();
-                // Clear existing timer
-                if (this.debounceTimer) {
-                    clearTimeout(this.debounceTimer);
-                }
-                // Set new timer to call after 200ms of no count changes
-                this.debounceTimer = setTimeout(() => {
-                    this.aggregateAndEvaluateActions();
-                }, 200);
+            this.widgetCoreService.registeredWidgetsCount();
+            if (this.debounceTimer) {
+                clearTimeout(this.debounceTimer);
+            }
+            this.debounceTimer = setTimeout(() => {
+                this.aggregateAndEvaluateActions();
+            }, DIALOG_WIDGET_COUNT_STABLE_DELAY_MS);
+        }, ...(ngDevMode ? [{ debugName: "#widgetActionsEffect" }] : /* istanbul ignore next */ []));
+        this.#dirtyBaselineEffect = effect(() => {
+            if (this.dirtyBaselineCaptured) {
+                return;
+            }
+            const store = this.getWidgetContextStore();
+            if (!store) {
+                return;
             }
-        }, ...(ngDevMode ? [{ debugName: "#eff" }] : /* istanbul ignore next */ []));
+            store.data();
+            this.widgetCoreService?.registeredWidgetsCount();
+            this.scheduleDirtyBaselineCapture();
+        }, ...(ngDevMode ? [{ debugName: "#dirtyBaselineEffect" }] : /* istanbul ignore next */ []));
     }
     //#endregion
     //#region ----   Lifecycle   ----
     ngOnInit() {
-        this.context.set(this.config?.context || {});
+        const initialContext = this.config?.context || {};
+        this.context.set(initialContext);
+        this.dirtyBaselineFallbackTimer = setTimeout(() => {
+            this.captureDirtyBaselineIfNeeded();
+        }, DIALOG_DIRTY_BASELINE_FALLBACK_DELAY_MS);
+        this.document.addEventListener('keydown', this.onDialogShortcutCapture, true);
+        this.destroyRef.onDestroy(() => {
+            this.document.removeEventListener('keydown', this.onDialogShortcutCapture, true);
+            if (this.dirtyBaselineIdleTimer) {
+                clearTimeout(this.dirtyBaselineIdleTimer);
+            }
+            if (this.dirtyBaselineFallbackTimer) {
+                clearTimeout(this.dirtyBaselineFallbackTimer);
+            }
+        });
         void this.invokeLayoutContextChangedHooks();
     }
-    #eff;
+    //#endregion
+    //#region ----   Popup Close Gate   ----
+    /**
+     * Popup shell hook — handles header **X** and **Esc** (when `closeButton` is enabled).
+     * This is the only place that prompts for unsaved changes.
+     */
+    async onClosing(e) {
+        if (this.dismissConfirmPromise) {
+            e.cancel = true;
+            return;
+        }
+        if (this.skipNextOnClosingDirtyCheck) {
+            this.skipNextOnClosingDirtyCheck = false;
+            this.completeDismissResolve();
+            return;
+        }
+        if (!this.config?.confirmCloseWhenDirty?.enabled) {
+            this.completeDismissResolve();
+            return;
+        }
+        if (!(await this.confirmDismissIfDirty())) {
+            e.cancel = true;
+            this.pendingDismissResolvePayload = undefined;
+            return;
+        }
+        this.completeDismissResolve();
+    }
+    /**
+     * Footer cancel and other in-app dismiss actions. Routes through `super.close()` so the
+     * popup shell invokes {@link onClosing} exactly once (same path as **X** / **Esc**).
+     */
+    requestDismiss(resolvePayload) {
+        this.pendingDismissResolvePayload = resolvePayload ?? this.createDialogRef('cancel');
+        super.close();
+    }
+    /** Invokes `show()` callback with the pending payload or a default cancel {@link AXPDialogRef}. */
+    completeDismissResolve() {
+        const payload = this.pendingDismissResolvePayload;
+        this.pendingDismissResolvePayload = undefined;
+        if (payload !== undefined) {
+            this.resolveDialog(payload);
+            return;
+        }
+        if (!this.callbackInvoked) {
+            this.resolveDialog(this.createDialogRef('cancel'));
+        }
+    }
+    //#endregion
+    //#region ----   Dirty State   ----
+    getWidgetContextStore() {
+        return this.layoutRenderer()?.getContainer()?.contextService;
+    }
+    scheduleDirtyBaselineCapture() {
+        if (this.dirtyBaselineCaptured) {
+            return;
+        }
+        if (this.dirtyBaselineIdleTimer) {
+            clearTimeout(this.dirtyBaselineIdleTimer);
+        }
+        this.dirtyBaselineIdleTimer = setTimeout(() => {
+            this.captureDirtyBaselineIfNeeded();
+        }, DIALOG_DIRTY_BASELINE_IDLE_MS);
+    }
+    /**
+     * Captures a dialog-local baseline once after widget init/normalization goes idle.
+     */
+    captureDirtyBaselineIfNeeded() {
+        if (this.dirtyBaselineCaptured) {
+            return;
+        }
+        const store = this.getWidgetContextStore();
+        if (!store) {
+            return;
+        }
+        const widgetCount = this.widgetCoreService?.registeredWidgetsCount() ?? 0;
+        if (widgetCount === 0) {
+            return;
+        }
+        const snapshot = store.data();
+        this.dirtyBaseline = captureFormContextBaseline(snapshot);
+        store.commitBaseline();
+        this.dirtyBaselineCaptured = true;
+        if (this.dirtyBaselineIdleTimer) {
+            clearTimeout(this.dirtyBaselineIdleTimer);
+            this.dirtyBaselineIdleTimer = undefined;
+        }
+        if (this.dirtyBaselineFallbackTimer) {
+            clearTimeout(this.dirtyBaselineFallbackTimer);
+            this.dirtyBaselineFallbackTimer = undefined;
+        }
+    }
+    #widgetActionsEffect;
+    #dirtyBaselineEffect;
     //#endregion
     handleContextChanged(event) {
         this.context.set(event);
@@ -2459,7 +2928,10 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
         }
         const payload = {
             sessionKey: this.contextChangedHooksSessionKey,
-            getContext: () => (this.context() ?? {}),
+            getContext: () => {
+                const store = this.getWidgetContextStore();
+                return (store?.data() ?? this.context() ?? {});
+            },
             metadata: meta,
             patchContext: (partial) => {
                 const merged = merge({}, this.context(), partial);
@@ -2525,6 +2997,7 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
         }
         const context = this.context();
         const onAction = this.config?.onAction;
+        // `onAction` return value is passed through to `show()` unchanged — see dialog-resolve.util.ts.
         if (onAction) {
             const dialogRef = this.createDialogRef(cmd);
             try {
@@ -2533,6 +3006,12 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
                 if (this.shouldKeepDialogOpenAfterCommandResult(result)) {
                     return;
                 }
+                if (cmd === 'cancel' &&
+                    shouldRouteOnActionCancelThroughDismissGate(this.config?.confirmCloseWhenDirty?.enabled)) {
+                    this.isDialogLoading.set(false);
+                    this.requestDismiss(result);
+                    return;
+                }
                 this.resolveDialog(result);
                 await this.closeWithOptionalSkipValidate(result);
             }
@@ -2544,21 +3023,57 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
             }
             return;
         }
-        // Fallback: treat as regular dialog action (cancel/confirm/custom)
+        // Fallback: layout-builder custom footer commands (e.g. signature-apply, upload-image).
+        // See dialog-resolve.util.ts — resolves {@link AXPDialogRef}; does not auto-close except cancel.
         const result = { context, action: cmd };
         this.dialogResult = result;
-        if (this.data) {
-            this.data.context = result.context;
-            this.data.action = result.action;
-        }
-        this.resolveDialog({
-            ...this.createDialogRef(cmd),
-            action: () => result.action,
-        });
-        // Without `onAction`, only the configured cancel action dismisses the dialog (not submit/custom).
+        syncLegacyDialogDataSideFields(this.data, result.context, result.action);
+        const dialogRefPayload = buildLayoutBuilderCustomActionRef((command) => this.createDialogRef(command), cmd);
         if (cmd === 'cancel') {
-            await this.close(result);
+            this.requestDismiss(dialogRefPayload);
+            return;
+        }
+        this.resolveDialog(dialogRefPayload);
+    }
+    isDialogDirty() {
+        const confirmOptions = this.config?.confirmCloseWhenDirty;
+        if (!confirmOptions?.enabled || !this.dirtyBaselineCaptured) {
+            return false;
         }
+        const store = this.getWidgetContextStore();
+        if (!store) {
+            return false;
+        }
+        const current = store.data();
+        const baseline = this.dirtyBaseline ?? store.initial();
+        if (typeof confirmOptions.isDirty === 'function') {
+            return confirmOptions.isDirty(current, baseline);
+        }
+        return (store.isUserDirty() ||
+            (this.widgetCoreService?.hasDirtyWidgets() ?? false) ||
+            isFormContextDirty(current, baseline));
+    }
+    async confirmDismissIfDirty() {
+        if (this.dismissConfirmPromise) {
+            return this.dismissConfirmPromise;
+        }
+        const confirmOptions = this.config?.confirmCloseWhenDirty;
+        if (!confirmOptions?.enabled || !this.isDialogDirty()) {
+            return true;
+        }
+        this.dismissConfirmPromise = this.promptUnsavedChangesConfirm(confirmOptions);
+        try {
+            return await this.dismissConfirmPromise;
+        }
+        finally {
+            this.dismissConfirmPromise = undefined;
+        }
+    }
+    async promptUnsavedChangesConfirm(confirmOptions) {
+        const title = await this.translationService.translateAsync(confirmOptions.title ?? '@general:messages.unsaved-changes.title');
+        const message = await this.translationService.translateAsync(confirmOptions.message ?? '@general:messages.unsaved-changes.message');
+        const dialogResult = await this.dialogService.confirm(title, message, 'warning', 'horizontal', false, 'cancel');
+        return dialogResult.result === true;
     }
     /** Whether the layout form should be validated before running this footer command. */
     shouldValidateBeforeAction(cmd) {
@@ -2614,10 +3129,12 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
     async closeWithOptionalSkipValidate(result) {
         if (result && typeof result === 'object' && result.skipValidate) {
             this.result.emit(result);
-            await super.close(result);
+            this.skipNextOnClosingDirtyCheck = true;
+            this.pendingDismissResolvePayload = undefined;
+            super.close(result);
             return;
         }
-        await this.close(result);
+        await this.close(result, { skipDirtyConfirm: true });
     }
     /** Resolves footer/widget action command to a string (e.g. `cancel`, `submit`, `widget:...`). */
     resolveActionCommandName(command) {
@@ -2664,9 +3181,10 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
             //
         }
     }
-    async close(result) {
-        if (!this.callbackInvoked) {
-            this.resolveDialog(this.createDialogRef('cancel'));
+    async close(result, options) {
+        if (options?.skipDirtyConfirm) {
+            this.skipNextOnClosingDirtyCheck = true;
+            this.pendingDismissResolvePayload = undefined;
         }
         if (result) {
             const isValid = await this.layoutRenderer()?.validate();
@@ -2716,6 +3234,7 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
             placement,
             scope: a.scope,
             predicateApiWidgetName: a.predicateApiWidgetName,
+            shortcuts: resolveConfiguredFooterActionShortcuts(typeof a.command === 'string' ? a.command : a.command?.name, a.shortcuts),
         });
         const prefix = (footer?.prefix || []).map((a) => mapOne(a, 'prefix'));
         const suffix = (footer?.suffix || []).map((a) => mapOne(a, 'suffix'));
@@ -3124,5 +3643,5 @@ var previewWidgetField_command = /*#__PURE__*/Object.freeze({
  * Generated bundle index. Do not edit.
  */
 
-export { AXPDialogRendererComponent, AXPLayoutBuilderService, AXPLayoutConversionService, AXPLayoutRendererComponent, AXPPreviewWidgetFieldCommand, AXP_LAYOUT_BUILDER_DIALOG_BEFORE_OPEN_HOOK_KEY, AXP_LAYOUT_BUILDER_DIALOG_CONFIG_HOOK_KEY, AXP_LAYOUT_BUILDER_DIALOG_CONTEXT_CHANGED_HOOK_KEY, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY, LayoutBuilderModule, createDismissedDialogRef };
+export { AXPDialogRendererComponent, AXPLayoutBuilderService, AXPLayoutConversionService, AXPLayoutRendererComponent, AXPPreviewWidgetFieldCommand, AXP_LAYOUT_BUILDER_DIALOG_BEFORE_OPEN_HOOK_KEY, AXP_LAYOUT_BUILDER_DIALOG_CONFIG_HOOK_KEY, AXP_LAYOUT_BUILDER_DIALOG_CONTEXT_CHANGED_HOOK_KEY, AXP_PREVIEW_WIDGET_FIELD_COMMAND_KEY, DEFAULT_CANCEL_DIALOG_ACTION_SHORTCUTS, DEFAULT_SUBMIT_DIALOG_ACTION_SHORTCUTS, LayoutBuilderModule, createDismissedDialogRef };
 //# sourceMappingURL=acorex-platform-layout-builder.mjs.map