@amadeus-it-group/ngrx-devtool 0.1.2

package/ngrx-devtool/fesm2022/amadeus-it-group-ngrx-devtool.mjs

@@ -0,0 +1,1354 @@
+import * as i0 from '@angular/core';
+import { inject, Injectable, PLATFORM_ID, ErrorHandler, Injector, afterNextRender, APP_INITIALIZER } from '@angular/core';
+import { EffectSources, Actions, EFFECTS_ERROR_HANDLER } from '@ngrx/effects';
+import { Subject, ReplaySubject, BehaviorSubject, takeUntil as takeUntil$1, filter, tap, Observable } from 'rxjs';
+import { takeUntil, tap as tap$1 } from 'rxjs/operators';
+import { isPlatformBrowser } from '@angular/common';
+import { createSelector } from '@ngrx/store';
+
+const REPLAY_BUFFER_SIZE$1 = 100;
+const TIMELINE_MAX_SIZE = 1000;
+const TIMELINE_TRIM_SIZE = 500;
+const EFFECT_TIMELINE_MAX_SIZE = 500;
+const CORRELATION_TIMEOUT_MS = 30000;
+class EffectTrackerService {
+    effectSources = inject(EffectSources, { optional: true });
+    destroy$ = new Subject();
+    actionTimeline = [];
+    effectTimeline = [];
+    effectActionPatterns = new Set();
+    pendingCorrelations = new Map();
+    correlationCounter = 0;
+    lastTriggerAction = null;
+    effectEvents$ = new ReplaySubject(REPLAY_BUFFER_SIZE$1);
+    constructor() {
+        this.subscribeToEffectEvents();
+    }
+    subscribeToEffectEvents() {
+        const devToolsSources = this.effectSources;
+        if (devToolsSources?.effectEvents$) {
+            devToolsSources.effectEvents$.pipe(takeUntil(this.destroy$)).subscribe((event) => {
+                this.handleEffectEvent(event);
+                this.effectEvents$.next(event);
+            });
+        }
+    }
+    handleEffectEvent(event) {
+        switch (event.lifecycle) {
+            case 'emitted':
+                if (event.action) {
+                    const trackedEffect = {
+                        effectName: event.effectName,
+                        sourceName: event.sourceName,
+                        propertyName: event.propertyName,
+                        triggerAction: this.lastTriggerAction?.type,
+                        resultAction: event.action.type,
+                        startTime: event.timestamp - (event.duration ?? 0),
+                        endTime: event.timestamp,
+                        duration: event.duration,
+                        status: 'completed',
+                    };
+                    this.effectTimeline.push(trackedEffect);
+                    this.effectActionPatterns.add(event.action.type);
+                }
+                break;
+            case 'error': {
+                const erroredEffect = {
+                    effectName: event.effectName,
+                    sourceName: event.sourceName,
+                    propertyName: event.propertyName,
+                    triggerAction: this.lastTriggerAction?.type,
+                    startTime: event.timestamp - (event.duration ?? 0),
+                    endTime: event.timestamp,
+                    duration: event.duration,
+                    status: 'error',
+                    error: event.error,
+                };
+                this.effectTimeline.push(erroredEffect);
+                break;
+            }
+        }
+        if (this.effectTimeline.length > EFFECT_TIMELINE_MAX_SIZE) {
+            this.effectTimeline = this.effectTimeline.slice(-EFFECT_TIMELINE_MAX_SIZE / 2);
+        }
+    }
+    isEffectAction(actionType) {
+        return this.effectActionPatterns.has(actionType);
+    }
+    trackAction(action) {
+        const isEffect = this.isEffectAction(action.type);
+        if (!isEffect) {
+            this.lastTriggerAction = action;
+        }
+        const correlationId = isEffect
+            ? this.findCorrelation()
+            : this.createCorrelation(action);
+        const effectName = this.findEffectNameForAction(action.type);
+        const tracked = {
+            action: action.type,
+            payload: action,
+            timestamp: Date.now(),
+            source: isEffect ? 'effect' : 'user',
+            correlationId,
+            effectName,
+        };
+        this.actionTimeline.push(tracked);
+        if (this.actionTimeline.length > TIMELINE_MAX_SIZE) {
+            this.actionTimeline = this.actionTimeline.slice(-TIMELINE_TRIM_SIZE);
+        }
+        return tracked;
+    }
+    getTimeline() {
+        return [...this.actionTimeline];
+    }
+    clearTimeline() {
+        this.actionTimeline = [];
+        this.pendingCorrelations.clear();
+    }
+    createCorrelation(action) {
+        const correlationId = `corr_${++this.correlationCounter}_${Date.now()}`;
+        this.pendingCorrelations.set(correlationId, {
+            action,
+            timestamp: Date.now(),
+        });
+        setTimeout(() => {
+            this.pendingCorrelations.delete(correlationId);
+        }, CORRELATION_TIMEOUT_MS);
+        return correlationId;
+    }
+    findCorrelation() {
+        const entries = Array.from(this.pendingCorrelations.entries());
+        return entries.length > 0 ? entries[entries.length - 1][0] : undefined;
+    }
+    findEffectNameForAction(actionType) {
+        for (let i = this.effectTimeline.length - 1; i >= Math.max(0, this.effectTimeline.length - 10); i--) {
+            const effect = this.effectTimeline[i];
+            if (effect.resultAction === actionType) {
+                return effect.effectName;
+            }
+        }
+        return undefined;
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.effectEvents$.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: EffectTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: EffectTrackerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: EffectTrackerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class WebSocketService {
+    platformId = inject(PLATFORM_ID);
+    isBrowser = isPlatformBrowser(this.platformId);
+    socket = null;
+    messageBuffer = [];
+    wsUrl = null;
+    initialized = false;
+    connectionState$ = new BehaviorSubject(false);
+    incomingMessages$ = new BehaviorSubject(null);
+    get isConnected() {
+        return this.connectionState$.getValue();
+    }
+    get connected$() {
+        return this.connectionState$.asObservable();
+    }
+    get messages$() {
+        return this.incomingMessages$.asObservable();
+    }
+    initialize(wsUrl = 'ws://localhost:4000') {
+        if (this.initialized) {
+            // If already initialized with same URL, skip
+            if (this.wsUrl === wsUrl) {
+                return;
+            }
+            // If different URL, close existing and reinitialize
+            this.close();
+        }
+        this.initialized = true;
+        this.wsUrl = wsUrl;
+        this.setupWebSocket(wsUrl);
+    }
+    send(message) {
+        const payload = JSON.stringify(message);
+        if (this.isConnected && this.socket?.readyState === WebSocket.OPEN) {
+            this.socket.send(payload);
+        }
+        else if (this.isBrowser) {
+            this.messageBuffer.push(payload);
+        }
+    }
+    sendRaw(payload) {
+        if (this.isConnected && this.socket?.readyState === WebSocket.OPEN) {
+            this.socket.send(payload);
+        }
+        else if (this.isBrowser) {
+            this.messageBuffer.push(payload);
+        }
+    }
+    ngOnDestroy() {
+        this.close();
+        this.connectionState$.complete();
+        this.incomingMessages$.complete();
+    }
+    close() {
+        this.socket?.close();
+        this.socket = null;
+        this.connectionState$.next(false);
+        this.initialized = false;
+        this.wsUrl = null;
+    }
+    setupWebSocket(wsUrl) {
+        if (!this.isBrowser) {
+            return;
+        }
+        this.socket = new WebSocket(wsUrl);
+        this.socket.onopen = () => {
+            this.connectionState$.next(true);
+            this.flushBuffer();
+        };
+        this.socket.onclose = () => {
+            this.connectionState$.next(false);
+        };
+        this.socket.onerror = (error) => {
+            console.warn('[NgRx DevTool] WebSocket error:', error);
+        };
+        this.socket.onmessage = (event) => {
+            try {
+                const message = JSON.parse(event.data);
+                this.incomingMessages$.next(message);
+            }
+            catch {
+                // Ignore non-JSON messages
+            }
+        };
+    }
+    flushBuffer() {
+        while (this.messageBuffer.length > 0 && this.isConnected) {
+            const message = this.messageBuffer.shift();
+            if (message && this.socket?.readyState === WebSocket.OPEN) {
+                this.socket.send(message);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: WebSocketService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: WebSocketService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: WebSocketService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class ActionsInterceptorService {
+    actions$ = inject(Actions);
+    effectTracker = inject(EffectTrackerService);
+    webSocketService = inject(WebSocketService);
+    destroy$ = new Subject();
+    initialized = false;
+    initialize(wsUrl = 'ws://localhost:4000') {
+        if (this.initialized) {
+            return;
+        }
+        this.initialized = true;
+        this.webSocketService.initialize(wsUrl);
+        this.setupMessageListener();
+        this.setupActionInterception();
+        this.setupEffectEventForwarding();
+    }
+    getTimeline() {
+        return this.effectTracker.getTimeline();
+    }
+    clearTimeline() {
+        this.effectTracker.clearTimeline();
+        this.sendMessage({
+            type: 'TIMELINE_CLEARED',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    setupMessageListener() {
+        this.webSocketService.messages$.pipe(takeUntil$1(this.destroy$), filter((message) => message !== null), tap((message) => {
+            if (message['type'] === 'CLEAR_REQUEST') {
+                this.effectTracker.clearTimeline();
+            }
+        })).subscribe();
+    }
+    setupActionInterception() {
+        this.actions$.pipe(takeUntil$1(this.destroy$), tap((action) => {
+            const tracked = this.effectTracker.trackAction(action);
+            const message = {
+                type: 'ACTION_TRACKED',
+                action: action.type,
+                payload: this.sanitizePayload(action),
+                isEffectResult: tracked.source === 'effect',
+                effectName: tracked.effectName,
+                correlationId: tracked.correlationId,
+                timestamp: new Date().toISOString(),
+            };
+            this.sendMessage(message);
+        })).subscribe();
+    }
+    setupEffectEventForwarding() {
+        this.effectTracker.effectEvents$.pipe(takeUntil$1(this.destroy$), tap((event) => {
+            const message = {
+                type: 'EFFECT_EVENT',
+                action: event.action?.type,
+                effectName: event.effectName,
+                effectEvent: {
+                    name: event.effectName,
+                    lifecycle: event.lifecycle,
+                    duration: event.duration,
+                    executionId: event.executionId,
+                    dispatch: event.dispatch,
+                },
+                timestamp: new Date().toISOString(),
+            };
+            this.sendMessage(message);
+        })).subscribe({
+            error: (err) => console.error('[NgRx DevTool] Effect event forwarding error:', err)
+        });
+    }
+    sendMessage(message) {
+        this.webSocketService.send(message);
+    }
+    sanitizePayload(action) {
+        try {
+            JSON.stringify(action);
+            return action;
+        }
+        catch {
+            return { type: action.type, _note: 'Non-serializable payload' };
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: ActionsInterceptorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: ActionsInterceptorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: ActionsInterceptorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** NgRx internal metadata key for createEffect() */
+const CREATE_EFFECT_METADATA_KEY = '__@ngrx/effects_create__';
+const REPLAY_BUFFER_SIZE = 100;
+class DevToolsEffectSources extends EffectSources {
+    effectEvents$ = new ReplaySubject(REPLAY_BUFFER_SIZE);
+    registeredEffects = new Map();
+    executionCounter = 0;
+    constructor() {
+        super(inject(ErrorHandler), inject(EFFECTS_ERROR_HANDLER));
+    }
+    addEffects(effectSourceInstance) {
+        const sourceName = this.resolveSourceName(effectSourceInstance);
+        if (sourceName) {
+            const metadata = this.extractEffectMetadata(effectSourceInstance);
+            if (metadata.length > 0) {
+                this.registeredEffects.set(sourceName, metadata);
+                this.instrumentEffects(effectSourceInstance, sourceName, metadata);
+            }
+        }
+        super.addEffects(effectSourceInstance);
+    }
+    getRegisteredEffects() {
+        return this.registeredEffects;
+    }
+    ngOnDestroy() {
+        this.effectEvents$.complete();
+    }
+    instrumentEffects(instance, sourceName, metadata) {
+        for (const { propertyName, dispatch } of metadata) {
+            const original = instance[propertyName];
+            if (!original)
+                continue;
+            const effectName = `${sourceName}.${propertyName}`;
+            if (typeof original === 'function') {
+                const factory = original;
+                const wrapped = () => this.wrapEffectObservable(factory(), effectName, dispatch);
+                this.copyEffectMetadata(factory, wrapped);
+                instance[propertyName] = wrapped;
+            }
+            else if (this.isObservable(original)) {
+                const wrapped = this.wrapEffectObservable(original, effectName, dispatch);
+                this.copyEffectMetadata(original, wrapped);
+                instance[propertyName] = wrapped;
+            }
+        }
+    }
+    wrapEffectObservable(source$, effectName, dispatch) {
+        const [sourceName, propertyName] = this.parseEffectName(effectName);
+        return new Observable(subscriber => {
+            let lastEmitTime = Date.now();
+            const subscription = source$.pipe(tap$1({
+                next: (value) => {
+                    const now = Date.now();
+                    this.emitEvent({
+                        effectName,
+                        sourceName,
+                        propertyName,
+                        lifecycle: dispatch ? 'emitted' : 'executed',
+                        action: dispatch ? value : undefined,
+                        timestamp: now,
+                        duration: now - lastEmitTime,
+                        executionId: this.generateExecutionId(effectName),
+                        dispatch,
+                    });
+                    lastEmitTime = now;
+                },
+                error: (err) => {
+                    const now = Date.now();
+                    this.emitEvent({
+                        effectName,
+                        sourceName,
+                        propertyName,
+                        lifecycle: 'error',
+                        error: err,
+                        timestamp: now,
+                        duration: now - lastEmitTime,
+                        executionId: this.generateExecutionId(effectName),
+                    });
+                },
+            })).subscribe(subscriber);
+            return () => subscription.unsubscribe();
+        });
+    }
+    copyEffectMetadata(original, wrapped) {
+        const originalRecord = original;
+        const metadata = originalRecord[CREATE_EFFECT_METADATA_KEY];
+        if (metadata) {
+            Object.defineProperty(wrapped, CREATE_EFFECT_METADATA_KEY, {
+                value: metadata,
+                configurable: true,
+            });
+        }
+    }
+    extractEffectMetadata(instance) {
+        const metadata = [];
+        for (const propertyName of Object.getOwnPropertyNames(instance)) {
+            try {
+                const property = instance[propertyName];
+                const config = property?.[CREATE_EFFECT_METADATA_KEY];
+                if (config) {
+                    metadata.push({
+                        propertyName,
+                        dispatch: config.dispatch !== false,
+                        functional: config.functional === true,
+                        useEffectsErrorHandler: config.useEffectsErrorHandler !== false,
+                    });
+                }
+            }
+            catch {
+                // Ignore reflection errors for non-effect properties
+            }
+        }
+        return metadata;
+    }
+    resolveSourceName(instance) {
+        if (!instance)
+            return null;
+        if (typeof instance.ngrxOnIdentifyEffects === 'function') {
+            const id = instance.ngrxOnIdentifyEffects();
+            if (id)
+                return id;
+        }
+        const constructorName = instance.constructor?.name;
+        if (this.isValidClassName(constructorName)) {
+            return constructorName;
+        }
+        const proto = Object.getPrototypeOf(instance);
+        const protoName = proto?.constructor?.name;
+        if (this.isValidClassName(protoName)) {
+            return protoName;
+        }
+        const effectProps = Object.getOwnPropertyNames(instance)
+            .filter(p => p.endsWith('$') || p.startsWith('load') || p.startsWith('fetch'));
+        if (effectProps.length > 0) {
+            return `Effects(${effectProps.slice(0, 2).join(', ')}...)`;
+        }
+        return constructorName ?? 'UnknownEffect';
+    }
+    isValidClassName(name) {
+        return Boolean(name && name.length > 1 && name !== 'Object' && name !== 'Function');
+    }
+    isObservable(value) {
+        return Boolean(value && typeof value.subscribe === 'function');
+    }
+    parseEffectName(effectName) {
+        const [sourceName, propertyName = 'unknown'] = effectName.split('.');
+        return [sourceName, propertyName];
+    }
+    generateExecutionId(effectName) {
+        return `${effectName}_${++this.executionCounter}`;
+    }
+    emitEvent(event) {
+        this.effectEvents$.next(event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: DevToolsEffectSources, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: DevToolsEffectSources });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: DevToolsEffectSources, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+// Models
+
+const ENTRIES_MAX_SIZE = 1000;
+const ENTRIES_TRIM_SIZE = 500;
+const DEFAULT_THRESHOLDS = {
+    maxReducerTime: 16,
+    maxStateSize: 5 * 1024 * 1024,
+    maxStateChangeSize: 1024 * 1024,
+    maxActionsPerSecond: 60,
+    maxPayloadSize: 100 * 1024,
+};
+class PerformanceTrackerService {
+    entries = [];
+    warnings = [];
+    platformId = inject(PLATFORM_ID);
+    injector = inject(Injector);
+    isBrowser = isPlatformBrowser(this.platformId);
+    thresholds = DEFAULT_THRESHOLDS;
+    firstActionTime = null;
+    measureRenderTime(actionType, reducer, callback) {
+        const startTime = performance.now();
+        const nextState = reducer();
+        if (!this.isBrowser) {
+            callback(0);
+            return nextState;
+        }
+        afterNextRender(() => {
+            const renderTime = parseFloat((performance.now() - startTime).toFixed(2));
+            const entry = {
+                actionType,
+                timestamp: Date.now(),
+                renderTime,
+            };
+            this.entries.push(entry);
+            if (this.firstActionTime === null) {
+                this.firstActionTime = entry.timestamp;
+            }
+            if (this.entries.length > ENTRIES_MAX_SIZE) {
+                this.entries = this.entries.slice(-ENTRIES_TRIM_SIZE);
+            }
+            callback(renderTime);
+        }, { injector: this.injector });
+        return nextState;
+    }
+    getEntries() {
+        return [...this.entries];
+    }
+    getStats() {
+        if (this.entries.length === 0) {
+            return {
+                avgRenderTime: 0,
+                maxRenderTime: 0,
+                slowestAction: null,
+                totalActions: 0,
+            };
+        }
+        const renderTimes = this.entries.map(e => e.renderTime);
+        const avgRenderTime = renderTimes.reduce((a, b) => a + b, 0) / renderTimes.length;
+        const maxRenderTime = Math.max(...renderTimes);
+        const slowestEntry = this.entries.reduce((prev, curr) => curr.renderTime > prev.renderTime ? curr : prev);
+        return {
+            avgRenderTime,
+            maxRenderTime,
+            slowestAction: slowestEntry.actionType,
+            totalActions: this.entries.length,
+        };
+    }
+    getAggregatedStats() {
+        const stats = this.getStats();
+        const actionTypeStats = this.getActionTypeStats();
+        const elapsedTime = this.firstActionTime
+            ? (Date.now() - this.firstActionTime) / 1000
+            : 1;
+        return {
+            totalActions: stats.totalActions,
+            avgReducerTime: stats.avgRenderTime,
+            maxReducerTime: stats.maxRenderTime,
+            slowestAction: stats.slowestAction,
+            currentStateSize: 0,
+            actionsPerSecond: stats.totalActions / Math.max(elapsedTime, 1),
+            performanceScore: this.calculatePerformanceScore(stats),
+            actionTypeStats,
+        };
+    }
+    getThresholds() {
+        return this.thresholds;
+    }
+    setThresholds(thresholds) {
+        this.thresholds = { ...this.thresholds, ...thresholds };
+    }
+    getWarningsSummary() {
+        const summaryMap = new Map();
+        for (const warning of this.warnings) {
+            const existing = summaryMap.get(warning.type);
+            if (existing) {
+                summaryMap.set(warning.type, {
+                    ...existing,
+                    count: existing.count + 1,
+                    severity: this.maxSeverity(existing.severity, warning.severity),
+                });
+            }
+            else {
+                summaryMap.set(warning.type, {
+                    type: warning.type,
+                    count: 1,
+                    severity: warning.severity,
+                });
+            }
+        }
+        return Array.from(summaryMap.values());
+    }
+    getSlowestRenders(limit = 10) {
+        return [...this.entries]
+            .sort((a, b) => b.renderTime - a.renderTime)
+            .slice(0, limit);
+    }
+    clear() {
+        this.entries = [];
+        this.warnings = [];
+        this.firstActionTime = null;
+    }
+    getActionTypeStats() {
+        const statsMap = new Map();
+        for (const entry of this.entries) {
+            const existing = statsMap.get(entry.actionType);
+            if (existing) {
+                existing.count++;
+                existing.totalTime += entry.renderTime;
+                existing.avgTime = existing.totalTime / existing.count;
+                existing.maxTime = Math.max(existing.maxTime, entry.renderTime);
+                existing.lastExecuted = entry.timestamp;
+            }
+            else {
+                statsMap.set(entry.actionType, {
+                    count: 1,
+                    totalTime: entry.renderTime,
+                    avgTime: entry.renderTime,
+                    maxTime: entry.renderTime,
+                    lastExecuted: entry.timestamp,
+                });
+            }
+        }
+        return statsMap;
+    }
+    calculatePerformanceScore(stats) {
+        let score = 100;
+        if (stats.avgRenderTime > this.thresholds.maxReducerTime) {
+            score -= Math.min(30, (stats.avgRenderTime - this.thresholds.maxReducerTime) * 2);
+        }
+        if (stats.maxRenderTime > this.thresholds.maxReducerTime * 2) {
+            score -= Math.min(20, (stats.maxRenderTime - this.thresholds.maxReducerTime * 2) / 2);
+        }
+        return Math.max(0, Math.round(score));
+    }
+    maxSeverity(a, b) {
+        const order = { low: 0, medium: 1, high: 2 };
+        return order[a] >= order[b] ? a : b;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: PerformanceTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: PerformanceTrackerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: PerformanceTrackerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var PerformanceWarningType;
+(function (PerformanceWarningType) {
+    PerformanceWarningType["SLOW_REDUCER"] = "SLOW_REDUCER";
+    PerformanceWarningType["LARGE_STATE"] = "LARGE_STATE";
+    PerformanceWarningType["LARGE_STATE_CHANGE"] = "LARGE_STATE_CHANGE";
+    PerformanceWarningType["FREQUENT_ACTIONS"] = "FREQUENT_ACTIONS";
+    PerformanceWarningType["LARGE_PAYLOAD"] = "LARGE_PAYLOAD";
+    PerformanceWarningType["MEMORY_PRESSURE"] = "MEMORY_PRESSURE";
+    PerformanceWarningType["HIGH_RENDER_IMPACT"] = "HIGH_RENDER_IMPACT";
+})(PerformanceWarningType || (PerformanceWarningType = {}));
+
+class PerformanceAnalyzerService {
+    previousStats = null;
+    performanceTracker = inject(PerformanceTrackerService);
+    generateReport() {
+        const stats = this.performanceTracker.getAggregatedStats();
+        const recommendations = this.generateRecommendations(stats);
+        const hotspots = this.identifyHotspots(stats);
+        const trends = this.analyzeTrends(stats);
+        const report = {
+            timestamp: new Date().toISOString(),
+            overallScore: stats.performanceScore,
+            scoreGrade: this.getScoreGrade(stats.performanceScore),
+            stats,
+            recommendations,
+            hotspots,
+            trends,
+        };
+        this.previousStats = stats;
+        return report;
+    }
+    getQuickSummary() {
+        const stats = this.performanceTracker.getAggregatedStats();
+        const warnings = this.performanceTracker.getWarningsSummary();
+        let mainIssue = null;
+        const highSeverityWarning = warnings.find(w => w.severity === 'high');
+        if (highSeverityWarning) {
+            mainIssue = this.getWarningDescription(highSeverityWarning.type);
+        }
+        return {
+            score: stats.performanceScore,
+            grade: this.getScoreGrade(stats.performanceScore),
+            mainIssue,
+            actionCount: stats.totalActions,
+            avgReducerTime: stats.avgReducerTime,
+        };
+    }
+    analyzeActionType(actionType) {
+        const stats = this.performanceTracker.getAggregatedStats();
+        const actionStats = stats.actionTypeStats.get(actionType);
+        const thresholds = this.performanceTracker.getThresholds();
+        const issues = [];
+        const suggestions = [];
+        if (!actionStats) {
+            return { stats: undefined, isProblematic: false, issues, suggestions };
+        }
+        if (actionStats.avgTime > thresholds.maxReducerTime) {
+            issues.push(`Average execution time (${actionStats.avgTime.toFixed(2)}ms) exceeds threshold`);
+            suggestions.push('Consider optimizing the reducer logic for this action');
+        }
+        const totalActions = stats.totalActions;
+        const percentOfTotal = (actionStats.count / totalActions) * 100;
+        if (percentOfTotal > 30 && actionStats.count > 10) {
+            issues.push(`This action represents ${percentOfTotal.toFixed(1)}% of all actions`);
+            suggestions.push('Consider debouncing or batching this action if dispatched frequently');
+        }
+        if (actionStats.maxTime > actionStats.avgTime * 3 && actionStats.maxTime > thresholds.maxReducerTime) {
+            issues.push(`Occasional spikes in execution time (max: ${actionStats.maxTime.toFixed(2)}ms)`);
+            suggestions.push('Investigate what causes performance spikes - possibly large payload or complex state updates');
+        }
+        return {
+            stats: actionStats,
+            isProblematic: issues.length > 0,
+            issues,
+            suggestions,
+        };
+    }
+    generateRecommendations(stats) {
+        const recommendations = [];
+        const thresholds = this.performanceTracker.getThresholds();
+        const warnings = this.performanceTracker.getWarningsSummary();
+        if (stats.avgReducerTime > thresholds.maxReducerTime) {
+            recommendations.push({
+                category: 'reducer',
+                title: 'Optimize Reducer Performance',
+                description: `Your reducers are taking an average of ${stats.avgReducerTime.toFixed(2)}ms to execute. For smooth 60fps animations, reducers should complete in under ${thresholds.maxReducerTime}ms.`,
+                impact: stats.avgReducerTime > thresholds.maxReducerTime * 2 ? 'high' : 'medium',
+                codeExample: `import { createReducer, on } from '@ngrx/store';
+import { produce } from 'immer';
+
+on(someAction, (state, { items }) => ({
+  ...state,
+  items
+}))`,
+                learnMoreUrl: 'https://ngrx.io/guide/store/reducers#reducer-functions',
+            });
+        }
+        if (stats.currentStateSize > thresholds.maxStateSize * 0.5) {
+            recommendations.push({
+                category: 'state',
+                title: 'Consider State Normalization',
+                description: `Your state size is ${this.formatBytes(stats.currentStateSize)}. Large states can slow down serialization and increase memory usage.`,
+                impact: stats.currentStateSize > thresholds.maxStateSize ? 'high' : 'medium',
+                codeExample: `{ users: [{ id: 1, posts: [{ id: 1, ... }] }] }
+
+{
+  users: { ids: [1], entities: { 1: { id: 1 } } },
+  posts: { ids: [1], entities: { 1: { id: 1, userId: 1 } } }
+}`,
+                learnMoreUrl: 'https://ngrx.io/guide/entity',
+            });
+        }
+        if (stats.actionsPerSecond > thresholds.maxActionsPerSecond * 0.5) {
+            recommendations.push({
+                category: 'actions',
+                title: 'Reduce Action Dispatch Frequency',
+                description: `You're dispatching ${stats.actionsPerSecond.toFixed(1)} actions per second. High frequency can cause performance issues.`,
+                impact: stats.actionsPerSecond > thresholds.maxActionsPerSecond ? 'high' : 'medium',
+                codeExample: `import { debounceTime } from 'rxjs/operators';
+
+searchInput$.pipe(
+  debounceTime(300)
+).subscribe(term => {
+  this.store.dispatch(searchAction({ term }));
+});
+
+this.store.dispatch(batchUpdateAction({ items: allItems }));`,
+            });
+        }
+        if (stats.slowestAction && stats.maxReducerTime > thresholds.maxReducerTime * 2) {
+            recommendations.push({
+                category: 'reducer',
+                title: `Optimize "${stats.slowestAction}"`,
+                description: `This action has the highest execution time (${stats.maxReducerTime.toFixed(2)}ms). Focus optimization efforts here for maximum impact. Profile this specific action to identify bottlenecks.`,
+                impact: 'high',
+            });
+        }
+        const memoryWarnings = warnings.filter(w => w.type === PerformanceWarningType.MEMORY_PRESSURE);
+        if (memoryWarnings.length > 0) {
+            recommendations.push({
+                category: 'memory',
+                title: 'Address Memory Pressure',
+                description: 'Your application is using a significant portion of available memory. This can lead to garbage collection pauses.',
+                impact: 'high',
+                codeExample: `ngOnDestroy() {
+  this.store.dispatch(clearTemporaryData());
+}
+
+this.store.dispatch(loadPage({ page: 1, pageSize: 50 }));`,
+            });
+        }
+        if (stats.performanceScore >= 80 && recommendations.length === 0) {
+            recommendations.push({
+                category: 'general',
+                title: 'Performance is Good! 🎉',
+                description: 'Your NgRx store is performing well. Continue following best practices.',
+                impact: 'low',
+            });
+        }
+        return recommendations;
+    }
+    identifyHotspots(stats) {
+        const hotspots = [];
+        const totalTime = Array.from(stats.actionTypeStats.values())
+            .reduce((sum, s) => sum + s.totalTime, 0);
+        stats.actionTypeStats.forEach((actionStats, actionType) => {
+            const percentOfTotal = (actionStats.totalTime / totalTime) * 100;
+            const thresholds = this.performanceTracker.getThresholds();
+            let issue = '';
+            if (actionStats.avgTime > thresholds.maxReducerTime) {
+                issue = 'Slow reducer execution';
+            }
+            else if (percentOfTotal > 20 && actionStats.count > 5) {
+                issue = 'High time consumption';
+            }
+            else if (actionStats.maxTime > actionStats.avgTime * 5) {
+                issue = 'Inconsistent performance';
+            }
+            if (issue) {
+                hotspots.push({
+                    actionType,
+                    issue,
+                    avgTime: actionStats.avgTime,
+                    callCount: actionStats.count,
+                    totalTime: actionStats.totalTime,
+                    percentOfTotal,
+                });
+            }
+        });
+        return hotspots.sort((a, b) => b.totalTime - a.totalTime).slice(0, 5);
+    }
+    analyzeTrends(currentStats) {
+        if (!this.previousStats) {
+            return {
+                reducerTimesTrend: 'stable',
+                stateSizeTrend: 'stable',
+                actionFrequencyTrend: 'stable',
+            };
+        }
+        const prev = this.previousStats;
+        let reducerTimesTrend = 'stable';
+        const timeDiff = currentStats.avgReducerTime - prev.avgReducerTime;
+        if (timeDiff > 2)
+            reducerTimesTrend = 'degrading';
+        else if (timeDiff < -2)
+            reducerTimesTrend = 'improving';
+        let stateSizeTrend = 'stable';
+        const sizeDiff = currentStats.currentStateSize - prev.currentStateSize;
+        const sizeChangePercent = Math.abs(sizeDiff) / (prev.currentStateSize || 1) * 100;
+        if (sizeChangePercent > 10) {
+            stateSizeTrend = sizeDiff > 0 ? 'growing' : 'shrinking';
+        }
+        let actionFrequencyTrend = 'stable';
+        const freqDiff = currentStats.actionsPerSecond - prev.actionsPerSecond;
+        if (freqDiff > 5)
+            actionFrequencyTrend = 'increasing';
+        else if (freqDiff < -5)
+            actionFrequencyTrend = 'decreasing';
+        return {
+            reducerTimesTrend,
+            stateSizeTrend,
+            actionFrequencyTrend,
+        };
+    }
+    getScoreGrade(score) {
+        if (score >= 90)
+            return 'A';
+        if (score >= 80)
+            return 'B';
+        if (score >= 70)
+            return 'C';
+        if (score >= 60)
+            return 'D';
+        return 'F';
+    }
+    getWarningDescription(type) {
+        const descriptions = {
+            SLOW_REDUCER: 'Slow reducer execution',
+            LARGE_STATE: 'Large state size',
+            LARGE_STATE_CHANGE: 'Large state changes',
+            FREQUENT_ACTIONS: 'High action frequency',
+            LARGE_PAYLOAD: 'Large action payloads',
+            MEMORY_PRESSURE: 'Memory pressure',
+        };
+        return descriptions[type] || type;
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(k));
+        return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: PerformanceAnalyzerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: PerformanceAnalyzerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: PerformanceAnalyzerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function estimateRenderImpact(prevState, nextState) {
+    const analysis = analyzeStateChange(prevState, nextState);
+    const factors = [];
+    let totalScore = 0;
+    if (analysis.rootPropertiesChanged > 0) {
+        const impact = Math.min(analysis.rootPropertiesChanged * 15, 40);
+        totalScore += impact;
+        factors.push({
+            name: 'Root State Changes',
+            description: `${analysis.rootPropertiesChanged} top-level state slice(s) changed`,
+            impact,
+            details: 'Each root change can trigger re-renders in components selecting that slice',
+        });
+    }
+    if (analysis.arrayChanges.length > 0) {
+        const largestArrayChange = Math.max(...analysis.arrayChanges.map(a => Math.abs(a.newLength - a.previousLength)));
+        const impact = Math.min(largestArrayChange * 2 + analysis.arrayChanges.length * 5, 50);
+        totalScore += impact;
+        factors.push({
+            name: 'Array Mutations',
+            description: `${analysis.arrayChanges.length} array(s) changed`,
+            impact,
+            details: analysis.arrayChanges.map(a => `${a.path}: ${a.previousLength} → ${a.newLength} items`).join(', '),
+        });
+    }
+    if (analysis.largeObjectChanges.length > 0) {
+        const totalSize = analysis.largeObjectChanges.reduce((sum, o) => sum + o.size, 0);
+        const impact = Math.min(totalSize / 10000 * 20, 30);
+        totalScore += impact;
+        factors.push({
+            name: 'Large Object Changes',
+            description: `${analysis.largeObjectChanges.length} large object(s) changed (${formatBytes(totalSize)})`,
+            impact,
+            details: 'Large objects can cause expensive diffing and template updates',
+        });
+    }
+    if (analysis.maxChangeDepth > 3) {
+        const impact = Math.min((analysis.maxChangeDepth - 3) * 5, 15);
+        totalScore += impact;
+        factors.push({
+            name: 'Deep State Changes',
+            description: `Changes at depth ${analysis.maxChangeDepth}`,
+            impact,
+            details: 'Deeply nested changes may indicate non-normalized state',
+        });
+    }
+    if (analysis.totalPropertiesChanged > 10) {
+        const impact = Math.min(analysis.totalPropertiesChanged / 5, 20);
+        totalScore += impact;
+        factors.push({
+            name: 'Property Change Volume',
+            description: `${analysis.totalPropertiesChanged} total properties changed`,
+            impact,
+        });
+    }
+    totalScore = Math.min(Math.round(totalScore), 100);
+    let level;
+    if (totalScore < 25)
+        level = 'low';
+    else if (totalScore < 50)
+        level = 'medium';
+    else if (totalScore < 75)
+        level = 'high';
+    else
+        level = 'critical';
+    const estimatedComponentsAffected = Math.ceil(analysis.rootPropertiesChanged * 2 +
+        analysis.arrayChanges.length * 3 +
+        analysis.largeObjectChanges.length);
+    const recommendations = generateRecommendations(analysis, factors);
+    return {
+        score: totalScore,
+        level,
+        estimatedComponentsAffected,
+        factors,
+        recommendations,
+    };
+}
+function analyzeStateChange(prevState, nextState) {
+    const analysis = {
+        rootPropertiesChanged: 0,
+        totalPropertiesChanged: 0,
+        arrayChanges: [],
+        largeObjectChanges: [],
+        maxChangeDepth: 0,
+    };
+    if (!prevState || !nextState || typeof prevState !== 'object' || typeof nextState !== 'object') {
+        return analysis;
+    }
+    const prevObj = prevState;
+    const nextObj = nextState;
+    const allKeys = new Set([...Object.keys(prevObj), ...Object.keys(nextObj)]);
+    for (const key of allKeys) {
+        if (prevObj[key] !== nextObj[key]) {
+            analysis.rootPropertiesChanged++;
+            analyzeDeep(prevObj[key], nextObj[key], key, 1, analysis);
+        }
+    }
+    return analysis;
+}
+function analyzeDeep(prev, next, path, depth, analysis) {
+    analysis.maxChangeDepth = Math.max(analysis.maxChangeDepth, depth);
+    analysis.totalPropertiesChanged++;
+    if (Array.isArray(prev) || Array.isArray(next)) {
+        const prevArr = Array.isArray(prev) ? prev : [];
+        const nextArr = Array.isArray(next) ? next : [];
+        if (prevArr.length !== nextArr.length || prev !== next) {
+            analysis.arrayChanges.push({
+                path,
+                previousLength: prevArr.length,
+                newLength: nextArr.length,
+                itemsAdded: Math.max(0, nextArr.length - prevArr.length),
+                itemsRemoved: Math.max(0, prevArr.length - nextArr.length),
+            });
+        }
+        return;
+    }
+    if (typeof next === 'object' && next !== null) {
+        const size = estimateSize(next);
+        if (size > 5000) {
+            analysis.largeObjectChanges.push({
+                path,
+                size,
+                changeType: prev === undefined || prev === null ? 'added' : 'modified',
+            });
+        }
+        if (depth < 10) {
+            const prevObj = (prev && typeof prev === 'object' ? prev : {});
+            const nextObj = next;
+            const allKeys = new Set([...Object.keys(prevObj), ...Object.keys(nextObj)]);
+            for (const key of allKeys) {
+                if (prevObj[key] !== nextObj[key]) {
+                    analyzeDeep(prevObj[key], nextObj[key], `${path}.${key}`, depth + 1, analysis);
+                }
+            }
+        }
+    }
+}
+function estimateSize(obj) {
+    try {
+        return JSON.stringify(obj).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function generateRecommendations(analysis, factors) {
+    const recommendations = [];
+    const largeArrayChanges = analysis.arrayChanges.filter(a => a.newLength > 100);
+    if (largeArrayChanges.length > 0) {
+        recommendations.push('Consider using trackBy in *ngFor for large arrays to reduce DOM updates');
+        recommendations.push('Use virtual scrolling (cdk-virtual-scroll-viewport) for lists with 100+ items');
+    }
+    if (analysis.largeObjectChanges.length > 0) {
+        recommendations.push('Break down large state objects into smaller, normalized entities');
+        recommendations.push('Use OnPush change detection strategy in components displaying this data');
+    }
+    if (analysis.maxChangeDepth > 4) {
+        recommendations.push('Normalize deeply nested state using @ngrx/entity for better performance');
+    }
+    if (analysis.rootPropertiesChanged > 2) {
+        recommendations.push('Consider batching related state updates into a single action');
+    }
+    const totalImpact = factors.reduce((sum, f) => sum + f.impact, 0);
+    if (totalImpact > 50) {
+        recommendations.push('Use memoized selectors to prevent unnecessary recomputations');
+        recommendations.push('Consider using component-level state for frequently changing UI state');
+    }
+    return recommendations;
+}
+
+class SelectorTrackerService {
+    selectorMetrics = new Map();
+    recentInvocations = [];
+    pendingAction = null;
+    endToEndTimings = [];
+    markActionDispatch(actionType) {
+        this.pendingAction = {
+            type: actionType,
+            dispatchTime: performance.now(),
+        };
+    }
+    markReducerComplete(reducerTime) {
+        if (this.pendingAction) {
+            this.pendingAction.reducerCompleteTime = performance.now();
+            this.pendingAction.reducerTime = reducerTime;
+        }
+    }
+    recordSelectorInvocation(selectorName, computationTime, wasRecomputed, inputChanged) {
+        const invocation = {
+            selectorName,
+            timestamp: Date.now(),
+            computationTime,
+            wasRecomputed,
+            inputChanged,
+            triggeringAction: this.pendingAction?.type,
+        };
+        this.recentInvocations.push(invocation);
+        const existing = this.selectorMetrics.get(selectorName);
+        if (existing) {
+            existing.invocationCount++;
+            if (wasRecomputed) {
+                existing.recomputationCount++;
+                existing.totalComputationTime += computationTime;
+                existing.avgComputationTime = existing.totalComputationTime / existing.recomputationCount;
+                existing.maxComputationTime = Math.max(existing.maxComputationTime, computationTime);
+                existing.lastComputationTime = computationTime;
+            }
+            existing.cacheHitRate = ((existing.invocationCount - existing.recomputationCount) / existing.invocationCount) * 100;
+            existing.lastInvoked = Date.now();
+            if (this.pendingAction?.type && !existing.triggeringActions.includes(this.pendingAction.type)) {
+                existing.triggeringActions.push(this.pendingAction.type);
+                if (existing.triggeringActions.length > 10) {
+                    existing.triggeringActions.shift();
+                }
+            }
+        }
+        else {
+            this.selectorMetrics.set(selectorName, {
+                name: selectorName,
+                invocationCount: 1,
+                recomputationCount: wasRecomputed ? 1 : 0,
+                totalComputationTime: wasRecomputed ? computationTime : 0,
+                avgComputationTime: wasRecomputed ? computationTime : 0,
+                maxComputationTime: wasRecomputed ? computationTime : 0,
+                lastComputationTime: wasRecomputed ? computationTime : 0,
+                cacheHitRate: wasRecomputed ? 0 : 100,
+                lastInvoked: Date.now(),
+                triggeringActions: this.pendingAction?.type ? [this.pendingAction.type] : [],
+            });
+        }
+        if (this.recentInvocations.length > 500) {
+            this.recentInvocations = this.recentInvocations.slice(-250);
+        }
+    }
+    markSelectorsComplete() {
+        if (!this.pendingAction)
+            return null;
+        const now = performance.now();
+        const affectedSelectors = this.recentInvocations
+            .filter(inv => inv.triggeringAction === this.pendingAction?.type)
+            .map(inv => inv.selectorName)
+            .filter((name, index, arr) => arr.indexOf(name) === index);
+        const timing = {
+            actionType: this.pendingAction.type,
+            actionDispatchTime: this.pendingAction.dispatchTime,
+            reducerCompleteTime: this.pendingAction.reducerCompleteTime ?? now,
+            selectorsCompleteTime: now,
+            totalTime: now - this.pendingAction.dispatchTime,
+            reducerTime: this.pendingAction.reducerTime ?? 0,
+            selectorTime: now - (this.pendingAction.reducerCompleteTime ?? this.pendingAction.dispatchTime),
+            affectedSelectors,
+        };
+        this.endToEndTimings.push(timing);
+        if (this.endToEndTimings.length > 100) {
+            this.endToEndTimings = this.endToEndTimings.slice(-50);
+        }
+        this.pendingAction = null;
+        return timing;
+    }
+    getAllMetrics() {
+        return new Map(this.selectorMetrics);
+    }
+    getMetrics(selectorName) {
+        return this.selectorMetrics.get(selectorName);
+    }
+    getSlowestSelectors(limit = 10) {
+        return Array.from(this.selectorMetrics.values())
+            .sort((a, b) => b.totalComputationTime - a.totalComputationTime)
+            .slice(0, limit);
+    }
+    getInefficientSelectors(cacheHitThreshold = 50) {
+        return Array.from(this.selectorMetrics.values())
+            .filter(m => m.cacheHitRate < cacheHitThreshold && m.invocationCount > 5)
+            .sort((a, b) => a.cacheHitRate - b.cacheHitRate);
+    }
+    getEndToEndTimings() {
+        return [...this.endToEndTimings];
+    }
+    getAverageEndToEndTime() {
+        if (this.endToEndTimings.length === 0)
+            return 0;
+        const total = this.endToEndTimings.reduce((sum, t) => sum + t.totalTime, 0);
+        return total / this.endToEndTimings.length;
+    }
+    clear() {
+        this.selectorMetrics.clear();
+        this.recentInvocations = [];
+        this.endToEndTimings = [];
+        this.pendingAction = null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: SelectorTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: SelectorTrackerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.5", ngImport: i0, type: SelectorTrackerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+let globalSelectorTracker = null;
+function setSelectorTracker(tracker) {
+    globalSelectorTracker = tracker;
+}
+function trackSelector(name, selector) {
+    let lastResult;
+    let lastInput;
+    const trackedSelector = ((state) => {
+        const startTime = performance.now();
+        const result = selector(state);
+        const endTime = performance.now();
+        const computationTime = endTime - startTime;
+        const wasRecomputed = result !== lastResult;
+        const inputChanged = state !== lastInput;
+        lastResult = result;
+        lastInput = state;
+        if (globalSelectorTracker) {
+            globalSelectorTracker.recordSelectorInvocation(name, computationTime, wasRecomputed, inputChanged);
+        }
+        return result;
+    });
+    trackedSelector.release = selector.release;
+    trackedSelector.projector = selector.projector;
+    trackedSelector.setResult = selector.setResult;
+    trackedSelector.clearResult = selector.clearResult;
+    return trackedSelector;
+}
+function createTrackedSelector(name, ...args) {
+    const selector = createSelector(...args);
+    return trackSelector(name, selector);
+}
+function TrackedSelector(name) {
+    return function (target, propertyKey) {
+        const originalSelector = target[propertyKey];
+        if (originalSelector) {
+            target[propertyKey] = trackSelector(name, originalSelector);
+        }
+    };
+}
+
+function createDevToolMetaReducer(wsUrlOrConfig = 'ws://localhost:4000') {
+    const config = typeof wsUrlOrConfig === 'string'
+        ? { wsUrl: wsUrlOrConfig }
+        : wsUrlOrConfig;
+    const wsUrl = config.wsUrl ?? 'ws://localhost:4000';
+    const enablePerf = config.enablePerformanceTracking ?? true;
+    return function devToolMetaReducer(reducer) {
+        const performanceTracker = inject(PerformanceTrackerService);
+        const webSocketService = inject(WebSocketService);
+        // Initialize WebSocket connection (no-op if already initialized)
+        webSocketService.initialize(wsUrl);
+        return function (state, action) {
+            const prevState = state;
+            const timestamp = new Date().toISOString();
+            let nextState;
+            if (enablePerf) {
+                nextState = performanceTracker.measureRenderTime(action.type, () => reducer(state, action), (renderTime) => {
+                    const message = {
+                        type: 'STATE_CHANGE',
+                        action,
+                        prevState,
+                        nextState,
+                        timestamp,
+                        renderPerformance: { renderTime }
+                    };
+                    webSocketService.send(message);
+                });
+            }
+            else {
+                nextState = reducer(state, action);
+                const message = {
+                    type: 'STATE_CHANGE',
+                    action,
+                    prevState,
+                    nextState,
+                    timestamp,
+                };
+                webSocketService.send(message);
+            }
+            return nextState;
+        };
+    };
+}
+function loggerMetaReducer(reducer) {
+    return createDevToolMetaReducer('ws://localhost:4000')(reducer);
+}
+
+function provideNgrxDevTool(config = {}) {
+    const providers = [
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (interceptor) => () => {
+                interceptor.initialize(config.wsUrl ?? 'ws://localhost:4000');
+            },
+            deps: [ActionsInterceptorService],
+            multi: true,
+        },
+    ];
+    if (config.trackEffects !== false) {
+        providers.push({
+            provide: EffectSources,
+            useClass: DevToolsEffectSources,
+        });
+    }
+    return providers;
+}
+function provideEffectTracking() {
+    return {
+        provide: EffectSources,
+        useClass: DevToolsEffectSources,
+    };
+}
+
+/*
+ * Public API Surface of ngrx-devtool
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActionsInterceptorService, DevToolsEffectSources, EffectTrackerService, PerformanceAnalyzerService, PerformanceTrackerService, PerformanceWarningType, SelectorTrackerService, TrackedSelector, WebSocketService, createDevToolMetaReducer, createTrackedSelector, estimateRenderImpact, loggerMetaReducer, provideEffectTracking, provideNgrxDevTool, setSelectorTracker, trackSelector };
+//# sourceMappingURL=amadeus-it-group-ngrx-devtool.mjs.map