@acorex-platform/module-activity-insight-client 0.0.20

package/fesm2022/acorex-platform-module-activity-insight-client.mjs

@@ -0,0 +1,1606 @@
+import { AXPHookService, AXPBroadcastEventService, AXP_MODULE_MANIFEST_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, provideAppStartUpTask, AXP_APP_STARTUP_PRIORITY } from '@acorex-platform/framework-client/core';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPEntityService, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_MODIFIER } from '@acorex-platform/framework-client/layout/entity';
+import { AXPRuntimeTransportService, AXPCommandEventsService, AXPRuntimeModule } from '@acorex-platform/framework-client/runtime';
+import * as i0 from '@angular/core';
+import { inject, Injectable, DestroyRef, NgModule, InjectionToken } from '@angular/core';
+import { Router, NavigationEnd, ROUTES } from '@angular/router';
+import * as i1 from '@acorex-platform/framework-client/common';
+import { AXPSearchCommandProvider, AXPSettingsService, AXPCommonModule, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex-platform/framework-client/common';
+import { RootConfig, AXMActivityInsightMenuKeys, AXPActivityInsightSettings, AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG, AXPInsightsReportingPermissionKeys, maskActivityProperties, truncateActivityProperties, AXMActivityEventNames } from '@acorex-platform/module-activity-insight-client/contracts';
+import { AXPWidgetsList } from '@acorex-platform/framework-shared/core';
+import { AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { distinctUntilChanged, filter } from 'rxjs';
+import { AXMActivityInsightTransportKeys } from '@acorex-platform/module-activity-insight-contracts';
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+const ActivityInsightManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'platform',
+    domain: 'platform',
+    dependencies: [],
+};
+//#endregion
+
+//#region ----   Imports   ----
+const ADMINISTRATION_MENU_KEY = 'Common:Menu:Administration';
+//#endregion
+class AXMActivityInsightMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    featurePath(segment) {
+        const app = this.sessionService.application?.name ?? 'app';
+        return `/${app}/m/${RootConfig.module.name}/${segment}`;
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const entityPath = (entityName) => this.entityService.createPath(module.name, entityName);
+        context.find(ADMINISTRATION_MENU_KEY).addItems([
+            {
+                name: AXMActivityInsightMenuKeys.ActivityInsight.Root,
+                priority: 4,
+                text: module.title,
+                icon: module.icon,
+                type: 'menu',
+                policy: { features: [module.name] },
+                children: [
+                    {
+                        name: AXMActivityInsightMenuKeys.ActivityInsight.Events,
+                        text: RootConfig.entities.activityEvent.titlePlural,
+                        path: entityPath(RootConfig.entities.activityEvent.name),
+                        icon: RootConfig.entities.activityEvent.icon,
+                        priority: 1,
+                    },
+                    {
+                        name: AXMActivityInsightMenuKeys.ActivityInsight.Timelines,
+                        text: '@activity-insight:module.menus.timelines.title',
+                        path: this.featurePath('timelines'),
+                        icon: 'fa-light fa-timeline',
+                        priority: 2,
+                    },
+                    {
+                        name: AXMActivityInsightMenuKeys.ActivityInsight.Policies,
+                        text: '@activity-insight:module.menus.policies.title',
+                        type: 'menu',
+                        icon: 'fa-light fa-sliders',
+                        priority: 3,
+                        children: [
+                            {
+                                name: 'ActivityInsight:Menu:TrackingRules',
+                                text: RootConfig.entities.trackingRule.titlePlural,
+                                path: entityPath(RootConfig.entities.trackingRule.name),
+                                icon: RootConfig.entities.trackingRule.icon,
+                                priority: 1,
+                            },
+                            {
+                                name: 'ActivityInsight:Menu:RetentionPolicies',
+                                text: RootConfig.entities.retentionPolicy.titlePlural,
+                                path: entityPath(RootConfig.entities.retentionPolicy.name),
+                                icon: RootConfig.entities.retentionPolicy.icon,
+                                priority: 2,
+                            },
+                            {
+                                name: 'ActivityInsight:Menu:MaskingPolicies',
+                                text: RootConfig.entities.maskingPolicy.titlePlural,
+                                path: entityPath(RootConfig.entities.maskingPolicy.name),
+                                icon: RootConfig.entities.maskingPolicy.icon,
+                                priority: 3,
+                            },
+                            {
+                                name: 'ActivityInsight:Menu:SamplingPolicies',
+                                text: RootConfig.entities.samplingPolicy.titlePlural,
+                                path: entityPath(RootConfig.entities.samplingPolicy.name),
+                                icon: RootConfig.entities.samplingPolicy.icon,
+                                priority: 4,
+                            },
+                            {
+                                name: 'ActivityInsight:Menu:DataSources',
+                                text: RootConfig.entities.activityDataSource.titlePlural,
+                                path: entityPath(RootConfig.entities.activityDataSource.name),
+                                icon: RootConfig.entities.activityDataSource.icon,
+                                priority: 5,
+                            },
+                            {
+                                name: 'ActivityInsight:Menu:SavedViews',
+                                text: RootConfig.entities.activitySavedView.titlePlural,
+                                path: entityPath(RootConfig.entities.activitySavedView.name),
+                                icon: RootConfig.entities.activitySavedView.icon,
+                                priority: 6,
+                            },
+                        ],
+                    },
+                ],
+            },
+        ]);
+    }
+}
+
+class AXPActivityInsightSettingProvider {
+    async provide(context) {
+        const trackingVisibility = `{{ context.eval('${AXPActivityInsightSettings.Enabled}') }}`;
+        const defaults = AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG;
+        context
+            .addGroup('activity-insight', '@activity-insight:settings.group.title', '@activity-insight:settings.group.description', 'fa-light fa-chart-network', undefined, 910)
+            .addSection('tracking', '@activity-insight:settings.tracking.title', '@activity-insight:settings.tracking.description')
+            .addSetting({
+            key: AXPActivityInsightSettings.Enabled,
+            title: '@activity-insight:settings.tracking.items.enabled.title',
+            description: '@activity-insight:settings.tracking.items.enabled.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: true,
+            widget: { type: AXPWidgetsList.Editors.ToggleSwitch },
+        })
+            .endSection()
+            .addSection('buffer', '@activity-insight:settings.buffer.title', '@activity-insight:settings.buffer.description')
+            .addSetting({
+            key: AXPActivityInsightSettings.FlushIntervalMs,
+            title: '@activity-insight:settings.buffer.items.flush-interval.title',
+            description: '@activity-insight:settings.buffer.items.flush-interval.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaults.flushIntervalMs,
+            widget: {
+                type: AXPWidgetsList.Editors.NumberBox,
+                options: { minValue: 1000, maxValue: 60000, step: 1000, suffix: 'ms', visibility: trackingVisibility },
+            },
+        })
+            .addSetting({
+            key: AXPActivityInsightSettings.MaxBatchSize,
+            title: '@activity-insight:settings.buffer.items.max-batch-size.title',
+            description: '@activity-insight:settings.buffer.items.max-batch-size.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaults.maxBatchSize,
+            widget: {
+                type: AXPWidgetsList.Editors.NumberBox,
+                options: { minValue: 1, maxValue: 500, visibility: trackingVisibility },
+            },
+        })
+            .addSetting({
+            key: AXPActivityInsightSettings.MaxPayloadBytes,
+            title: '@activity-insight:settings.buffer.items.max-payload-bytes.title',
+            description: '@activity-insight:settings.buffer.items.max-payload-bytes.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaults.maxPayloadBytes,
+            widget: {
+                type: AXPWidgetsList.Editors.NumberBox,
+                options: { minValue: 4096, maxValue: 65536, visibility: trackingVisibility },
+            },
+        })
+            .addSetting({
+            key: AXPActivityInsightSettings.MaxQueueSize,
+            title: '@activity-insight:settings.buffer.items.max-queue-size.title',
+            description: '@activity-insight:settings.buffer.items.max-queue-size.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaults.maxQueueSize,
+            widget: {
+                type: AXPWidgetsList.Editors.NumberBox,
+                options: { minValue: 100, maxValue: 10000, visibility: trackingVisibility },
+            },
+        })
+            .addSetting({
+            key: AXPActivityInsightSettings.FlushOnVisibilityHidden,
+            title: '@activity-insight:settings.buffer.items.flush-on-hidden.title',
+            description: '@activity-insight:settings.buffer.items.flush-on-hidden.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaults.flushOnVisibilityHidden,
+            widget: {
+                type: AXPWidgetsList.Editors.ToggleSwitch,
+                options: { visibility: trackingVisibility },
+            },
+        })
+            .addSetting({
+            key: AXPActivityInsightSettings.UseBeaconForFinalFlush,
+            title: '@activity-insight:settings.buffer.items.use-beacon.title',
+            description: '@activity-insight:settings.buffer.items.use-beacon.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: defaults.useBeaconForFinalFlush,
+            widget: {
+                type: AXPWidgetsList.Editors.ToggleSwitch,
+                options: { visibility: trackingVisibility },
+            },
+        })
+            .endSection()
+            .addSection('privacy', '@activity-insight:settings.privacy.title', '@activity-insight:settings.privacy.description')
+            .addSetting({
+            key: AXPActivityInsightSettings.MaskingEnabled,
+            title: '@activity-insight:settings.privacy.items.masking-enabled.title',
+            description: '@activity-insight:settings.privacy.items.masking-enabled.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: true,
+            widget: {
+                type: AXPWidgetsList.Editors.ToggleSwitch,
+                options: { visibility: trackingVisibility },
+            },
+        })
+            .addSetting({
+            key: AXPActivityInsightSettings.SamplingEnabled,
+            title: '@activity-insight:settings.privacy.items.sampling-enabled.title',
+            description: '@activity-insight:settings.privacy.items.sampling-enabled.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: true,
+            widget: {
+                type: AXPWidgetsList.Editors.ToggleSwitch,
+                options: { visibility: trackingVisibility },
+            },
+        })
+            .addSetting({
+            key: AXPActivityInsightSettings.TrackAiContent,
+            title: '@activity-insight:settings.privacy.items.track-ai-content.title',
+            description: '@activity-insight:settings.privacy.items.track-ai-content.description',
+            scope: 'P',
+            overridableAt: [],
+            isInherited: false,
+            defaultValue: false,
+            widget: {
+                type: AXPWidgetsList.Editors.ToggleSwitch,
+                options: { visibility: trackingVisibility },
+            },
+        })
+            .endSection()
+            .endGroup();
+    }
+}
+
+class AXMActivityInsightSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [];
+    }
+}
+
+//#endregion
+//#region ----- Permission Definition Provider -----
+/**
+ * Registers activity-insight capabilities into the shared Insights & Reporting group.
+ */
+class AXMActivityInsightPermissionDefinitionProvider {
+    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.ActivityInsight, `${G}.insights-reporting-activity-insight.title`, `${G}.insights-reporting-activity-insight.description`, { parent: groups.InsightsReporting.Root, order: 20 })
+            .addPermission(keys.ViewActivityInsight, `${P}.view-activity-insight.title`, `${P}.view-activity-insight.description`)
+            .endPermission()
+            .addPermission(keys.ManageActivityInsight, `${P}.manage-activity-insight.title`, `${P}.manage-activity-insight.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const activityInsightFeatureRoutes = [
+    {
+        path: `:app/m/${RootConfig.module.name}`,
+        children: [
+            {
+                path: '',
+                redirectTo: `${RootConfig.entities.activityEvent.name}/list`,
+                pathMatch: 'full',
+            },
+            {
+                path: 'timelines',
+                loadComponent: () => import('./acorex-platform-module-activity-insight-client-activity-timeline-page.component-DULl2SRF.mjs').then((m) => m.AXMActivityInsightTimelinePageComponent),
+            },
+            {
+                path: 'dashboard',
+                loadComponent: () => import('./acorex-platform-module-activity-insight-client-activity-dashboard-page.component-CAcsbq4I.mjs').then((m) => m.AXMActivityInsightDashboardPageComponent),
+            },
+        ],
+    },
+];
+
+const ACTIVITY_TRACKING_PLUGIN_NAME = 'tracking';
+function normalizeActivityTrackingPluginOptions(options) {
+    const opts = options ?? {};
+    return {
+        enabled: opts.enabled ?? true,
+        list: {
+            open: opts.list?.open ?? true,
+            filterApply: opts.list?.filterApply ?? true,
+            search: opts.list?.search ?? true,
+            sort: opts.list?.sort ?? false,
+            export: opts.list?.export ?? false,
+        },
+        detail: {
+            open: opts.detail?.open ?? true,
+            tabChange: opts.detail?.tabChange ?? false,
+        },
+        form: {
+            createStart: opts.form?.createStart ?? false,
+            updateStart: opts.form?.updateStart ?? false,
+            submit: opts.form?.submit ?? true,
+            validationError: opts.form?.validationError ?? true,
+            fieldChange: {
+                enabled: opts.form?.fieldChange?.enabled ?? false,
+                include: opts.form?.fieldChange?.include ?? [],
+                exclude: opts.form?.fieldChange?.exclude ?? [],
+            },
+        },
+        commands: opts.commands ?? { '*': true },
+        queries: opts.queries ?? { list: true, byKey: false, lookup: false },
+        masking: opts.masking ?? { fields: [] },
+        sampling: opts.sampling ?? {},
+    };
+}
+function isActivityTrackingEnabled(options) {
+    return normalizeActivityTrackingPluginOptions(options).enabled !== false;
+}
+const activityTrackingPlugin = {
+    name: ACTIVITY_TRACKING_PLUGIN_NAME,
+    order: 1,
+    apply: (ctx, options) => {
+        const normalized = normalizeActivityTrackingPluginOptions(options);
+        const existing = ctx.plugins.find(ACTIVITY_TRACKING_PLUGIN_NAME).get();
+        if (existing) {
+            ctx.plugins.find(ACTIVITY_TRACKING_PLUGIN_NAME).update((p) => ({ ...p, options: normalized }));
+        }
+        else {
+            ctx.plugins.add({ name: ACTIVITY_TRACKING_PLUGIN_NAME, options: normalized });
+        }
+    },
+};
+
+const activityTrackingDefaultsModifier = {
+    entityName: '*',
+    order: 5,
+    modifier: (ctx) => {
+        const plugins = ctx.plugins.list();
+        if (plugins.some((p) => p.name === ACTIVITY_TRACKING_PLUGIN_NAME)) {
+            return;
+        }
+        ctx.plugins.add({
+            name: ACTIVITY_TRACKING_PLUGIN_NAME,
+            options: normalizeActivityTrackingPluginOptions({ enabled: true }),
+        });
+    },
+};
+
+const PRIORITY_ORDER = ['high', 'normal', 'low'];
+const COALESCE_KEYS = new Set([
+    'entity.filter.applied',
+    'entity.search.applied',
+    'entity.sort.applied',
+    'form.field.changed',
+]);
+const DEFAULT_DEBOUNCE_MS = {
+    'entity.search.applied': 800,
+    'entity.sort.applied': 300,
+    'entity.filter.applied': 300,
+    'form.field.changed': 500,
+    'query.executed': 1500,
+};
+class AXMActivityBuffer {
+    constructor(config) {
+        this.config = config;
+        this.lanes = {
+            high: [],
+            normal: [],
+            low: [],
+        };
+        this.debounceTimers = new Map();
+        this.droppedCount = 0;
+        this.debounceMs = { ...DEFAULT_DEBOUNCE_MS, ...(config.debounceMs ?? {}) };
+    }
+    enqueue(event) {
+        const priority = event.priority ?? 'normal';
+        const queued = { ...event, priority };
+        const debounceKey = this.debounceMs[event.name];
+        if (debounceKey != null) {
+            this.scheduleDebounced(event.name, queued, debounceKey);
+            return;
+        }
+        this.push(queued);
+    }
+    drain(maxCount) {
+        const out = [];
+        for (const lane of PRIORITY_ORDER) {
+            while (this.lanes[lane].length && (maxCount == null || out.length < maxCount)) {
+                const next = this.lanes[lane].shift();
+                if (next) {
+                    out.push(next);
+                }
+            }
+        }
+        return out;
+    }
+    peekCount() {
+        return PRIORITY_ORDER.reduce((sum, lane) => sum + this.lanes[lane].length, 0);
+    }
+    get dropped() {
+        return this.droppedCount;
+    }
+    clear() {
+        for (const lane of PRIORITY_ORDER) {
+            this.lanes[lane].length = 0;
+        }
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+    }
+    requeueFront(events) {
+        for (let i = events.length - 1; i >= 0; i--) {
+            const event = events[i];
+            const priority = event.priority ?? 'normal';
+            this.lanes[priority].unshift({ ...event, priority });
+        }
+    }
+    scheduleDebounced(name, event, delayMs) {
+        const key = `${name}:${event.entityName ?? ''}:${event.route ?? ''}`;
+        const existing = this.debounceTimers.get(key);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const timer = setTimeout(() => {
+            this.debounceTimers.delete(key);
+            this.push(event);
+        }, delayMs);
+        this.debounceTimers.set(key, timer);
+    }
+    push(event) {
+        if (COALESCE_KEYS.has(event.name)) {
+            this.coalesce(event);
+        }
+        const priority = event.priority ?? 'normal';
+        this.lanes[priority].push(event);
+        this.enforceCapacity();
+    }
+    coalesce(event) {
+        const lane = this.lanes[event.priority ?? 'normal'];
+        const index = lane.findIndex((e) => e.name === event.name &&
+            e.entityName === event.entityName &&
+            e.route === event.route &&
+            e.viewId === event.viewId);
+        if (index >= 0) {
+            lane.splice(index, 1);
+        }
+    }
+    enforceCapacity() {
+        while (this.size() > this.config.maxQueueSize) {
+            if (this.lanes.low.length) {
+                this.lanes.low.shift();
+                this.droppedCount++;
+                continue;
+            }
+            if (this.coalesceOverflow()) {
+                continue;
+            }
+            if (this.lanes.normal.length) {
+                this.lanes.normal.shift();
+                this.droppedCount++;
+                continue;
+            }
+            break;
+        }
+    }
+    coalesceOverflow() {
+        let merged = false;
+        for (const name of COALESCE_KEYS) {
+            for (const lane of PRIORITY_ORDER) {
+                const duplicates = this.lanes[lane].filter((e) => e.name === name);
+                if (duplicates.length > 1) {
+                    const keep = duplicates[duplicates.length - 1];
+                    this.lanes[lane] = this.lanes[lane].filter((e) => e.name !== name || e === keep);
+                    merged = true;
+                }
+            }
+        }
+        return merged;
+    }
+    size() {
+        return PRIORITY_ORDER.reduce((sum, lane) => sum + this.lanes[lane].length, 0);
+    }
+}
+
+const DEFAULT_QUERY_SAMPLING_RATE = 0.25;
+const NOISE_BLOCKED_NAMES = new Set([
+    'form.field.changed',
+    'ui.hover',
+    'ui.keypress',
+    'ui.scroll',
+]);
+class AXMActivityInsightActivityPolicyService {
+    constructor() {
+        this.settingsService = inject(AXPSettingsService);
+        this.enabledOverride = null;
+        this.entityPolicy = null;
+    }
+    setEntityPolicy(policy) {
+        this.entityPolicy = policy;
+    }
+    enable() {
+        this.enabledOverride = true;
+    }
+    disable() {
+        this.enabledOverride = false;
+    }
+    async isEnabled() {
+        if (this.enabledOverride != null) {
+            return this.enabledOverride;
+        }
+        try {
+            const setting = await this.settingsService.get(AXPActivityInsightSettings.Enabled);
+            if (setting === false) {
+                return false;
+            }
+        }
+        catch {
+            // settings unavailable — default to enabled
+        }
+        return this.entityPolicy?.enabled !== false;
+    }
+    async shouldTrack(event) {
+        if (!(await this.isEnabled())) {
+            return false;
+        }
+        if (NOISE_BLOCKED_NAMES.has(event.name)) {
+            return false;
+        }
+        if (this.entityPolicy?.enabled === false) {
+            return false;
+        }
+        if (!(await this.passesSampling(event))) {
+            return false;
+        }
+        return true;
+    }
+    async applyMasking(event) {
+        const maskingEnabled = await this.isMaskingEnabled();
+        if (!maskingEnabled) {
+            return event;
+        }
+        const policy = {
+            enabled: true,
+            denylist: this.entityPolicy?.masking?.fields,
+            maxPropertyBytes: AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG.maxPropertyBytes,
+        };
+        const properties = event.properties
+            ? maskActivityProperties(event.properties, policy)
+            : undefined;
+        const metadata = event.metadata
+            ? maskActivityProperties(event.metadata, policy)
+            : undefined;
+        return {
+            ...event,
+            properties: truncateActivityProperties(properties, policy.maxPropertyBytes ?? 4000),
+            metadata: truncateActivityProperties(metadata, policy.maxPropertyBytes ?? 4000),
+        };
+    }
+    defaultPriorityFor(eventName) {
+        if (eventName === AXMActivityEventNames.Query.Executed) {
+            return 'low';
+        }
+        if (eventName === AXMActivityEventNames.Error.Seen) {
+            return 'high';
+        }
+        return 'normal';
+    }
+    async isMaskingEnabled() {
+        try {
+            return (await this.settingsService.get(AXPActivityInsightSettings.MaskingEnabled)) !== false;
+        }
+        catch {
+            return true;
+        }
+    }
+    async passesSampling(event) {
+        try {
+            const samplingEnabled = await this.settingsService.get(AXPActivityInsightSettings.SamplingEnabled);
+            if (samplingEnabled === false) {
+                return true;
+            }
+        }
+        catch {
+            // default sampling on
+        }
+        const entityRate = this.entityPolicy?.sampling?.[event.name];
+        const rate = entityRate ??
+            (event.name === AXMActivityEventNames.Query.Executed ? DEFAULT_QUERY_SAMPLING_RATE : 1);
+        if (rate >= 1) {
+            return true;
+        }
+        if (rate <= 0) {
+            return false;
+        }
+        return Math.random() < rate;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightActivityPolicyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightActivityPolicyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightActivityPolicyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXMActivityInsightActivityTransport {
+    constructor() {
+        this.transportService = inject(AXPRuntimeTransportService);
+        this.retryAttempt = 0;
+    }
+    async send(events, options = {}) {
+        if (!events.length) {
+            return true;
+        }
+        const maxBytes = options.maxPayloadBytes ??
+            (options.final
+                ? AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG.finalFlushMaxBytes
+                : AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG.maxPayloadBytes);
+        const batch = this.buildBatch(this.trimToPayload(events, maxBytes));
+        try {
+            const result = await this.transportService.execute(AXMActivityInsightTransportKeys.Event.BulkIngest, {
+                batch,
+                final: options.final,
+                useBeacon: Boolean(options.final && AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG.useBeaconForFinalFlush),
+            });
+            if (result.accepted) {
+                this.retryAttempt = 0;
+                return true;
+            }
+            return false;
+        }
+        catch (err) {
+            console.debug('[ActivityInsight] transport failed', err);
+            return false;
+        }
+    }
+    nextRetryDelayMs() {
+        const { retryBackoffMs, retryLimit } = AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG;
+        if (this.retryAttempt >= retryLimit) {
+            return -1;
+        }
+        const delay = retryBackoffMs * 2 ** this.retryAttempt;
+        this.retryAttempt++;
+        return delay;
+    }
+    resetRetry() {
+        this.retryAttempt = 0;
+    }
+    buildBatch(events) {
+        return {
+            batchId: crypto.randomUUID(),
+            sentAt: new Date().toISOString(),
+            events,
+        };
+    }
+    trimToPayload(events, maxBytes) {
+        const sorted = [...events].sort((a, b) => {
+            const rank = (p) => (p === 'high' ? 0 : p === 'normal' ? 1 : 2);
+            return rank(a.priority) - rank(b.priority);
+        });
+        const out = [];
+        for (const event of sorted) {
+            const candidate = [...out, event];
+            if (JSON.stringify(this.buildBatch(candidate)).length <= maxBytes) {
+                out.push(event);
+            }
+        }
+        return out.length ? out : sorted.slice(0, 1);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightActivityTransport, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightActivityTransport, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightActivityTransport, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXMActivityInsightJourneyService {
+    constructor() {
+        this.activities = new Map();
+        this.journeys = new Map();
+    }
+    startJourney(name, sessionId) {
+        const journey = {
+            id: crypto.randomUUID(),
+            name,
+            sessionId,
+            startedAt: new Date().toISOString(),
+        };
+        this.journeys.set(journey.id, journey);
+        return { ...journey, status: 'started' };
+    }
+    endJourney(journeyId, status = 'completed', result) {
+        const journey = this.journeys.get(journeyId);
+        if (!journey) {
+            return null;
+        }
+        this.journeys.delete(journeyId);
+        return {
+            ...journey,
+            endedAt: new Date().toISOString(),
+            status,
+            result,
+        };
+    }
+    getActiveJourney(journeyId) {
+        return this.journeys.get(journeyId);
+    }
+    startActivity(name, options) {
+        const activity = {
+            id: crypto.randomUUID(),
+            name,
+            startedAt: new Date().toISOString(),
+            parentActivityId: options?.parentActivityId,
+            journeyId: options?.journeyId,
+            properties: options?.properties,
+        };
+        this.activities.set(activity.id, activity);
+        return activity;
+    }
+    endActivity(activityId, status = 'completed', properties) {
+        const activity = this.activities.get(activityId);
+        if (!activity) {
+            return null;
+        }
+        this.activities.delete(activityId);
+        const endedAt = new Date().toISOString();
+        const durationMs = Date.parse(endedAt) - Date.parse(activity.startedAt);
+        return {
+            ...activity,
+            endedAt,
+            status,
+            durationMs,
+            properties: { ...activity.properties, ...properties },
+        };
+    }
+    buildActivityStartedEvent(activity, enrich) {
+        return {
+            id: activity.id,
+            name: activity.name,
+            status: 'started',
+            timestamp: activity.startedAt,
+            parentActivityId: activity.parentActivityId,
+            journeyId: activity.journeyId,
+            properties: activity.properties,
+            ...enrich,
+        };
+    }
+    buildActivityEndedEvent(activity, enrich) {
+        return {
+            id: activity.id,
+            name: activity.name,
+            status: activity.status,
+            timestamp: activity.endedAt,
+            durationMs: activity.durationMs,
+            parentActivityId: activity.parentActivityId,
+            journeyId: activity.journeyId,
+            properties: activity.properties,
+            ...enrich,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightJourneyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightJourneyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightJourneyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const ACTIVITY_TRACK_HOOK_KEY = 'activity:track';
+const ACTIVITY_BEFORE_SEND_HOOK_KEY = 'activity-insight.before-send';
+const SESSION_STORAGE_KEY = 'axm-activity-session-id';
+const MIN_FLUSH_INTERVAL_MS = 1_000;
+const MAX_FLUSH_INTERVAL_MS = 60_000;
+const MIN_BATCH_SIZE = 1;
+const MAX_BATCH_SIZE = 500;
+class AXMActivityInsightTrackerService {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+        this.settingsService = inject(AXPSettingsService);
+        this.hooks = inject(AXPHookService);
+        this.policy = inject(AXMActivityInsightActivityPolicyService);
+        this.transport = inject(AXMActivityInsightActivityTransport);
+        this.journeyService = inject(AXMActivityInsightJourneyService);
+        this.router = inject(Router);
+        this.destroyRef = inject(DestroyRef);
+        this.buffer = new AXMActivityBuffer({
+            maxQueueSize: AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG.maxQueueSize,
+        });
+        this.flushTimer = null;
+        this.flushTimerStarting = false;
+        this.flushChain = Promise.resolve();
+        this.pendingRetry = null;
+        this.initialized = false;
+        this.visibilityHandlersRegistered = false;
+        this.currentJourneyId = null;
+    }
+    init() {
+        if (this.initialized || typeof window === 'undefined') {
+            return;
+        }
+        this.initialized = true;
+        this.sessionService.isReadyForAppScopedApi$
+            .pipe(distinctUntilChanged())
+            .subscribe((ready) => {
+            if (ready) {
+                this.onSessionActive();
+            }
+            else {
+                this.onSessionInactive();
+            }
+        });
+        if (!this.visibilityHandlersRegistered) {
+            this.registerVisibilityFlush();
+            this.visibilityHandlersRegistered = true;
+        }
+        this.destroyRef.onDestroy(() => {
+            void this.flush('final');
+            this.onSessionInactive();
+        });
+    }
+    async track(name, payload = {}) {
+        await this.trackMany([{ name, ...payload }]);
+    }
+    async trackMany(events) {
+        if (!this.canTrack()) {
+            return;
+        }
+        for (const partial of events) {
+            try {
+                const built = await this.buildEvent(partial);
+                if (!(await this.policy.shouldTrack(built))) {
+                    continue;
+                }
+                const masked = await this.policy.applyMasking(built);
+                const finalEvent = await this.hooks.runAsync(ACTIVITY_BEFORE_SEND_HOOK_KEY, masked);
+                if (!finalEvent) {
+                    continue;
+                }
+                this.buffer.enqueue(finalEvent);
+            }
+            catch (err) {
+                console.debug('[ActivityInsight] track skipped', err);
+            }
+        }
+        await this.flushIfNeeded();
+    }
+    startJourney(name) {
+        const journey = this.journeyService.startJourney(name, this.ensureSessionId());
+        this.currentJourneyId = journey.id;
+        void this.track(name, {
+            type: 'system',
+            category: 'custom',
+            journeyId: journey.id,
+            status: 'started',
+        });
+        return journey;
+    }
+    endJourney(journeyId, status = 'completed', result) {
+        const id = journeyId ?? this.currentJourneyId;
+        if (!id) {
+            return;
+        }
+        const journey = this.journeyService.endJourney(id, status, result);
+        if (!journey) {
+            return;
+        }
+        if (this.currentJourneyId === id) {
+            this.currentJourneyId = null;
+        }
+        void this.track(journey.name, {
+            type: 'system',
+            category: 'custom',
+            journeyId: journey.id,
+            status,
+            properties: result,
+        });
+        void this.flush('manual');
+    }
+    startActivity(name, properties) {
+        const activity = this.journeyService.startActivity(name, {
+            journeyId: this.currentJourneyId ?? undefined,
+            properties,
+        });
+        void this.track(name, {
+            id: activity.id,
+            type: 'action',
+            category: 'custom',
+            status: 'started',
+            parentActivityId: activity.parentActivityId,
+            journeyId: activity.journeyId,
+            properties,
+        });
+        return activity.id;
+    }
+    endActivity(activityId, status = 'completed', properties) {
+        const ended = this.journeyService.endActivity(activityId, status, properties);
+        if (!ended) {
+            return;
+        }
+        void this.track(ended.name, {
+            id: ended.id,
+            type: 'action',
+            category: 'custom',
+            status: ended.status,
+            durationMs: ended.durationMs,
+            parentActivityId: ended.parentActivityId,
+            journeyId: ended.journeyId,
+            properties: ended.properties,
+        });
+    }
+    trackPageView(route) {
+        void this.track(AXMActivityEventNames.Page.Viewed, {
+            type: 'view',
+            category: 'navigation',
+            route: route ?? this.router.url,
+        });
+    }
+    trackClick(name, properties) {
+        void this.track(name, { type: 'action', category: 'custom', properties });
+    }
+    trackEntityListOpen(module, entityName, properties) {
+        void this.track(AXMActivityEventNames.Entity.ListOpened, {
+            type: 'view',
+            category: 'entity',
+            module,
+            entityName,
+            properties,
+        });
+    }
+    trackEntityDetailOpen(module, entityName, entityId, properties) {
+        void this.track(AXMActivityEventNames.Entity.DetailOpened, {
+            type: 'view',
+            category: 'entity',
+            module,
+            entityName,
+            entityId,
+            properties,
+        });
+    }
+    trackFilterApply(entityName, properties) {
+        void this.track(AXMActivityEventNames.Entity.FilterApplied, {
+            type: 'action',
+            category: 'entity',
+            entityName,
+            properties,
+            priority: 'low',
+        });
+    }
+    trackSearch(entityName, properties) {
+        void this.track(AXMActivityEventNames.Entity.SearchApplied, {
+            type: 'action',
+            category: 'entity',
+            entityName,
+            properties,
+            priority: 'low',
+        });
+    }
+    trackSort(entityName, properties) {
+        void this.track(AXMActivityEventNames.Entity.SortApplied, {
+            type: 'action',
+            category: 'entity',
+            entityName,
+            properties,
+            priority: 'low',
+        });
+    }
+    trackCommandExecution(commandName, options) {
+        void this.track(AXMActivityEventNames.Command.Executed, {
+            type: 'action',
+            category: 'command',
+            commandName,
+            status: options?.success === false ? 'failed' : 'completed',
+            durationMs: options?.durationMs,
+            properties: options?.properties,
+        });
+    }
+    trackQueryExecution(queryName, options) {
+        void this.track(AXMActivityEventNames.Query.Executed, {
+            type: 'system',
+            category: 'query',
+            queryName,
+            status: options?.success === false ? 'failed' : 'completed',
+            durationMs: options?.durationMs,
+            properties: options?.properties,
+            priority: 'low',
+        });
+    }
+    trackFormSubmit(entityName, properties) {
+        void this.track(AXMActivityEventNames.Form.Submitted, {
+            type: 'action',
+            category: 'form',
+            entityName,
+            properties,
+        });
+    }
+    trackValidationError(entityName, properties) {
+        void this.track(AXMActivityEventNames.Form.ValidationFailed, {
+            type: 'error',
+            category: 'form',
+            entityName,
+            properties,
+            severity: 'normal',
+        });
+    }
+    trackAiInteraction(name, properties) {
+        void this.track(name, { type: 'action', category: 'ai', properties });
+    }
+    trackError(error, properties) {
+        const message = error instanceof Error ? error.message : String(error);
+        void this.track(AXMActivityEventNames.Error.Seen, {
+            type: 'error',
+            category: 'error',
+            severity: 'high',
+            priority: 'high',
+            properties: { message, ...properties },
+        });
+    }
+    async flush(reason = 'manual') {
+        if (!this.canTrack()) {
+            return;
+        }
+        this.flushChain = this.flushChain.then(async () => {
+            const events = this.buffer.drain();
+            if (!events.length) {
+                return;
+            }
+            const sent = await this.transport.send(events, { final: reason === 'final' });
+            if (!sent) {
+                this.buffer.requeueFront(events);
+                this.scheduleRetry();
+                return;
+            }
+            this.transport.resetRetry();
+        });
+        await this.flushChain;
+    }
+    enable() {
+        this.policy.enable();
+    }
+    disable() {
+        this.policy.disable();
+    }
+    getSessionId() {
+        return this.ensureSessionId();
+    }
+    canTrack() {
+        return Boolean(this.sessionService.getToken());
+    }
+    onSessionActive() {
+        this.ensureSessionId();
+        this.startFlushTimer();
+    }
+    onSessionInactive() {
+        this.stopFlushTimer();
+        this.cancelPendingRetry();
+        this.buffer.clear();
+        this.transport.resetRetry();
+        this.currentJourneyId = null;
+    }
+    cancelPendingRetry() {
+        if (this.pendingRetry) {
+            clearTimeout(this.pendingRetry);
+            this.pendingRetry = null;
+        }
+    }
+    async buildEvent(partial) {
+        const session = this.sessionService;
+        const priority = partial.priority ?? this.policy.defaultPriorityFor(partial.name);
+        return {
+            id: partial.id ?? crypto.randomUUID(),
+            name: partial.name,
+            type: partial.type ?? this.inferType(partial.name),
+            category: partial.category ?? this.inferCategory(partial.name),
+            timestamp: partial.timestamp ?? new Date().toISOString(),
+            sessionId: partial.sessionId ?? this.ensureSessionId(),
+            journeyId: partial.journeyId ?? this.currentJourneyId ?? undefined,
+            parentActivityId: partial.parentActivityId,
+            userId: partial.userId ?? session.user?.id,
+            username: partial.username ?? session.user?.name,
+            tenantId: partial.tenantId ?? session.tenant?.id,
+            applicationId: partial.applicationId ?? session.application?.id,
+            source: partial.source ?? 'frontend',
+            route: partial.route ?? this.router.url,
+            module: partial.module,
+            entityName: partial.entityName,
+            entityId: partial.entityId,
+            viewId: partial.viewId,
+            widgetId: partial.widgetId,
+            commandName: partial.commandName,
+            queryName: partial.queryName,
+            workflowId: partial.workflowId,
+            aiConversationId: partial.aiConversationId,
+            status: partial.status,
+            durationMs: partial.durationMs,
+            severity: partial.severity,
+            priority,
+            properties: partial.properties,
+            metadata: partial.metadata ?? { sdkVersion: '1.0.0' },
+        };
+    }
+    inferType(name) {
+        if (name.startsWith('error.') || name.includes('validation')) {
+            return 'error';
+        }
+        if (name.startsWith('page.') || name.includes('.opened')) {
+            return 'view';
+        }
+        if (name.startsWith('query.')) {
+            return 'system';
+        }
+        return 'action';
+    }
+    inferCategory(name) {
+        if (name.startsWith('page.'))
+            return 'navigation';
+        if (name.startsWith('entity.'))
+            return 'entity';
+        if (name.startsWith('command.'))
+            return 'command';
+        if (name.startsWith('query.'))
+            return 'query';
+        if (name.startsWith('form.'))
+            return 'form';
+        if (name.startsWith('ai.'))
+            return 'ai';
+        if (name.startsWith('workflow.'))
+            return 'workflow';
+        if (name.startsWith('security.'))
+            return 'security';
+        if (name.startsWith('error.'))
+            return 'error';
+        return 'custom';
+    }
+    ensureSessionId() {
+        try {
+            let id = sessionStorage.getItem(SESSION_STORAGE_KEY);
+            if (!id) {
+                id = crypto.randomUUID();
+                sessionStorage.setItem(SESSION_STORAGE_KEY, id);
+            }
+            return id;
+        }
+        catch {
+            return crypto.randomUUID();
+        }
+    }
+    async flushIfNeeded() {
+        const maxBatchSize = await this.getBufferSetting(AXPActivityInsightSettings.MaxBatchSize, AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG.maxBatchSize, MIN_BATCH_SIZE, MAX_BATCH_SIZE);
+        if (this.buffer.peekCount() >= maxBatchSize) {
+            await this.flush('batch-size');
+        }
+    }
+    startFlushTimer() {
+        if (this.flushTimer || this.flushTimerStarting) {
+            return;
+        }
+        this.flushTimerStarting = true;
+        void this.getBufferSetting(AXPActivityInsightSettings.FlushIntervalMs, AXM_DEFAULT_ACTIVITY_BUFFER_CONFIG.flushIntervalMs, MIN_FLUSH_INTERVAL_MS, MAX_FLUSH_INTERVAL_MS)
+            .then((ms) => {
+            if (this.flushTimer) {
+                return;
+            }
+            this.flushTimer = setInterval(() => void this.flush('interval'), ms);
+        })
+            .finally(() => {
+            this.flushTimerStarting = false;
+        });
+    }
+    stopFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.flushTimerStarting = false;
+    }
+    registerVisibilityFlush() {
+        if (typeof document === 'undefined') {
+            return;
+        }
+        const handler = () => {
+            if (document.visibilityState === 'hidden') {
+                void this.flush('visibility');
+            }
+        };
+        document.addEventListener('visibilitychange', handler);
+        window.addEventListener('pagehide', () => void this.flush('final'));
+        this.destroyRef.onDestroy(() => {
+            document.removeEventListener('visibilitychange', handler);
+        });
+    }
+    scheduleRetry() {
+        const delay = this.transport.nextRetryDelayMs();
+        if (delay < 0 || this.pendingRetry) {
+            return;
+        }
+        this.pendingRetry = setTimeout(() => {
+            this.pendingRetry = null;
+            void this.flush('manual');
+        }, delay);
+    }
+    async getSetting(key, fallback) {
+        try {
+            const value = await this.settingsService.get(key);
+            return value ?? fallback;
+        }
+        catch {
+            return fallback;
+        }
+    }
+    async getBufferSetting(key, fallback, min, max) {
+        try {
+            const value = await this.settingsService.get(key);
+            return this.clampBufferNumber(value, fallback, min, max);
+        }
+        catch {
+            return fallback;
+        }
+    }
+    clampBufferNumber(value, fallback, min, max) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            return fallback;
+        }
+        return Math.min(max, Math.max(min, Math.round(value)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightTrackerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightTrackerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXMActivityInsightPageViewInstrumentation {
+    constructor() {
+        this.router = inject(Router);
+        this.tracker = inject(AXMActivityInsightTrackerService);
+    }
+    init() {
+        this.router.events.pipe(filter((e) => e instanceof NavigationEnd)).subscribe((event) => {
+            this.tracker.trackPageView(event.urlAfterRedirects);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightPageViewInstrumentation, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightPageViewInstrumentation, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightPageViewInstrumentation, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class AXMActivityInsightCommandInstrumentation {
+    constructor() {
+        this.commandEvents = inject(AXPCommandEventsService);
+        this.tracker = inject(AXMActivityInsightTrackerService);
+        this.destroyRef = inject(DestroyRef);
+    }
+    init() {
+        const unsubscribe = this.commandEvents.listen((event) => this.handle(event));
+        this.destroyRef.onDestroy(unsubscribe);
+    }
+    handle(event) {
+        if (event.stage !== 'after') {
+            return;
+        }
+        this.tracker.trackCommandExecution(event.key, {
+            success: event.success,
+            durationMs: event.durationMs,
+            properties: {
+                executionId: event.executionId,
+                input: event.input,
+                error: event.error,
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightCommandInstrumentation, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightCommandInstrumentation, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightCommandInstrumentation, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const QUERY_EXECUTION_EVENT_KEY = '@queries:execution';
+class AXMActivityInsightQueryInstrumentation {
+    constructor() {
+        this.broadcast = inject(AXPBroadcastEventService);
+        this.tracker = inject(AXMActivityInsightTrackerService);
+        this.destroyRef = inject(DestroyRef);
+    }
+    init() {
+        const subscription = this.broadcast
+            .listen(QUERY_EXECUTION_EVENT_KEY)
+            .subscribe(({ data }) => this.handle(data));
+        this.destroyRef.onDestroy(() => subscription.unsubscribe());
+    }
+    handle(event) {
+        if (event.stage !== 'after') {
+            return;
+        }
+        this.tracker.trackQueryExecution(event.key, {
+            success: event.success,
+            durationMs: event.durationMs,
+            properties: {
+                executionId: event.executionId,
+                input: event.input,
+                error: event.error,
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightQueryInstrumentation, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightQueryInstrumentation, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightQueryInstrumentation, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const EntityLifecycleHookKeys = {
+    ListOpened: 'entity.list.opened',
+    ListCriteriaApplied: 'entity.list.criteria-applied',
+    DetailOpened: 'entity.detail.opened',
+    FormSubmitted: 'entity.form.submitted',
+    FormValidationFailed: 'entity.form.validation-failed',
+};
+class AXMActivityInsightEntityInstrumentation {
+    constructor() {
+        this.tracker = inject(AXMActivityInsightTrackerService);
+    }
+    init() {
+        // Hook providers are registered via module; this ensures tracker is ready.
+    }
+    handleListOpened(data) {
+        const module = String(data['module'] ?? data['moduleName'] ?? '');
+        const entityName = String(data['entityName'] ?? data['entity'] ?? '');
+        this.tracker.trackEntityListOpen(module, entityName, data);
+    }
+    handleDetailOpened(data) {
+        const module = String(data['module'] ?? data['moduleName'] ?? '');
+        const entityName = String(data['entityName'] ?? data['entity'] ?? '');
+        const entityId = data['entityId'] != null ? String(data['entityId']) : undefined;
+        this.tracker.trackEntityDetailOpen(module, entityName, entityId, data);
+    }
+    handleCriteriaApplied(data) {
+        const entityName = String(data['entityName'] ?? data['entity'] ?? '');
+        const kind = String(data['kind'] ?? data['deltaType'] ?? 'filter');
+        if (kind === 'search') {
+            this.tracker.trackSearch(entityName, data);
+            return;
+        }
+        if (kind === 'sort') {
+            this.tracker.trackSort(entityName, data);
+            return;
+        }
+        this.tracker.trackFilterApply(entityName, data);
+    }
+    handleFormSubmitted(data) {
+        const entityName = String(data['entityName'] ?? data['entity'] ?? '');
+        this.tracker.trackFormSubmit(entityName, data);
+    }
+    handleValidationFailed(data) {
+        const entityName = String(data['entityName'] ?? data['entity'] ?? '');
+        this.tracker.trackValidationError(entityName, data);
+    }
+    handleEntityCrud(data) {
+        const operation = String(data['operation'] ?? '');
+        const entityName = String(data['entityName'] ?? '');
+        const nameMap = {
+            inserted: AXMActivityEventNames.Entity.Created,
+            updated: AXMActivityEventNames.Entity.Updated,
+            deleted: AXMActivityEventNames.Entity.Deleted,
+        };
+        const name = nameMap[operation];
+        if (!name) {
+            return;
+        }
+        void this.tracker.track(name, {
+            type: 'action',
+            category: 'entity',
+            entityName,
+            entityId: data['entityId'] != null ? String(data['entityId']) : undefined,
+            properties: data,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightEntityInstrumentation, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightEntityInstrumentation, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightEntityInstrumentation, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function createHookProvider(key, handler) {
+    return {
+        key,
+        priority: 50,
+        execute: (data) => {
+            const svc = inject(AXMActivityInsightEntityInstrumentation);
+            handler(svc, data);
+        },
+    };
+}
+const AXMActivityInsightEntityHookProviders = [
+    createHookProvider(EntityLifecycleHookKeys.ListOpened, (svc, data) => svc.handleListOpened(data)),
+    createHookProvider(EntityLifecycleHookKeys.DetailOpened, (svc, data) => svc.handleDetailOpened(data)),
+    createHookProvider(EntityLifecycleHookKeys.ListCriteriaApplied, (svc, data) => svc.handleCriteriaApplied(data)),
+    createHookProvider(EntityLifecycleHookKeys.FormSubmitted, (svc, data) => svc.handleFormSubmitted(data)),
+    createHookProvider(EntityLifecycleHookKeys.FormValidationFailed, (svc, data) => svc.handleValidationFailed(data)),
+    createHookProvider('entity.inserted', (svc, data) => svc.handleEntityCrud({ ...data, operation: 'inserted' })),
+    createHookProvider('entity.updated', (svc, data) => svc.handleEntityCrud({ ...data, operation: 'updated' })),
+    createHookProvider('entity.deleted', (svc, data) => svc.handleEntityCrud({ ...data, operation: 'deleted' })),
+];
+
+class AXMActivityInsightErrorHandler {
+    constructor() {
+        this.tracker = inject(AXMActivityInsightTrackerService);
+    }
+    handleError(error, next) {
+        try {
+            this.tracker.trackError(error);
+        }
+        catch {
+            // tracking must never break error handling
+        }
+        next(error);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMActivityInsightModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightModule, imports: [AXPRuntimeModule, i1.AXPCommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightModule, providers: [
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: () => activityInsightFeatureRoutes,
+            },
+            { provide: AXP_MODULE_MANIFEST_PROVIDER, useValue: ActivityInsightManifest, multi: true },
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMActivityInsightPermissionDefinitionProvider,
+                multi: true,
+            },
+            { provide: AXP_MENU_PROVIDER, useClass: AXMActivityInsightMenuProvider, multi: true },
+            { provide: AXP_SETTING_DEFINITION_PROVIDER, useClass: AXPActivityInsightSettingProvider, multi: true },
+            { provide: AXP_SEARCH_PROVIDER, useClass: AXMActivityInsightSearchCommandProvider, multi: true },
+            { provide: AXP_ENTITY_ACTION_PLUGIN, useValue: activityTrackingPlugin, multi: true },
+            { provide: AXP_ENTITY_MODIFIER, useValue: activityTrackingDefaultsModifier, multi: true },
+            ...AXMActivityInsightEntityHookProviders.map((provider) => ({
+                provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                useValue: provider,
+                multi: true,
+            })),
+            {
+                provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                multi: true,
+                useFactory: () => ({
+                    key: ACTIVITY_TRACK_HOOK_KEY,
+                    priority: 0,
+                    execute: (data) => {
+                        const tracker = inject(AXMActivityInsightTrackerService);
+                        if (data?.name) {
+                            void tracker.trackMany([data]);
+                        }
+                    },
+                }),
+            },
+            provideAppStartUpTask(() => {
+                const tracker = inject(AXMActivityInsightTrackerService);
+                const pageView = inject(AXMActivityInsightPageViewInstrumentation);
+                const command = inject(AXMActivityInsightCommandInstrumentation);
+                const query = inject(AXMActivityInsightQueryInstrumentation);
+                const entity = inject(AXMActivityInsightEntityInstrumentation);
+                return {
+                    name: 'activity-insight-instrumentation',
+                    priority: AXP_APP_STARTUP_PRIORITY.activityInsight,
+                    run: async () => {
+                        tracker.init();
+                        pageView.init();
+                        command.init();
+                        query.init();
+                        entity.init();
+                    },
+                };
+            }),
+        ], imports: [AXPRuntimeModule,
+            AXPCommonModule.forChild({ errorHandlers: [AXMActivityInsightErrorHandler] })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMActivityInsightModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPRuntimeModule,
+                        AXPCommonModule.forChild({ errorHandlers: [AXMActivityInsightErrorHandler] }),
+                    ],
+                    providers: [
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: () => activityInsightFeatureRoutes,
+                        },
+                        { provide: AXP_MODULE_MANIFEST_PROVIDER, useValue: ActivityInsightManifest, multi: true },
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMActivityInsightPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        { provide: AXP_MENU_PROVIDER, useClass: AXMActivityInsightMenuProvider, multi: true },
+                        { provide: AXP_SETTING_DEFINITION_PROVIDER, useClass: AXPActivityInsightSettingProvider, multi: true },
+                        { provide: AXP_SEARCH_PROVIDER, useClass: AXMActivityInsightSearchCommandProvider, multi: true },
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, useValue: activityTrackingPlugin, multi: true },
+                        { provide: AXP_ENTITY_MODIFIER, useValue: activityTrackingDefaultsModifier, multi: true },
+                        ...AXMActivityInsightEntityHookProviders.map((provider) => ({
+                            provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                            useValue: provider,
+                            multi: true,
+                        })),
+                        {
+                            provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                            multi: true,
+                            useFactory: () => ({
+                                key: ACTIVITY_TRACK_HOOK_KEY,
+                                priority: 0,
+                                execute: (data) => {
+                                    const tracker = inject(AXMActivityInsightTrackerService);
+                                    if (data?.name) {
+                                        void tracker.trackMany([data]);
+                                    }
+                                },
+                            }),
+                        },
+                        provideAppStartUpTask(() => {
+                            const tracker = inject(AXMActivityInsightTrackerService);
+                            const pageView = inject(AXMActivityInsightPageViewInstrumentation);
+                            const command = inject(AXMActivityInsightCommandInstrumentation);
+                            const query = inject(AXMActivityInsightQueryInstrumentation);
+                            const entity = inject(AXMActivityInsightEntityInstrumentation);
+                            return {
+                                name: 'activity-insight-instrumentation',
+                                priority: AXP_APP_STARTUP_PRIORITY.activityInsight,
+                                run: async () => {
+                                    tracker.init();
+                                    pageView.init();
+                                    command.init();
+                                    query.init();
+                                    entity.init();
+                                },
+                            };
+                        }),
+                    ],
+                }]
+        }] });
+
+const AXM_ACTIVITY_TRACKING_RULE_PROVIDER = new InjectionToken('AXM_ACTIVITY_TRACKING_RULE_PROVIDER');
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMActivityInsightJourneyService, AXMActivityInsightModule, AXMActivityInsightTrackerService, AXM_ACTIVITY_TRACKING_RULE_PROVIDER };
+//# sourceMappingURL=acorex-platform-module-activity-insight-client.mjs.map