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

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

@@ -1,17 +1,18 @@
 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 { normalizeKeyboardShortcuts, AXPHookService, findOverlayContainerAncestor, getNestedVisibleOverlayPanes, getTopVisibleOverlayContainer, AXPExpressionEvaluatorService, 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 * as i2$1 from '@acorex/components/decorators';
@@ -20,9 +21,156 @@ 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 { AXPUnsavedChangesConfirmService } from '@acorex/platform/common';
 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 flattenDialogActionShortcutChords([...defaults, ...overrides]);
+    }
+    return flattenDialogActionShortcutChords(defaults);
+}
+/**
+ * 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 flattenDialogActionShortcutChords(shortcuts) {
+    const chords = normalizeKeyboardShortcuts(shortcuts).flatMap((shortcut) => shortcut.keys);
+    const deduped = dedupeDialogActionShortcuts(chords);
+    return deduped.length ? deduped : 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 +495,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 +1799,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 +1865,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 +1876,7 @@ class DialogContainerBuilder {
             metadata: this.dialogState.dialogOptions.metadata,
             actions: this.dialogState.actions,
             onAction: this.dialogState.dialogOptions?.onAction,
+            confirmCloseWhenDirty,
         };
         // 
         if (hookService) {
@@ -1912,7 +2080,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 +2088,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 +2100,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 +2560,91 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * 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;
+}
+/**
+ * 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 = findOverlayContainerAncestor(dialogHost);
+    if (getNestedVisibleOverlayPanes(document, dialogOverlay).length > 0) {
+        return true;
+    }
+    const topContainer = getTopVisibleOverlayContainer(document);
+    if (!topContainer) {
+        return false;
+    }
+    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 = findOverlayContainerAncestor(dialogHost);
+    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;
+}
+
+/** 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 +2652,18 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
         this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
         this.commandService = inject(AXPCommandService);
         this.hookService = inject(AXPHookService, { optional: true });
+        this.unsavedChangesConfirm = inject(AXPUnsavedChangesConfirmService);
+        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;
+        /** Skips dirty confirmation on the next {@link onClosing} (successful submit / programmatic close). */
+        this.skipNextOnClosingDirtyCheck = false;
+        /** Blocks re-entrant {@link onClosing} while the first close gate is still resolving. */
+        this.closeGateInProgress = 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 +2677,136 @@ 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.unsavedChangesConfirm.isConfirmPending()) {
+                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);
             }
-        }, ...(ngDevMode ? [{ debugName: "#eff" }] : /* istanbul ignore next */ []));
+            this.debounceTimer = setTimeout(() => {
+                this.aggregateAndEvaluateActions();
+            }, DIALOG_WIDGET_COUNT_STABLE_DELAY_MS);
+        }, ...(ngDevMode ? [{ debugName: "#widgetActionsEffect" }] : /* istanbul ignore next */ []));
     }
     //#endregion
     //#region ----   Lifecycle   ----
     ngOnInit() {
-        this.context.set(this.config?.context || {});
+        const initialContext = this.config?.context || {};
+        this.context.set(initialContext);
+        this.document.addEventListener('keydown', this.onDialogShortcutCapture, true);
+        this.destroyRef.onDestroy(() => {
+            this.document.removeEventListener('keydown', this.onDialogShortcutCapture, true);
+        });
         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.unsavedChangesConfirm.isConfirmPending() || this.closeGateInProgress) {
+            e.cancel = true;
+            return;
+        }
+        this.closeGateInProgress = true;
+        try {
+            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();
+        }
+        finally {
+            this.closeGateInProgress = false;
+        }
+    }
+    /**
+     * 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   ----
+    getWidgetContainer() {
+        return this.layoutRenderer()?.getContainer();
+    }
+    #widgetActionsEffect;
     //#endregion
     handleContextChanged(event) {
         this.context.set(event);
@@ -2459,7 +2825,10 @@ class AXPDialogRendererComponent extends AXBasePageComponent {
         }
         const payload = {
             sessionKey: this.contextChangedHooksSessionKey,
-            getContext: () => (this.context() ?? {}),
+            getContext: () => {
+                const store = this.getWidgetContainer()?.contextService;
+                return (store?.data() ?? this.context() ?? {});
+            },
             metadata: meta,
             patchContext: (partial) => {
                 const merged = merge({}, this.context(), partial);
@@ -2525,6 +2894,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 +2903,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 +2920,43 @@ 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) {
+            return false;
+        }
+        const container = this.getWidgetContainer();
+        if (!container?.isSavedCommitted()) {
+            return false;
+        }
+        const store = container.contextService;
+        if (typeof confirmOptions.isDirty === 'function') {
+            return confirmOptions.isDirty(store.data(), store.saved());
         }
+        return container.isFormDirty();
+    }
+    confirmDismissIfDirty() {
+        const confirmOptions = this.config?.confirmCloseWhenDirty;
+        if (!confirmOptions?.enabled || !this.isDialogDirty()) {
+            return Promise.resolve(true);
+        }
+        return this.unsavedChangesConfirm.confirmIfDirty(true, {
+            enabled: confirmOptions.enabled,
+            title: confirmOptions.title,
+            message: confirmOptions.message,
+        });
     }
     /** Whether the layout form should be validated before running this footer command. */
     shouldValidateBeforeAction(cmd) {
@@ -2614,10 +3012,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 +3064,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 +3117,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 +3526,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