@acorex-platform/module-report-management-client 0.0.38 → 0.0.46

package/fesm2022/acorex-platform-module-report-management-client-acorex-platform-module-report-management-client-D5dCG62j.mjs

@@ -0,0 +1,1545 @@
+import { AXPExpressionEvaluatorService, provideAppStartUpTask, AXP_APP_STARTUP_PRIORITY, AXP_FEATURE_DEFINITION_PROVIDER, provideLazyProvider } from '@acorex-platform/framework-client/core';
+import { AXPDomainModule } from '@acorex-platform/framework-client/domain';
+import { AXPEntityService, resolveEntityPluginDetailPageOrder, AXP_ENTITY_ACTION_PLUGIN, provideEntity } from '@acorex-platform/framework-client/layout/entity';
+import { AXP_PAGE_COMPONENT_PROVIDER } from '@acorex-platform/framework-client/layout/components';
+import { AXPRootLayoutComponent } from '@acorex-platform/framework-client/themes/default';
+import * as i0 from '@angular/core';
+import { Injectable, inject, DestroyRef, Injector, effect, NgModule } from '@angular/core';
+import { ROUTES } from '@angular/router';
+import { AXPInsightsReportingPermissionKeys, RootConfig, AXPReportManagementMenuKeys, AXPReportManagementFeatureKeys, AXPReportManagementSettings, AXP_REPORT_MANAGEMENT_GENERATION_SETTING_DEFAULTS, buildReportGenerationNotificationCorrelationId, AXMReportManagementQueryKeys, REPORT_GENERATION_NOTIFICATION_DEFINITION_KEY } from '@acorex-platform/module-report-management-client/contracts';
+import { AXPTabNavigationService, AXPBackgroundOperationHandler, AXP_BACKGROUND_OPERATION_HANDLERS, AXP_USER_NOTIFICATION_SERVICE, AXP_PROTECTED_ROUTE_GUARDS, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPQueryService, AXPCommandService, AXPRuntimeModule, provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import { AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXPWidgetsList, runtimeQueryPayloadData, resolveMultiLanguageString, runtimeQueryObjectData, runtimeQueryCollectionData } from '@acorex-platform/framework-shared/core';
+import { get, isString } from 'lodash-es';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPInAppInboxConnectorService } from '@acorex-platform/module-communication-management-client';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { map, distinctUntilChanged } from 'rxjs';
+import { AXPopupService } from '@acorex/components/popup';
+
+//#endregion
+//#region ----- Permission Definition Provider -----
+/**
+ * Registers report capabilities into the shared Insights & Reporting group.
+ */
+class AXMPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPInsightsReportingPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:insights-reporting.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.InsightsReporting.Root, `${G}.insights-reporting.title`, `${G}.insights-reporting.description`, { order: 100 });
+        context
+            .addGroup(groups.InsightsReporting.Reports, `${G}.insights-reporting-reports.title`, `${G}.insights-reporting-reports.description`, { parent: groups.InsightsReporting.Root, order: 10 })
+            .addPermission(keys.Access, `${P}.access.title`, `${P}.access.description`)
+            .endPermission()
+            .addPermission(keys.MaintainReports, `${P}.maintain-reports.title`, `${P}.maintain-reports.description`)
+            .endPermission()
+            .addPermission(keys.Setup, `${P}.setup.title`, `${P}.setup.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        context.addItems([
+            {
+                name: AXPReportManagementMenuKeys.Reports,
+                text: RootConfig.entities.report.titlePlural,
+                path: this.entityService.withEntity(module.name, RootConfig.entities.report.name).createPath(),
+                icon: RootConfig.entities.report.icon,
+                priority: 8300,
+                policy: {
+                    features: [module.name],
+                    permissions: [AXPInsightsReportingPermissionKeys.MaintainReports],
+                },
+            },
+        ]);
+    }
+}
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Feature Definition Provider   ----
+/**
+ * Report Management Feature Definition Provider.
+ * Provides feature definitions for the Report Management module.
+ */
+class AXPReportManagementFeatureDefinitionProvider {
+    async provide(context) {
+        // Report Builder feature
+        context.addFeature(AXPReportManagementFeatureKeys.ReportBuilder, {
+            title: '@report-management:features.report-builder.title',
+            description: '@report-management:features.report-builder.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+        // Saved Reports feature
+        context.addFeature(AXPReportManagementFeatureKeys.SavedReports, {
+            title: '@report-management:features.saved-reports.title',
+            description: '@report-management:features.saved-reports.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+        // Scheduled Reports feature
+        context.addFeature(AXPReportManagementFeatureKeys.ScheduledReports, {
+            title: '@report-management:features.scheduled-reports.title',
+            description: '@report-management:features.scheduled-reports.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+        // Background Reports feature
+        context.addFeature(AXPReportManagementFeatureKeys.BackgroundReports, {
+            title: '@report-management:features.background-reports.title',
+            description: '@report-management:features.background-reports.description',
+            defaultValue: true,
+            type: 'boolean',
+        });
+    }
+}
+//#endregion
+
+//#region ----- Report management settings -----
+const DEDUPE_POLICY_ITEMS = [
+    {
+        value: 'none',
+        text: '@report-management:settings.generation.items.dedupe-policy.options.none',
+    },
+    {
+        value: 'in-flight',
+        text: '@report-management:settings.generation.items.dedupe-policy.options.in-flight',
+    },
+    {
+        value: 'in-flight-or-cooldown',
+        text: '@report-management:settings.generation.items.dedupe-policy.options.in-flight-or-cooldown',
+    },
+];
+class AXMReportManagementSettingProvider {
+    async provide(context) {
+        const cooldownPolicy = `{{ context.eval('${AXPReportManagementSettings.GenerationDedupePolicy}') === 'in-flight-or-cooldown' }}`;
+        context
+            .addGroup('report-management', '@report-management:settings.group.title', '@report-management:settings.group.description', 'fa-light fa-chart-line', undefined, 840)
+            .addSection('generation', '@report-management:settings.generation.title', '@report-management:settings.generation.description')
+            .addSetting({
+            key: AXPReportManagementSettings.GenerationDedupePolicy,
+            title: '@report-management:settings.generation.items.dedupe-policy.title',
+            description: '@report-management:settings.generation.items.dedupe-policy.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: AXP_REPORT_MANAGEMENT_GENERATION_SETTING_DEFAULTS[AXPReportManagementSettings.GenerationDedupePolicy],
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'value',
+                    textField: 'text',
+                    dataSource: DEDUPE_POLICY_ITEMS,
+                },
+            },
+            validationRules: [{ rule: 'required' }],
+        })
+            .addSetting({
+            key: AXPReportManagementSettings.GenerationDedupeCooldownMinutes,
+            title: '@report-management:settings.generation.items.dedupe-cooldown-minutes.title',
+            description: '@report-management:settings.generation.items.dedupe-cooldown-minutes.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: AXP_REPORT_MANAGEMENT_GENERATION_SETTING_DEFAULTS[AXPReportManagementSettings.GenerationDedupeCooldownMinutes],
+            widget: {
+                type: AXPWidgetsList.Editors.NumberBox,
+                options: { minValue: 0, maxValue: 1440, visibility: cooldownPolicy },
+            },
+            validationRules: [{ rule: 'required' }],
+        })
+            .addSetting({
+            key: AXPReportManagementSettings.GenerationMaxConcurrentPerUser,
+            title: '@report-management:settings.generation.items.max-concurrent-per-user.title',
+            description: '@report-management:settings.generation.items.max-concurrent-per-user.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: AXP_REPORT_MANAGEMENT_GENERATION_SETTING_DEFAULTS[AXPReportManagementSettings.GenerationMaxConcurrentPerUser],
+            widget: {
+                type: AXPWidgetsList.Editors.NumberBox,
+                options: { minValue: 0, maxValue: 50 },
+            },
+            validationRules: [{ rule: 'required' }],
+        })
+            .endSection()
+            .endGroup();
+    }
+}
+//#endregion
+
+//#region ----- Types -----
+//#endregion
+//#region ----- Date helpers -----
+/** Local calendar date as `yyyy-MM-dd` (session "today" for report ranges). */
+function formatReportDateOnly(date = new Date()) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function resolveTodayDateRange(date = new Date()) {
+    const day = formatReportDateOnly(date);
+    return { from: day, to: day };
+}
+function isReportDateRangeObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const raw = value;
+    const from = raw['from'] ?? raw['start'];
+    const to = raw['to'] ?? raw['end'];
+    return typeof from === 'string' && typeof to === 'string' && !!from.trim() && !!to.trim();
+}
+function toReportDateRangeFilterValue(range) {
+    return {
+        operation: { type: 'between' },
+        value: { from: range.from, to: range.to },
+    };
+}
+/**
+ * Converts report default / binding values into filter-form context shape.
+ * - `'today'` and `{ from, to }` → `{ operation: between, value }`
+ * - existing filter objects are left unchanged
+ */
+function resolveReportFilterDefaultValue(value, now = new Date()) {
+    if (value === 'today') {
+        return toReportDateRangeFilterValue(resolveTodayDateRange(now));
+    }
+    if (isReportDateRangeObject(value)) {
+        return toReportDateRangeFilterValue({
+            from: String(value.from ?? value.start),
+            to: String(value.to ?? value.end),
+        });
+    }
+    return value;
+}
+function collectReportParameterDefaults(parameterGroups, now = new Date()) {
+    const defaults = {};
+    for (const group of parameterGroups ?? []) {
+        for (const param of group.parameters ?? []) {
+            const rawDefault = param.widget?.defaultValue ?? param.widget?.options?.['defaultValue'];
+            if (rawDefault === undefined) {
+                continue;
+            }
+            defaults[param.path] = resolveReportFilterDefaultValue(rawDefault, now);
+        }
+    }
+    return defaults;
+}
+//#endregion
+//#region ----- Parameter resolution -----
+/**
+ * Resolves special parameter tokens after expression evaluation.
+ * - `dateRange: 'today'` → `{ from, to }` for the local calendar day
+ */
+function resolveReportParameterValues(parameters, now = new Date()) {
+    if (!parameters) {
+        return {};
+    }
+    const resolved = {};
+    for (const [key, value] of Object.entries(parameters)) {
+        if (value === 'today') {
+            resolved[key] = resolveTodayDateRange(now);
+            continue;
+        }
+        resolved[key] = value;
+    }
+    return resolved;
+}
+/**
+ * Maps entity-binding parameter declarations into OpenInPopup command parameters.
+ * Field paths become `context.eval` expressions; `today` and `{from,to}` stay literal.
+ */
+function mapEntityBindingParameters(parameters) {
+    if (!parameters) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(parameters).map(([key, value]) => [key, toBindingParameterExpression(value)]));
+}
+function toBindingParameterExpression(value) {
+    if (value === 'today') {
+        return 'today';
+    }
+    if (isReportDateRangeObject(value)) {
+        return {
+            from: String(value.from ?? value.start),
+            to: String(value.to ?? value.end),
+        };
+    }
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.includes('{{') || trimmed.includes('context.eval')) {
+        return value;
+    }
+    return `{{ context.eval('${trimmed}') }}`;
+}
+//#endregion
+//#region ----- Viewer query params -----
+/**
+ * Flattens popup/filter parameters into report-viewer URL query params
+ * (`field.operation.type` + `field.value` / nested `from`/`to`).
+ */
+function flattenReportParametersToQueryParams(parameters) {
+    const result = {};
+    for (const [field, rawValue] of Object.entries(parameters)) {
+        if (rawValue === null || rawValue === undefined || rawValue === '') {
+            continue;
+        }
+        if (isReportDateRangeObject(rawValue)) {
+            const from = String(rawValue.from ?? rawValue.start);
+            const to = String(rawValue.to ?? rawValue.end);
+            result[`${field}.operation.type`] = 'between';
+            result[`${field}.value.from`] = from;
+            result[`${field}.value.to`] = to;
+            continue;
+        }
+        if (typeof rawValue === 'object' && !Array.isArray(rawValue) && 'operation' in rawValue) {
+            const filterObj = rawValue;
+            if (filterObj.operation?.type) {
+                result[`${field}.operation.type`] = String(filterObj.operation.type);
+            }
+            if (isReportDateRangeObject(filterObj.value)) {
+                result[`${field}.value.from`] = String(filterObj.value.from ?? filterObj.value.start);
+                result[`${field}.value.to`] = String(filterObj.value.to ?? filterObj.value.end);
+            }
+            else if (filterObj.value !== undefined && filterObj.value !== null && filterObj.value !== '') {
+                result[`${field}.value`] = Array.isArray(filterObj.value)
+                    ? filterObj.value.map(String).join(',')
+                    : String(filterObj.value);
+            }
+            continue;
+        }
+        result[`${field}.operation.type`] = Array.isArray(rawValue) ? 'in' : 'equal';
+        result[`${field}.value`] = Array.isArray(rawValue) ? rawValue.map(String).join(',') : String(rawValue);
+    }
+    return result;
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+const OPEN_REPORT_IN_POPUP_COMMAND = 'ReportManagement.Report:OpenInPopup';
+const ENTITY_REPORTS_PAGE_COMPONENT_KEY = 'entity-reports-page';
+//#endregion
+//#region ----- Display helpers -----
+function normalizeReportEntityDisplays(display) {
+    if (!display) {
+        return new Set(['page']);
+    }
+    const list = Array.isArray(display) ? display : [display];
+    return new Set(list);
+}
+function bindingShowsOnPage(binding) {
+    const displays = normalizeReportEntityDisplays(binding.display);
+    // Default / empty → page. Explicit lists without `page` hide from the Reports page.
+    return displays.has('page') || displays.size === 0;
+}
+function resolveBindingTitle(report, binding) {
+    if (typeof binding.title === 'string' && binding.title.trim()) {
+        return binding.title.trim();
+    }
+    return report.title;
+}
+function resolveBindingDescription(report, binding) {
+    if (typeof binding.description === 'string' && binding.description.trim()) {
+        return binding.description.trim();
+    }
+    if (typeof report.description === 'string') {
+        const trimmed = report.description.trim();
+        return trimmed || undefined;
+    }
+    return report.description;
+}
+function buildOpenInPopupCommandOptions(report, binding) {
+    return {
+        reportId: report.id,
+        layoutId: binding.layoutId,
+        title: resolveBindingTitle(report, binding),
+        parameters: mapEntityBindingParameters(binding.parameters),
+    };
+}
+function extractEntityBindings(report, entityType) {
+    const bindings = report.entities ?? [];
+    return bindings
+        .filter((binding) => binding?.entity === entityType)
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Plugin factory -----
+/**
+ * Entity `reports` plugin — contributes a Reports detail page for definitions
+ * bound via `entities[]`. Reports open from that page (not entity Actions).
+ *
+ * Takes {@link Injector} for factory signature parity with other entity plugins.
+ */
+function createEntityReportsPlugin(_injector) {
+    return {
+        name: 'reports',
+        order: 55,
+        apply: async (ctx, options) => {
+            const opts = options ?? {};
+            const entityType = `${ctx.entity.module}.${ctx.entity.name}`;
+            const pageTitle = opts.title?.trim() || '@report-management:entity-reports.page.title';
+            //#region ----- Reports detail page -----
+            ctx.entity.pages ??= [];
+            const pageExists = ctx.entity.pages.some((p) => p.componentKey === ENTITY_REPORTS_PAGE_COMPONENT_KEY);
+            const pageOrder = resolveEntityPluginDetailPageOrder({ relatedEntities: ctx.entity.relatedEntities, pages: ctx.entity.pages }, 'reports', {
+                componentKey: ENTITY_REPORTS_PAGE_COMPONENT_KEY,
+                skipPage: pageExists ? { componentKey: ENTITY_REPORTS_PAGE_COMPONENT_KEY } : undefined,
+            });
+            const page = {
+                componentKey: ENTITY_REPORTS_PAGE_COMPONENT_KEY,
+                title: pageTitle,
+                icon: opts.icon ?? 'fa-light fa-chart-mixed',
+                layout: { order: pageOrder },
+                options: { entityType },
+            };
+            if (!pageExists) {
+                ctx.entity.pages.push(page);
+            }
+            else {
+                const pages = ctx.entity.pages;
+                const index = pages.findIndex((p) => p.componentKey === ENTITY_REPORTS_PAGE_COMPONENT_KEY);
+                if (index >= 0) {
+                    pages[index] = { ...pages[index], ...page };
+                }
+            }
+            //#endregion
+            ctx.entity.extensions ??= {};
+            ctx.entity.extensions.reports = {
+                entityType,
+            };
+        },
+    };
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Command -----
+/** Opens a report in the full-page report viewer. */
+class AXPOpenReportViewerCommand {
+    constructor() {
+        //#region ----- Services & Dependencies -----
+        this.sessionService = inject(AXPSessionService);
+        this.tabNavigation = inject(AXPTabNavigationService);
+        this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.translate = inject(AXTranslationService);
+        this.inboxConnector = inject(AXPInAppInboxConnectorService, { optional: true });
+    }
+    //#endregion
+    //#region ----- Command Implementation -----
+    async execute(input) {
+        const rowData = this.resolveRowData(input);
+        const options = await this.resolveOptions(input, rowData);
+        if (!options.reportId) {
+            return {
+                success: false,
+                message: {
+                    text: await this.translate.translateAsync('@report-management:report-viewer.messages.error.invalid-popup-target'),
+                },
+            };
+        }
+        const runId = typeof options.runId === 'string' ? options.runId.trim() : '';
+        if (runId) {
+            await this.dismissReportGenerationInboxNotification(runId);
+        }
+        const appName = this.sessionService.application?.name;
+        if (!appName) {
+            return {
+                success: false,
+                message: {
+                    text: await this.translate.translateAsync('@report-management:report-viewer.messages.error.invalid-popup-target'),
+                },
+            };
+        }
+        // Put reportId in the path (not queryParams): tabular navigation drops NavigationExtras.
+        const path = runId
+            ? `${appName}/${RootConfig.module.route}/viewer/${options.reportId}?runId=${encodeURIComponent(runId)}`
+            : `${appName}/${RootConfig.module.route}/viewer/${options.reportId}`;
+        await this.tabNavigation.navigate(path);
+        return { success: true, kind: 'object', data: undefined };
+    }
+    //#endregion
+    //#region ----- Helpers -----
+    async dismissReportGenerationInboxNotification(runId) {
+        if (!this.inboxConnector) {
+            return;
+        }
+        try {
+            await this.inboxConnector.dismissByCorrelationId(buildReportGenerationNotificationCorrelationId(runId));
+        }
+        catch {
+            // Best-effort — navigation should still proceed.
+        }
+    }
+    resolveRowData(input) {
+        const ctx = input;
+        if (ctx?.data && typeof ctx.data === 'object') {
+            return ctx.data;
+        }
+        if (input['data'] &&
+            typeof input['data'] === 'object') {
+            return input['data'];
+        }
+        return input;
+    }
+    async resolveOptions(input, rowData) {
+        const typedInput = input;
+        const rawOptions = {
+            reportId: typedInput.reportId,
+            runId: typedInput.runId,
+            ...(typedInput.options ?? {}),
+        };
+        const scope = {
+            context: {
+                eval: (path) => get(rowData, path),
+            },
+        };
+        return (await this.expressionEvaluator.evaluate(rawOptions, scope));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPOpenReportViewerCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPOpenReportViewerCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPOpenReportViewerCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var openReportViewer_command = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPOpenReportViewerCommand: AXPOpenReportViewerCommand
+});
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Handler -----
+class AXMReportGenerationBackgroundOperationHandler extends AXPBackgroundOperationHandler {
+    constructor() {
+        super(...arguments);
+        this.providerKey = 'report-management';
+        this.openViewer = inject(AXPOpenReportViewerCommand);
+        this.queryService = inject(AXPQueryService);
+    }
+    async execute(command, operation) {
+        if (command.name !== 'click') {
+            return;
+        }
+        const reportRequestId = get(operation.data, 'reportRequestId') ??
+            get(operation.data, 'payload.reportRequestId') ??
+            get(operation.data, 'command.payload.reportRequestId');
+        if (typeof reportRequestId !== 'string' || !reportRequestId.trim()) {
+            return;
+        }
+        const result = await this.queryService.fetch(AXMReportManagementQueryKeys.ReportGeneration.Get, { id: reportRequestId });
+        const request = runtimeQueryPayloadData(result);
+        if (!request?.reportId) {
+            return;
+        }
+        if (request.status === 'completed') {
+            await this.openViewer.execute({ reportId: request.reportId, runId: request.id });
+            return;
+        }
+        await this.openViewer.execute({ reportId: request.reportId });
+    }
+    resolveCta(operation) {
+        if (operation.status === 'failed' && operation.capabilities.retryable) {
+            return {
+                text: '@general:background-operation.actions.retry',
+                icon: 'fa-light fa-arrow-rotate-right',
+                color: 'primary',
+                look: 'solid',
+                command: { name: 'retry' },
+            };
+        }
+        if (operation.status === 'completed' && operation.capabilities.clickable) {
+            return {
+                text: '@report-management:report-generation.notifications.actions.open-viewer',
+                icon: 'fa-light fa-file-chart-column',
+                color: 'primary',
+                look: 'solid',
+                command: { name: 'click' },
+            };
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportGenerationBackgroundOperationHandler, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportGenerationBackgroundOperationHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportGenerationBackgroundOperationHandler, decorators: [{
+            type: Injectable
+        }] });
+//#endregion
+//#region ----- Providers -----
+const AXM_REPORT_GENERATION_BACKGROUND_OPERATION_HANDLERS = [
+    {
+        provide: AXP_BACKGROUND_OPERATION_HANDLERS,
+        useExisting: AXMReportGenerationBackgroundOperationHandler,
+        multi: true,
+    },
+    AXMReportGenerationBackgroundOperationHandler,
+];
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+const TOASTED_KEYS_STORAGE = 'axp:report-generation-inbox-toast-keys';
+//#endregion
+//#region ----- Bridge -----
+/**
+ * When a report-generation inbox row arrives (user was not watching inline),
+ * mirrors it as a transient toast with an open action. Inbox persistence stays server-owned.
+ */
+class AXMReportGenerationInboxToastBridgeService {
+    constructor() {
+        //#region ----- Dependencies -----
+        this.inboxConnector = inject(AXPInAppInboxConnectorService, { optional: true });
+        this.userNotificationService = inject(AXP_USER_NOTIFICATION_SERVICE);
+        this.commandService = inject(AXPCommandService);
+        this.translationService = inject(AXTranslationService);
+        this.sessionService = inject(AXPSessionService);
+        this.destroyRef = inject(DestroyRef);
+        this.injector = inject(Injector);
+        //#endregion
+        //#region ----- State -----
+        this.started = false;
+        this.inboxBaselined = false;
+        this.boundUserId = null;
+        this.toastedKeys = new Set();
+    }
+    //#endregion
+    //#region ----- Lifecycle -----
+    start() {
+        if (this.started || !this.inboxConnector) {
+            return;
+        }
+        this.started = true;
+        this.sessionService.isReadyForAppScopedApi$
+            .pipe(map(() => this.sessionService.user?.id?.trim() || null), distinctUntilChanged(), takeUntilDestroyed(this.destroyRef))
+            .subscribe((userId) => {
+            this.bindSessionUser(userId);
+        });
+        this.bindSessionUser(this.sessionService.user?.id?.trim() || null);
+        effect(() => {
+            const userId = this.sessionService.user?.id?.trim();
+            const inboxLoading = this.inboxConnector?.loading() ?? false;
+            const items = this.readReportGenerationItems();
+            if (!this.sessionService.isReadyForAppScopedApi || !userId) {
+                return;
+            }
+            if (!this.inboxBaselined) {
+                for (const item of items) {
+                    this.markToasted(this.toastKey(item));
+                }
+                if (!inboxLoading) {
+                    this.inboxBaselined = true;
+                }
+                return;
+            }
+            for (const item of items) {
+                const key = this.toastKey(item);
+                if (this.toastedKeys.has(key)) {
+                    continue;
+                }
+                this.markToasted(key);
+                void this.showToastForInboxItem(item);
+            }
+        }, { injector: this.injector });
+    }
+    //#endregion
+    //#region ----- Toast -----
+    async showToastForInboxItem(item) {
+        const action = item.actions?.[0];
+        const actionTitle = action?.title
+            ? await this.translationService.translateAsync(action.title)
+            : await this.translationService.translateAsync('@report-management:report-generation.notifications.actions.open-viewer');
+        const toastActions = action?.command?.name
+            ? [
+                {
+                    text: actionTitle,
+                    color: 'primary',
+                    onClick: () => this.executeInboxAction(item, action),
+                },
+            ]
+            : undefined;
+        await this.userNotificationService.notify({
+            correlationId: item.correlationId?.trim() || item.id,
+            title: await this.resolveText(item.title),
+            body: await this.resolveText(item.body),
+            icon: item.iconClass ?? this.resolveIcon(item),
+            delivery: {
+                toast: {
+                    color: this.resolveToastColor(item),
+                    location: 'bottom-center',
+                    closeButton: true,
+                    timeOut: 8_000,
+                    timeOutProgress: true,
+                    showActions: !!toastActions?.length,
+                },
+            },
+            toastActions,
+        });
+    }
+    async executeInboxAction(item, action) {
+        if (!action.command?.name) {
+            return;
+        }
+        await this.commandService.execute(action.command.name, action.command.options ?? {});
+    }
+    //#endregion
+    //#region ----- Helpers -----
+    readReportGenerationItems() {
+        const userId = this.sessionService.user?.id?.trim();
+        return (this.inboxConnector?.inboxList() ?? []).filter((item) => {
+            if (item.definitionKey !== REPORT_GENERATION_NOTIFICATION_DEFINITION_KEY) {
+                return false;
+            }
+            const recipientUserId = item.recipientUserId?.trim();
+            return !recipientUserId || recipientUserId === userId;
+        });
+    }
+    toastKey(item) {
+        return item.correlationId?.trim() || item.id;
+    }
+    bindSessionUser(userId) {
+        if (userId === this.boundUserId) {
+            return;
+        }
+        this.boundUserId = userId;
+        this.inboxBaselined = false;
+        this.toastedKeys.clear();
+        if (userId) {
+            this.loadPersistedToastedKeys(userId);
+        }
+    }
+    markToasted(key) {
+        const normalized = key.trim();
+        if (!normalized) {
+            return;
+        }
+        this.toastedKeys.add(normalized);
+        this.persistToastedKeys();
+    }
+    toastedStorageKey(userId) {
+        return `${TOASTED_KEYS_STORAGE}:${userId}`;
+    }
+    loadPersistedToastedKeys(userId) {
+        try {
+            const raw = sessionStorage.getItem(this.toastedStorageKey(userId));
+            if (!raw) {
+                return;
+            }
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) {
+                return;
+            }
+            for (const entry of parsed) {
+                if (typeof entry === 'string' && entry.trim()) {
+                    this.toastedKeys.add(entry.trim());
+                }
+            }
+        }
+        catch {
+            // Ignore corrupt session storage.
+        }
+    }
+    persistToastedKeys() {
+        const userId = this.boundUserId?.trim();
+        if (!userId) {
+            return;
+        }
+        try {
+            sessionStorage.setItem(this.toastedStorageKey(userId), JSON.stringify([...this.toastedKeys]));
+        }
+        catch {
+            // Ignore quota / privacy errors.
+        }
+    }
+    async resolveText(value) {
+        const text = value?.trim();
+        if (!text) {
+            return '';
+        }
+        if (text.startsWith('@')) {
+            return this.translationService.translateAsync(text);
+        }
+        return text;
+    }
+    resolveToastColor(item) {
+        switch (item.priority) {
+            case 'Danger':
+                return 'danger';
+            case 'Warning':
+                return 'warning';
+            default:
+                return 'success';
+        }
+    }
+    resolveIcon(item) {
+        if (item.priority === 'Danger') {
+            return 'fa-light fa-circle-exclamation';
+        }
+        if (item.priority === 'Warning') {
+            return 'fa-light fa-triangle-exclamation';
+        }
+        return 'fa-light fa-circle-check';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportGenerationInboxToastBridgeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportGenerationInboxToastBridgeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportGenerationInboxToastBridgeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Providers -----
+function provideReportGenerationInboxToastBridge() {
+    return [
+        provideAppStartUpTask(() => {
+            const bridge = inject(AXMReportGenerationInboxToastBridgeService);
+            const inbox = inject(AXPInAppInboxConnectorService, { optional: true });
+            return {
+                name: 'report-generation-inbox-toast-bridge',
+                priority: AXP_APP_STARTUP_PRIORITY.realtimeHandlers,
+                run: async () => {
+                    if (inbox) {
+                        await inbox.ensureReady();
+                        await inbox.refresh();
+                    }
+                    bridge.start();
+                },
+            };
+        }),
+    ];
+}
+//#endregion
+
+function routesFacory() {
+    let routes = [
+        {
+            path: `:app/${RootConfig.module.route}/viewer`,
+            canActivate: [...AXP_PROTECTED_ROUTE_GUARDS],
+            data: { tab: true, rootLayout: true },
+            loadComponent: () => {
+                return AXPRootLayoutComponent;
+            },
+            children: [
+                {
+                    path: ':reportId',
+                    loadComponent: () => import('./acorex-platform-module-report-management-client-report-viewer-page.component-YUdzA4B9.mjs').then((c) => c.AXPReportViewerPageComponent),
+                    data: { reuse: true },
+                },
+                {
+                    path: '',
+                    loadComponent: () => import('./acorex-platform-module-report-management-client-report-viewer-page.component-YUdzA4B9.mjs').then((c) => c.AXPReportViewerPageComponent),
+                    data: { reuse: true },
+                },
+            ],
+        },
+    ];
+    return routes;
+}
+class AXMReportManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMReportManagementModule, imports: [AXPDomainModule,
+            AXPRuntimeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportManagementModule, providers: [
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFacory,
+            },
+            provideEntity([RootConfig.entities.report.fullName, RootConfig.entities.category.fullName]),
+            // Provider references (now using tokens)
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FEATURE_DEFINITION_PROVIDER,
+                useClass: AXPReportManagementFeatureDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMReportManagementSettingProvider,
+                multi: true,
+            },
+            ...AXM_REPORT_GENERATION_BACKGROUND_OPERATION_HANDLERS,
+            ...provideReportGenerationInboxToastBridge(),
+            provideCommandSetups([
+                {
+                    key: 'ReportManagement.Report:OpenInPopup',
+                    command: () => Promise.resolve().then(function () { return openReportInPopup_command; }).then((c) => c.AXPOpenReportInPopupCommand),
+                },
+                {
+                    key: 'ReportManagement.Report:OpenViewer',
+                    command: () => Promise.resolve().then(function () { return openReportViewer_command; }).then((c) => c.AXPOpenReportViewerCommand),
+                },
+            ]),
+            {
+                provide: AXP_ENTITY_ACTION_PLUGIN,
+                multi: true,
+                useFactory: () => createEntityReportsPlugin(inject(Injector)),
+            },
+            provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-platform-module-report-management-client-entity-reports-page-component.provider-0eSOzb0y.mjs').then((m) => m.AXMEntityReportsPageComponentProvider)),
+        ], imports: [AXPDomainModule,
+            AXPRuntimeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMReportManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPDomainModule,
+                        AXPRuntimeModule,
+                        // Entity Modules
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFacory,
+                        },
+                        provideEntity([RootConfig.entities.report.fullName, RootConfig.entities.category.fullName]),
+                        // Provider references (now using tokens)
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FEATURE_DEFINITION_PROVIDER,
+                            useClass: AXPReportManagementFeatureDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMReportManagementSettingProvider,
+                            multi: true,
+                        },
+                        ...AXM_REPORT_GENERATION_BACKGROUND_OPERATION_HANDLERS,
+                        ...provideReportGenerationInboxToastBridge(),
+                        provideCommandSetups([
+                            {
+                                key: 'ReportManagement.Report:OpenInPopup',
+                                command: () => Promise.resolve().then(function () { return openReportInPopup_command; }).then((c) => c.AXPOpenReportInPopupCommand),
+                            },
+                            {
+                                key: 'ReportManagement.Report:OpenViewer',
+                                command: () => Promise.resolve().then(function () { return openReportViewer_command; }).then((c) => c.AXPOpenReportViewerCommand),
+                            },
+                        ]),
+                        {
+                            provide: AXP_ENTITY_ACTION_PLUGIN,
+                            multi: true,
+                            useFactory: () => createEntityReportsPlugin(inject(Injector)),
+                        },
+                        provideLazyProvider(AXP_PAGE_COMPONENT_PROVIDER, () => import('./acorex-platform-module-report-management-client-entity-reports-page-component.provider-0eSOzb0y.mjs').then((m) => m.AXMEntityReportsPageComponentProvider)),
+                    ],
+                }]
+        }] });
+
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+/**
+ * Report Viewer Service
+ *
+ * Handles report definition retrieval, caching, and layout actions.
+ */
+class AXPReportViewerService {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.entityService = inject(AXPEntityService);
+        this.reportDefinitionService = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.report.name)
+            .data();
+        //#endregion
+        //#region ----   Cache Storage   ----
+        /** Cache for individual report definitions by id */
+        this.definitionsById = new Map();
+        /** Pending API requests to prevent duplicate calls */
+        this.pendingReportRequests = new Map();
+    }
+    //#endregion
+    //#region ----   Public API: Report Definitions   ----
+    /**
+     * Reports bound to a host entity type via `entities[].entity`.
+     * Falls back to an in-memory filter when the nested-array query returns nothing
+     * (or is unsupported by the current query backend).
+     */
+    async getReportsByEntityType(entityType) {
+        if (!entityType?.trim()) {
+            return [];
+        }
+        let items = [];
+        try {
+            const result = await this.reportDefinitionService.query({
+                skip: 0,
+                take: 1000,
+                filter: {
+                    logic: 'and',
+                    filters: [
+                        {
+                            field: 'entities.entity',
+                            operator: { type: 'equal' },
+                            value: entityType,
+                        },
+                    ],
+                },
+            });
+            items = (result.items ?? []);
+        }
+        catch {
+            items = [];
+        }
+        if (items.length === 0) {
+            try {
+                const fallback = await this.reportDefinitionService.query({
+                    skip: 0,
+                    take: 1000,
+                });
+                items = (fallback.items ?? []).filter((report) => (report.entities ?? []).some((binding) => binding?.entity === entityType));
+            }
+            catch {
+                items = [];
+            }
+        }
+        const bound = [];
+        for (const report of items) {
+            this.definitionsById.set(report.id, report);
+            for (const binding of extractEntityBindings(report, entityType)) {
+                bound.push({ report, binding });
+            }
+        }
+        return bound.sort((a, b) => (a.binding.order ?? 0) - (b.binding.order ?? 0) ||
+            resolveMultiLanguageString(a.report.title, 'en-US').localeCompare(resolveMultiLanguageString(b.report.title, 'en-US')));
+    }
+    /**
+     * Get single report definition by ID with O(1) lookup
+     */
+    async getReportById(id) {
+        if (this.definitionsById.has(id)) {
+            return this.definitionsById.get(id);
+        }
+        if (this.pendingReportRequests.has(id)) {
+            return this.pendingReportRequests.get(id);
+        }
+        const requestPromise = this.loadReport(id);
+        this.pendingReportRequests.set(id, requestPromise);
+        return requestPromise;
+    }
+    //#endregion
+    //#region ----   Public API: Layout Actions   ----
+    /**
+     * Get general actions list for a layout type.
+     * Override in connectivity layer (mock/API) to provide general actions.
+     */
+    getGeneralActionsList(layoutType) {
+        return [];
+    }
+    /**
+     * Get merged actions for a layout definition.
+     * Combines general actions with layout-specific actions.
+     */
+    getMergedActions(layoutDefinition) {
+        const generalActions = this.getGeneralActionsList(layoutDefinition.layout.type);
+        const customActions = layoutDefinition.actions || [];
+        const customActionsMap = new Map();
+        customActions.forEach((action) => {
+            if (action.name) {
+                customActionsMap.set(action.name, action);
+            }
+        });
+        const merged = [];
+        const usedNames = new Set();
+        generalActions.forEach((action) => {
+            if (action.name && customActionsMap.has(action.name)) {
+                merged.push(customActionsMap.get(action.name));
+                usedNames.add(action.name);
+            }
+            else {
+                merged.push(action);
+                if (action.name) {
+                    usedNames.add(action.name);
+                }
+            }
+        });
+        customActions.forEach((action) => {
+            if (action.name && !usedNames.has(action.name)) {
+                merged.push(action);
+                usedNames.add(action.name);
+            }
+            else if (!action.name) {
+                merged.push(action);
+            }
+        });
+        return merged;
+    }
+    getPrimaryActions(layoutDefinition) {
+        return this.getMergedActions(layoutDefinition).filter((action) => action.priority === 'primary');
+    }
+    getSecondaryActions(layoutDefinition) {
+        return this.getMergedActions(layoutDefinition).filter((action) => action.priority === 'secondary');
+    }
+    //#endregion
+    //#region ----   Private: Data Loading   ----
+    /**
+     * Load single report from entity service and cache result.
+     * Can be overridden in extended services (e.g., API layer).
+     */
+    async loadReport(id) {
+        try {
+            const result = (await this.reportDefinitionService.byKey(id));
+            if (result) {
+                this.definitionsById.set(id, result);
+                return result;
+            }
+            return undefined;
+        }
+        finally {
+            this.pendingReportRequests.delete(id);
+        }
+    }
+    //#endregion
+    //#region ----   Cache Management   ----
+    isReportCached(reportId) {
+        return this.definitionsById.has(reportId) || this.pendingReportRequests.has(reportId);
+    }
+    clearAllCache() {
+        this.definitionsById.clear();
+        this.pendingReportRequests.clear();
+    }
+    clearReportsCache() {
+        this.definitionsById.clear();
+        this.pendingReportRequests.clear();
+    }
+    //#endregion
+    //#region ----   Action Handlers (Override in Connectivity Layer)   ----
+    async executeAction(commandName, options) {
+        console.log(`Execute action: ${commandName} - should be implemented in connectivity layer`, options);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+function AXPieChartReportMapper(data) {
+    return Object.entries(data)
+        .map(([key, value]) => ({
+        id: key,
+        label: key,
+        value: Number(value),
+    }))
+        .filter((item) => Number.isFinite(item.value) && item.value > 0);
+}
+function AXBarChartReportMapper(data) {
+    return Object.entries(data)
+        .map(([key, value]) => ({
+        id: key,
+        label: key,
+        value: Number(value),
+    }))
+        .filter((item) => Number.isFinite(item.value));
+}
+function AXLineChartReportMapper(data) {
+    const entries = Object.entries(data);
+    if (entries.length === 0) {
+        return [];
+    }
+    const dataPoints = entries.map(([key, value]) => ({
+        x: key,
+        y: value,
+    }));
+    return [
+        {
+            id: 'series-1',
+            label: 'Data Series',
+            tooltipLabel: 'Countries Info',
+            lineColor: '#d81159',
+            fillColor: '#d8115920',
+            data: dataPoints,
+        },
+    ];
+}
+//#region ----   Helpers   ----
+/**
+ * Determines whether a filter value should be treated as empty.
+ * This handles deep objects, arrays, and primitives so that
+ * values like { from: null, to: null } are considered empty.
+ */
+function isEmptyFilterValue(value) {
+    if (value === null || value === undefined || value === '') {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0 || value.every((item) => isEmptyFilterValue(item));
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return true;
+        }
+        // Consider object empty if all nested values are empty
+        return entries.every(([, v]) => isEmptyFilterValue(v));
+    }
+    return false;
+}
+//#endregion
+/**
+ * Converts AXPContextData (filter context) to AXPFilterClause format
+ *
+ * Input format:
+ * {
+ *   "fieldName": {
+ *     "operation": { "type": "between" },
+ *     "value": { "from": "...", "to": "..." }
+ *   }
+ * }
+ *
+ * Output format:
+ * {
+ *   logic: 'and',
+ *   filters: [
+ *     {
+ *       field: 'fieldName',
+ *       operator: { type: 'between' },
+ *       value: { from: "...", to: "..." }
+ *     }
+ *   ]
+ * }
+ */
+function convertContextDataToFilterClause(context) {
+    const filters = [];
+    // Iterate through all keys in context
+    for (const [fieldName, fieldData] of Object.entries(context)) {
+        if (fieldName.endsWith('EditorObj') || fieldName.startsWith('__')) {
+            continue;
+        }
+        // Drill-down and URL shortcuts may pass plain parameter values (e.g. { brand: 'id' })
+        if (fieldData === null || fieldData === undefined || typeof fieldData !== 'object' || Array.isArray(fieldData)) {
+            if (!isEmptyFilterValue(fieldData)) {
+                filters.push({
+                    field: fieldName,
+                    operator: {
+                        type: Array.isArray(fieldData) ? 'in' : 'equal',
+                    },
+                    value: fieldData,
+                });
+            }
+            continue;
+        }
+        // Plain `{ from, to }` / `{ start, end }` objects (e.g. dateRange from OpenInPopup)
+        if (isReportDateRangeObject(fieldData) && !('operation' in fieldData)) {
+            // Date-range widgets use `between`; CDK operator union is narrower than runtime.
+            filters.push({
+                field: fieldName,
+                operator: { type: 'between' },
+                value: {
+                    from: String(fieldData.from ?? fieldData.start),
+                    to: String(fieldData.to ?? fieldData.end),
+                },
+            });
+            continue;
+        }
+        // Skip structured filter objects without operation metadata
+        if (!('operation' in fieldData)) {
+            continue;
+        }
+        const operation = fieldData.operation;
+        const value = fieldData.value;
+        // Skip if operation type is missing
+        if (!operation || !operation.type) {
+            continue;
+        }
+        // Skip if value is effectively empty (null/undefined/empty string,
+        // empty object/array, or deep object where all nested values are empty)
+        if (isEmptyFilterValue(value)) {
+            continue;
+        }
+        // Create filter clause
+        const filter = {
+            field: fieldName,
+            operator: {
+                type: operation.type,
+            },
+            value: value,
+        };
+        filters.push(filter);
+    }
+    // Return filter clause with AND logic
+    if (filters.length === 0) {
+        return {
+            logic: 'and',
+            filters: [],
+        };
+    }
+    return {
+        logic: 'and',
+        filters: filters,
+    };
+}
+function asPdfSource(record) {
+    if (!record) {
+        return null;
+    }
+    const url = typeof record['url'] === 'string' ? record['url'] : undefined;
+    const base64 = typeof record['base64'] === 'string' ? record['base64'] : undefined;
+    const blob = record['blob'] instanceof Blob ? record['blob'] : undefined;
+    const filename = typeof record['filename'] === 'string' ? record['filename'] : undefined;
+    if (url == null && base64 == null && blob == null) {
+        return null;
+    }
+    return { url, base64, blob, filename };
+}
+function queryResultToPdfSource(queryResult) {
+    if (!queryResult?.success) {
+        return null;
+    }
+    const fromObject = asPdfSource((runtimeQueryPayloadData(queryResult) ?? runtimeQueryObjectData(queryResult)));
+    if (fromObject) {
+        return fromObject;
+    }
+    const page = runtimeQueryCollectionData(queryResult);
+    return asPdfSource(page?.items?.[0]);
+}
+function queryResultToChartSeries(queryResult, mapping) {
+    if (!queryResult?.success) {
+        return {};
+    }
+    const objectData = runtimeQueryObjectData(queryResult);
+    if (objectData && !('items' in objectData)) {
+        const series = {};
+        for (const [key, value] of Object.entries(objectData)) {
+            const n = Number(value);
+            if (Number.isFinite(n)) {
+                series[key] = n;
+            }
+        }
+        if (Object.keys(series).length > 0) {
+            return series;
+        }
+    }
+    const page = runtimeQueryCollectionData(queryResult);
+    const rows = (page?.items ?? []);
+    if (rows.length === 0) {
+        return {};
+    }
+    const firstRow = rows[0] ?? {};
+    const keys = Object.keys(firstRow);
+    const xField = mapping?.xField ?? keys[0] ?? 'x';
+    const yFieldsRaw = mapping?.yFields;
+    const yField = Array.isArray(yFieldsRaw)
+        ? yFieldsRaw[0]
+        : yFieldsRaw
+            ? String(yFieldsRaw)
+            : (keys[1] ?? 'value');
+    const chartData = {};
+    for (const row of rows) {
+        const key = String(row[xField] ?? '');
+        if (!key) {
+            continue;
+        }
+        const value = Number(row[yField] ?? 0);
+        if (Number.isFinite(value)) {
+            chartData[key] = value;
+        }
+    }
+    return chartData;
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Command -----
+/** Opens a report in a results-only popup. Pass `runId` to show a frozen generation run. */
+class AXPOpenReportInPopupCommand {
+    constructor() {
+        //#region ----- Services & Dependencies -----
+        this.popupService = inject(AXPopupService);
+        this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.translate = inject(AXTranslationService);
+        this.reportViewerService = inject(AXPReportViewerService);
+        this.inboxConnector = inject(AXPInAppInboxConnectorService, { optional: true });
+    }
+    //#endregion
+    //#region ----- Command Implementation -----
+    async execute(input) {
+        const rowData = this.resolveRowData(input);
+        const options = await this.resolveOptions(input, rowData);
+        if (!options.reportId) {
+            return {
+                success: false,
+                message: {
+                    text: await this.translate.translateAsync('@report-management:report-viewer.messages.error.invalid-popup-target'),
+                },
+            };
+        }
+        const runId = typeof options.runId === 'string' ? options.runId.trim() : '';
+        if (runId) {
+            await this.dismissReportGenerationInboxNotification(runId);
+        }
+        const popupTitle = await this.resolvePopupTitle(options, rowData, runId);
+        const parameters = resolveReportParameterValues(options.parameters);
+        const comp = (await import('./acorex-platform-module-report-management-client-report-popup-viewer.component-BJq1BeUz.mjs')).AXPReportPopupViewerComponent;
+        this.popupService.open(comp, {
+            title: popupTitle,
+            size: 'lg',
+            maximizable: true,
+            data: {
+                reportId: options.reportId,
+                layoutId: options.layoutId,
+                runId,
+                parameters,
+                hideColumnFields: options.hideColumnFields ?? [],
+            },
+        });
+        return {
+            success: true,
+            kind: 'object',
+            data: undefined,
+            metadata: { refresh: false },
+        };
+    }
+    //#endregion
+    //#region ----- Helpers -----
+    resolveRowData(input) {
+        const ctx = input;
+        if (ctx?.data && typeof ctx.data === 'object') {
+            return ctx.data;
+        }
+        if (input['data'] &&
+            typeof input['data'] === 'object') {
+            return input['data'];
+        }
+        return input;
+    }
+    async resolveOptions(input, rowData) {
+        const typedInput = input;
+        const rawOptions = {
+            reportId: typedInput.reportId,
+            layoutId: typedInput.layoutId,
+            runId: typedInput.runId,
+            title: typedInput.title,
+            parameters: typedInput.parameters,
+            hideColumnFields: typedInput.hideColumnFields,
+            ...(typedInput.options ?? {}),
+        };
+        const scope = {
+            context: {
+                eval: (path) => get(rowData, path),
+            },
+        };
+        return (await this.expressionEvaluator.evaluate(rawOptions, scope));
+    }
+    async resolvePopupTitle(options, rowData, runId) {
+        let baseTitle = await this.resolveExplicitPopupTitle(options.title, rowData);
+        if (!baseTitle && options.reportId) {
+            const report = await this.reportViewerService.getReportById(options.reportId);
+            if (report?.title) {
+                baseTitle =
+                    this.translate.resolve(report.title) ||
+                        resolveMultiLanguageString(report.title, this.translate.getActiveLang() || 'en-US') ||
+                        '';
+            }
+        }
+        if (!baseTitle) {
+            baseTitle = await this.translate.translateAsync('@report-management:report-viewer.components.report-popup-viewer.title');
+        }
+        if (!runId) {
+            return baseTitle;
+        }
+        return this.translate.translateAsync('@report-management:report-viewer.components.report-popup-viewer.generated-title', { params: { title: baseTitle } });
+    }
+    async resolveExplicitPopupTitle(title, rowData) {
+        if (title && typeof title === 'object') {
+            const resolved = this.translate.resolve(title);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        if (!isString(title) || !title.trim()) {
+            return '';
+        }
+        const scope = {
+            context: {
+                eval: (path) => get(rowData, path),
+            },
+        };
+        const evaluated = await this.expressionEvaluator.evaluate(title, scope);
+        return isString(evaluated) ? evaluated : title;
+    }
+    async dismissReportGenerationInboxNotification(runId) {
+        if (!this.inboxConnector) {
+            return;
+        }
+        try {
+            await this.inboxConnector.dismissByCorrelationId(buildReportGenerationNotificationCorrelationId(runId));
+        }
+        catch {
+            // Best-effort — opening the report should still proceed.
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPOpenReportInPopupCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPOpenReportInPopupCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPOpenReportInPopupCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var openReportInPopup_command = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPOpenReportInPopupCommand: AXPOpenReportInPopupCommand
+});
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXPReportViewerService as A, ENTITY_REPORTS_PAGE_COMPONENT_KEY as E, OPEN_REPORT_IN_POPUP_COMMAND as O, AXPOpenReportViewerCommand as a, collectReportParameterDefaults as b, convertContextDataToFilterClause as c, queryResultToChartSeries as d, AXLineChartReportMapper as e, AXPieChartReportMapper as f, AXBarChartReportMapper as g, bindingShowsOnPage as h, buildOpenInPopupCommandOptions as i, resolveBindingTitle as j, resolveBindingDescription as k, AXMPermissionDefinitionProvider as l, AXMReportManagementModule as m, AXPOpenReportInPopupCommand as n, queryResultToPdfSource as q, resolveReportFilterDefaultValue as r };
+//# sourceMappingURL=acorex-platform-module-report-management-client-acorex-platform-module-report-management-client-D5dCG62j.mjs.map