@acorex-platform/module-report-management-client 0.0.18 → 0.0.24

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

@@ -0,0 +1,4232 @@
+import { AXPExpressionEvaluatorService, AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, provideLazyProvider, applySystemActionDefault, AXPDeviceService } from '@acorex-platform/framework-client/core';
+import { RootConfig, AXPInsightsReportingPermissionKeys, AXPReportManagementMenuKeys, AXPReportManagementFeatureKeys, AXMReportManagementQueryKeys, AXMReportManagementCommandKeys } from '@acorex-platform/module-report-management-client/contracts';
+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, AXPStateMessageComponent, AXPTextCommandColumnComponent, AXPThemeLayoutStartSideComponent, AXPThemeLayoutHeaderComponent, AXPThemeLayoutBlockComponent, AXPThemeLayoutFooterComponent } 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, Injector, NgModule, computed, effect, untracked, signal, ChangeDetectionStrategy, Component, ViewEncapsulation, viewChild, DestroyRef, input } from '@angular/core';
+import { ROUTES, ActivatedRoute } from '@angular/router';
+import { AXPTabNavigationService, AXPBackgroundOperationHandler, AXP_BACKGROUND_OPERATION_HANDLERS, AXP_PROTECTED_ROUTE_GUARDS, AXP_MENU_PROVIDER, AXPSettingsService, commandMessageTextForError, AXPCommonSettings } from '@acorex-platform/framework-client/common';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPQueryService, AXPRuntimeModule, provideCommandSetups, AXPCommandService } from '@acorex-platform/framework-client/runtime';
+import { AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { get, isString } from 'lodash-es';
+import { AXPopupService } from '@acorex/components/popup';
+import { resolveMultiLanguageString, runtimeQueryPayloadData, runtimeQueryObjectData, runtimeQueryCollectionData, AXPPlatformScope, AXPWidgetsList, getSystemActions } from '@acorex-platform/framework-shared/core';
+import * as i1 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { AXBadgeModule } from '@acorex/components/badge';
+import * as i1$2 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i4 from '@acorex/components/check-box';
+import { AXCheckBoxModule } from '@acorex/components/check-box';
+import * as i2$3 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import { AXLoadingModule } from '@acorex/components/loading';
+import { AXLoadingDialogService, AXLoadingDialogModule } from '@acorex/components/loading-dialog';
+import { AXUnsubscriber } from '@acorex/core/utils';
+import { AXPLayoutRendererComponent } from '@acorex-platform/framework-client/layout/builder';
+import { AXPPageLayoutBaseComponent, AXPPageLayoutComponent, AXPPageLayoutBase } from '@acorex-platform/framework-client/layout/views';
+import { AXPLayoutThemeService } from '@acorex-platform/framework-client/themes/shared';
+import * as i2 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i2$2 from '@angular/forms';
+import { FormsModule } from '@angular/forms';
+import { Subscription, combineLatest } from 'rxjs';
+import { AXPPageStatus } from '@acorex-platform/framework-shared/widget-core';
+import { AXLocaleService } from '@acorex/core/locale';
+import * as i2$1 from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPWidgetRegistryService, AXPWidgetCoreModule } from '@acorex-platform/framework-client/layout/widget-core';
+import { AXToastService } from '@acorex/components/toast';
+import { signalStore, withState, withComputed, withMethods, patchState, withHooks } from '@ngrx/signals';
+import { set } from 'lodash';
+import { AXBarChartComponent } from '@acorex/charts/bar-chart';
+import { AXChartLegendComponent } from '@acorex/charts/chart-legend';
+import { AXDonutChartComponent } from '@acorex/charts/donut-chart';
+import { AXLineChartComponent } from '@acorex/charts/line-chart';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i1$1 from '@acorex/components/data-table';
+import { AXDataTableModule } from '@acorex/components/data-table';
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+import { AXDataSource } from '@acorex/cdk/common';
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Report Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const ReportManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'platform',
+    domain: 'data',
+    required: true,
+    // Module dependencies (optional)
+};
+//#endregion
+
+//#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 ----- 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$1 = '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
+
+//#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);
+    }
+    //#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() : '';
+        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-B9msMMod.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;
+    }
+    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
+});
+
+//#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);
+    }
+    //#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 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 runId = typeof options.runId === 'string' ? options.runId.trim() : '';
+        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 -----
+    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.openPopup = inject(AXPOpenReportInPopupCommand);
+        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.openPopup.execute({ reportId: request.reportId, runId: request.id });
+            return;
+        }
+        await this.openViewer.execute({ reportId: request.reportId });
+    }
+    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,
+];
+
+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: () => Promise.resolve().then(function () { return reportViewerPage_component; }).then((c) => c.AXPReportViewerPageComponent),
+                    data: { reuse: true },
+                },
+                {
+                    path: '',
+                    loadComponent: () => Promise.resolve().then(function () { return reportViewerPage_component; }).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]),
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: ReportManagementManifest,
+                multi: true,
+            },
+            // 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,
+            },
+            ...AXM_REPORT_GENERATION_BACKGROUND_OPERATION_HANDLERS,
+            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-C6tJPxri.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]),
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: ReportManagementManifest,
+                            multi: true,
+                        },
+                        // 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,
+                        },
+                        ...AXM_REPORT_GENERATION_BACKGROUND_OPERATION_HANDLERS,
+                        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-C6tJPxri.mjs').then((m) => m.AXMEntityReportsPageComponentProvider)),
+                    ],
+                }]
+        }] });
+
+//#region ----   Report Viewer User Settings Service   ----
+class AXPReportViewerUserSettingsService {
+    constructor() {
+        this.settingsService = inject(AXPSettingsService);
+    }
+    getSettingKey(reportId) {
+        return `ReportManagement:Report:${reportId}`;
+    }
+    async load(reportId) {
+        const stored = await this.settingsService.get(this.getSettingKey(reportId));
+        return stored ?? null;
+    }
+    getTableLayoutState(settings, layoutId) {
+        return settings?.layouts?.[layoutId]?.table;
+    }
+    async saveActiveLayoutId(reportId, layoutId) {
+        await this.patch(reportId, (prev) => ({
+            ...prev,
+            activeLayoutId: layoutId,
+        }));
+    }
+    async saveTableColumnOrder(reportId, layoutId, columns) {
+        await this.patchTable(reportId, layoutId, (table) => ({
+            ...table,
+            columns,
+        }));
+    }
+    async saveTableColumnWidth(reportId, layoutId, field, width, baseColumns) {
+        const columns = baseColumns.map((col) => col.field === field ? { ...col, width } : col);
+        await this.saveTableColumnOrder(reportId, layoutId, columns);
+    }
+    async saveTableSorts(reportId, layoutId, sorts) {
+        await this.patchTable(reportId, layoutId, (table) => ({
+            ...table,
+            sorts,
+        }));
+    }
+    async saveTablePageSize(reportId, layoutId, pageSize) {
+        await this.patchTable(reportId, layoutId, (table) => ({
+            ...table,
+            pageSize,
+        }));
+    }
+    async patch(reportId, updateFn) {
+        await this.settingsService.scope(AXPPlatformScope.User).update(this.getSettingKey(reportId), (prev) => {
+            const base = (prev && typeof prev === 'object' ? prev : {});
+            return updateFn(base);
+        });
+    }
+    async patchTable(reportId, layoutId, updateFn) {
+        await this.patch(reportId, (prev) => {
+            const next = { ...prev };
+            const currentTable = prev.layouts?.[layoutId]?.table ?? {};
+            const updatedTable = updateFn(currentTable);
+            set(next, `layouts.${layoutId}.table`, updatedTable);
+            return next;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerUserSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerUserSettingsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerUserSettingsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ----   Constants   ----
+const OPEN_REPORT_IN_POPUP_COMMAND = 'ReportManagement.Report:OpenInPopup';
+//#endregion
+//#region ----   Row Action Builder   ----
+/**
+ * Builds table row actions from declarative group-by drill-down definitions.
+ * Skips row commands when linked display columns are used.
+ */
+function buildDrillRowActionsFromGroupBy(definitions, currentReportId) {
+    if (!definitions?.length || !currentReportId || hasGroupByDrillLinks(definitions)) {
+        return [];
+    }
+    const hasExplicitDefault = definitions.some((definition) => definition.default);
+    return definitions.map((definition, index) => {
+        const isDefault = definition.default ?? (!hasExplicitDefault && index === 0);
+        return {
+            title: definition.title ?? 'View',
+            command: {
+                name: OPEN_REPORT_IN_POPUP_COMMAND,
+                options: buildDrillCommandOptions(definition, currentReportId),
+            },
+            type: 'view',
+            priority: definition.priority ?? 'primary',
+            default: isDefault,
+            iconOnly: false,
+        };
+    });
+}
+//#endregion
+//#region ----   Drill Link Columns   ----
+/**
+ * Whether group-by definitions use linked display columns instead of row command actions.
+ */
+function hasGroupByDrillLinks(definitions) {
+    return definitions?.some((definition) => isGroupByDrillLinkDefinition(definition)) ?? false;
+}
+function isGroupByDrillLinkDefinition(definition) {
+    return Boolean(definition.displayField) && definition.linkDisplay !== false;
+}
+function findGroupByDefinitionForDisplayField(definitions, field) {
+    return definitions?.find((definition) => definition.displayField === field && isGroupByDrillLinkDefinition(definition));
+}
+function buildGroupByDrillCommandOptions(definition, currentReportId) {
+    return buildDrillCommandOptions(definition, currentReportId);
+}
+function resolveGroupByDrillLinkFields(definitions) {
+    if (!definitions?.length) {
+        return [];
+    }
+    return definitions
+        .filter((definition) => isGroupByDrillLinkDefinition(definition))
+        .map((definition) => definition.displayField)
+        .filter(Boolean);
+}
+//#endregion
+//#region ----   Helpers   ----
+function buildDrillCommandOptions(definition, currentReportId) {
+    const drillDown = definition.drillDown;
+    const reportId = drillDown.reportId ?? currentReportId;
+    return {
+        reportId,
+        layoutId: drillDown.layoutId,
+        title: resolveDrillTitle(definition, drillDown.title),
+        parameters: mapDrillParameters(drillDown.parameters),
+        hideColumnFields: resolveDrillHideColumnFields(definition),
+    };
+}
+function resolveDrillHideColumnFields(definition) {
+    const fields = new Set(definition.fields);
+    if (definition.displayField) {
+        fields.add(definition.displayField);
+    }
+    return [...fields];
+}
+function resolveDrillTitle(definition, explicitTitle) {
+    if (explicitTitle) {
+        return explicitTitle;
+    }
+    if (definition.displayField) {
+        return `{{ context.eval('${definition.displayField}') }}`;
+    }
+    return undefined;
+}
+function mapDrillParameters(parameters) {
+    if (!parameters) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(parameters).map(([parameterKey, rowField]) => [
+        parameterKey,
+        toRowExpression(rowField),
+    ]));
+}
+function toRowExpression(value) {
+    const trimmed = value.trim();
+    if (trimmed.includes('{{') || trimmed.includes('context.eval')) {
+        return value;
+    }
+    return `{{ context.eval('${value}') }}`;
+}
+//#endregion
+
+/** Infers a column display widget when the report definition omits `widget.type`. */
+const NUMERIC_COLUMN_FIELD_PATTERN = /(?:count|total|average|avg|min|max|price|value|amount|quantity|number|year|month|quarter|experience|rate|percent|score|age|duration|hours?|days?)$/i;
+function buildReportTableColumns(definitionColumns, savedColumns) {
+    const base = definitionColumns
+        ?.filter((col) => col.visible !== false)
+        .map((col) => mapDefinitionColumn(col)) ?? [];
+    return applySavedColumnLayout(base, savedColumns);
+}
+/**
+ * Builds columns and evaluates `visible` expressions (`permission.check` / `feature.check`).
+ */
+async function buildReportTableColumnsAsync(definitionColumns, savedColumns, expressionEvaluator) {
+    const visibleColumns = [];
+    for (const col of definitionColumns ?? []) {
+        if (await isReportColumnVisible(col.visible, expressionEvaluator)) {
+            visibleColumns.push(col);
+        }
+    }
+    const base = visibleColumns.map((col) => mapDefinitionColumn(col));
+    return applySavedColumnLayout(base, savedColumns);
+}
+async function isReportColumnVisible(visible, expressionEvaluator) {
+    if (visible === false) {
+        return false;
+    }
+    if (visible === undefined || visible === true) {
+        return true;
+    }
+    if (typeof visible === 'string' && expressionEvaluator.isExpression(visible)) {
+        try {
+            return Boolean(await expressionEvaluator.evaluate(visible));
+        }
+        catch {
+            return true;
+        }
+    }
+    return Boolean(visible);
+}
+function applySavedColumnLayout(base, savedColumns) {
+    if (!savedColumns?.length) {
+        return base;
+    }
+    const widthMap = new Map(savedColumns.map((col) => [col.field, col.width]));
+    const orderIndex = new Map(savedColumns.map((col, index) => [col.field, index]));
+    return [...base]
+        .map((col) => {
+        const savedWidth = widthMap.get(col.field);
+        const resolvedWidth = typeof savedWidth === 'number' ? savedWidth : parseColumnResizeWidth(savedWidth) ?? col.width;
+        return {
+            ...col,
+            width: resolvedWidth,
+        };
+    })
+        .sort((a, b) => {
+        const aIndex = orderIndex.get(a.field) ?? Number.MAX_SAFE_INTEGER;
+        const bIndex = orderIndex.get(b.field) ?? Number.MAX_SAFE_INTEGER;
+        return aIndex - bIndex;
+    });
+}
+function toColumnUserState(columns) {
+    return columns.map((col) => ({
+        field: col.field,
+        width: typeof col.width === 'number' ? col.width : parseColumnResizeWidth(col.width) ?? undefined,
+    }));
+}
+function inferReportColumnWidgetType(field) {
+    return NUMERIC_COLUMN_FIELD_PATTERN.test(field)
+        ? AXPWidgetsList.Editors.NumberBox
+        : AXPWidgetsList.Editors.TextBox;
+}
+function resolveColumnWidget(col) {
+    const path = col.widget?.path ?? col.field;
+    if (col.widget?.type) {
+        return { ...col.widget, path };
+    }
+    return {
+        type: inferReportColumnWidgetType(col.field),
+        path,
+    };
+}
+function mapDefinitionColumn(col) {
+    return {
+        field: col.field,
+        title: col.title || col.field,
+        width: col.width || 'auto',
+        visible: col.visible !== false,
+        align: col.align || 'left',
+        sortable: col.sortable === true,
+        pin: col.pin,
+        widget: resolveColumnWidget(col),
+    };
+}
+function parseColumnResizeWidth(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function resolveColumnFieldFromDataField(dataField) {
+    if (dataField.startsWith('col-')) {
+        return dataField.slice(4);
+    }
+    if (dataField.includes('-')) {
+        return dataField.split('-').slice(1).join('-');
+    }
+    return dataField;
+}
+function applyGroupByDrillLinksToColumns(columns, groupByDefinitions) {
+    if (!groupByDefinitions?.length) {
+        return columns;
+    }
+    const linkFields = new Set(groupByDefinitions
+        .filter((definition) => isGroupByDrillLinkDefinition(definition))
+        .map((definition) => definition.displayField)
+        .filter(Boolean));
+    if (linkFields.size === 0) {
+        return columns;
+    }
+    return columns.map((column) => {
+        if (!linkFields.has(column.field)) {
+            return column;
+        }
+        return {
+            ...column,
+            isGroupByDrillLink: true,
+            drillDisplayField: column.field,
+        };
+    });
+}
+//#endregion
+
+const AXPReportViewerViewModel = signalStore(withState(() => ({
+    reportDefinition: null,
+    currentLayout: null,
+    filterContext: {},
+    allowFetchData: false,
+    shouldExecuteReport: false,
+    executionRequestId: 0,
+    lastAppliedFilterContext: null, // Track last applied filters
+    hasBeenExecuted: false, // Track if report has been executed at least once
+    status: AXPPageStatus.Idle,
+    error: null,
+    showRowIndexColumn: false,
+    reportUserSettings: null,
+    runId: null,
+    frozen: false,
+    freeze: null,
+    backgroundQueued: false,
+    parametersReadonly: false,
+    selectedLayoutIds: [],
+})), withComputed((store, widgetRegistryService = inject(AXPWidgetRegistryService)) => ({
+    //#region ----   Layout Management   ----
+    availableLayouts: computed(() => {
+        const report = store.reportDefinition();
+        if (!report?.layouts)
+            return [];
+        const freeze = store.freeze();
+        const layouts = store.frozen() && freeze?.dataSources?.length
+            ? report.layouts.filter((layout) => freeze.dataSources.some((source) => source.layoutId === layout.id))
+            : report.layouts;
+        return layouts.map((layout) => ({
+            id: layout.id,
+            title: layout.title,
+            icon: layout.icon,
+            type: layout.layout.type,
+        }));
+    }),
+    defaultLayout: computed(() => {
+        const report = store.reportDefinition();
+        if (!report?.layouts?.length)
+            return null;
+        // Find layout marked as default, or use first layout
+        return report.layouts.find((l) => l.isDefault) || report.layouts[0];
+    }),
+    activeLayoutId: computed(() => store.currentLayout()?.id || null),
+    layoutType: computed(() => store.currentLayout()?.layout?.type || null),
+    //#endregion
+    //#region ----   Layout-Specific Configurations   ----
+    tableLayoutConfig: computed(() => {
+        const layout = store.currentLayout();
+        return layout?.layout?.type === 'table' ? layout.layout : null;
+    }),
+    chartLayoutConfig: computed(() => {
+        const layout = store.currentLayout();
+        return layout?.layout?.type === 'chart' ? layout.layout : null;
+    }),
+    pdfLayoutConfig: computed(() => {
+        const layout = store.currentLayout();
+        return layout?.layout?.type === 'pdf' ? layout.layout : null;
+    }),
+    //#endregion
+    //#region ----   State Indicators   ----
+    isLoading: computed(() => store.status() === AXPPageStatus.Processing),
+    isExecuting: computed(() => store.status() === AXPPageStatus.Submitting),
+    hasError: computed(() => store.error() !== null),
+    canExecute: computed(() => {
+        // Always allow execution if there's an error (to enable retry)
+        if (store.error() !== null) {
+            return true;
+        }
+        if ((store.reportDefinition()?.generation?.mode ?? 'interactive') === 'background') {
+            if (store.backgroundQueued()) {
+                return false;
+            }
+            return store.selectedLayoutIds().length > 0;
+        }
+        // Allow execution if there are unapplied filters
+        const currentContext = store.filterContext();
+        const lastApplied = store.lastAppliedFilterContext();
+        const hasBeenExecuted = store.hasBeenExecuted();
+        if (hasBeenExecuted && JSON.stringify(currentContext) !== JSON.stringify(lastApplied)) {
+            return true;
+        }
+        // Allow execution if report hasn't been executed yet
+        if (!hasBeenExecuted) {
+            return true;
+        }
+        // Otherwise, don't allow execution
+        return false;
+    }),
+    hasMultipleLayouts: computed(() => {
+        const report = store.reportDefinition();
+        const freeze = store.freeze();
+        if (store.frozen() && freeze?.dataSources?.length) {
+            return freeze.dataSources.length > 1;
+        }
+        return (report?.layouts?.length ?? 0) > 1;
+    }),
+    title: computed(() => store.reportDefinition()?.title ?? '@report-management:report-viewer.components.report-viewer.title'),
+    description: computed(() => store.reportDefinition()?.description ?? null),
+    //#endregion
+    //#region ----   Form Configuration   ----
+    formDefinition: computed(() => {
+        const report = store.reportDefinition();
+        if (!report || !report.parameterGroups) {
+            return { groups: [] };
+        }
+        const formDefinition = {
+            groups: report.parameterGroups.map((group) => ({
+                name: group.name,
+                title: group.title,
+                description: group.description,
+                parameters: group.parameters.map((param) => {
+                    const editorType = param.widget.type ?? '';
+                    const widget = widgetRegistryService.getOptional(editorType);
+                    const filterType = widget?.defaultFilterWidgetName ?? editorType;
+                    // date-time / text filter aliases do not mount reliably in report filter forms;
+                    // keep the editor widget and enable filterMode instead.
+                    const useEditorFilter = editorType === 'date-time-editor' ||
+                        filterType === 'datetime-filter' ||
+                        editorType === 'text-editor' ||
+                        filterType === 'string-filter';
+                    const widgetType = useEditorFilter ? editorType || filterType : filterType;
+                    const rawDefault = param.widget.defaultValue ?? param.widget.options?.['defaultValue'];
+                    const resolvedDefault = rawDefault === undefined ? undefined : resolveReportFilterDefaultValue(rawDefault);
+                    return {
+                        path: param.path,
+                        title: param.title,
+                        description: param.description,
+                        visible: param.visible,
+                        badge: `{{ filter.getTitle(context.eval("${param.path}.operation.type")) }}`,
+                        widget: {
+                            path: param.path,
+                            type: widgetType,
+                            ...(resolvedDefault !== undefined ? { defaultValue: resolvedDefault } : {}),
+                            options: {
+                                ...param.widget.options,
+                                clearButton: true,
+                                hasClearButton: true,
+                                ...(useEditorFilter ? { filterMode: true } : {}),
+                            },
+                            triggers: param.widget.triggers,
+                        }
+                    };
+                }),
+            })),
+        };
+        return formDefinition;
+    }),
+    //#endregion
+    //#region ----   Layout Type Detection   ----
+    isTableLayout: computed(() => store.currentLayout()?.layout?.type === 'table'),
+    isChartLayout: computed(() => store.currentLayout()?.layout?.type === 'chart'),
+    isPdfLayout: computed(() => store.currentLayout()?.layout?.type === 'pdf'),
+    //#endregion
+    //#region ----   Filter States   ----
+    hasUnappliedFilters: computed(() => {
+        const currentContext = store.filterContext();
+        const lastApplied = store.lastAppliedFilterContext();
+        const hasBeenExecuted = store.hasBeenExecuted();
+        // If report has never been executed, don't show unapplied filters warning
+        if (!hasBeenExecuted) {
+            return false;
+        }
+        // If no filters have been applied yet, return true
+        if (lastApplied === null) {
+            return true;
+        }
+        // Check if current filters are different from last applied filters
+        const currentKeys = Object.keys(currentContext);
+        const lastKeys = Object.keys(lastApplied);
+        if (currentKeys.length !== lastKeys.length) {
+            return true;
+        }
+        // Check if any values are different
+        for (const key of currentKeys) {
+            if (currentContext[key] !== lastApplied[key]) {
+                return true;
+            }
+        }
+        return false;
+    }),
+    //#endregion
+    //#region ----   Action States   ----
+    canSelectRows: computed(() => {
+        const layout = store.currentLayout();
+        return (layout?.layout?.type === 'table' &&
+            layout.layout.options?.selectable?.mode &&
+            layout.layout.options?.selectable?.mode !== 'none');
+    }),
+    tableLayoutUserSettings: computed(() => {
+        const settings = store.reportUserSettings();
+        const layoutId = store.currentLayout()?.id;
+        if (!settings || !layoutId) {
+            return null;
+        }
+        return settings.layouts?.[layoutId]?.table ?? null;
+    }),
+    reportId: computed(() => store.reportDefinition()?.id ?? null),
+    isFrozen: computed(() => store.frozen()),
+    isBackgroundQueued: computed(() => store.backgroundQueued()),
+    isBackgroundReportMode: computed(() => (store.reportDefinition()?.generation?.mode ?? 'interactive') === 'background'),
+    hasSelectedBackgroundLayouts: computed(() => store.selectedLayoutIds().length > 0),
+    areParametersReadonly: computed(() => store.parametersReadonly() || store.frozen()),
+    canSwitchLayout: computed(() => {
+        if (store.frozen() && (store.freeze()?.dataSources?.length ?? 0) <= 1) {
+            return false;
+        }
+        return (store.reportDefinition()?.layouts?.length ?? 0) > 1 && store.status() !== AXPPageStatus.Submitting;
+    }),
+    generationMode: computed(() => store.reportDefinition()?.generation?.mode ?? 'interactive'),
+    //#endregion
+})), withMethods((store, reportDefinitionService = inject(AXPReportViewerService), reportUserSettingsService = inject(AXPReportViewerUserSettingsService), queryService = inject(AXPQueryService), commandService = inject(AXPCommandService), toastService = inject(AXToastService), translationService = inject(AXTranslationService)) => {
+    let activeFetchCount = 0;
+    const generateInBackground = async () => {
+        const report = store.reportDefinition();
+        const isBackgroundMode = (report?.generation?.mode ?? 'interactive') === 'background';
+        const layoutIds = isBackgroundMode
+            ? store.selectedLayoutIds()
+            : store.currentLayout()
+                ? [store.currentLayout().id]
+                : [];
+        if (!report || layoutIds.length === 0) {
+            patchState(store, {
+                error: layoutIds.length === 0
+                    ? '@report-management:report-generation.errors.no-layouts-selected'
+                    : '@report-management:report-viewer.messages.error.report-or-layout-not-found',
+            });
+            return;
+        }
+        patchState(store, { status: AXPPageStatus.Submitting, error: null });
+        try {
+            const result = await commandService.executeRemote(AXMReportManagementCommandKeys.ReportGeneration.Create, {
+                reportId: report.id,
+                layoutIds,
+                layoutId: layoutIds[0],
+                parameters: store.filterContext(),
+                trigger: 'manual',
+            });
+            if (!result?.success) {
+                patchState(store, {
+                    status: AXPPageStatus.Error,
+                    error: commandMessageTextForError(result?.message?.text) ||
+                        '@report-management:report-generation.errors.create-failed',
+                });
+                return;
+            }
+            patchState(store, {
+                status: AXPPageStatus.Submitted,
+                backgroundQueued: true,
+                allowFetchData: false,
+                hasBeenExecuted: false,
+            });
+            toastService.show({
+                color: 'success',
+                title: await translationService.translateAsync('@report-management:report-generation.messages.queued-title'),
+                content: await translationService.translateAsync('@report-management:report-generation.messages.queued-body'),
+            });
+        }
+        catch (error) {
+            patchState(store, {
+                status: AXPPageStatus.Error,
+                error: error instanceof Error
+                    ? error.message
+                    : '@report-management:report-generation.errors.create-failed',
+            });
+        }
+    };
+    const executeReport = async () => {
+        try {
+            if (store.status() === AXPPageStatus.Processing ||
+                store.status() === AXPPageStatus.Submitting) {
+                return;
+            }
+            if (store.frozen()) {
+                patchState(store, {
+                    allowFetchData: true,
+                    shouldExecuteReport: true,
+                    executionRequestId: store.executionRequestId() + 1,
+                    hasBeenExecuted: true,
+                });
+                return;
+            }
+            const report = store.reportDefinition();
+            const layout = store.currentLayout();
+            if (!report || !layout) {
+                patchState(store, {
+                    error: '@report-management:report-viewer.messages.error.report-or-layout-not-found',
+                });
+                return;
+            }
+            if ((report.generation?.mode ?? 'interactive') === 'background') {
+                await generateInBackground();
+                return;
+            }
+            patchState(store, {
+                status: AXPPageStatus.Submitting,
+                error: null,
+                allowFetchData: true,
+                shouldExecuteReport: true,
+                executionRequestId: store.executionRequestId() + 1,
+                lastAppliedFilterContext: { ...store.filterContext() }, // Mark current filters as applied
+                hasBeenExecuted: true, // Mark that report has been executed at least once
+            });
+            patchState(store, {
+                status: AXPPageStatus.Submitted,
+                error: null,
+            });
+        }
+        catch (error) {
+            patchState(store, {
+                status: AXPPageStatus.Error,
+                error: error instanceof Error ? error.message : '@report-management:report-viewer.messages.error.unexpected-execution',
+            });
+        }
+    };
+    const buildSummaryFromLayout = (layoutDef) => {
+        const tableLayout = layoutDef.layout;
+        if (tableLayout?.type !== 'table' || !Array.isArray(tableLayout.summary)) {
+            return undefined;
+        }
+        const footer = tableLayout.summary.filter((s) => s.displayIn === 'reportFooter');
+        return footer.length > 0 ? footer : undefined;
+    };
+    const fetchData = async (query) => {
+        const report = store.reportDefinition();
+        const layout = store.currentLayout();
+        if (!report || !layout) {
+            return null;
+        }
+        if (store.frozen()) {
+            const freeze = store.freeze();
+            const layoutId = layout.id;
+            const source = freeze?.dataSources.find((item) => item.layoutId === layoutId) ?? freeze?.dataSources[0];
+            if (!source?.result) {
+                return null;
+            }
+            const collection = runtimeQueryCollectionData(source.result);
+            if (!collection) {
+                return source.result;
+            }
+            const skip = query?.skip ?? 0;
+            const take = query?.take ?? collection.items.length;
+            return {
+                ...source.result,
+                success: true,
+                kind: 'collection',
+                data: {
+                    ...collection,
+                    items: collection.items.slice(skip, skip + take),
+                },
+            };
+        }
+        if (activeFetchCount > 0) {
+            return null;
+        }
+        activeFetchCount++;
+        patchState(store, {
+            status: AXPPageStatus.Processing,
+            error: null,
+        });
+        let nextStatus = AXPPageStatus.Idle;
+        try {
+            const dataSource = layout.dataSource;
+            if (!dataSource || dataSource.type !== 'query' || !dataSource.name) {
+                nextStatus = AXPPageStatus.Error;
+                patchState(store, {
+                    error: '@report-management:report-viewer.messages.error.failed-to-execute',
+                });
+                return null;
+            }
+            const filterClause = convertContextDataToFilterClause(store.filterContext());
+            const runtimeSort = query?.sort?.length
+                ? query.sort.map((s) => ({
+                    name: s.field,
+                    dir: s.dir,
+                }))
+                : dataSource.sortFields;
+            const summary = buildSummaryFromLayout(layout);
+            const queryInput = {
+                skip: query?.skip ?? 0,
+                take: query?.take ?? null,
+                filter: filterClause,
+                ...(runtimeSort?.length
+                    ? {
+                        sort: runtimeSort.map((s) => ({
+                            field: s.name,
+                            dir: s.dir,
+                        })),
+                    }
+                    : {}),
+                ...(summary ? { summary } : {}),
+            };
+            const queryResult = await queryService.fetch(dataSource.name, queryInput);
+            if (!queryResult?.success) {
+                nextStatus = AXPPageStatus.Error;
+                patchState(store, {
+                    error: commandMessageTextForError(queryResult?.message?.text) ||
+                        '@report-management:report-viewer.messages.error.failed-to-execute',
+                });
+                return null;
+            }
+            return queryResult;
+        }
+        catch (error) {
+            nextStatus = AXPPageStatus.Error;
+            const message = error instanceof Error && error.message
+                ? error.message
+                : '@report-management:report-viewer.messages.error.failed-to-execute';
+            patchState(store, {
+                error: message,
+            });
+            console.error('Error executing report:', error);
+            return null;
+        }
+        finally {
+            activeFetchCount--;
+            patchState(store, {
+                status: nextStatus,
+            });
+        }
+    };
+    return {
+        //#region ----   Report Loading   ----
+        async loadReport(reportId) {
+            patchState(store, {
+                status: AXPPageStatus.Processing,
+                error: null,
+            });
+            try {
+                const report = await reportDefinitionService.getReportById(reportId);
+                if (report) {
+                    // Configure parameter widgets with proper paths
+                    report.parameterGroups.forEach((group) => {
+                        group.parameters.forEach((param) => {
+                            param.widget.path = param.path;
+                        });
+                    });
+                    const userSettings = await reportUserSettingsService.load(reportId);
+                    const defaultLayout = report.layouts.find((l) => l.isDefault) || report.layouts[0];
+                    const savedLayout = userSettings?.activeLayoutId
+                        ? report.layouts.find((l) => l.id === userSettings.activeLayoutId)
+                        : undefined;
+                    patchState(store, {
+                        reportDefinition: report,
+                        currentLayout: savedLayout ?? defaultLayout,
+                        filterContext: collectReportParameterDefaults(report.parameterGroups),
+                        allowFetchData: false,
+                        hasBeenExecuted: false,
+                        executionRequestId: 0,
+                        reportUserSettings: userSettings,
+                        runId: null,
+                        frozen: false,
+                        freeze: null,
+                        backgroundQueued: false,
+                        parametersReadonly: false,
+                        selectedLayoutIds: report.layouts.map((layout) => layout.id),
+                    });
+                }
+            }
+            catch (error) {
+                patchState(store, {
+                    error: '@report-management:report-viewer.messages.error.failed-to-load',
+                });
+                console.error('Error loading report:', error);
+            }
+            finally {
+                patchState(store, {
+                    status: AXPPageStatus.Idle,
+                });
+            }
+        },
+        //#endregion
+        //#region ----   Layout Management   ----
+        switchLayout(layoutId) {
+            const report = store.reportDefinition();
+            if (!report)
+                return;
+            const layout = report.layouts.find((l) => l.id === layoutId);
+            if (layout) {
+                patchState(store, {
+                    currentLayout: layout,
+                    reportUserSettings: {
+                        ...(store.reportUserSettings() ?? {}),
+                        activeLayoutId: layoutId,
+                    },
+                });
+                void reportUserSettingsService.saveActiveLayoutId(report.id, layoutId);
+            }
+        },
+        isBackgroundLayoutSelected(layoutId) {
+            return store.selectedLayoutIds().includes(layoutId);
+        },
+        setBackgroundLayoutSelected(layoutId, selected) {
+            const current = store.selectedLayoutIds();
+            if (selected) {
+                if (current.includes(layoutId)) {
+                    return;
+                }
+                patchState(store, { selectedLayoutIds: [...current, layoutId] });
+                return;
+            }
+            patchState(store, {
+                selectedLayoutIds: current.filter((id) => id !== layoutId),
+            });
+        },
+        async saveTableColumnOrder(columns) {
+            const reportId = store.reportDefinition()?.id;
+            const layoutId = store.currentLayout()?.id;
+            if (!reportId || !layoutId) {
+                return;
+            }
+            await reportUserSettingsService.saveTableColumnOrder(reportId, layoutId, toColumnUserState(columns));
+            patchState(store, {
+                reportUserSettings: mergeTableColumnsIntoSettings(store.reportUserSettings(), layoutId, toColumnUserState(columns)),
+            });
+        },
+        async saveTableColumnWidth(field, width, columns) {
+            const reportId = store.reportDefinition()?.id;
+            const layoutId = store.currentLayout()?.id;
+            if (!reportId || !layoutId) {
+                return;
+            }
+            const columnState = toColumnUserState(columns);
+            await reportUserSettingsService.saveTableColumnWidth(reportId, layoutId, field, width, columnState);
+            patchState(store, {
+                reportUserSettings: mergeTableColumnsIntoSettings(store.reportUserSettings(), layoutId, columnState),
+            });
+        },
+        async saveTableSorts(sorts) {
+            const reportId = store.reportDefinition()?.id;
+            const layoutId = store.currentLayout()?.id;
+            if (!reportId || !layoutId) {
+                return;
+            }
+            await reportUserSettingsService.saveTableSorts(reportId, layoutId, sorts);
+            patchState(store, {
+                reportUserSettings: mergeTableSortsIntoSettings(store.reportUserSettings(), layoutId, sorts),
+            });
+        },
+        async saveTablePageSize(pageSize) {
+            const reportId = store.reportDefinition()?.id;
+            const layoutId = store.currentLayout()?.id;
+            if (!reportId || !layoutId) {
+                return;
+            }
+            await reportUserSettingsService.saveTablePageSize(reportId, layoutId, pageSize);
+            patchState(store, {
+                reportUserSettings: mergeTablePageSizeIntoSettings(store.reportUserSettings(), layoutId, pageSize),
+            });
+        },
+        //#endregion
+        //#region ----   Data Execution   ----
+        executeReport,
+        fetchData,
+        generateInBackground,
+        nudgeFetch() {
+            if (!store.allowFetchData()) {
+                return;
+            }
+            patchState(store, { executionRequestId: store.executionRequestId() + 1 });
+        },
+        async loadFrozenRun(runId) {
+            patchState(store, { status: AXPPageStatus.Processing, error: null });
+            try {
+                const result = await queryService.fetch(AXMReportManagementQueryKeys.ReportGeneration.GetViewerFreeze, { id: runId });
+                const freeze = runtimeQueryPayloadData(result);
+                if (!result?.success || !freeze) {
+                    patchState(store, {
+                        error: commandMessageTextForError(result?.message?.text) ||
+                            '@report-management:report-generation.errors.freeze-not-found',
+                    });
+                    return;
+                }
+                let report = store.reportDefinition();
+                if (freeze.definition) {
+                    report = {
+                        id: freeze.reportId,
+                        title: freeze.definition.title,
+                        categoryIds: report?.categoryIds ?? [],
+                        parameterGroups: report?.parameterGroups ?? [],
+                        layouts: freeze.definition.layouts,
+                        defaultLayoutId: freeze.definition.defaultLayoutId,
+                        generation: report?.generation,
+                    };
+                }
+                else if (!report) {
+                    report = (await reportDefinitionService.getReportById(freeze.reportId)) ?? null;
+                }
+                if (!report) {
+                    patchState(store, {
+                        error: '@report-management:report-viewer.messages.error.failed-to-load',
+                    });
+                    return;
+                }
+                const defaultLayout = report.layouts.find((layout) => layout.id === freeze.definition?.defaultLayoutId) ||
+                    report.layouts.find((layout) => layout.id === freeze.dataSources[0]?.layoutId) ||
+                    report.layouts[0];
+                patchState(store, {
+                    reportDefinition: report,
+                    currentLayout: defaultLayout,
+                    filterContext: freeze.parameters ?? {},
+                    lastAppliedFilterContext: freeze.parameters ?? {},
+                    allowFetchData: true,
+                    shouldExecuteReport: true,
+                    hasBeenExecuted: true,
+                    executionRequestId: store.executionRequestId() + 1,
+                    runId,
+                    frozen: true,
+                    freeze,
+                    backgroundQueued: false,
+                    parametersReadonly: true,
+                    status: AXPPageStatus.Idle,
+                });
+            }
+            catch (error) {
+                patchState(store, {
+                    error: error instanceof Error
+                        ? error.message
+                        : '@report-management:report-generation.errors.freeze-not-found',
+                });
+            }
+            finally {
+                patchState(store, { status: AXPPageStatus.Idle });
+            }
+        },
+        //#endregion
+        //#region ----   Drill View   ----
+        /**
+         * Applies the same layout in drill-down mode: hides group-by columns, keeps summary and data source.
+         */
+        applyDrillView(options) {
+            const layout = store.currentLayout();
+            if (!layout || layout.layout.type !== 'table') {
+                return;
+            }
+            const tableLayout = layout.layout;
+            const hiddenFields = new Set(options.hideColumnFields);
+            const nextTableLayout = {
+                ...tableLayout,
+                columns: tableLayout.columns.map((column) => hiddenFields.has(column.field) ? { ...column, visible: false } : column),
+                groupBy: undefined,
+                actions: [],
+            };
+            patchState(store, {
+                currentLayout: {
+                    ...layout,
+                    layout: nextTableLayout,
+                },
+            });
+        },
+        //#endregion
+        //#region ----   Filter Management   ----
+        updateFilterContext(context) {
+            patchState(store, {
+                filterContext: { ...store.filterContext(), ...context },
+                shouldExecuteReport: false, // Reset execution flag when filters change
+            });
+        },
+        clearFilters() {
+            patchState(store, {
+                allowFetchData: false,
+                shouldExecuteReport: false,
+                filterContext: collectReportParameterDefaults(store.reportDefinition()?.parameterGroups),
+                lastAppliedFilterContext: null, // Reset applied filters when clearing
+                hasBeenExecuted: false, // Reset execution state when clearing filters
+            });
+        },
+        resetFilters() {
+            patchState(store, {
+                allowFetchData: false,
+            });
+        },
+        //#endregion
+        //#region ----   Export Management   ----
+        async exportReport(format) {
+            const layout = store.currentLayout();
+            if (!layout?.export) {
+                console.warn('@report-management:report-viewer.messages.warnings.export-not-configured');
+                return;
+            }
+            try {
+                // Export logic would go here
+                // This would typically call a different command for export
+                console.log(`Exporting report in ${format} format`);
+            }
+            catch (error) {
+                console.error('Error exporting report:', error);
+            }
+        },
+        //#endregion
+        //#region ----   Utility Methods   ----
+        refresh() {
+            return executeReport();
+        },
+        clearError() {
+            patchState(store, {
+                error: null,
+            });
+        },
+        clearExecutionState() {
+            patchState(store, {
+                hasBeenExecuted: false,
+                allowFetchData: false,
+                shouldExecuteReport: false,
+                executionRequestId: 0,
+            });
+        },
+        cancel() {
+            patchState(store, {
+                status: AXPPageStatus.Idle,
+                hasBeenExecuted: false,
+                error: null,
+            });
+            //TODO: Cancel the report execution
+        },
+        reset() {
+            patchState(store, {
+                reportDefinition: null,
+                currentLayout: null,
+                filterContext: {},
+                allowFetchData: false,
+                shouldExecuteReport: false,
+                executionRequestId: 0,
+                lastAppliedFilterContext: null,
+                hasBeenExecuted: false,
+                status: AXPPageStatus.Idle,
+                error: null,
+                reportUserSettings: null,
+                runId: null,
+                frozen: false,
+                freeze: null,
+                backgroundQueued: false,
+                parametersReadonly: false,
+            });
+        },
+        //#endregion
+    };
+}), withHooks((store, translationService = inject(AXTranslationService), localeService = inject(AXLocaleService), settingsService = inject(AXPSettingsService)) => {
+    const settingSubs = new Subscription();
+    const syncShowRowIndexColumn = async () => {
+        try {
+            const value = await settingsService.get(AXPCommonSettings.ShowRowIndexColumn);
+            patchState(store, { showRowIndexColumn: value ?? false });
+        }
+        catch {
+            patchState(store, { showRowIndexColumn: false });
+        }
+    };
+    return {
+        async onInit() {
+            translationService.langChanges$.subscribe(() => {
+                // Handle language change if needed
+            });
+            localeService.profileChanged$.subscribe(() => {
+                // Handle locale change if needed
+            });
+            void syncShowRowIndexColumn();
+            settingSubs.add(settingsService.onLoaded.subscribe(() => void syncShowRowIndexColumn()));
+            settingSubs.add(settingsService.onChanged.subscribe(() => void syncShowRowIndexColumn()));
+        },
+        onDestroy() {
+            settingSubs.unsubscribe();
+        },
+    };
+}));
+//#region ----   Settings Merge Helpers   ----
+function mergeTableColumnsIntoSettings(settings, layoutId, columns) {
+    const base = settings ?? {};
+    return {
+        ...base,
+        layouts: {
+            ...base.layouts,
+            [layoutId]: {
+                ...base.layouts?.[layoutId],
+                table: {
+                    ...base.layouts?.[layoutId]?.table,
+                    columns,
+                },
+            },
+        },
+    };
+}
+function mergeTableSortsIntoSettings(settings, layoutId, sorts) {
+    const base = settings ?? {};
+    return {
+        ...base,
+        layouts: {
+            ...base.layouts,
+            [layoutId]: {
+                ...base.layouts?.[layoutId],
+                table: {
+                    ...base.layouts?.[layoutId]?.table,
+                    sorts,
+                },
+            },
+        },
+    };
+}
+function mergeTablePageSizeIntoSettings(settings, layoutId, pageSize) {
+    const base = settings ?? {};
+    return {
+        ...base,
+        layouts: {
+            ...base.layouts,
+            [layoutId]: {
+                ...base.layouts?.[layoutId],
+                table: {
+                    ...base.layouts?.[layoutId]?.table,
+                    pageSize,
+                },
+            },
+        },
+    };
+}
+//#endregion
+
+class AXPReportChartViewComponent {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.vm = inject(AXPReportViewerViewModel);
+        this.AXPPageStatus = AXPPageStatus;
+        //#endregion
+        //#region ----   Computed Properties   ----
+        /**
+         * Current chart layout configuration
+         */
+        this.chartLayout = computed(() => {
+            const layout = this.vm.currentLayout();
+            return layout?.layout.type === 'chart' ? layout.layout : null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "chartLayout" }] : /* istanbul ignore next */ []));
+        /**
+         * Chart configuration options
+         */
+        this.chartOptions = computed(() => {
+            const chartLayout = this.chartLayout();
+            return chartLayout?.options || null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "chartOptions" }] : /* istanbul ignore next */ []));
+        /**
+         * Chart type for rendering
+         */
+        this.chartType = computed(() => {
+            const options = this.chartOptions();
+            return options?.chartType || 'bar';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "chartType" }] : /* istanbul ignore next */ []));
+        /**
+         * Data mapping configuration
+         */
+        this.dataMapping = computed(() => {
+            const options = this.chartOptions();
+            return options?.dataMapping || null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "dataMapping" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Effects   ----
+        /**
+         * Effect to fetch chart data when conditions are met
+         */
+        this.#fetchData = effect(() => {
+            if (this.vm.allowFetchData() && this.vm.shouldExecuteReport() && this.chartOptions()) {
+                void untracked(() => this.vm.fetchData()).then((result) => {
+                    if (!result) {
+                        return;
+                    }
+                    const series = queryResultToChartSeries(result, this.dataMapping());
+                    const seriesColors = this.chartOptions()?.styling?.seriesColors;
+                    switch (this.chartType()) {
+                        case 'bar': {
+                            // Mapper returns flat bars for report series (not clustered).
+                            const bars = AXBarChartReportMapper(series);
+                            this.barChartData.set(applySeriesColors(bars, seriesColors));
+                            break;
+                        }
+                        case 'doughnut': {
+                            this.donutChartData.set(applySeriesColors(AXPieChartReportMapper(series), seriesColors));
+                            break;
+                        }
+                        case 'line':
+                        default: {
+                            this.lineChartData.set(AXLineChartReportMapper(series));
+                            break;
+                        }
+                    }
+                });
+            }
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#fetchData" }] : /* istanbul ignore next */ []));
+        this.legendOptions = signal({
+            mode: 'vertical',
+            showValues: true,
+            showPercentage: true,
+            interactive: true,
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "legendOptions" }] : /* istanbul ignore next */ []));
+        this.barChartData = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "barChartData" }] : /* istanbul ignore next */ []));
+        this.barChartOptions = signal({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "barChartOptions" }] : /* istanbul ignore next */ []));
+        this.donutChartData = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "donutChartData" }] : /* istanbul ignore next */ []));
+        this.donutChartOptions = signal({
+            totalLabel: 'Total',
+            showTooltip: true,
+            showDataLabels: false,
+            donutWidth: 28,
+            cornerRadius: 4,
+            animationDuration: 800,
+            animationEasing: 'cubic-out',
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "donutChartOptions" }] : /* istanbul ignore next */ []));
+        this.lineChartData = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "lineChartData" }] : /* istanbul ignore next */ []));
+        this.lineChartOptions = signal({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "lineChartOptions" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if bar chart data has items
+         */
+        this.hasBarChartData = computed(() => {
+            const data = this.barChartData();
+            return Array.isArray(data) && data.length > 0;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasBarChartData" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if donut chart data has items
+         */
+        this.hasDonutChartData = computed(() => {
+            const data = this.donutChartData();
+            return Array.isArray(data) && data.length > 0;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasDonutChartData" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if line chart data has items
+         */
+        this.hasLineChartData = computed(() => {
+            const data = this.lineChartData();
+            return Array.isArray(data) && data.length > 0;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasLineChartData" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if chart has any data (for any chart type)
+         */
+        this.hasChartData = computed(() => {
+            return this.hasBarChartData() || this.hasDonutChartData() || this.hasLineChartData();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasChartData" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if report has been executed and has no data
+         */
+        this.showNoDataState = computed(() => {
+            return this.vm.hasBeenExecuted() && !this.hasChartData();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "showNoDataState" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----   Effects   ----
+    /**
+     * Effect to fetch chart data when conditions are met
+     */
+    #fetchData;
+    //#endregion
+    //#region ----   Helper Methods   ----
+    /**
+     * Check if chart is ready to render
+     */
+    isChartReady() {
+        return !!(this.chartOptions() && this.dataMapping());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportChartViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPReportChartViewComponent, isStandalone: true, selector: "axp-report-chart-view", host: { classAttribute: "axp-report-chart-view w-full h-full flex flex-col" }, ngImport: i0, template: "<ng-container *translate=\"let t\">\n  @if (vm.status() === AXPPageStatus.Processing) {\n    <!-- Loading State -->\n    <div class=\"__loading flex flex-col items-center justify-center h-full gap-6 p-8\">\n      <div class=\"spinner spin w-10 h-10\"></div>\n      <div class=\"__loading-text text-sm opacity-70\">\n        {{ t('@report-management:report-viewer.components.chart.messages.loading') | async }}\n      </div>\n    </div>\n  } @else if (vm.status() === AXPPageStatus.Error) {\n    <!-- Error State -->\n    <axp-state-message\n      mode=\"error\"\n      icon=\"fa-light fa-exclamation-triangle\"\n      [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n      [description]=\"vm.error() || '@report-management:report-viewer.messages.error.fetch-description'\"\n    >\n    </axp-state-message>\n  } @else if (isChartReady() && showNoDataState()) {\n    <!-- No Data State -->\n    <axp-state-message\n      icon=\"fa-light fa-chart-pie\"\n      [title]=\"'@report-management:report-viewer.components.chart.empty-states.no-data.title'\"\n      [description]=\"'@report-management:report-viewer.components.chart.empty-states.no-data.description'\"\n    >\n    </axp-state-message>\n  } @else if (isChartReady()) {\n    <!-- Chart Content -->\n    <section\n      class=\"__chart-container overflow-auto md:overflow-hidden rounded-2xl border h-full flex flex-col\"\n    >\n      @if (chartLayout()?.header) {\n        <header\n          class=\"__chart-header p-4 md:p-6 border-b flex flex-col sm:flex-row gap-2 sm:items-center sm:justify-between\"\n        >\n          <h3 class=\"__chart-title text-base md:text-lg font-semibold truncate\">\n            {{ chartLayout()?.header?.title }}\n          </h3>\n          @if (chartLayout()?.header?.showDate) {\n            <div class=\"__chart-date text-xs md:text-sm opacity-70 font-medium flex-shrink-0\">\n              {{ '@general:common.date.today' | translate | async }}\n            </div>\n          }\n        </header>\n      }\n\n      <div class=\"__chart-body flex min-h-0 flex-1 flex-col p-3 md:p-6\">\n        @switch (chartType()) {\n          @case ('bar') {\n            <!-- ----- Bar chart with side legend ----- -->\n            <div class=\"__chart-wrapper flex h-full min-h-0 w-full flex-col items-center gap-4 lg:flex-row lg:gap-6\">\n              <div\n                class=\"__chart-content flex h-full min-h-[250px] w-full flex-1 items-center justify-center overflow-hidden md:min-h-[300px]\"\n              >\n                <ax-bar-chart #barChart [data]=\"barChartData()\" [options]=\"barChartOptions()\"></ax-bar-chart>\n              </div>\n              @if (hasBarChartData()) {\n                <div class=\"__chart-legend w-fit flex-shrink-0\">\n                  <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"barChart\"></ax-chart-legend>\n                </div>\n              }\n            </div>\n          }\n          @case ('doughnut') {\n            <!-- ----- Donut in a square box; vertical legend on the right (same as bar) ----- -->\n            <div class=\"__chart-wrapper flex h-full min-h-0 w-full flex-col items-center gap-4 lg:flex-row lg:gap-6\">\n              <div\n                class=\"__chart-content flex h-full min-h-[250px] w-full flex-1 items-center justify-center overflow-hidden md:min-h-[300px]\"\n              >\n                <div\n                  class=\"__chart-radial relative aspect-square h-full max-h-full w-auto max-w-full min-h-64 min-w-64 overflow-hidden\"\n                >\n                  <ax-donut-chart\n                    #donutChart\n                    [data]=\"donutChartData()\"\n                    [options]=\"donutChartOptions()\"\n                  ></ax-donut-chart>\n                </div>\n              </div>\n              @if (hasDonutChartData()) {\n                <div class=\"__chart-legend w-fit flex-shrink-0\">\n                  <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"donutChart\"></ax-chart-legend>\n                </div>\n              }\n            </div>\n          }\n          @default {\n            <!-- ----- Line chart with side legend ----- -->\n            <div class=\"__chart-wrapper flex h-full min-h-0 w-full flex-col items-center gap-4 lg:flex-row lg:gap-6\">\n              <div\n                class=\"__chart-content flex h-full min-h-[250px] w-full flex-1 items-center justify-center overflow-hidden md:min-h-[300px]\"\n              >\n                <ax-line-chart #lineChart [data]=\"lineChartData()\" [options]=\"lineChartOptions()\"></ax-line-chart>\n              </div>\n              @if (hasLineChartData()) {\n                <div class=\"__chart-legend w-fit flex-shrink-0\">\n                  <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"lineChart\"></ax-chart-legend>\n                </div>\n              }\n            </div>\n          }\n        }\n      </div>\n\n      @if (chartLayout()?.footer) {\n        <footer class=\"__chart-footer p-4 md:p-6 border-t\">\n          @if (chartLayout()?.footer?.customHtml) {\n            <div [innerHTML]=\"$safeNavigationMigration(chartLayout()?.footer?.customHtml)\"></div>\n          }\n        </footer>\n      }\n    </section>\n  } @else {\n    <!-- No Configuration State -->\n    <axp-state-message\n      icon=\"fa-light fa-chart-line\"\n      [title]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.title'\"\n      [description]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.description'\"\n    >\n    </axp-state-message>\n  }\n</ng-container>\n", styles: [":host ::ng-deep .__chart-radial ax-donut-chart{display:block!important;width:100%!important;height:100%!important;min-height:0!important;max-height:100%!important}:host ::ng-deep .__chart-radial ax-donut-chart .ax-donut-chart{min-height:0!important;height:100%!important;width:100%!important}:host ::ng-deep ax-chart-legend{display:block!important;height:auto!important;max-height:none;width:100%}:host ::ng-deep .ax-chart-legend{height:auto;max-height:none}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i1.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: AXBarChartComponent, selector: "ax-bar-chart", inputs: ["data", "options"], outputs: ["barClick"] }, { kind: "component", type: AXDonutChartComponent, selector: "ax-donut-chart", inputs: ["data", "options"], outputs: ["segmentClick", "segmentHover"] }, { kind: "component", type: AXLineChartComponent, selector: "ax-line-chart", inputs: ["data", "options"], outputs: ["pointClick"] }, { kind: "component", type: AXChartLegendComponent, selector: "ax-chart-legend", inputs: ["chart", "options"], outputs: ["itemClick", "itemMouseEnter", "itemMouseLeave"] }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "titleParams", "descriptionParams", "look"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i1.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportChartViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-report-chart-view', imports: [
+                        CommonModule,
+                        AXTranslationModule,
+                        AXPWidgetCoreModule,
+                        AXBarChartComponent,
+                        AXDonutChartComponent,
+                        AXLineChartComponent,
+                        AXChartLegendComponent,
+                        AXPStateMessageComponent,
+                    ], host: {
+                        class: 'axp-report-chart-view w-full h-full flex flex-col',
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *translate=\"let t\">\n  @if (vm.status() === AXPPageStatus.Processing) {\n    <!-- Loading State -->\n    <div class=\"__loading flex flex-col items-center justify-center h-full gap-6 p-8\">\n      <div class=\"spinner spin w-10 h-10\"></div>\n      <div class=\"__loading-text text-sm opacity-70\">\n        {{ t('@report-management:report-viewer.components.chart.messages.loading') | async }}\n      </div>\n    </div>\n  } @else if (vm.status() === AXPPageStatus.Error) {\n    <!-- Error State -->\n    <axp-state-message\n      mode=\"error\"\n      icon=\"fa-light fa-exclamation-triangle\"\n      [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n      [description]=\"vm.error() || '@report-management:report-viewer.messages.error.fetch-description'\"\n    >\n    </axp-state-message>\n  } @else if (isChartReady() && showNoDataState()) {\n    <!-- No Data State -->\n    <axp-state-message\n      icon=\"fa-light fa-chart-pie\"\n      [title]=\"'@report-management:report-viewer.components.chart.empty-states.no-data.title'\"\n      [description]=\"'@report-management:report-viewer.components.chart.empty-states.no-data.description'\"\n    >\n    </axp-state-message>\n  } @else if (isChartReady()) {\n    <!-- Chart Content -->\n    <section\n      class=\"__chart-container overflow-auto md:overflow-hidden rounded-2xl border h-full flex flex-col\"\n    >\n      @if (chartLayout()?.header) {\n        <header\n          class=\"__chart-header p-4 md:p-6 border-b flex flex-col sm:flex-row gap-2 sm:items-center sm:justify-between\"\n        >\n          <h3 class=\"__chart-title text-base md:text-lg font-semibold truncate\">\n            {{ chartLayout()?.header?.title }}\n          </h3>\n          @if (chartLayout()?.header?.showDate) {\n            <div class=\"__chart-date text-xs md:text-sm opacity-70 font-medium flex-shrink-0\">\n              {{ '@general:common.date.today' | translate | async }}\n            </div>\n          }\n        </header>\n      }\n\n      <div class=\"__chart-body flex min-h-0 flex-1 flex-col p-3 md:p-6\">\n        @switch (chartType()) {\n          @case ('bar') {\n            <!-- ----- Bar chart with side legend ----- -->\n            <div class=\"__chart-wrapper flex h-full min-h-0 w-full flex-col items-center gap-4 lg:flex-row lg:gap-6\">\n              <div\n                class=\"__chart-content flex h-full min-h-[250px] w-full flex-1 items-center justify-center overflow-hidden md:min-h-[300px]\"\n              >\n                <ax-bar-chart #barChart [data]=\"barChartData()\" [options]=\"barChartOptions()\"></ax-bar-chart>\n              </div>\n              @if (hasBarChartData()) {\n                <div class=\"__chart-legend w-fit flex-shrink-0\">\n                  <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"barChart\"></ax-chart-legend>\n                </div>\n              }\n            </div>\n          }\n          @case ('doughnut') {\n            <!-- ----- Donut in a square box; vertical legend on the right (same as bar) ----- -->\n            <div class=\"__chart-wrapper flex h-full min-h-0 w-full flex-col items-center gap-4 lg:flex-row lg:gap-6\">\n              <div\n                class=\"__chart-content flex h-full min-h-[250px] w-full flex-1 items-center justify-center overflow-hidden md:min-h-[300px]\"\n              >\n                <div\n                  class=\"__chart-radial relative aspect-square h-full max-h-full w-auto max-w-full min-h-64 min-w-64 overflow-hidden\"\n                >\n                  <ax-donut-chart\n                    #donutChart\n                    [data]=\"donutChartData()\"\n                    [options]=\"donutChartOptions()\"\n                  ></ax-donut-chart>\n                </div>\n              </div>\n              @if (hasDonutChartData()) {\n                <div class=\"__chart-legend w-fit flex-shrink-0\">\n                  <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"donutChart\"></ax-chart-legend>\n                </div>\n              }\n            </div>\n          }\n          @default {\n            <!-- ----- Line chart with side legend ----- -->\n            <div class=\"__chart-wrapper flex h-full min-h-0 w-full flex-col items-center gap-4 lg:flex-row lg:gap-6\">\n              <div\n                class=\"__chart-content flex h-full min-h-[250px] w-full flex-1 items-center justify-center overflow-hidden md:min-h-[300px]\"\n              >\n                <ax-line-chart #lineChart [data]=\"lineChartData()\" [options]=\"lineChartOptions()\"></ax-line-chart>\n              </div>\n              @if (hasLineChartData()) {\n                <div class=\"__chart-legend w-fit flex-shrink-0\">\n                  <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"lineChart\"></ax-chart-legend>\n                </div>\n              }\n            </div>\n          }\n        }\n      </div>\n\n      @if (chartLayout()?.footer) {\n        <footer class=\"__chart-footer p-4 md:p-6 border-t\">\n          @if (chartLayout()?.footer?.customHtml) {\n            <div [innerHTML]=\"$safeNavigationMigration(chartLayout()?.footer?.customHtml)\"></div>\n          }\n        </footer>\n      }\n    </section>\n  } @else {\n    <!-- No Configuration State -->\n    <axp-state-message\n      icon=\"fa-light fa-chart-line\"\n      [title]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.title'\"\n      [description]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.description'\"\n    >\n    </axp-state-message>\n  }\n</ng-container>\n", styles: [":host ::ng-deep .__chart-radial ax-donut-chart{display:block!important;width:100%!important;height:100%!important;min-height:0!important;max-height:100%!important}:host ::ng-deep .__chart-radial ax-donut-chart .ax-donut-chart{min-height:0!important;height:100%!important;width:100%!important}:host ::ng-deep ax-chart-legend{display:block!important;height:auto!important;max-height:none;width:100%}:host ::ng-deep .ax-chart-legend{height:auto;max-height:none}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }] });
+//#region ----- Series color helpers -----
+function applySeriesColors(items, seriesColors) {
+    if (!seriesColors || Object.keys(seriesColors).length === 0) {
+        return items;
+    }
+    return items.map((item) => {
+        const color = seriesColors[item.id] ?? (item.label ? seriesColors[item.label] : undefined);
+        return color ? { ...item, color } : item;
+    });
+}
+
+class AXPReportPdfViewComponent {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.vm = inject(AXPReportViewerViewModel);
+        this.AXPPageStatus = AXPPageStatus;
+        this.sanitizer = inject(DomSanitizer);
+        //#endregion
+        //#region ----   Computed Properties   ----
+        /**
+         * Current PDF layout configuration
+         */
+        this.pdfLayout = computed(() => {
+            const layout = this.vm.currentLayout();
+            return layout?.layout.type === 'pdf' ? layout.layout : null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "pdfLayout" }] : /* istanbul ignore next */ []));
+        /**
+         * PDF layout options
+         */
+        this.pdfOptions = computed(() => {
+            const pdfLayout = this.pdfLayout();
+            return pdfLayout?.options || {};
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "pdfOptions" }] : /* istanbul ignore next */ []));
+        /**
+         * PDF source URL (sanitized for embed)
+         */
+        this.pdfSource = computed(() => {
+            const pdfData = this.pdfData();
+            if (!pdfData) {
+                return null;
+            }
+            // Handle URL
+            if (pdfData.url) {
+                return this.sanitizer.bypassSecurityTrustResourceUrl(pdfData.url);
+            }
+            // Handle base64
+            if (pdfData.base64) {
+                const base64Data = pdfData.base64.startsWith('data:')
+                    ? pdfData.base64
+                    : `data:application/pdf;base64,${pdfData.base64}`;
+                return this.sanitizer.bypassSecurityTrustResourceUrl(base64Data);
+            }
+            // Handle blob
+            if (pdfData.blob) {
+                const blobUrl = URL.createObjectURL(pdfData.blob);
+                return this.sanitizer.bypassSecurityTrustResourceUrl(blobUrl);
+            }
+            return null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "pdfSource" }] : /* istanbul ignore next */ []));
+        /**
+         * PDF filename for download
+         */
+        this.pdfFilename = computed(() => {
+            const pdfData = this.pdfData();
+            return pdfData?.filename || 'report.pdf';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "pdfFilename" }] : /* istanbul ignore next */ []));
+        /**
+         * PDF embed height
+         */
+        this.embedHeight = computed(() => {
+            const options = this.pdfOptions();
+            return options.height || '100%';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "embedHeight" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if PDF is ready to render
+         */
+        this.isPdfReady = computed(() => {
+            return !!this.pdfSource();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isPdfReady" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if download button should be shown
+         */
+        this.showDownloadButton = computed(() => {
+            const options = this.pdfOptions();
+            return options.showDownloadButton !== false; // Default to true
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "showDownloadButton" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if print button should be shown
+         */
+        this.showPrintButton = computed(() => {
+            const options = this.pdfOptions();
+            return options.showPrintButton !== false; // Default to true
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "showPrintButton" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if zoom controls should be shown
+         */
+        this.showZoomControls = computed(() => {
+            const options = this.pdfOptions();
+            return options.showZoomControls !== false; // Default to true
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "showZoomControls" }] : /* istanbul ignore next */ []));
+        /**
+         * Check if fullscreen button should be shown
+         */
+        this.showFullscreenButton = computed(() => {
+            const options = this.pdfOptions();
+            return options.showFullscreenButton !== false; // Default to true
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "showFullscreenButton" }] : /* istanbul ignore next */ []));
+        /**
+         * Current zoom level
+         */
+        this.currentZoom = signal(100, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "currentZoom" }] : /* istanbul ignore next */ []));
+        /**
+         * PDF data from execution result
+         */
+        this.pdfData = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "pdfData" }] : /* istanbul ignore next */ []));
+        /**
+         * Fullscreen state
+         */
+        this.isFullscreen = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isFullscreen" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Effects   ----
+        /**
+         * Effect to fetch PDF data when conditions are met
+         */
+        this.#fetchData = effect(() => {
+            if (this.vm.allowFetchData() && this.vm.shouldExecuteReport() && this.pdfLayout()) {
+                void untracked(() => this.vm.fetchData()).then((result) => {
+                    if (!result) {
+                        return;
+                    }
+                    const pdfResult = queryResultToPdfSource(result);
+                    this.pdfData.set(pdfResult);
+                    if (pdfResult) {
+                        const options = this.pdfOptions();
+                        if (options.defaultZoom) {
+                            this.currentZoom.set(options.defaultZoom);
+                        }
+                    }
+                });
+            }
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#fetchData" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----   Effects   ----
+    /**
+     * Effect to fetch PDF data when conditions are met
+     */
+    #fetchData;
+    //#endregion
+    //#region ----   Methods   ----
+    /**
+     * Handle download PDF
+     */
+    downloadPdf() {
+        const pdfData = this.pdfData();
+        if (!pdfData) {
+            return;
+        }
+        let url;
+        let filename = this.pdfFilename();
+        let shouldRevokeUrl = false;
+        if (pdfData.url) {
+            // For URL, create a temporary link
+            url = pdfData.url;
+        }
+        else if (pdfData.base64) {
+            // Convert base64 to blob and create URL
+            const base64Data = pdfData.base64.startsWith('data:')
+                ? pdfData.base64.split(',')[1]
+                : pdfData.base64;
+            const byteCharacters = atob(base64Data);
+            const byteNumbers = new Array(byteCharacters.length);
+            for (let i = 0; i < byteCharacters.length; i++) {
+                byteNumbers[i] = byteCharacters.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            const blob = new Blob([byteArray], { type: 'application/pdf' });
+            url = URL.createObjectURL(blob);
+            shouldRevokeUrl = true;
+        }
+        else if (pdfData.blob) {
+            url = URL.createObjectURL(pdfData.blob);
+            shouldRevokeUrl = true;
+        }
+        else {
+            return;
+        }
+        // Create download link
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = filename;
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        // Clean up blob URL if created
+        if (shouldRevokeUrl) {
+            setTimeout(() => URL.revokeObjectURL(url), 100);
+        }
+    }
+    /**
+     * Handle print PDF
+     */
+    printPdf() {
+        const pdfData = this.pdfData();
+        if (!pdfData) {
+            return;
+        }
+        let url;
+        if (pdfData.url) {
+            url = pdfData.url;
+        }
+        else if (pdfData.base64) {
+            const base64Data = pdfData.base64.startsWith('data:')
+                ? pdfData.base64
+                : `data:application/pdf;base64,${pdfData.base64}`;
+            url = base64Data;
+        }
+        else if (pdfData.blob) {
+            url = URL.createObjectURL(pdfData.blob);
+        }
+        else {
+            return;
+        }
+        // Open PDF in new window for printing
+        const printWindow = window.open(url, '_blank');
+        if (printWindow) {
+            printWindow.onload = () => {
+                printWindow.print();
+            };
+        }
+    }
+    /**
+     * Handle zoom in
+     */
+    zoomIn() {
+        const current = this.currentZoom();
+        if (current < 500) {
+            this.currentZoom.set(Math.min(current + 25, 500));
+        }
+    }
+    /**
+     * Handle zoom out
+     */
+    zoomOut() {
+        const current = this.currentZoom();
+        if (current > 25) {
+            this.currentZoom.set(Math.max(current - 25, 25));
+        }
+    }
+    /**
+     * Handle zoom reset
+     */
+    zoomReset() {
+        const options = this.pdfOptions();
+        this.currentZoom.set(options.defaultZoom || 100);
+    }
+    /**
+     * Handle fullscreen toggle
+     */
+    toggleFullscreen() {
+        const isFullscreen = this.isFullscreen();
+        this.isFullscreen.set(!isFullscreen);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportPdfViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPReportPdfViewComponent, isStandalone: true, selector: "axp-report-pdf-view", host: { classAttribute: "axp-report-pdf-view w-full h-full flex flex-col" }, ngImport: i0, template: "<ng-container *translate=\"let t\">\n    @if (vm.status() === AXPPageStatus.Processing) {\n    <!-- Loading State -->\n    <div class=\"__loading flex flex-col items-center justify-center h-full gap-6 p-8\">\n        <div class=\"spinner spin w-10 h-10\"></div>\n        <div class=\"__loading-text text-sm opacity-70\">\n            {{ t('@report-management:report-viewer.components.pdf.messages.loading') | async }}\n        </div>\n    </div>\n    } @else if (vm.status() === AXPPageStatus.Error) {\n    <!-- Error State -->\n    <axp-state-message mode=\"error\" icon=\"fa-light fa-exclamation-triangle\"\n        [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n        [description]=\"vm.error() || '@report-management:report-viewer.messages.error.fetch-description'\">\n    </axp-state-message>\n    } @else if (isPdfReady()) {\n    <!-- PDF Embed Only -->\n    <embed class=\"__pdf-embed w-full h-full\" [src]=\"pdfSource()\" type=\"application/pdf\" />\n    } @else {\n    <!-- No PDF Data State -->\n    <axp-state-message icon=\"fa-light fa-file-pdf\"\n        [title]=\"'@report-management:report-viewer.components.pdf.empty-states.no-data.title'\"\n        [description]=\"'@report-management:report-viewer.components.pdf.empty-states.no-data.description'\">\n    </axp-state-message>\n    }\n</ng-container>", styles: [".axp-report-pdf-view .__loading{min-height:400px}.axp-report-pdf-view .__pdf-container{background:var(--ax-color-background)}.axp-report-pdf-view .__pdf-container.__fullscreen{position:fixed;z-index:9999;inset:0;border-radius:0}.axp-report-pdf-view .__pdf-toolbar{background:var(--ax-color-surface)}.axp-report-pdf-view .__pdf-body{background:var(--ax-color-background-secondary)}.axp-report-pdf-view .__pdf-wrapper{min-height:400px}.axp-report-pdf-view .__pdf-embed{--tw-border-style: none;border-style:none;box-shadow:0 2px 8px #0000001a;transition:width .3s ease,height .3s ease}.axp-report-pdf-view .__zoom-level{-webkit-user-select:none;user-select:none}@media(max-width:640px){.axp-report-pdf-view .__zoom-controls{margin-top:calc(var(--spacing, .25rem) * 2);width:100%;justify-content:center;margin-left:0}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i1.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "titleParams", "descriptionParams", "look"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportPdfViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-report-pdf-view', imports: [
+                        CommonModule,
+                        AXButtonModule,
+                        AXDecoratorModule,
+                        AXTranslationModule,
+                        AXPWidgetCoreModule,
+                        AXPStateMessageComponent,
+                    ], host: {
+                        class: 'axp-report-pdf-view w-full h-full flex flex-col',
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<ng-container *translate=\"let t\">\n    @if (vm.status() === AXPPageStatus.Processing) {\n    <!-- Loading State -->\n    <div class=\"__loading flex flex-col items-center justify-center h-full gap-6 p-8\">\n        <div class=\"spinner spin w-10 h-10\"></div>\n        <div class=\"__loading-text text-sm opacity-70\">\n            {{ t('@report-management:report-viewer.components.pdf.messages.loading') | async }}\n        </div>\n    </div>\n    } @else if (vm.status() === AXPPageStatus.Error) {\n    <!-- Error State -->\n    <axp-state-message mode=\"error\" icon=\"fa-light fa-exclamation-triangle\"\n        [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n        [description]=\"vm.error() || '@report-management:report-viewer.messages.error.fetch-description'\">\n    </axp-state-message>\n    } @else if (isPdfReady()) {\n    <!-- PDF Embed Only -->\n    <embed class=\"__pdf-embed w-full h-full\" [src]=\"pdfSource()\" type=\"application/pdf\" />\n    } @else {\n    <!-- No PDF Data State -->\n    <axp-state-message icon=\"fa-light fa-file-pdf\"\n        [title]=\"'@report-management:report-viewer.components.pdf.empty-states.no-data.title'\"\n        [description]=\"'@report-management:report-viewer.components.pdf.empty-states.no-data.description'\">\n    </axp-state-message>\n    }\n</ng-container>", styles: [".axp-report-pdf-view .__loading{min-height:400px}.axp-report-pdf-view .__pdf-container{background:var(--ax-color-background)}.axp-report-pdf-view .__pdf-container.__fullscreen{position:fixed;z-index:9999;inset:0;border-radius:0}.axp-report-pdf-view .__pdf-toolbar{background:var(--ax-color-surface)}.axp-report-pdf-view .__pdf-body{background:var(--ax-color-background-secondary)}.axp-report-pdf-view .__pdf-wrapper{min-height:400px}.axp-report-pdf-view .__pdf-embed{--tw-border-style: none;border-style:none;box-shadow:0 2px 8px #0000001a;transition:width .3s ease,height .3s ease}.axp-report-pdf-view .__zoom-level{-webkit-user-select:none;user-select:none}@media(max-width:640px){.axp-report-pdf-view .__zoom-controls{margin-top:calc(var(--spacing, .25rem) * 2);width:100%;justify-content:center;margin-left:0}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }] });
+
+class AXPReportTableViewComponent {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.vm = inject(AXPReportViewerViewModel);
+        this.commandService = inject(AXPCommandService);
+        this.expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        this.grid = viewChild('grid', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "grid" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   State   ----
+        this.columns = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "columns" }] : /* istanbul ignore next */ []));
+        this.sortedFields = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sortedFields" }] : /* istanbul ignore next */ []));
+        this.tableSummary = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "tableSummary" }] : /* istanbul ignore next */ []));
+        this.handledExecutionRequestId = 0;
+        this.lastDataSourcePreferencesKey = null;
+        //#endregion
+        //#region ----   Effects   ----
+        this.#resetExecutionHandler = effect(() => {
+            const reportId = this.vm.reportId();
+            untracked(() => {
+                this.handledExecutionRequestId = 0;
+                this.lastDataSourcePreferencesKey = null;
+                void reportId;
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#resetExecutionHandler" }] : /* istanbul ignore next */ []));
+        this.#syncTableColumns = effect(() => {
+            const layoutDef = this.vm.currentLayout();
+            const tableLayout = layoutDef?.layout;
+            if (!tableLayout || tableLayout.type !== 'table') {
+                this.columns.set([]);
+                return;
+            }
+            const savedTable = this.vm.tableLayoutUserSettings();
+            const groupBy = tableLayout.groupBy;
+            const columns = tableLayout.columns;
+            const savedColumns = savedTable?.columns;
+            void (async () => {
+                const builtColumns = await buildReportTableColumnsAsync(columns, savedColumns, this.expressionEvaluator);
+                this.columns.set(applyGroupByDrillLinksToColumns(builtColumns, groupBy));
+            })();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#syncTableColumns" }] : /* istanbul ignore next */ []));
+        this.#syncDataSourcePreferences = effect(() => {
+            const layoutDef = this.vm.currentLayout();
+            if (!layoutDef) {
+                return;
+            }
+            const tableLayout = layoutDef.layout;
+            if (!tableLayout || tableLayout.type !== 'table') {
+                return;
+            }
+            const savedTable = this.vm.tableLayoutUserSettings();
+            const queryDataSource = layoutDef.dataSource;
+            const defaultSort = tableLayout.options?.sorting?.length
+                ? tableLayout.options.sorting
+                : (queryDataSource?.sortFields ?? []);
+            const effectiveSort = savedTable?.sorts?.length ? savedTable.sorts : defaultSort;
+            const pageSize = savedTable?.pageSize ?? 10;
+            const preferencesKey = `${layoutDef.id}:${pageSize}:${JSON.stringify(effectiveSort)}`;
+            if (this.lastDataSourcePreferencesKey === preferencesKey) {
+                return;
+            }
+            untracked(() => {
+                this.lastDataSourcePreferencesKey = preferencesKey;
+                this.sortedFields.set(effectiveSort);
+                this.applySortToDataSource(effectiveSort);
+                this.dataSource.setPageSize(pageSize);
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#syncDataSourcePreferences" }] : /* istanbul ignore next */ []));
+        /**
+         * Refresh grid once per execute-report request.
+         */
+        this.#fetchData = effect(() => {
+            const requestId = this.vm.executionRequestId();
+            const grid = this.grid();
+            if (!grid || requestId <= this.handledExecutionRequestId || !this.vm.allowFetchData()) {
+                return;
+            }
+            untracked(() => {
+                this.handledExecutionRequestId = requestId;
+                grid.refresh();
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#fetchData" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Computed Properties   ----
+        this.layout = computed(() => {
+            return this.vm.currentLayout()?.layout;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "layout" }] : /* istanbul ignore next */ []));
+        this.dataSource = new AXDataSource({
+            load: async (e) => {
+                if (!this.vm.allowFetchData()) {
+                    this.tableSummary.set(null);
+                    return { items: [], total: 0 };
+                }
+                const result = await this.vm.fetchData(e);
+                const page = runtimeQueryCollectionData(result);
+                if (!page) {
+                    this.tableSummary.set(null);
+                    return { items: [], total: 0 };
+                }
+                this.tableSummary.set(page.aggregateRows?.[0] ?? null);
+                return {
+                    items: (page.items ?? []),
+                    total: Number(page.total ?? page.items?.length ?? 0),
+                };
+            },
+            pageSize: 10,
+            key: 'id',
+        });
+        this.visibleColumns = computed(() => this.columns().filter((c) => c.visible), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "visibleColumns" }] : /* istanbul ignore next */ []));
+        this.paginationEnabled = computed(() => {
+            return this.layout().options?.pagination !== false;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "paginationEnabled" }] : /* istanbul ignore next */ []));
+        this.hasReportFooterSummary = computed(() => {
+            return ((this.layout().summary?.some((s) => s.displayIn === 'reportFooter') ?? false) &&
+                this.tableSummary() !== null);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasReportFooterSummary" }] : /* istanbul ignore next */ []));
+        this.rowActions = computed(() => {
+            const tableLayout = this.layout();
+            const generated = buildDrillRowActionsFromGroupBy(tableLayout.groupBy, this.vm.reportDefinition()?.id);
+            const manual = tableLayout.actions ?? [];
+            return [...generated, ...manual];
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "rowActions" }] : /* istanbul ignore next */ []));
+        this.primaryRowAction = computed(() => {
+            return (this.rowActions().filter((a) => a.priority === 'primary')?.map((a) => this.convertToRowCommandItem(a)) ??
+                []);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "primaryRowAction" }] : /* istanbul ignore next */ []));
+        this.hasPrimaryRowAction = computed(() => {
+            return this.primaryRowAction().length > 0;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasPrimaryRowAction" }] : /* istanbul ignore next */ []));
+        this.secondaryRowAction = computed(() => {
+            return (this.rowActions()
+                .filter((a) => a.priority === 'secondary')
+                ?.map((a) => this.convertToRowCommandItem(a)) ?? []);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "secondaryRowAction" }] : /* istanbul ignore next */ []));
+        this.hasSecondaryRowAction = computed(() => {
+            return this.secondaryRowAction().length > 0;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasSecondaryRowAction" }] : /* istanbul ignore next */ []));
+        this.defaultGroupByDrillDefinition = computed(() => {
+            const groupBy = this.layout().groupBy;
+            if (!hasGroupByDrillLinks(groupBy)) {
+                return null;
+            }
+            return groupBy?.find((definition) => definition.default) ?? groupBy?.[0] ?? null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "defaultGroupByDrillDefinition" }] : /* istanbul ignore next */ []));
+        this.defaultRowAction = computed(() => {
+            const defaultAction = this.rowActions().find((a) => a.default);
+            if (!defaultAction) {
+                return null;
+            }
+            return this.convertToRowCommandItem(defaultAction);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "defaultRowAction" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----   Effects   ----
+    #resetExecutionHandler;
+    #syncTableColumns;
+    #syncDataSourcePreferences;
+    /**
+     * Refresh grid once per execute-report request.
+     */
+    #fetchData;
+    //#endregion
+    //#region ----   Event Handlers   ----
+    handleRowClick(event) {
+        void this.handleRowAction(event.name, event.data);
+    }
+    handleDbRowClick(event) {
+        const defaultGroupByDrill = this.defaultGroupByDrillDefinition();
+        if (defaultGroupByDrill?.displayField) {
+            void this.handleGroupByDrill(defaultGroupByDrill.displayField, event.data);
+            return;
+        }
+        if (this.defaultRowAction()) {
+            void this.handleRowAction(this.defaultRowAction().name, event.data);
+        }
+    }
+    async handleGroupByDrill(displayField, data) {
+        const definition = findGroupByDefinitionForDisplayField(this.layout().groupBy, displayField);
+        if (!definition) {
+            return;
+        }
+        const reportId = this.vm.reportDefinition()?.id;
+        if (!reportId) {
+            return;
+        }
+        const commandOptions = buildGroupByDrillCommandOptions(definition, reportId);
+        const evaluatedOptions = await this.evaluateActionOptions(commandOptions, data);
+        await this.commandService.execute('ReportManagement.Report:OpenInPopup', {
+            data: data,
+            options: evaluatedOptions,
+        });
+    }
+    async handleRowAction(name, data) {
+        const action = this.rowActions().find((item) => item.command?.name === name);
+        const commandName = action?.command?.name ?? name;
+        const evaluatedOptions = await this.evaluateActionOptions(action?.command?.options, data);
+        await this.commandService.execute(commandName, {
+            data: data,
+            options: evaluatedOptions,
+        });
+    }
+    async evaluateActionOptions(options, data) {
+        if (!options) {
+            return {};
+        }
+        const scope = {
+            context: {
+                eval: (path) => get(data, path),
+            },
+        };
+        return (await this.expressionEvaluator.evaluate(options, scope));
+    }
+    handleColumnSort(columnField) {
+        const column = this.layout().columns?.find((c) => c.field === columnField);
+        if (!column?.sortable) {
+            return;
+        }
+        const activeSorts = [...this.sortedFields()];
+        const index = activeSorts.findIndex((s) => s.name === columnField);
+        const currentDir = index >= 0 ? activeSorts[index].dir : undefined;
+        const newDir = currentDir === 'asc' ? 'desc' : currentDir === 'desc' ? undefined : 'asc';
+        const nextSorts = newDir ? [{ name: columnField, dir: newDir }] : [];
+        this.sortedFields.set(nextSorts);
+        this.applySortToDataSource(nextSorts);
+        void this.vm.saveTableSorts(nextSorts);
+        this.grid()?.refresh();
+    }
+    onColumnSizeChanged(event) {
+        if (!event.isUserInteraction || event.type !== 'end' || !event.data) {
+            return;
+        }
+        const dataField = String(event.data.dataField ?? '');
+        const field = resolveColumnFieldFromDataField(dataField);
+        const width = parseColumnResizeWidth(event.data.width);
+        if (!field || width == null) {
+            return;
+        }
+        const nextColumns = this.columns().map((col) => col.field === field ? { ...col, width } : col);
+        this.columns.set(nextColumns);
+        void this.vm.saveTableColumnWidth(field, width, nextColumns);
+    }
+    onColumnsOrderChanged(event) {
+        if (!event.isUserInteraction || !event.data?.event) {
+            return;
+        }
+        const dragEvent = event.data.event;
+        const offset = this.leadingColumnCount();
+        const previousIndex = dragEvent.previousIndex - offset;
+        const currentIndex = dragEvent.currentIndex - offset;
+        if (previousIndex < 0 || currentIndex < 0) {
+            return;
+        }
+        const nextColumns = [...this.columns()];
+        const source = nextColumns[previousIndex];
+        if (!source || source.pin) {
+            return;
+        }
+        if (nextColumns[currentIndex]?.pin) {
+            return;
+        }
+        moveItemInArray(nextColumns, previousIndex, currentIndex);
+        this.columns.set(nextColumns);
+        void this.vm.saveTableColumnOrder(nextColumns);
+    }
+    onPageChanged(event) {
+        if (event.isUserInteraction) {
+            void this.vm.saveTablePageSize(event.take);
+        }
+    }
+    //#endregion
+    //#region ----   Sort Helpers   ----
+    resolveColumnSortDirection(columnField) {
+        const dir = this.sortedFields().find((s) => s.name === columnField)?.dir;
+        return dir === 'asc' || dir === 'desc' ? dir : undefined;
+    }
+    //#endregion
+    //#region ----   Summary Helpers   ----
+    getSummaryDisplayValue(field) {
+        const summary = this.tableSummary();
+        if (!summary || !(field in summary)) {
+            return null;
+        }
+        const value = summary[field];
+        if (value == null) {
+            return null;
+        }
+        return String(value);
+    }
+    isFirstVisibleColumn(field) {
+        return this.visibleColumns()[0]?.field === field;
+    }
+    //#endregion
+    //#region ----   Helpers   ----
+    leadingColumnCount() {
+        let count = 0;
+        if (this.vm.showRowIndexColumn()) {
+            count++;
+        }
+        if (this.vm.canSelectRows()) {
+            count++;
+        }
+        return count;
+    }
+    applySortToDataSource(sorts) {
+        const sortOptions = sorts.map((s) => ({ field: s.name, dir: s.dir }));
+        this.dataSource.sort(...sortOptions);
+    }
+    convertToRowCommandItem(action) {
+        const systemAction = getSystemActions(action.type);
+        if (!systemAction) {
+            return {
+                icon: action.icon ?? 'fa-light fa-eye',
+                iconOnly: action.iconOnly ?? true,
+                text: action.title,
+                name: action.command?.name,
+                divided: action.break,
+                color: action.color,
+            };
+        }
+        const defaultAction = applySystemActionDefault(action, systemAction.key);
+        return {
+            icon: defaultAction.icon ?? 'fa-light fa-eye',
+            iconOnly: action.iconOnly ?? true,
+            text: defaultAction.title,
+            name: action.command?.name,
+            divided: defaultAction.break ?? action.break,
+            color: defaultAction.color,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportTableViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPReportTableViewComponent, isStandalone: true, selector: "axp-report-table-view", host: { classAttribute: "axp-report-table-view flex flex-col flex-1 min-h-0 h-full w-full" }, viewQueries: [{ propertyName: "grid", first: true, predicate: ["grid"], descendants: true, isSignal: true }], ngImport: i0, template: "<ax-data-table\n  #grid\n  [dataSource]=\"dataSource\"\n  [paging]=\"paginationEnabled()\"\n  [showFooter]=\"hasReportFooterSummary()\"\n  [allowReordering]=\"true\"\n  (onRowDbClick)=\"handleDbRowClick($event)\"\n  (onColumnSizeChanged)=\"onColumnSizeChanged($event)\"\n  (onColumnsOrderChanged)=\"onColumnsOrderChanged($event)\"\n  (onPageChanged)=\"onPageChanged($event)\"\n  class=\"flex-1 min-h-0 h-full\"\n>\n  @if (vm.showRowIndexColumn()) {\n    <ax-index-column\n      [caption]=\"('@general:terms.common.row-number' | translate | async)!\"\n      fixed=\"start\"\n      [width]=\"'80px'\"\n      [padZero]=\"false\"\n    ></ax-index-column>\n  }\n  @if (vm.canSelectRows()) {\n    <ax-select-column fixed=\"start\" [width]=\"'50px'\"></ax-select-column>\n  }\n  @for (column of columns(); track column.field) {\n    @if (column.visible) {\n      <ng-template #footerCell>\n        <div\n          class=\"w-full truncate\"\n          [class.text-start]=\"column.align === 'left'\"\n          [class.text-center]=\"column.align === 'center'\"\n          [class.text-end]=\"column.align === 'right'\"\n        >\n          @if (isFirstVisibleColumn(column.field) && hasReportFooterSummary()) {\n            <span class=\"font-medium\">\n              {{ '@report-management:report-viewer.components.table.footer-total' | translate | async }}\n            </span>\n          } @else if (getSummaryDisplayValue(column.field); as summaryValue) {\n            <span>{{ summaryValue }}</span>\n          }\n        </div>\n      </ng-template>\n      @if (column.isGroupByDrillLink && column.drillDisplayField) {\n        <axp-text-command-column\n          [customWidth]=\"column.width == 'auto' ? 'auto' : column.width + 'px'\"\n          [caption]=\"(column.title | translate | async)!\"\n          [textField]=\"column.drillDisplayField\"\n          [columnFixed]=\"column.pin\"\n          [sortEnabled]=\"column.sortable\"\n          [headerSortDirection]=\"resolveColumnSortDirection(column.field)\"\n          [footerTemplate]=\"footerCell\"\n          (sortToggle)=\"handleColumnSort(column.field)\"\n          (commandClick)=\"handleGroupByDrill(column.drillDisplayField, $event.data)\"\n        ></axp-text-command-column>\n      } @else {\n        <axp-widget-column-renderer\n          [customWidth]=\"column.width == 'auto' ? 'auto' : column.width + 'px'\"\n          [caption]=\"(column.title | translate | async)!\"\n          [node]=\"column.widget!\"\n          [sortEnabled]=\"column.sortable\"\n          [headerSortDirection]=\"resolveColumnSortDirection(column.field)\"\n          [columnFixed]=\"column.pin\"\n          [footerTemplate]=\"footerCell\"\n          (sortToggle)=\"handleColumnSort(column.field)\"\n        ></axp-widget-column-renderer>\n      }\n    }\n  }\n  @if (hasPrimaryRowAction()) {\n    <ax-command-column\n      fixed=\"end\"\n      [width]=\"primaryRowAction().length * 70 + 'px'\"\n      [items]=\"primaryRowAction()\"\n      (onItemClick)=\"handleRowClick($event)\"\n    ></ax-command-column>\n  }\n  @if (hasSecondaryRowAction()) {\n    <ax-dropdown-command-column\n      fixed=\"end\"\n      [width]=\"'60px'\"\n      [items]=\"secondaryRowAction()\"\n      (onItemClick)=\"handleRowClick($event)\"\n    ></ax-dropdown-command-column>\n  }\n</ax-data-table>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXDataTableModule }, { kind: "component", type: i1$1.AXDataTableComponent, selector: "ax-data-table", inputs: ["dataSource", "selectedRows", "parentField", "hasChildrenField", "rowDetailsTemplate", "rowCssClass", "cellCssClass", "highlightText", "look", "rowTemplate", "emptyTemplate", "noDataTemplate", "alternative", "showHeader", "fixedHeader", "showFooter", "fixedFooter", "itemHeight", "allowReordering", "paging", "fetchDataMode", "loading", "focusedRow"], outputs: ["selectedRowsChange", "focusedRowChange", "onRowClick", "onRowDbClick", "onColumnsOrderChanged", "onColumnSizeChanged", "onPageChanged"] }, { kind: "component", type: i1$1.AXRowIndexColumnComponent, selector: "ax-index-column", inputs: ["width", "caption", "fixed", "footerTemplate", "padZero"] }, { kind: "component", type: i1$1.AXRowSelectColumnComponent, selector: "ax-select-column", inputs: ["width", "caption", "fixed"] }, { kind: "component", type: i1$1.AXRowCommandColumnComponent, selector: "ax-command-column", inputs: ["width", "caption", "fixed", "footerTemplate", "items"], outputs: ["onItemClick"] }, { kind: "component", type: i1$1.AXRowDropdownCommandColumnComponent, selector: "ax-dropdown-command-column", inputs: ["width", "caption", "fixed", "footerTemplate", "emptyStateTemplate", "emptyStateText", "items"], outputs: ["onItemClick"] }, { kind: "ngmodule", type: AXLoadingModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: i2$1.AXPWidgetColumnRendererComponent, selector: "axp-widget-column-renderer", inputs: ["caption", "customExpandIcon", "customCollapseIcon", "customWidth", "node", "footerTemplate", "expandHandler", "sortEnabled", "headerSortDirection", "headerSortPriority", "columnFixed", "cellTemplate", "headerTemplate"], outputs: ["sortToggle"] }, { kind: "component", type: AXPTextCommandColumnComponent, selector: "axp-text-command-column", inputs: ["caption", "textField", "customWidth", "columnFixed", "footerTemplate", "sortEnabled", "headerSortDirection", "headerSortPriority", "disabled", "emptyDisplay"], outputs: ["commandClick", "sortToggle"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i1.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportTableViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-report-table-view', imports: [
+                        CommonModule,
+                        AXDataTableModule,
+                        AXLoadingModule,
+                        AXDecoratorModule,
+                        AXTranslationModule,
+                        AXPWidgetCoreModule,
+                        AXPTextCommandColumnComponent,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: {
+                        class: 'axp-report-table-view flex flex-col flex-1 min-h-0 h-full w-full',
+                    }, template: "<ax-data-table\n  #grid\n  [dataSource]=\"dataSource\"\n  [paging]=\"paginationEnabled()\"\n  [showFooter]=\"hasReportFooterSummary()\"\n  [allowReordering]=\"true\"\n  (onRowDbClick)=\"handleDbRowClick($event)\"\n  (onColumnSizeChanged)=\"onColumnSizeChanged($event)\"\n  (onColumnsOrderChanged)=\"onColumnsOrderChanged($event)\"\n  (onPageChanged)=\"onPageChanged($event)\"\n  class=\"flex-1 min-h-0 h-full\"\n>\n  @if (vm.showRowIndexColumn()) {\n    <ax-index-column\n      [caption]=\"('@general:terms.common.row-number' | translate | async)!\"\n      fixed=\"start\"\n      [width]=\"'80px'\"\n      [padZero]=\"false\"\n    ></ax-index-column>\n  }\n  @if (vm.canSelectRows()) {\n    <ax-select-column fixed=\"start\" [width]=\"'50px'\"></ax-select-column>\n  }\n  @for (column of columns(); track column.field) {\n    @if (column.visible) {\n      <ng-template #footerCell>\n        <div\n          class=\"w-full truncate\"\n          [class.text-start]=\"column.align === 'left'\"\n          [class.text-center]=\"column.align === 'center'\"\n          [class.text-end]=\"column.align === 'right'\"\n        >\n          @if (isFirstVisibleColumn(column.field) && hasReportFooterSummary()) {\n            <span class=\"font-medium\">\n              {{ '@report-management:report-viewer.components.table.footer-total' | translate | async }}\n            </span>\n          } @else if (getSummaryDisplayValue(column.field); as summaryValue) {\n            <span>{{ summaryValue }}</span>\n          }\n        </div>\n      </ng-template>\n      @if (column.isGroupByDrillLink && column.drillDisplayField) {\n        <axp-text-command-column\n          [customWidth]=\"column.width == 'auto' ? 'auto' : column.width + 'px'\"\n          [caption]=\"(column.title | translate | async)!\"\n          [textField]=\"column.drillDisplayField\"\n          [columnFixed]=\"column.pin\"\n          [sortEnabled]=\"column.sortable\"\n          [headerSortDirection]=\"resolveColumnSortDirection(column.field)\"\n          [footerTemplate]=\"footerCell\"\n          (sortToggle)=\"handleColumnSort(column.field)\"\n          (commandClick)=\"handleGroupByDrill(column.drillDisplayField, $event.data)\"\n        ></axp-text-command-column>\n      } @else {\n        <axp-widget-column-renderer\n          [customWidth]=\"column.width == 'auto' ? 'auto' : column.width + 'px'\"\n          [caption]=\"(column.title | translate | async)!\"\n          [node]=\"column.widget!\"\n          [sortEnabled]=\"column.sortable\"\n          [headerSortDirection]=\"resolveColumnSortDirection(column.field)\"\n          [columnFixed]=\"column.pin\"\n          [footerTemplate]=\"footerCell\"\n          (sortToggle)=\"handleColumnSort(column.field)\"\n        ></axp-widget-column-renderer>\n      }\n    }\n  }\n  @if (hasPrimaryRowAction()) {\n    <ax-command-column\n      fixed=\"end\"\n      [width]=\"primaryRowAction().length * 70 + 'px'\"\n      [items]=\"primaryRowAction()\"\n      (onItemClick)=\"handleRowClick($event)\"\n    ></ax-command-column>\n  }\n  @if (hasSecondaryRowAction()) {\n    <ax-dropdown-command-column\n      fixed=\"end\"\n      [width]=\"'60px'\"\n      [items]=\"secondaryRowAction()\"\n      (onItemClick)=\"handleRowClick($event)\"\n    ></ax-dropdown-command-column>\n  }\n</ax-data-table>\n" }]
+        }], propDecorators: { grid: [{ type: i0.ViewChild, args: ['grid', { isSignal: true }] }] } });
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+const STYLE_PREFIX = /^(fa-light|fa-solid|fa-regular|fa-thin|fa-duotone)\s+/;
+const REPORT_LAYOUT_TITLE_KEYS = {
+    table: '@report-management:report-viewer.layouts.table.title',
+    bar: '@report-management:report-viewer.layouts.bar-chart.title',
+    doughnut: '@report-management:report-viewer.layouts.doughnut-chart.title',
+    pie: '@report-management:report-viewer.layouts.pie-chart.title',
+    line: '@report-management:report-viewer.layouts.line-chart.title',
+    pdf: '@report-management:report-viewer.layouts.pdf.title',
+    chart: '@report-management:report-viewer.layouts.chart.title',
+};
+const DEFAULT_LAYOUT_GLYPHS = {
+    table: 'fa-table',
+    pdf: 'fa-file-pdf',
+    chart: 'fa-chart-mixed',
+};
+//#endregion
+//#region ----- Layout switcher helpers -----
+function reportLayoutTitleKey(option) {
+    if (option.type === 'table') {
+        return REPORT_LAYOUT_TITLE_KEYS.table;
+    }
+    if (option.type === 'pdf') {
+        return REPORT_LAYOUT_TITLE_KEYS.pdf;
+    }
+    const glyph = stripIconStylePrefix(option.icon);
+    if (glyph.includes('fa-chart-bar')) {
+        return REPORT_LAYOUT_TITLE_KEYS.bar;
+    }
+    if (glyph.includes('fa-chart-pie')) {
+        return REPORT_LAYOUT_TITLE_KEYS.doughnut;
+    }
+    if (glyph.includes('fa-chart-line')) {
+        return REPORT_LAYOUT_TITLE_KEYS.line;
+    }
+    return REPORT_LAYOUT_TITLE_KEYS.chart;
+}
+function reportLayoutGlyph(icon, option) {
+    const fromIcon = stripIconStylePrefix(icon);
+    if (fromIcon) {
+        return fromIcon;
+    }
+    if (option.type === 'table') {
+        return DEFAULT_LAYOUT_GLYPHS['table'];
+    }
+    if (option.type === 'pdf') {
+        return DEFAULT_LAYOUT_GLYPHS['pdf'];
+    }
+    return DEFAULT_LAYOUT_GLYPHS['chart'];
+}
+function reportLayoutPageIcon(icon, option) {
+    return `fa-light ${reportLayoutGlyph(icon, option)}`;
+}
+function isDistinctLayoutTitle(layoutTitle, reportTitle, locale) {
+    const resolvedLayout = resolveMultiLanguageString(layoutTitle, locale).trim();
+    if (!resolvedLayout) {
+        return false;
+    }
+    const resolvedReport = resolveMultiLanguageString(reportTitle, locale).trim();
+    return resolvedLayout !== resolvedReport;
+}
+function stripIconStylePrefix(icon) {
+    if (!icon?.trim()) {
+        return '';
+    }
+    return icon.trim().replace(STYLE_PREFIX, '').trim();
+}
+//#endregion
+
+class AXPReportViewerPageComponent extends AXPPageLayoutBaseComponent {
+    constructor() {
+        super();
+        //#region ----   Dependencies   ----
+        this.layoutService = inject(AXPLayoutThemeService);
+        this.deviceService = inject(AXPDeviceService);
+        this.route = inject(ActivatedRoute);
+        this.unsubscriber = inject(AXUnsubscriber);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.destroyRef = inject(DestroyRef);
+        this.reportViewerService = inject(AXPReportViewerService);
+        this.entityService = inject(AXPEntityService);
+        //#endregion
+        //#region ----   Inputs   ----
+        this.reportId = input(/* @ts-ignore */
+        ...(ngDevMode ? [undefined, { debugName: "reportId" }] : /* istanbul ignore next */ []));
+        this.reportParameters = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "reportParameters" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   ViewChildren   ----
+        this.filtersForm = viewChild('filtersForm', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "filtersForm" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   ViewModel   ----
+        this.vm = inject(AXPReportViewerViewModel);
+        //#endregion
+        //#region ----   Effects   ----
+        this.watchNavigationLoading = effect(() => {
+            const isBusy = this.vm.isLoading() || this.vm.isExecuting();
+            untracked(() => {
+                this.layoutService.setNavigationLoading(isBusy);
+                //
+                if (isBusy) {
+                    void this.openContentLoading();
+                }
+                else {
+                    this.closeContentLoading();
+                }
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "watchNavigationLoading" }] : /* istanbul ignore next */ []));
+        //#endregion
+        this.loadingDialogRef = null;
+        this.isDialogOpening = false;
+        this.lastReportRouteKey = null;
+        //#region ----   Computed Properties   ----
+        this.showFiltersPanel = () => this.deviceService.isLarge();
+        this.showReportDisplay = () => !this.vm.isBackgroundReportMode() &&
+            !this.vm.isBackgroundQueued() &&
+            (this.deviceService.isLarge() || (this.deviceService.isSmall() && this.vm.hasBeenExecuted()));
+        //#endregion
+        //#region ----   Layout Configurations   ----
+        this.defaultLayout = () => ({
+            positions: {
+                sm: { colSpan: 12 },
+                md: { colSpan: 6 },
+                lg: { colSpan: 12 },
+            },
+        });
+        this.compactLayout = () => ({
+            positions: {
+                sm: { colSpan: 12 },
+                md: { colSpan: 4 },
+                lg: { colSpan: 3 },
+            },
+        });
+        this.layoutPageIcon = reportLayoutPageIcon;
+        this.destroyRef.onDestroy(() => this.closeContentLoading());
+    }
+    reportsListPath() {
+        return this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.report.name)
+            .createPath();
+    }
+    //#endregion
+    //#region ----   Lifecycle   ----
+    async ngOnInit() {
+        await super.ngOnInit();
+        // Reload when reportId or runId changes. Ignore other query params (live filters).
+        this.unsubscriber
+            .takeUntilDestroy(combineLatest([this.route.paramMap, this.route.queryParamMap]))
+            .subscribe(async ([params, queryParams]) => {
+            const reportId = params.get('reportId') || queryParams.get('reportId') || this.reportId();
+            if (!reportId) {
+                return;
+            }
+            const runId = queryParams.get('runId')?.trim() || '';
+            const routeKey = `${reportId}::${runId}`;
+            if (routeKey === this.lastReportRouteKey) {
+                return;
+            }
+            this.lastReportRouteKey = routeKey;
+            await this.loadReportAndRefresh(reportId);
+        });
+    }
+    /**
+     * Effect to handle data fetching when chart configuration changes
+     */
+    //#endregion
+    //#region ----   Helper Methods   ----
+    async loadReportAndRefresh(reportId) {
+        const runId = this.route.snapshot.queryParamMap.get('runId')?.trim();
+        if (runId) {
+            await this.vm.loadReport(reportId);
+            await this.vm.loadFrozenRun(runId);
+            this.recompute();
+            return;
+        }
+        await this.vm.loadReport(reportId);
+        // Force refresh of page layout (breadcrumbs, title, etc.) after report loads
+        this.recompute();
+        // Handle initial parameters from query string
+        const queryParams = this.route.snapshot.queryParams;
+        const initialParams = { ...queryParams };
+        delete initialParams['reportId'];
+        delete initialParams['runId'];
+        // Parse filter context values coming from URL (they are strings)
+        const parsedInitialParams = this.parseFilterContextFromUrl(initialParams);
+        // Merge with component input parameters (`today` / `{ from, to }` → filter shape)
+        const rawParams = { ...parsedInitialParams, ...this.reportParameters() };
+        const allParams = Object.fromEntries(Object.entries(rawParams).map(([key, value]) => [key, resolveReportFilterDefaultValue(value)]));
+        if (Object.keys(allParams).length > 0) {
+            console.log('Applying initial parameters:', allParams);
+            this.vm.updateFilterContext(allParams);
+            // Auto-execute if parameters are provided
+            setTimeout(async () => {
+                await this.vm.executeReport();
+            }, 500); // Small delay to ensure form is ready
+        }
+    }
+    async openContentLoading() {
+        if (this.loadingDialogRef || this.isDialogOpening) {
+            return;
+        }
+        this.isDialogOpening = true;
+        try {
+            const [title, description, cancelText] = await Promise.all([
+                this.translateService.translateAsync('@report-management:report-viewer.messages.loading.in-progress-title'),
+                this.translateService.translateAsync('@report-management:report-viewer.messages.loading.in-progress-description'),
+                this.translateService.translateAsync('@report-management:report-viewer.messages.loading.cancel-button'),
+            ]);
+            this.loadingDialogRef = this.loadingDialog.show({
+                title,
+                mode: 'indeterminate',
+                progressColor: 'primary',
+                text: description,
+                buttons: [
+                    {
+                        text: cancelText,
+                        color: 'danger',
+                        onClick: () => {
+                            this.closeContentLoading();
+                            this.vm.cancel();
+                        },
+                    },
+                ],
+            });
+        }
+        finally {
+            this.isDialogOpening = false;
+        }
+    }
+    closeContentLoading() {
+        if (!this.loadingDialogRef) {
+            return;
+        }
+        this.loadingDialogRef.close();
+        this.loadingDialogRef = null;
+    }
+    /**
+     * Synchronizes filter context to URL query parameters using dot notation
+     * @param filterContext The current filter context to sync
+     */
+    syncFiltersToUrl(filterContext) {
+        // Get current query params
+        const currentParams = this.route.snapshot.queryParams;
+        const reportId = currentParams['reportId'];
+        // Get all filter keys from current params (excluding reportId and internal fields)
+        const currentFilterKeys = new Set();
+        Object.keys(currentParams).forEach((key) => {
+            if (key !== 'reportId' &&
+                key !== 'runId' &&
+                !key.endsWith('EditorObj') &&
+                !key.startsWith('__') &&
+                !key.endsWith('EditorValue') &&
+                !key.includes('.displayText')) {
+                // Extract root key (before first dot) for filter identification
+                const rootKey = key.includes('.') ? key.split('.')[0] : key;
+                currentFilterKeys.add(rootKey);
+            }
+        });
+        // Build new query params - start with current params and remove filter-related ones
+        const queryParams = { ...currentParams };
+        // Remove all filter-related params first (we'll add them back if they have values)
+        Object.keys(queryParams).forEach((key) => {
+            if (key !== 'reportId' &&
+                key !== 'runId' &&
+                !key.endsWith('EditorObj') &&
+                !key.startsWith('__') &&
+                !key.endsWith('EditorValue') &&
+                !key.includes('.displayText')) {
+                delete queryParams[key];
+            }
+        });
+        const processedFilterKeys = new Set();
+        // Add filter params that have values
+        Object.keys(filterContext).forEach((key) => {
+            // Skip internal editor fields (EditorObj, __EditorValue)
+            if (key.endsWith('EditorObj') || key.startsWith('__') || key.endsWith('EditorValue')) {
+                return;
+            }
+            processedFilterKeys.add(key);
+            const value = filterContext[key];
+            // Check if value is empty (null, undefined, empty string, or empty array)
+            const isEmpty = this.isFilterValueEmpty(value);
+            if (!isEmpty) {
+                const flattened = this.flattenToDotNotation(key, value);
+                Object.assign(queryParams, flattened);
+            }
+            // If empty, we don't add it to queryParams, so it will be removed from URL
+        });
+        // Remove filter keys that are no longer in filterContext
+        currentFilterKeys.forEach((filterKey) => {
+            if (!processedFilterKeys.has(filterKey)) {
+                // This filter was removed - ensure all related params are removed
+                Object.keys(currentParams).forEach((paramKey) => {
+                    if (paramKey === filterKey || paramKey.startsWith(`${filterKey}.`)) {
+                        delete queryParams[paramKey];
+                    }
+                });
+            }
+        });
+        // Preserve reportId / runId if exists
+        if (reportId) {
+            queryParams['reportId'] = String(reportId);
+        }
+        else {
+            delete queryParams['reportId'];
+        }
+        const runId = currentParams['runId'];
+        if (runId) {
+            queryParams['runId'] = String(runId);
+        }
+        else {
+            delete queryParams['runId'];
+        }
+        // Update URL without reloading
+        this.router.navigate([], {
+            relativeTo: this.route,
+            queryParams: queryParams,
+            replaceUrl: true, // Don't add to browser history
+        });
+    }
+    /**
+     * Checks if a filter value is considered empty
+     */
+    isFilterValueEmpty(value) {
+        if (value === null || value === undefined || value === '') {
+            return true;
+        }
+        // Check if it's a filter object with empty value
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            const filterObj = value;
+            const filterValue = filterObj.value;
+            if (filterValue === null || filterValue === undefined || filterValue === '') {
+                return true;
+            }
+            if (Array.isArray(filterValue) && filterValue.length === 0) {
+                return true;
+            }
+            // Check nested object values
+            if (typeof filterValue === 'object' && !Array.isArray(filterValue)) {
+                const hasAnyValue = Object.values(filterValue).some((v) => v !== null && v !== undefined && v !== '');
+                return !hasAnyValue;
+            }
+        }
+        // Check if it's an empty array
+        if (Array.isArray(value) && value.length === 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Flattens filter context to dot notation query parameters
+     * Only includes operation.type and value - skips displayText and other fields
+     * Example: { operation: { type: 'in' }, value: ['POST', 'GET'] }
+     *          -> { 'fieldName.operation.type': 'in', 'fieldName.value': 'POST,GET' }
+     */
+    flattenToDotNotation(prefix, value) {
+        const result = {};
+        if (value == null) {
+            return result;
+        }
+        // Handle filter context object - only extract operation.type and value
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            const filterObj = value;
+            // Extract operation.type if exists
+            if (filterObj.operation?.type) {
+                result[`${prefix}.operation.type`] = String(filterObj.operation.type);
+            }
+            // Extract value - handle arrays and primitives
+            if (filterObj.value !== undefined && filterObj.value !== null && filterObj.value !== '') {
+                if (Array.isArray(filterObj.value)) {
+                    if (filterObj.value.length > 0) {
+                        result[`${prefix}.value`] = filterObj.value.map((v) => String(v)).join(',');
+                    }
+                }
+                else if (typeof filterObj.value === 'object') {
+                    // If value is an object, flatten it recursively
+                    const flattenedValue = this.flattenValueObject(filterObj.value);
+                    Object.assign(result, flattenedValue);
+                }
+                else {
+                    result[`${prefix}.value`] = String(filterObj.value);
+                }
+            }
+            return result;
+        }
+        // Handle primitives directly
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            result[prefix] = String(value);
+            return result;
+        }
+        // Handle arrays - join with comma
+        if (Array.isArray(value)) {
+            if (value.length > 0) {
+                result[prefix] = value.map(v => String(v)).join(',');
+            }
+            return result;
+        }
+        // Fallback: convert to string
+        result[prefix] = String(value);
+        return result;
+    }
+    /**
+     * Flattens a value object (for nested objects in value field)
+     */
+    flattenValueObject(obj, prefix = '') {
+        const result = {};
+        if (obj == null || typeof obj !== 'object') {
+            return result;
+        }
+        for (const [key, val] of Object.entries(obj)) {
+            const newPrefix = prefix ? `${prefix}.${key}` : key;
+            if (val == null) {
+                continue;
+            }
+            if (typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean') {
+                result[newPrefix] = String(val);
+            }
+            else if (Array.isArray(val)) {
+                if (val.length > 0) {
+                    result[newPrefix] = val.map((v) => String(v)).join(',');
+                }
+            }
+            else if (typeof val === 'object') {
+                const flattened = this.flattenValueObject(val, newPrefix);
+                Object.assign(result, flattened);
+            }
+        }
+        return result;
+    }
+    /**
+     * Reconstructs filter context from dot notation query parameters
+     * Only parses operation.type and value - ignores other fields
+     * Example: { 'fieldName.operation.type': 'in', 'fieldName.value': 'POST,GET' }
+     *          -> { fieldName: { operation: { type: 'in' }, value: ['POST', 'GET'] } }
+     */
+    parseFilterContextFromUrl(params) {
+        const result = {};
+        // Filter out reportId and internal editor fields
+        const filteredParams = {};
+        for (const [key, value] of Object.entries(params)) {
+            // Skip reportId and internal editor fields (EditorObj, __EditorValue, displayText)
+            if (key !== 'reportId' &&
+                key !== 'runId' &&
+                !key.endsWith('EditorObj') &&
+                !key.startsWith('__') &&
+                !key.endsWith('EditorValue') &&
+                !key.includes('.displayText')) {
+                filteredParams[key] = value;
+            }
+        }
+        // Group by root key (before first dot)
+        for (const [key, value] of Object.entries(filteredParams)) {
+            if (!key.includes('.')) {
+                // Simple key without dot notation - skip (we only want operation.type and value)
+                continue;
+            }
+            // Split by dot and reconstruct nested structure
+            const parts = key.split('.');
+            const rootKey = parts[0];
+            const path = parts.slice(1);
+            // Only process operation.type and value paths
+            if (path.length === 2 && path[0] === 'operation' && path[1] === 'type') {
+                // operation.type
+                if (!result[rootKey]) {
+                    result[rootKey] = { operation: {} };
+                }
+                if (!result[rootKey].operation) {
+                    result[rootKey].operation = {};
+                }
+                result[rootKey].operation.type = String(value);
+            }
+            else if (path.length === 1 && path[0] === 'value') {
+                // value
+                if (!result[rootKey]) {
+                    result[rootKey] = {};
+                }
+                result[rootKey].value = this.parseValue(String(value));
+            }
+            else if (path.length > 1 && path[0] === 'value') {
+                // nested value object (e.g., value.from, value.to for between)
+                if (!result[rootKey]) {
+                    result[rootKey] = {};
+                }
+                if (!result[rootKey].value) {
+                    result[rootKey].value = {};
+                }
+                const valuePath = path.slice(1);
+                this.setNestedValue(result[rootKey].value, valuePath, this.parseValue(String(value)));
+            }
+        }
+        // Post-process: Convert values to arrays if operation.type is 'in' or 'notIn'
+        // Also reconstruct EditorObj for lookup widgets (from value only, no displayText)
+        for (const [key, value] of Object.entries(result)) {
+            if (value && typeof value === 'object' && value.operation?.type) {
+                const operationType = value.operation.type;
+                // If operation is 'in' or 'notIn', ensure value is an array
+                if ((operationType === 'in' || operationType === 'notIn') && typeof value.value === 'string') {
+                    // Convert comma-separated string to array
+                    value.value = value.value.split(',').map((v) => v.trim()).filter((v) => v !== '');
+                }
+                // Reconstruct EditorObj for lookup widgets from value only
+                // This is needed because lookup widget expects EditorObj to exist
+                if (value.value !== undefined && value.value !== null && value.value !== '') {
+                    const editorObjKey = `${key}EditorObj`;
+                    const valueField = 'id'; // Default value field for lookup
+                    const textField = 'title'; // Default text field for lookup
+                    if (operationType === 'in' || operationType === 'notIn') {
+                        // Multiple selection: create array of objects with value as both id and title
+                        const values = Array.isArray(value.value) ? value.value : [value.value];
+                        result[editorObjKey] = values.map((val) => ({
+                            [valueField]: val,
+                            [textField]: val // Use value as title since we don't have displayText
+                        }));
+                    }
+                    else {
+                        // Single selection: create single object
+                        result[editorObjKey] = {
+                            [valueField]: value.value,
+                            [textField]: value.value // Use value as title since we don't have displayText
+                        };
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Sets a value in a nested object using a path array
+     */
+    setNestedValue(obj, path, value) {
+        let current = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+            const key = path[i];
+            if (!current[key] || typeof current[key] !== 'object') {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+        const lastKey = path[path.length - 1];
+        current[lastKey] = value;
+    }
+    /**
+     * Parses a string value, handling arrays (comma-separated) and primitives
+     */
+    parseValue(value) {
+        if (value === '') {
+            return value;
+        }
+        // Check if it's a comma-separated array
+        if (value.includes(',')) {
+            return value.split(',').map(v => this.parsePrimitive(v.trim()));
+        }
+        return this.parsePrimitive(value);
+    }
+    /**
+     * Parses a primitive value
+     * For query params, we keep everything as string to match user requirement
+     * Arrays are handled separately in parseValue
+     */
+    parsePrimitive(value) {
+        return value;
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    handleFiltersChange(event) {
+        this.vm.updateFilterContext(event);
+        this.syncFiltersToUrl(event);
+    }
+    handleFiltersInitiated(event) {
+        this.vm.updateFilterContext(event);
+    }
+    async handleExecuteReport() {
+        if (this.vm.isFrozen()) {
+            return;
+        }
+        const isValid = await this.filtersForm()?.validate();
+        if (!isValid?.result) {
+            return;
+        }
+        await this.vm.executeReport();
+    }
+    async handleGenerateInBackground() {
+        if (this.vm.isFrozen()) {
+            return;
+        }
+        const isValid = await this.filtersForm()?.validate();
+        if (!isValid?.result) {
+            return;
+        }
+        await this.vm.generateInBackground();
+        this.recompute();
+    }
+    canGenerateInBackground() {
+        return (this.sessionService.isFeatureEnabled(AXPReportManagementFeatureKeys.BackgroundReports) &&
+            !this.vm.isFrozen() &&
+            (this.vm.generationMode() === 'choose' || this.vm.generationMode() === 'background'));
+    }
+    handleRefresh() {
+        this.vm.refresh();
+    }
+    handleClearFilters() {
+        this.vm.clearFilters();
+        // Reset form if available
+        const form = this.filtersForm();
+        if (form) {
+            form.reset();
+        }
+        // Clear URL query parameters (preserve reportId if exists)
+        const currentParams = this.route.snapshot.queryParams;
+        const reportId = currentParams['reportId'];
+        const runId = currentParams['runId'];
+        this.router.navigate([], {
+            relativeTo: this.route,
+            queryParams: {
+                ...(reportId ? { reportId } : {}),
+                ...(runId ? { runId } : {}),
+            },
+            replaceUrl: true,
+        });
+    }
+    /**
+     * Handle download report action
+     * Gets PDF data from viewmodel and calls service executeAction method
+     */
+    async handleDownloadReport() {
+        if (!this.vm.isPdfLayout()) {
+            const warning = await this.translateService.translateAsync('@report-management:report-viewer.messages.warnings.download-pdf-only');
+            console.warn(warning);
+            return;
+        }
+        // Fetch PDF data if not already available
+        const pdfData = queryResultToPdfSource(await this.vm.fetchData());
+        if (pdfData) {
+            await this.reportViewerService.executeAction('download-report', { pdfData });
+        }
+        else {
+            const warning = await this.translateService.translateAsync('@report-management:report-viewer.messages.warnings.no-pdf-download');
+            console.warn(warning);
+        }
+    }
+    /**
+     * Handle print report action
+     * Gets PDF data from viewmodel and calls service executeAction method
+     */
+    async handlePrintReport() {
+        if (!this.vm.isPdfLayout()) {
+            const warning = await this.translateService.translateAsync('@report-management:report-viewer.messages.warnings.print-pdf-only');
+            console.warn(warning);
+            return;
+        }
+        // Fetch PDF data if not already available
+        const pdfData = queryResultToPdfSource(await this.vm.fetchData());
+        if (pdfData) {
+            await this.reportViewerService.executeAction('print-report', { pdfData });
+        }
+        else {
+            const warning = await this.translateService.translateAsync('@report-management:report-viewer.messages.warnings.no-pdf-print');
+            console.warn(warning);
+        }
+    }
+    /**
+     * Handle export report action
+     * Gets report data from viewmodel and calls service executeAction method
+     * @param format - Export format (excel, csv, pdf, image)
+     */
+    async handleExportReport(format) {
+        if (!format) {
+            const warning = await this.translateService.translateAsync('@report-management:report-viewer.messages.warnings.export-format-required');
+            console.warn(warning);
+            return;
+        }
+        // Fetch report data
+        const result = await this.vm.fetchData();
+        const reportData = runtimeQueryPayloadData(result);
+        if (reportData == null) {
+            const warning = await this.translateService.translateAsync('@report-management:report-viewer.messages.warnings.no-report-data-export');
+            console.warn(warning);
+            return;
+        }
+        const layout = this.vm.currentLayout();
+        await this.reportViewerService.executeAction('export-report', {
+            format,
+            reportData,
+            layoutDefinition: layout || undefined,
+        });
+    }
+    getLayoutSelectionLabel(layout) {
+        const locale = this.translateService.getActiveLang() || 'en-US';
+        const reportTitle = this.vm.reportDefinition()?.title;
+        if (isDistinctLayoutTitle(layout.title, reportTitle, locale)) {
+            return layout.title ?? reportLayoutTitleKey(layout);
+        }
+        return reportLayoutTitleKey(layout);
+    }
+    handleBackgroundLayoutToggle(layoutId, selected) {
+        this.vm.setBackgroundLayoutSelected(layoutId, selected);
+    }
+    //#endregion
+    //#region ----   Page Configuration Overrides   ----
+    async getPageBreadcrumbs() {
+        const breadcrumbs = [
+            {
+                name: 'reports',
+                title: await this.translateService.translateAsync('@report-management:module.menus.root.title'),
+                command: {
+                    name: 'navigate',
+                    options: {
+                        path: this.reportsListPath(),
+                    },
+                },
+            },
+        ];
+        const reportDefinition = this.vm.reportDefinition();
+        if (reportDefinition) {
+            breadcrumbs.push({
+                name: 'report-viewer',
+                title: reportDefinition.title,
+            });
+        }
+        return breadcrumbs;
+    }
+    async getPageTitle() {
+        const reportDefinition = this.vm.reportDefinition();
+        if (reportDefinition) {
+            return reportDefinition.title;
+        }
+        return await this.translateService.translateAsync('@report-management:report-viewer.components.report-viewer.title');
+    }
+    async getPageDescription() {
+        const reportDefinition = this.vm.reportDefinition();
+        return reportDefinition?.description || null;
+    }
+    getPageIcon() {
+        if (this.vm.isBackgroundReportMode() ||
+            this.vm.isBackgroundQueued() ||
+            !this.vm.hasMultipleLayouts() ||
+            !this.showReportDisplay()) {
+            return null;
+        }
+        const currentLayout = this.vm.currentLayout();
+        if (!currentLayout) {
+            return null;
+        }
+        return reportLayoutPageIcon(currentLayout.icon, {
+            type: currentLayout.layout.type,
+        });
+    }
+    async getTitleActions() {
+        if (this.vm.isBackgroundReportMode() ||
+            this.vm.isBackgroundQueued() ||
+            !this.vm.hasMultipleLayouts() ||
+            !this.showReportDisplay()) {
+            return [];
+        }
+        const currentLayoutId = this.vm.currentLayout()?.id;
+        const reportTitle = this.vm.reportDefinition()?.title;
+        const locale = this.translateService.getActiveLang() || 'en-US';
+        const items = [];
+        for (const layout of this.vm.availableLayouts()) {
+            items.push({
+                title: await this.resolveLayoutSwitcherTitle(layout, reportTitle, locale),
+                icon: reportLayoutGlyph(layout.icon, layout),
+                command: {
+                    name: 'switch-layout',
+                    metadata: { isLayout: true, layoutId: layout.id, isSelected: layout.id === currentLayoutId },
+                },
+            });
+        }
+        return items.sort((a, b) => resolveMultiLanguageString(a.title, locale).localeCompare(resolveMultiLanguageString(b.title, locale), undefined, { sensitivity: 'base' }));
+    }
+    async resolveLayoutSwitcherTitle(layout, reportTitle, locale) {
+        if (isDistinctLayoutTitle(layout.title, reportTitle, locale)) {
+            if (typeof layout.title === 'string' && layout.title.startsWith('@')) {
+                return await this.translateService.translateAsync(layout.title);
+            }
+            if (typeof layout.title === 'object') {
+                return this.translateService.resolve(layout.title) || layout.title;
+            }
+            return layout.title;
+        }
+        return await this.translateService.translateAsync(reportLayoutTitleKey(layout));
+    }
+    async getBackButton() {
+        // On mobile, if report has been executed (showing report), show "Filters" as back button
+        if (this.deviceService.isSmall() && this.vm.hasBeenExecuted()) {
+            return {
+                title: await this.translateService.translateAsync('@general:terms.interface.filter.title'),
+            };
+        }
+        return {
+            title: await this.translateService.translateAsync('@report-management:module.menus.root.title'),
+        };
+    }
+    async onBackButtonClick() {
+        // On mobile, if report has been executed (showing report), go back to filters
+        if (this.deviceService.isSmall() && this.vm.hasBeenExecuted()) {
+            this.vm.clearExecutionState();
+            return;
+        }
+        await this.router.navigateByUrl(this.reportsListPath());
+    }
+    async getPrimaryMenuItems() {
+        if (this.vm.isBackgroundReportMode() && !this.vm.isFrozen()) {
+            return [];
+        }
+        const currentLayout = this.vm.currentLayout();
+        if (!currentLayout) {
+            return [];
+        }
+        // Get primary actions from service (includes general actions + layout-specific actions)
+        const primaryActions = this.reportViewerService.getPrimaryActions(currentLayout);
+        // Convert AXPReportLayoutAction[] to AXPActionMenuItem[] (remove priority property)
+        return primaryActions.map(({ priority, ...action }) => action);
+    }
+    async getSecondaryMenuItems() {
+        if (this.vm.isBackgroundReportMode() && !this.vm.isFrozen()) {
+            return [];
+        }
+        const currentLayout = this.vm.currentLayout();
+        if (!currentLayout) {
+            return [];
+        }
+        const secondaryActions = this.reportViewerService.getSecondaryActions(currentLayout);
+        const items = secondaryActions.map(({ priority, ...action }) => action);
+        if (this.canGenerateInBackground() && this.vm.generationMode() === 'choose') {
+            items.unshift({
+                title: '@report-management:report-generation.actions.generate-in-background',
+                icon: 'fa-light fa-clock',
+                command: { name: 'generate-in-background' },
+            });
+        }
+        return items;
+    }
+    async execute(command) {
+        // Handle layout switching from title actions
+        if (command.metadata?.['isLayout']) {
+            const layoutId = command.metadata?.['layoutId'];
+            if (layoutId) {
+                this.vm.switchLayout(layoutId);
+                this.recompute();
+            }
+            return;
+        }
+        switch (command.name) {
+            case 'execute-report':
+                await this.handleExecuteReport();
+                break;
+            case 'generate-in-background':
+                await this.handleGenerateInBackground();
+                break;
+            case 'refresh-report':
+                this.handleRefresh();
+                break;
+            case 'reset-filters':
+                this.handleClearFilters();
+                break;
+            case 'download-report':
+                this.handleDownloadReport();
+                break;
+            case 'print-report':
+                this.handlePrintReport();
+                break;
+            case 'export-report':
+                await this.handleExportReport(command.options?.['format']);
+                break;
+            default:
+                const warning = await this.translateService.translateAsync('@report-management:report-viewer.messages.warnings.unknown-command', {
+                    params: { commandName: command.name },
+                });
+                console.warn(warning);
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerPageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPReportViewerPageComponent, isStandalone: true, selector: "axp-report-viewer-page", inputs: { reportId: { classPropertyName: "reportId", publicName: "reportId", isSignal: true, isRequired: false, transformFunction: null }, reportParameters: { classPropertyName: "reportParameters", publicName: "reportParameters", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "axp-report-viewer-page" }, providers: [
+            AXUnsubscriber,
+            AXPReportViewerViewModel,
+            {
+                provide: AXPPageLayoutBase,
+                useExisting: AXPReportViewerPageComponent,
+            },
+        ], viewQueries: [{ propertyName: "filtersForm", first: true, predicate: ["filtersForm"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: "<axp-page-layout *translate=\"let t\">\n  <!-- Left Panel: Filters (Always visible for desktop) -->\n  @if (showFiltersPanel()) {\n  <axp-layout-start-side>\n    <axp-layout-header>\n      <axp-layout-title>\n        {{ t('@report-management:report-viewer.components.filters.title') | async }}\n      </axp-layout-title>\n    </axp-layout-header>\n    <axp-layout-content>\n      @if (vm.reportDefinition()) {\n      <axp-layout-renderer #filtersForm [layout]=\"vm.formDefinition()\" [context]=\"vm.filterContext()\" [look]=\"'card'\"\n        (contextChange)=\"handleFiltersChange($event)\" (contextInitiated)=\"handleFiltersInitiated($event)\">\n      </axp-layout-renderer>\n      <!-- ----- Background report layout multi-select ----- -->\n      @if (vm.isBackgroundReportMode() && !vm.isBackgroundQueued() && vm.availableLayouts().length > 0) {\n        <div class=\"mt-4 pt-4 border-t\">\n          <div class=\"mb-2\">\n            <span class=\"text-sm font-medium\">\n              {{ t('@report-management:report-generation.components.background-layouts.title') | async }}\n            </span>\n          </div>\n          <p class=\"text-xs opacity-70 mb-3\">\n            {{ t('@report-management:report-generation.components.background-layouts.description') | async }}\n          </p>\n          <div class=\"flex flex-col gap-2\">\n            @for (layout of vm.availableLayouts(); track layout.id) {\n              <label class=\"flex items-center gap-2 p-2 rounded border cursor-pointer hover:bg-neutral-50\">\n                <ax-check-box\n                  [ngModel]=\"vm.isBackgroundLayoutSelected(layout.id)\"\n                  (ngModelChange)=\"handleBackgroundLayoutToggle(layout.id, $event)\"\n                ></ax-check-box>\n                <ax-icon [icon]=\"layoutPageIcon(layout.icon, layout)\"></ax-icon>\n                <span class=\"text-sm\">{{ getLayoutSelectionLabel(layout) | translate | async }}</span>\n              </label>\n            }\n          </div>\n        </div>\n      }\n      }\n    </axp-layout-content>\n    <axp-layout-footer class=\"p-4 border-t\" *translate=\"let t\">\n      @if (vm.hasUnappliedFilters()) {\n      <div class=\"w-full warning-lightest-surface mb-2 p-2 rounded border border-warning-200\">\n        <div class=\"flex items-center gap-2 text-warning-800\">\n          <ax-icon class=\"fa-light fa-exclamation-triangle text-sm\"></ax-icon>\n          <span class=\"text-xs\">{{\n            t('@report-management:report-viewer.components.filters.messages.warning.unapplied') | async\n            }}</span>\n        </div>\n      </div>\n      }\n      @if (vm.isBackgroundReportMode() && !vm.hasSelectedBackgroundLayouts() && !vm.isBackgroundQueued()) {\n        <div class=\"w-full warning-lightest-surface mb-2 p-2 rounded border border-warning-200\">\n          <div class=\"flex items-center gap-2 text-warning-800\">\n            <ax-icon class=\"fa-light fa-exclamation-triangle text-sm\"></ax-icon>\n            <span class=\"text-xs\">{{\n              t('@report-management:report-generation.errors.no-layouts-selected') | async\n              }}</span>\n          </div>\n        </div>\n      }\n      <ax-button class=\"w-full\" [disabled]=\"!vm.canExecute() || vm.areParametersReadonly() || vm.isBackgroundQueued()\"\n        [text]=\"(vm.isBackgroundReportMode()\n          ? t('@report-management:report-generation.actions.generate-in-background')\n          : t('@report-management:report-viewer.actions.execute.title')) | async\" [color]=\"'primary'\"\n        (onClick)=\"execute({ name: 'execute-report' })\">\n        <ax-prefix>\n          <ax-icon [icon]=\"vm.isBackgroundReportMode() ? 'fa-light fa-clock' : 'fa-light fa-play'\"></ax-icon>\n        </ax-prefix>\n      </ax-button>\n      <!-- ----- Secondary background generate for choose mode ----- -->\n      @if (canGenerateInBackground() && vm.generationMode() === 'choose') {\n        <ax-button class=\"w-full mt-2\" [disabled]=\"vm.areParametersReadonly()\"\n          [text]=\"t('@report-management:report-generation.actions.generate-in-background') | async\" [color]=\"'default'\"\n          (onClick)=\"execute({ name: 'generate-in-background' })\">\n          <ax-prefix>\n            <ax-icon icon=\"fa-light fa-clock\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      }\n    </axp-layout-footer>\n  </axp-layout-start-side>\n  }\n  <!-- Main Content: Report Display -->\n  <axp-page-content class=\"overflow-auto\">\n    @if (vm.isFrozen()) {\n      <!-- ----- Frozen run banner ----- -->\n      <div class=\"warning-lightest-surface mb-3 p-3 rounded border border-warning-200 text-warning-800 text-sm\">\n        {{ t('@report-management:report-generation.banners.frozen') | async }}\n      </div>\n    }\n    @if (vm.hasError()) {\n    <!-- Error State -->\n    <axp-state-message icon=\"fa-light fa-exclamation-triangle\"\n      [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n      [description]=\"vm.error() || '@report-management:report-viewer.messages.error.unexpected'\">\n      <div slot=\"actions\">\n        <ax-button look=\"outline\" color=\"primary\"\n          [text]=\"t('@report-management:report-viewer.actions.retry.title') | async\" (onClick)=\"vm.clearError()\">\n          <ax-prefix>\n            <ax-icon class=\"fa-light fa-refresh\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      </div>\n    </axp-state-message>\n    } @else if (!vm.reportDefinition()) {\n    <!-- No Report Selected State -->\n    <axp-state-message icon=\"fa-light fa-chart-line\"\n      [title]=\"'@report-management:report-viewer.components.report-viewer.empty-states.no-report.title'\"\n      [description]=\"'@report-management:report-viewer.components.report-viewer.empty-states.no-report.description'\">\n      <div slot=\"actions\">\n        <ax-button look=\"outline\" color=\"primary\"\n          [text]=\"t('@report-management:report-viewer.actions.browse-reports.title') | async\">\n          <ax-prefix>\n            <ax-icon class=\"fa-light fa-folder-open\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      </div>\n    </axp-state-message>\n    <!-- ----- Background report message state (no live layout preview) ----- -->\n    } @else if (vm.isBackgroundReportMode() || vm.isBackgroundQueued()) {\n      <!-- ----- Mobile filters and layout selection for background reports ----- -->\n      @if (deviceService.isSmall() && !vm.isBackgroundQueued()) {\n        <axp-layout-renderer #filtersForm [layout]=\"vm.formDefinition()\" [context]=\"vm.filterContext()\" [look]=\"'fieldset'\"\n          (contextChange)=\"handleFiltersChange($event)\" (contextInitiated)=\"handleFiltersInitiated($event)\">\n        </axp-layout-renderer>\n        @if (vm.availableLayouts().length > 0) {\n          <div class=\"mt-4 pt-4 border-t\">\n            <div class=\"flex items-center justify-between gap-2 mb-2\">\n              <span class=\"text-sm font-medium\">\n                {{ t('@report-management:report-generation.components.background-layouts.title') | async }}\n              </span>\n            </div>\n            <p class=\"text-xs opacity-70 mb-3\">\n              {{ t('@report-management:report-generation.components.background-layouts.description') | async }}\n            </p>\n            <div class=\"flex flex-col gap-2\">\n              @for (layout of vm.availableLayouts(); track layout.id) {\n                <label class=\"flex items-center gap-2 p-2 rounded border cursor-pointer\">\n                  <ax-check-box\n                    [ngModel]=\"vm.isBackgroundLayoutSelected(layout.id)\"\n                    (ngModelChange)=\"handleBackgroundLayoutToggle(layout.id, $event)\"\n                  ></ax-check-box>\n                  <ax-icon [icon]=\"layoutPageIcon(layout.icon, layout)\"></ax-icon>\n                  <span class=\"text-sm\">{{ getLayoutSelectionLabel(layout) | translate | async }}</span>\n                </label>\n              }\n            </div>\n          </div>\n        }\n      }\n      @if (vm.isBackgroundQueued()) {\n        <axp-state-message icon=\"fa-light fa-clock\"\n          [title]=\"'@report-management:report-generation.empty-states.background.queued-title'\"\n          [description]=\"'@report-management:report-generation.empty-states.background.queued-description'\">\n        </axp-state-message>\n      } @else {\n        <axp-state-message icon=\"fa-light fa-clock\"\n          [title]=\"'@report-management:report-generation.empty-states.background.title'\"\n          [description]=\"'@report-management:report-generation.empty-states.background.description'\">\n        </axp-state-message>\n      }\n    } @else {\n    <ng-container *ngTemplateOutlet=\"reportDisplay\"></ng-container>\n    }\n  </axp-page-content>\n</axp-page-layout>\n\n<!-- Desktop: Report Display Area -->\n<ng-template #reportDisplay>\n  @if (showReportDisplay()) {\n  <!-- Desktop & Mobile: Report Display Area -->\n  @if (vm.isTableLayout()) {\n  <axp-report-table-view> </axp-report-table-view>\n  } @else if (vm.isChartLayout()) {\n  <axp-report-chart-view> </axp-report-chart-view>\n  } @else if (vm.isPdfLayout()) {\n  <axp-report-pdf-view> </axp-report-pdf-view>\n  }\n  } @else if (vm.reportDefinition()) {\n  <!-- Mobile: Show filters  -->\n  <axp-layout-renderer #filtersForm [layout]=\"vm.formDefinition()\" [context]=\"vm.filterContext()\" [look]=\"'fieldset'\">\n  </axp-layout-renderer>\n  }\n</ng-template>\n\n<!-- Mobile: Execute Button -->\n@if (deviceService.isSmall() && ((!vm.isBackgroundReportMode() && !vm.hasBeenExecuted()) || (vm.isBackgroundReportMode() && !vm.isBackgroundQueued()))) {\n<axp-page-footer class=\"p-2 border-t\">\n  <ax-button class=\"w-full\" [disabled]=\"!vm.canExecute() || vm.areParametersReadonly()\"\n    [text]=\"(vm.isBackgroundReportMode()\n      ? '@report-management:report-generation.actions.generate-in-background'\n      : '@report-management:report-viewer.actions.execute.title') | translate | async\" [color]=\"'primary'\"\n    (onClick)=\"execute({ name: 'execute-report' })\">\n    <ax-prefix>\n      <ax-icon [icon]=\"vm.isBackgroundReportMode() ? 'fa-light fa-clock' : 'fa-light fa-play'\"></ax-icon>\n    </ax-prefix>\n  </ax-button>\n</axp-page-footer>\n}\n", styles: ["@layer properties;.axp-report-viewer-page{display:flex;height:100%;width:100%;flex-direction:column}.axp-report-viewer-page axp-layout-start-side{height:100%;width:calc(var(--spacing, .25rem) * 80);border-inline-end-style:var(--tw-border-style);border-inline-end-width:1px}@media(width>=1920px){.axp-report-viewer-page axp-layout-start-side{width:calc(var(--spacing, .25rem) * 96)}}.axp-report-viewer-page axp-layout-start-side>axp-layout-header{height:73px;border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.axp-report-viewer-page axp-layout-start-side axp-layout-content{overflow-x:auto;padding:calc(var(--spacing, .25rem) * 4)}.axp-report-viewer-page .__mobile-filters{display:flex;height:100%;flex-direction:column;overflow-y:auto}.axp-report-viewer-page .__mobile-filters .__mobile-filters-content{flex:1}.axp-report-viewer-page .__mobile-filters .__mobile-filters-footer{position:sticky;bottom:0;border-top-style:var(--tw-border-style);border-top-width:1px;background-color:var(--color-lightest);color:var(--color-on-lightest);border-color:var(--color-border-lightest);padding-top:calc(var(--spacing, .25rem) * 2)}.axp-report-viewer-page axp-page-content{display:flex;height:100%;flex-direction:column}.axp-report-viewer-page axp-report-table-view{flex:1;overflow:hidden}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2$2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1$2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXCheckBoxModule }, { kind: "component", type: i4.AXCheckBoxComponent, selector: "ax-check-box", inputs: ["disabled", "tabIndex", "readonly", "color", "value", "name", "id", "isLoading", "indeterminate"], outputs: ["onBlur", "onFocus", "valueChange", "onValueChanged"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2$3.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i2$3.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXLoadingModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i1.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "ngmodule", type: AXLoadingDialogModule }, { kind: "component", type: 
+                //
+                AXPLayoutRendererComponent, selector: "axp-layout-renderer", inputs: ["layout", "context", "look", "mode"], outputs: ["contextChange", "contextInitiated", "validityChange"] }, { kind: "component", type: AXPPageLayoutComponent, selector: "axp-page-layout" }, { kind: "component", type: AXPThemeLayoutStartSideComponent, selector: "axp-layout-page-start-side, axp-layout-start-side" }, { kind: "component", type: AXPThemeLayoutHeaderComponent, selector: "axp-layout-header" }, { kind: "component", type: AXPThemeLayoutBlockComponent, selector: "    axp-page-content,     axp-page-footer-container,    axp-page-footer,    axp-page-header,    axp-page-header-container,    axp-page-toolbar,    axp-layout-content,     axp-layout-page-content,     axp-layout-sections,    axp-layout-body,    axp-layout-page-body,    axp-layout-prefix,    axp-layout-suffix,    axp-layout-title-bar,    axp-layout-title,     axp-layout-title-actions,     axp-layout-nav-button,     axp-layout-description,     axp-layout-breadcrumbs,    axp-layout-list-action,    " }, { kind: "component", type: AXPReportTableViewComponent, selector: "axp-report-table-view" }, { kind: "component", type: AXPThemeLayoutFooterComponent, selector: "axp-layout-footer, axp-layout-page-footer" }, { kind: "component", type: AXPReportChartViewComponent, selector: "axp-report-chart-view" }, { kind: "component", type: AXPReportPdfViewComponent, selector: "axp-report-pdf-view" }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "titleParams", "descriptionParams", "look"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i1.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportViewerPageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-report-viewer-page', standalone: true, imports: [
+                        CommonModule,
+                        FormsModule,
+                        AXButtonModule,
+                        AXCheckBoxModule,
+                        AXDecoratorModule,
+                        AXLoadingModule,
+                        AXTranslationModule,
+                        AXBadgeModule,
+                        AXLoadingDialogModule,
+                        //
+                        AXPLayoutRendererComponent,
+                        AXPPageLayoutComponent,
+                        AXPThemeLayoutStartSideComponent,
+                        AXPThemeLayoutHeaderComponent,
+                        AXPThemeLayoutBlockComponent,
+                        AXPReportTableViewComponent,
+                        AXPThemeLayoutFooterComponent,
+                        AXPReportChartViewComponent,
+                        AXPReportPdfViewComponent,
+                        AXPStateMessageComponent,
+                    ], providers: [
+                        AXUnsubscriber,
+                        AXPReportViewerViewModel,
+                        {
+                            provide: AXPPageLayoutBase,
+                            useExisting: AXPReportViewerPageComponent,
+                        },
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, host: { class: 'axp-report-viewer-page' }, template: "<axp-page-layout *translate=\"let t\">\n  <!-- Left Panel: Filters (Always visible for desktop) -->\n  @if (showFiltersPanel()) {\n  <axp-layout-start-side>\n    <axp-layout-header>\n      <axp-layout-title>\n        {{ t('@report-management:report-viewer.components.filters.title') | async }}\n      </axp-layout-title>\n    </axp-layout-header>\n    <axp-layout-content>\n      @if (vm.reportDefinition()) {\n      <axp-layout-renderer #filtersForm [layout]=\"vm.formDefinition()\" [context]=\"vm.filterContext()\" [look]=\"'card'\"\n        (contextChange)=\"handleFiltersChange($event)\" (contextInitiated)=\"handleFiltersInitiated($event)\">\n      </axp-layout-renderer>\n      <!-- ----- Background report layout multi-select ----- -->\n      @if (vm.isBackgroundReportMode() && !vm.isBackgroundQueued() && vm.availableLayouts().length > 0) {\n        <div class=\"mt-4 pt-4 border-t\">\n          <div class=\"mb-2\">\n            <span class=\"text-sm font-medium\">\n              {{ t('@report-management:report-generation.components.background-layouts.title') | async }}\n            </span>\n          </div>\n          <p class=\"text-xs opacity-70 mb-3\">\n            {{ t('@report-management:report-generation.components.background-layouts.description') | async }}\n          </p>\n          <div class=\"flex flex-col gap-2\">\n            @for (layout of vm.availableLayouts(); track layout.id) {\n              <label class=\"flex items-center gap-2 p-2 rounded border cursor-pointer hover:bg-neutral-50\">\n                <ax-check-box\n                  [ngModel]=\"vm.isBackgroundLayoutSelected(layout.id)\"\n                  (ngModelChange)=\"handleBackgroundLayoutToggle(layout.id, $event)\"\n                ></ax-check-box>\n                <ax-icon [icon]=\"layoutPageIcon(layout.icon, layout)\"></ax-icon>\n                <span class=\"text-sm\">{{ getLayoutSelectionLabel(layout) | translate | async }}</span>\n              </label>\n            }\n          </div>\n        </div>\n      }\n      }\n    </axp-layout-content>\n    <axp-layout-footer class=\"p-4 border-t\" *translate=\"let t\">\n      @if (vm.hasUnappliedFilters()) {\n      <div class=\"w-full warning-lightest-surface mb-2 p-2 rounded border border-warning-200\">\n        <div class=\"flex items-center gap-2 text-warning-800\">\n          <ax-icon class=\"fa-light fa-exclamation-triangle text-sm\"></ax-icon>\n          <span class=\"text-xs\">{{\n            t('@report-management:report-viewer.components.filters.messages.warning.unapplied') | async\n            }}</span>\n        </div>\n      </div>\n      }\n      @if (vm.isBackgroundReportMode() && !vm.hasSelectedBackgroundLayouts() && !vm.isBackgroundQueued()) {\n        <div class=\"w-full warning-lightest-surface mb-2 p-2 rounded border border-warning-200\">\n          <div class=\"flex items-center gap-2 text-warning-800\">\n            <ax-icon class=\"fa-light fa-exclamation-triangle text-sm\"></ax-icon>\n            <span class=\"text-xs\">{{\n              t('@report-management:report-generation.errors.no-layouts-selected') | async\n              }}</span>\n          </div>\n        </div>\n      }\n      <ax-button class=\"w-full\" [disabled]=\"!vm.canExecute() || vm.areParametersReadonly() || vm.isBackgroundQueued()\"\n        [text]=\"(vm.isBackgroundReportMode()\n          ? t('@report-management:report-generation.actions.generate-in-background')\n          : t('@report-management:report-viewer.actions.execute.title')) | async\" [color]=\"'primary'\"\n        (onClick)=\"execute({ name: 'execute-report' })\">\n        <ax-prefix>\n          <ax-icon [icon]=\"vm.isBackgroundReportMode() ? 'fa-light fa-clock' : 'fa-light fa-play'\"></ax-icon>\n        </ax-prefix>\n      </ax-button>\n      <!-- ----- Secondary background generate for choose mode ----- -->\n      @if (canGenerateInBackground() && vm.generationMode() === 'choose') {\n        <ax-button class=\"w-full mt-2\" [disabled]=\"vm.areParametersReadonly()\"\n          [text]=\"t('@report-management:report-generation.actions.generate-in-background') | async\" [color]=\"'default'\"\n          (onClick)=\"execute({ name: 'generate-in-background' })\">\n          <ax-prefix>\n            <ax-icon icon=\"fa-light fa-clock\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      }\n    </axp-layout-footer>\n  </axp-layout-start-side>\n  }\n  <!-- Main Content: Report Display -->\n  <axp-page-content class=\"overflow-auto\">\n    @if (vm.isFrozen()) {\n      <!-- ----- Frozen run banner ----- -->\n      <div class=\"warning-lightest-surface mb-3 p-3 rounded border border-warning-200 text-warning-800 text-sm\">\n        {{ t('@report-management:report-generation.banners.frozen') | async }}\n      </div>\n    }\n    @if (vm.hasError()) {\n    <!-- Error State -->\n    <axp-state-message icon=\"fa-light fa-exclamation-triangle\"\n      [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n      [description]=\"vm.error() || '@report-management:report-viewer.messages.error.unexpected'\">\n      <div slot=\"actions\">\n        <ax-button look=\"outline\" color=\"primary\"\n          [text]=\"t('@report-management:report-viewer.actions.retry.title') | async\" (onClick)=\"vm.clearError()\">\n          <ax-prefix>\n            <ax-icon class=\"fa-light fa-refresh\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      </div>\n    </axp-state-message>\n    } @else if (!vm.reportDefinition()) {\n    <!-- No Report Selected State -->\n    <axp-state-message icon=\"fa-light fa-chart-line\"\n      [title]=\"'@report-management:report-viewer.components.report-viewer.empty-states.no-report.title'\"\n      [description]=\"'@report-management:report-viewer.components.report-viewer.empty-states.no-report.description'\">\n      <div slot=\"actions\">\n        <ax-button look=\"outline\" color=\"primary\"\n          [text]=\"t('@report-management:report-viewer.actions.browse-reports.title') | async\">\n          <ax-prefix>\n            <ax-icon class=\"fa-light fa-folder-open\"></ax-icon>\n          </ax-prefix>\n        </ax-button>\n      </div>\n    </axp-state-message>\n    <!-- ----- Background report message state (no live layout preview) ----- -->\n    } @else if (vm.isBackgroundReportMode() || vm.isBackgroundQueued()) {\n      <!-- ----- Mobile filters and layout selection for background reports ----- -->\n      @if (deviceService.isSmall() && !vm.isBackgroundQueued()) {\n        <axp-layout-renderer #filtersForm [layout]=\"vm.formDefinition()\" [context]=\"vm.filterContext()\" [look]=\"'fieldset'\"\n          (contextChange)=\"handleFiltersChange($event)\" (contextInitiated)=\"handleFiltersInitiated($event)\">\n        </axp-layout-renderer>\n        @if (vm.availableLayouts().length > 0) {\n          <div class=\"mt-4 pt-4 border-t\">\n            <div class=\"flex items-center justify-between gap-2 mb-2\">\n              <span class=\"text-sm font-medium\">\n                {{ t('@report-management:report-generation.components.background-layouts.title') | async }}\n              </span>\n            </div>\n            <p class=\"text-xs opacity-70 mb-3\">\n              {{ t('@report-management:report-generation.components.background-layouts.description') | async }}\n            </p>\n            <div class=\"flex flex-col gap-2\">\n              @for (layout of vm.availableLayouts(); track layout.id) {\n                <label class=\"flex items-center gap-2 p-2 rounded border cursor-pointer\">\n                  <ax-check-box\n                    [ngModel]=\"vm.isBackgroundLayoutSelected(layout.id)\"\n                    (ngModelChange)=\"handleBackgroundLayoutToggle(layout.id, $event)\"\n                  ></ax-check-box>\n                  <ax-icon [icon]=\"layoutPageIcon(layout.icon, layout)\"></ax-icon>\n                  <span class=\"text-sm\">{{ getLayoutSelectionLabel(layout) | translate | async }}</span>\n                </label>\n              }\n            </div>\n          </div>\n        }\n      }\n      @if (vm.isBackgroundQueued()) {\n        <axp-state-message icon=\"fa-light fa-clock\"\n          [title]=\"'@report-management:report-generation.empty-states.background.queued-title'\"\n          [description]=\"'@report-management:report-generation.empty-states.background.queued-description'\">\n        </axp-state-message>\n      } @else {\n        <axp-state-message icon=\"fa-light fa-clock\"\n          [title]=\"'@report-management:report-generation.empty-states.background.title'\"\n          [description]=\"'@report-management:report-generation.empty-states.background.description'\">\n        </axp-state-message>\n      }\n    } @else {\n    <ng-container *ngTemplateOutlet=\"reportDisplay\"></ng-container>\n    }\n  </axp-page-content>\n</axp-page-layout>\n\n<!-- Desktop: Report Display Area -->\n<ng-template #reportDisplay>\n  @if (showReportDisplay()) {\n  <!-- Desktop & Mobile: Report Display Area -->\n  @if (vm.isTableLayout()) {\n  <axp-report-table-view> </axp-report-table-view>\n  } @else if (vm.isChartLayout()) {\n  <axp-report-chart-view> </axp-report-chart-view>\n  } @else if (vm.isPdfLayout()) {\n  <axp-report-pdf-view> </axp-report-pdf-view>\n  }\n  } @else if (vm.reportDefinition()) {\n  <!-- Mobile: Show filters  -->\n  <axp-layout-renderer #filtersForm [layout]=\"vm.formDefinition()\" [context]=\"vm.filterContext()\" [look]=\"'fieldset'\">\n  </axp-layout-renderer>\n  }\n</ng-template>\n\n<!-- Mobile: Execute Button -->\n@if (deviceService.isSmall() && ((!vm.isBackgroundReportMode() && !vm.hasBeenExecuted()) || (vm.isBackgroundReportMode() && !vm.isBackgroundQueued()))) {\n<axp-page-footer class=\"p-2 border-t\">\n  <ax-button class=\"w-full\" [disabled]=\"!vm.canExecute() || vm.areParametersReadonly()\"\n    [text]=\"(vm.isBackgroundReportMode()\n      ? '@report-management:report-generation.actions.generate-in-background'\n      : '@report-management:report-viewer.actions.execute.title') | translate | async\" [color]=\"'primary'\"\n    (onClick)=\"execute({ name: 'execute-report' })\">\n    <ax-prefix>\n      <ax-icon [icon]=\"vm.isBackgroundReportMode() ? 'fa-light fa-clock' : 'fa-light fa-play'\"></ax-icon>\n    </ax-prefix>\n  </ax-button>\n</axp-page-footer>\n}\n", styles: ["@layer properties;.axp-report-viewer-page{display:flex;height:100%;width:100%;flex-direction:column}.axp-report-viewer-page axp-layout-start-side{height:100%;width:calc(var(--spacing, .25rem) * 80);border-inline-end-style:var(--tw-border-style);border-inline-end-width:1px}@media(width>=1920px){.axp-report-viewer-page axp-layout-start-side{width:calc(var(--spacing, .25rem) * 96)}}.axp-report-viewer-page axp-layout-start-side>axp-layout-header{height:73px;border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.axp-report-viewer-page axp-layout-start-side axp-layout-content{overflow-x:auto;padding:calc(var(--spacing, .25rem) * 4)}.axp-report-viewer-page .__mobile-filters{display:flex;height:100%;flex-direction:column;overflow-y:auto}.axp-report-viewer-page .__mobile-filters .__mobile-filters-content{flex:1}.axp-report-viewer-page .__mobile-filters .__mobile-filters-footer{position:sticky;bottom:0;border-top-style:var(--tw-border-style);border-top-width:1px;background-color:var(--color-lightest);color:var(--color-on-lightest);border-color:var(--color-border-lightest);padding-top:calc(var(--spacing, .25rem) * 2)}.axp-report-viewer-page axp-page-content{display:flex;height:100%;flex-direction:column}.axp-report-viewer-page axp-report-table-view{flex:1;overflow:hidden}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], ctorParameters: () => [], propDecorators: { reportId: [{ type: i0.Input, args: [{ isSignal: true, alias: "reportId", required: false }] }], reportParameters: [{ type: i0.Input, args: [{ isSignal: true, alias: "reportParameters", required: false }] }], filtersForm: [{ type: i0.ViewChild, args: ['filtersForm', { isSignal: true }] }] } });
+
+var reportViewerPage_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPReportViewerPageComponent: AXPReportViewerPageComponent
+});
+
+class AXPReportBarChartViewComponent {
+    constructor() {
+        //#region ----   Dependencies   ----
+        this.vm = inject(AXPReportViewerViewModel);
+        this.AXPPageStatus = AXPPageStatus;
+        //#endregion
+        //#region ----   Computed Properties   ----
+        /**
+         * Current chart layout configuration
+         */
+        this.chartLayout = computed(() => {
+            const layout = this.vm.currentLayout();
+            return layout?.layout.type === 'chart' ? layout.layout : null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "chartLayout" }] : /* istanbul ignore next */ []));
+        /**
+         * Chart configuration options
+         */
+        this.chartOptions = computed(() => {
+            const chartLayout = this.chartLayout();
+            return chartLayout?.options || null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "chartOptions" }] : /* istanbul ignore next */ []));
+        /**
+         * Chart type for rendering
+         */
+        this.chartType = computed(() => {
+            const options = this.chartOptions();
+            return options?.chartType || 'bar';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "chartType" }] : /* istanbul ignore next */ []));
+        /**
+         * Data mapping configuration
+         */
+        this.dataMapping = computed(() => {
+            const options = this.chartOptions();
+            return options?.dataMapping || null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "dataMapping" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Effects   ----
+        /**
+         * Effect to handle data fetching when chart configuration changes
+         */
+        this.#fetchData = effect(() => {
+            if (this.vm.allowFetchData() && this.vm.shouldExecuteReport() && this.chartOptions()) {
+                this.vm.fetchData().then((result) => {
+                    const barChartData = AXBarChartReportMapper(queryResultToChartSeries(result, this.dataMapping()));
+                    this.barChartData.set(barChartData);
+                });
+            }
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#fetchData" }] : /* istanbul ignore next */ []));
+        this.barChartData = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "barChartData" }] : /* istanbul ignore next */ []));
+        this.barChartOptions = signal({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "barChartOptions" }] : /* istanbul ignore next */ []));
+        this.legendOptions = signal({
+            mode: 'horizontal',
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "legendOptions" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----   Effects   ----
+    /**
+     * Effect to handle data fetching when chart configuration changes
+     */
+    #fetchData;
+    //#endregion
+    //#region ----   Event Handlers   ----
+    /**
+     * Handle chart click events
+     */
+    handleChartClick(event) {
+        // TODO: Implement chart click handling
+        console.log('Chart clicked:', event);
+    }
+    /**
+     * Handle chart data point selection
+     */
+    handleDataPointSelect(event) {
+        // TODO: Implement data point selection
+        console.log('Data point selected:', event);
+    }
+    //#endregion
+    //#region ----   Helper Methods   ----
+    /**
+     * Check if chart is ready to render
+     */
+    isChartReady() {
+        return !!(this.chartOptions() && this.dataMapping());
+    }
+    /**
+     * Get chart configuration for rendering
+     */
+    getChartConfig() {
+        // TODO: Transform AXPReportChartOptions to chart library format
+        return {
+            type: this.chartType(),
+            options: this.chartOptions(),
+            dataMapping: this.dataMapping(),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportBarChartViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPReportBarChartViewComponent, isStandalone: true, selector: "axp-report-bar-chart-view", ngImport: i0, template: "<div class=\"axp-report-chart-view\" *translate=\"let t\">\n  @if (vm.status() === AXPPageStatus.Processing) {\n  <!-- Loading State -->\n  <div class=\"__loading\">\n    <div class=\"spinner spin border-4 border-gray-200 border-t-primary rounded-full w-12 h-12\">\n    </div>\n    <div class=\"__loading-text\">\n      {{ t('@report-management:report-viewer.components.chart.messages.loading') | async }}\n    </div>\n  </div>\n  } @else if (vm.status() === AXPPageStatus.Error) {\n  <!-- Error State -->\n  <axp-state-message mode=\"error\" icon=\"fa-light fa-exclamation-triangle\"\n    [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n    [description]=\"vm.error() || '@report-management:report-viewer.messages.error.fetch-description'\">\n  </axp-state-message>\n  } @else if (isChartReady()) {\n  <!-- Chart Content -->\n  <div class=\"__chart-container\">\n    @if (chartLayout()?.header) {\n    <div class=\"__chart-header\">\n      <h3 class=\"__chart-title\">{{ chartLayout()?.header?.title }}</h3>\n      @if (chartLayout()?.header?.showDate) {\n      <div class=\"__chart-date\">{{ '@general:common.date.today' | translate | async }}</div>\n      }\n    </div>\n    }\n\n    <div class=\"__chart-body\">\n      <!-- Chart component will be rendered here -->\n      <div class=\"__chart-placeholder\">\n        <div class=\"__placeholder-content\">\n          <div class=\"flex flex-wrap items-center justify-center gap-10\"\n            [class]=\"legendOptions().mode === 'horizontal' ? 'flex-col' : 'flex-row'\">\n            <!-- Chart Area -->\n            <div class=\"flex-0 size-96\">\n              <ax-bar-chart #chart [data]=\"barChartData()\" [options]=\"barChartOptions()\"></ax-bar-chart>\n            </div>\n            <!-- Legend Area -->\n            @if (barChartData().length > 0) {\n            <div>\n              <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"chart\"></ax-chart-legend>\n            </div>\n            }\n          </div>\n        </div>\n      </div>\n    </div>\n\n    @if (chartLayout()?.footer) {\n    <div class=\"__chart-footer\">\n      @if (chartLayout()?.footer?.customHtml) {\n      <div [innerHTML]=\"$safeNavigationMigration(chartLayout()?.footer?.customHtml)\"></div>\n      }\n    </div>\n    }\n  </div>\n  } @else {\n  <!-- No Configuration State -->\n  <axp-state-message icon=\"fa-light fa-chart-column\"\n    [title]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.title'\"\n    [description]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.description'\">\n  </axp-state-message>\n  }\n</div>", styles: ["@layer properties;.axp-report-chart-view{display:flex;height:100%;width:100%;flex-direction:column}.axp-report-chart-view .__loading{display:flex;height:100%;flex-direction:column;align-items:center;justify-content:center;gap:calc(var(--spacing, .25rem) * 4);padding:calc(var(--spacing, .25rem) * 8)}.axp-report-chart-view .__loading .__loading-text{font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:var(--color-gray-600, oklch(44.6% .03 256.802))}.axp-report-chart-view .__chart-container{display:flex;height:100%;width:100%;flex-direction:column}.axp-report-chart-view .__chart-container .__chart-header{border-bottom-style:var(--tw-border-style);border-bottom-width:1px;background-color:var(--color-gray-50, oklch(98.5% .002 247.839));padding:calc(var(--spacing, .25rem) * 4)}.axp-report-chart-view .__chart-container .__chart-header .__chart-title{margin:0;font-size:var(--text-lg, 1.125rem);line-height:var(--tw-leading, var(--text-lg--line-height, calc(1.75 / 1.125)));--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600)}.axp-report-chart-view .__chart-container .__chart-header .__chart-date{margin-top:var(--spacing, .25rem);font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:var(--color-gray-600, oklch(44.6% .03 256.802))}.axp-report-chart-view .__chart-container .__chart-body{flex:1;overflow:hidden}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder{display:flex;height:100%;flex-direction:column;align-items:center;justify-content:center;gap:calc(var(--spacing, .25rem) * 6);text-align:center}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-icon{font-size:var(--text-6xl, 3.75rem);line-height:var(--tw-leading, var(--text-6xl--line-height, 1));color:rgba(var(--ax-sys-color-primary-surface))}@supports (color: color-mix(in lab,red,red)){.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-icon{color:color-mix(in oklab,rgba(var(--ax-sys-color-primary-surface)) 20%,transparent)}}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-content{max-width:var(--container-md, 28rem)}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-content .__placeholder-title{margin-bottom:calc(var(--spacing, .25rem) * 2);font-size:var(--text-xl, 1.25rem);line-height:var(--tw-leading, var(--text-xl--line-height, calc(1.75 / 1.25)));--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600)}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-content .__placeholder-description{margin-bottom:calc(var(--spacing, .25rem) * 4);color:var(--color-gray-600, oklch(44.6% .03 256.802))}.axp-report-chart-view .__chart-container .__chart-body .__chart-content{height:100%;width:100%}.axp-report-chart-view .__chart-container .__chart-footer{border-top-style:var(--tw-border-style);border-top-width:1px;background-color:var(--color-gray-50, oklch(98.5% .002 247.839));padding:calc(var(--spacing, .25rem) * 4);font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:var(--color-gray-600, oklch(44.6% .03 256.802))}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid;--tw-font-weight: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i1.AXTranslatorDirective, selector: "[translate]" }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "titleParams", "descriptionParams", "look"] }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: AXBarChartComponent, selector: "ax-bar-chart", inputs: ["data", "options"], outputs: ["barClick"] }, { kind: "component", type: AXChartLegendComponent, selector: "ax-chart-legend", inputs: ["chart", "options"], outputs: ["itemClick", "itemMouseEnter", "itemMouseLeave"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i1.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPReportBarChartViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-report-bar-chart-view', standalone: true, imports: [
+                        CommonModule,
+                        AXDecoratorModule,
+                        AXTranslationModule,
+                        AXPStateMessageComponent,
+                        AXPWidgetCoreModule,
+                        AXBarChartComponent,
+                        AXChartLegendComponent,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<div class=\"axp-report-chart-view\" *translate=\"let t\">\n  @if (vm.status() === AXPPageStatus.Processing) {\n  <!-- Loading State -->\n  <div class=\"__loading\">\n    <div class=\"spinner spin border-4 border-gray-200 border-t-primary rounded-full w-12 h-12\">\n    </div>\n    <div class=\"__loading-text\">\n      {{ t('@report-management:report-viewer.components.chart.messages.loading') | async }}\n    </div>\n  </div>\n  } @else if (vm.status() === AXPPageStatus.Error) {\n  <!-- Error State -->\n  <axp-state-message mode=\"error\" icon=\"fa-light fa-exclamation-triangle\"\n    [title]=\"'@report-management:report-viewer.messages.error.fetch-title'\"\n    [description]=\"vm.error() || '@report-management:report-viewer.messages.error.fetch-description'\">\n  </axp-state-message>\n  } @else if (isChartReady()) {\n  <!-- Chart Content -->\n  <div class=\"__chart-container\">\n    @if (chartLayout()?.header) {\n    <div class=\"__chart-header\">\n      <h3 class=\"__chart-title\">{{ chartLayout()?.header?.title }}</h3>\n      @if (chartLayout()?.header?.showDate) {\n      <div class=\"__chart-date\">{{ '@general:common.date.today' | translate | async }}</div>\n      }\n    </div>\n    }\n\n    <div class=\"__chart-body\">\n      <!-- Chart component will be rendered here -->\n      <div class=\"__chart-placeholder\">\n        <div class=\"__placeholder-content\">\n          <div class=\"flex flex-wrap items-center justify-center gap-10\"\n            [class]=\"legendOptions().mode === 'horizontal' ? 'flex-col' : 'flex-row'\">\n            <!-- Chart Area -->\n            <div class=\"flex-0 size-96\">\n              <ax-bar-chart #chart [data]=\"barChartData()\" [options]=\"barChartOptions()\"></ax-bar-chart>\n            </div>\n            <!-- Legend Area -->\n            @if (barChartData().length > 0) {\n            <div>\n              <ax-chart-legend [options]=\"legendOptions()\" [chart]=\"chart\"></ax-chart-legend>\n            </div>\n            }\n          </div>\n        </div>\n      </div>\n    </div>\n\n    @if (chartLayout()?.footer) {\n    <div class=\"__chart-footer\">\n      @if (chartLayout()?.footer?.customHtml) {\n      <div [innerHTML]=\"$safeNavigationMigration(chartLayout()?.footer?.customHtml)\"></div>\n      }\n    </div>\n    }\n  </div>\n  } @else {\n  <!-- No Configuration State -->\n  <axp-state-message icon=\"fa-light fa-chart-column\"\n    [title]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.title'\"\n    [description]=\"'@report-management:report-viewer.components.chart.empty-states.no-config.description'\">\n  </axp-state-message>\n  }\n</div>", styles: ["@layer properties;.axp-report-chart-view{display:flex;height:100%;width:100%;flex-direction:column}.axp-report-chart-view .__loading{display:flex;height:100%;flex-direction:column;align-items:center;justify-content:center;gap:calc(var(--spacing, .25rem) * 4);padding:calc(var(--spacing, .25rem) * 8)}.axp-report-chart-view .__loading .__loading-text{font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:var(--color-gray-600, oklch(44.6% .03 256.802))}.axp-report-chart-view .__chart-container{display:flex;height:100%;width:100%;flex-direction:column}.axp-report-chart-view .__chart-container .__chart-header{border-bottom-style:var(--tw-border-style);border-bottom-width:1px;background-color:var(--color-gray-50, oklch(98.5% .002 247.839));padding:calc(var(--spacing, .25rem) * 4)}.axp-report-chart-view .__chart-container .__chart-header .__chart-title{margin:0;font-size:var(--text-lg, 1.125rem);line-height:var(--tw-leading, var(--text-lg--line-height, calc(1.75 / 1.125)));--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600)}.axp-report-chart-view .__chart-container .__chart-header .__chart-date{margin-top:var(--spacing, .25rem);font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:var(--color-gray-600, oklch(44.6% .03 256.802))}.axp-report-chart-view .__chart-container .__chart-body{flex:1;overflow:hidden}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder{display:flex;height:100%;flex-direction:column;align-items:center;justify-content:center;gap:calc(var(--spacing, .25rem) * 6);text-align:center}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-icon{font-size:var(--text-6xl, 3.75rem);line-height:var(--tw-leading, var(--text-6xl--line-height, 1));color:rgba(var(--ax-sys-color-primary-surface))}@supports (color: color-mix(in lab,red,red)){.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-icon{color:color-mix(in oklab,rgba(var(--ax-sys-color-primary-surface)) 20%,transparent)}}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-content{max-width:var(--container-md, 28rem)}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-content .__placeholder-title{margin-bottom:calc(var(--spacing, .25rem) * 2);font-size:var(--text-xl, 1.25rem);line-height:var(--tw-leading, var(--text-xl--line-height, calc(1.75 / 1.25)));--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600)}.axp-report-chart-view .__chart-container .__chart-body .__chart-placeholder .__placeholder-content .__placeholder-description{margin-bottom:calc(var(--spacing, .25rem) * 4);color:var(--color-gray-600, oklch(44.6% .03 256.802))}.axp-report-chart-view .__chart-container .__chart-body .__chart-content{height:100%;width:100%}.axp-report-chart-view .__chart-container .__chart-footer{border-top-style:var(--tw-border-style);border-top-width:1px;background-color:var(--color-gray-50, oklch(98.5% .002 247.839));padding:calc(var(--spacing, .25rem) * 4);font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:var(--color-gray-600, oklch(44.6% .03 256.802))}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid;--tw-font-weight: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXPReportViewerViewModel as A, mapEntityBindingParameters as B, queryResultToChartSeries as C, queryResultToPdfSource as D, ENTITY_REPORTS_PAGE_COMPONENT_KEY as E, resolveReportParameterValues as F, resolveTodayDateRange as G, toReportDateRangeFilterValue as H, OPEN_REPORT_IN_POPUP_COMMAND$1 as O, AXPOpenReportViewerCommand as a, resolveReportFilterDefaultValue as b, reportLayoutTitleKey as c, AXPReportTableViewComponent as d, AXPReportChartViewComponent as e, AXPReportPdfViewComponent as f, AXPReportViewerService as g, bindingShowsOnPage as h, isDistinctLayoutTitle as i, buildOpenInPopupCommandOptions as j, resolveBindingTitle as k, resolveBindingDescription as l, AXBarChartReportMapper as m, AXLineChartReportMapper as n, AXMPermissionDefinitionProvider as o, AXMReportManagementModule as p, AXPOpenReportInPopupCommand as q, reportLayoutPageIcon as r, AXPReportBarChartViewComponent as s, AXPReportViewerPageComponent as t, AXPieChartReportMapper as u, collectReportParameterDefaults as v, convertContextDataToFilterClause as w, flattenReportParametersToQueryParams as x, formatReportDateOnly as y, isReportDateRangeObject as z };
+//# sourceMappingURL=acorex-platform-module-report-management-client-acorex-platform-module-report-management-client-BDCuhd5O.mjs.map