@amadeus-it-group/ngrx-devtool 0.1.2

package/ngrx-devtool/types/amadeus-it-group-ngrx-devtool.d.ts

@@ -0,0 +1,468 @@
+import { Action, Selector, MemoizedSelector, ActionReducer } from '@ngrx/store';
+import * as i0 from '@angular/core';
+import { OnDestroy, Provider } from '@angular/core';
+import { ReplaySubject, Observable } from 'rxjs';
+import { EffectSources } from '@ngrx/effects';
+
+type EffectLifecycle = 'triggered' | 'emitted' | 'executed' | 'error';
+interface EffectEvent {
+    readonly effectName: string;
+    readonly sourceName: string;
+    readonly propertyName: string;
+    readonly lifecycle: EffectLifecycle;
+    readonly timestamp: number;
+    readonly triggerAction?: Action;
+    readonly action?: Action;
+    readonly error?: unknown;
+    readonly duration?: number;
+    readonly executionId?: string;
+    readonly dispatch?: boolean;
+}
+interface EffectMetadataInfo {
+    readonly propertyName: string;
+    readonly dispatch: boolean;
+    readonly functional: boolean;
+    readonly useEffectsErrorHandler: boolean;
+}
+type ActionSource = 'user' | 'effect';
+type EffectStatus = 'completed' | 'error';
+interface TrackedAction {
+    readonly action: string;
+    readonly payload: unknown;
+    readonly timestamp: number;
+    readonly source: ActionSource;
+    readonly correlationId?: string;
+    readonly effectName?: string;
+}
+interface TrackedEffect {
+    readonly effectName: string;
+    readonly sourceName: string | null;
+    readonly propertyName: string;
+    readonly triggerAction?: string;
+    readonly resultAction?: string;
+    readonly startTime: number;
+    readonly endTime?: number;
+    readonly duration?: number;
+    readonly status: EffectStatus;
+    readonly error?: unknown;
+}
+type DevToolMessageType = 'ACTION_TRACKED' | 'EFFECT_EVENT' | 'TIMELINE_CLEARED';
+interface DevToolMessage {
+    readonly type: DevToolMessageType;
+    readonly action?: string;
+    readonly payload?: unknown;
+    readonly isEffectResult?: boolean;
+    readonly effectName?: string;
+    readonly correlationId?: string;
+    readonly effectEvent?: DevToolEffectEventPayload;
+    readonly timestamp: string;
+}
+interface DevToolEffectEventPayload {
+    readonly name: string;
+    readonly lifecycle: string;
+    readonly duration?: number;
+    readonly executionId?: string;
+    readonly dispatch?: boolean;
+}
+
+declare class ActionsInterceptorService implements OnDestroy {
+    private readonly actions$;
+    private readonly effectTracker;
+    private readonly webSocketService;
+    private readonly destroy$;
+    private initialized;
+    initialize(wsUrl?: string): void;
+    getTimeline(): readonly TrackedAction[];
+    clearTimeline(): void;
+    ngOnDestroy(): void;
+    private setupMessageListener;
+    private setupActionInterception;
+    private setupEffectEventForwarding;
+    private sendMessage;
+    private sanitizePayload;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsInterceptorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionsInterceptorService>;
+}
+
+declare class EffectTrackerService implements OnDestroy {
+    private readonly effectSources;
+    private readonly destroy$;
+    private actionTimeline;
+    private effectTimeline;
+    private readonly effectActionPatterns;
+    private readonly pendingCorrelations;
+    private correlationCounter;
+    private lastTriggerAction;
+    readonly effectEvents$: ReplaySubject<EffectEvent>;
+    constructor();
+    private subscribeToEffectEvents;
+    private handleEffectEvent;
+    isEffectAction(actionType: string): boolean;
+    trackAction(action: Action): TrackedAction;
+    getTimeline(): readonly TrackedAction[];
+    clearTimeline(): void;
+    private createCorrelation;
+    private findCorrelation;
+    private findEffectNameForAction;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EffectTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EffectTrackerService>;
+}
+
+interface EffectSourceInstance {
+    ngrxOnIdentifyEffects?(): string;
+    constructor: {
+        name?: string;
+    };
+    [key: string]: unknown;
+}
+declare class DevToolsEffectSources extends EffectSources implements OnDestroy {
+    readonly effectEvents$: ReplaySubject<EffectEvent>;
+    private readonly registeredEffects;
+    private executionCounter;
+    constructor();
+    addEffects(effectSourceInstance: EffectSourceInstance): void;
+    getRegisteredEffects(): ReadonlyMap<string, readonly EffectMetadataInfo[]>;
+    ngOnDestroy(): void;
+    private instrumentEffects;
+    private wrapEffectObservable;
+    private copyEffectMetadata;
+    private extractEffectMetadata;
+    private resolveSourceName;
+    private isValidClassName;
+    private isObservable;
+    private parseEffectName;
+    private generateExecutionId;
+    private emitEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolsEffectSources, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolsEffectSources>;
+}
+
+interface WebSocketMessage {
+    readonly type: string;
+}
+declare class WebSocketService implements OnDestroy {
+    private readonly platformId;
+    private readonly isBrowser;
+    private socket;
+    private messageBuffer;
+    private wsUrl;
+    private initialized;
+    private readonly connectionState$;
+    private readonly incomingMessages$;
+    get isConnected(): boolean;
+    get connected$(): Observable<boolean>;
+    get messages$(): Observable<WebSocketMessage | null>;
+    initialize(wsUrl?: string): void;
+    send<T extends WebSocketMessage>(message: T): void;
+    sendRaw(payload: string): void;
+    ngOnDestroy(): void;
+    private close;
+    private setupWebSocket;
+    private flushBuffer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketService>;
+}
+
+interface ActionDispatchedPayload {
+    readonly actionType: string;
+    readonly previousState: Record<string, unknown>;
+    readonly action: Record<string, unknown>;
+    readonly nextState: Record<string, unknown>;
+}
+interface PerformanceMetrics {
+    readonly reducerExecutionTime: number;
+    readonly stateSize: number;
+    readonly stateSizeChange: number;
+    readonly memoryUsage?: MemoryInfo;
+    readonly actionPayloadSize: number;
+}
+interface MemoryInfo {
+    readonly usedJSHeapSize: number;
+    readonly totalJSHeapSize: number;
+    readonly jsHeapSizeLimit: number;
+}
+interface PerformanceWarning {
+    readonly type: PerformanceWarningType;
+    readonly message: string;
+    readonly severity: 'low' | 'medium' | 'high';
+    readonly suggestion?: string;
+}
+declare enum PerformanceWarningType {
+    SLOW_REDUCER = "SLOW_REDUCER",
+    LARGE_STATE = "LARGE_STATE",
+    LARGE_STATE_CHANGE = "LARGE_STATE_CHANGE",
+    FREQUENT_ACTIONS = "FREQUENT_ACTIONS",
+    LARGE_PAYLOAD = "LARGE_PAYLOAD",
+    MEMORY_PRESSURE = "MEMORY_PRESSURE",
+    HIGH_RENDER_IMPACT = "HIGH_RENDER_IMPACT"
+}
+interface PerformanceThresholds {
+    readonly maxReducerTime: number;
+    readonly maxStateSize: number;
+    readonly maxStateChangeSize: number;
+    readonly maxActionsPerSecond: number;
+    readonly maxPayloadSize: number;
+}
+interface ActionTypeStats {
+    count: number;
+    totalTime: number;
+    avgTime: number;
+    maxTime: number;
+    lastExecuted: number;
+}
+interface ActionPerformanceEntry {
+    readonly actionType: string;
+    readonly timestamp: number;
+    readonly metrics: PerformanceMetrics;
+    readonly warnings: readonly PerformanceWarning[];
+}
+interface RenderImpactData {
+    readonly score: number;
+    readonly level: 'low' | 'medium' | 'high' | 'critical';
+    readonly estimatedComponentsAffected: number;
+    readonly factors: readonly RenderImpactFactorData[];
+    readonly recommendations: readonly string[];
+}
+interface RenderImpactFactorData {
+    readonly name: string;
+    readonly description: string;
+    readonly impact: number;
+    readonly details?: string;
+}
+interface SelectorMetricsData {
+    readonly name: string;
+    readonly invocationCount: number;
+    readonly recomputationCount: number;
+    readonly totalComputationTime: number;
+    readonly avgComputationTime: number;
+    maxComputationTime: number;
+    cacheHitRate: number;
+}
+
+interface RenderPerformanceEntry {
+    readonly actionType: string;
+    readonly timestamp: number;
+    readonly renderTime: number;
+}
+interface RenderPerformanceStats {
+    readonly avgRenderTime: number;
+    readonly maxRenderTime: number;
+    readonly slowestAction: string | null;
+    readonly totalActions: number;
+}
+interface AggregatedPerformanceStats {
+    readonly totalActions: number;
+    readonly avgReducerTime: number;
+    readonly maxReducerTime: number;
+    readonly slowestAction: string | null;
+    readonly currentStateSize: number;
+    readonly actionsPerSecond: number;
+    readonly performanceScore: number;
+    readonly actionTypeStats: Map<string, ActionTypeStats>;
+}
+interface WarningsSummary {
+    readonly type: PerformanceWarningType;
+    readonly count: number;
+    readonly severity: 'low' | 'medium' | 'high';
+}
+declare class PerformanceTrackerService {
+    private entries;
+    private warnings;
+    private readonly platformId;
+    private readonly injector;
+    private readonly isBrowser;
+    private thresholds;
+    private firstActionTime;
+    measureRenderTime<State>(actionType: string, reducer: () => State, callback: (renderTime: number) => void): State;
+    getEntries(): readonly RenderPerformanceEntry[];
+    getStats(): RenderPerformanceStats;
+    getAggregatedStats(): AggregatedPerformanceStats;
+    getThresholds(): PerformanceThresholds;
+    setThresholds(thresholds: Partial<PerformanceThresholds>): void;
+    getWarningsSummary(): WarningsSummary[];
+    getSlowestRenders(limit?: number): readonly RenderPerformanceEntry[];
+    clear(): void;
+    private getActionTypeStats;
+    private calculatePerformanceScore;
+    private maxSeverity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PerformanceTrackerService>;
+}
+
+interface PerformanceRecommendation {
+    readonly category: 'reducer' | 'state' | 'actions' | 'memory' | 'general';
+    readonly title: string;
+    readonly description: string;
+    readonly impact: 'low' | 'medium' | 'high';
+    readonly codeExample?: string;
+    readonly learnMoreUrl?: string;
+}
+interface PerformanceReport {
+    readonly timestamp: string;
+    readonly overallScore: number;
+    readonly scoreGrade: 'A' | 'B' | 'C' | 'D' | 'F';
+    readonly stats: AggregatedPerformanceStats;
+    readonly recommendations: readonly PerformanceRecommendation[];
+    readonly hotspots: readonly HotspotInfo[];
+    readonly trends: PerformanceTrends;
+}
+interface HotspotInfo {
+    readonly actionType: string;
+    readonly issue: string;
+    readonly avgTime: number;
+    readonly callCount: number;
+    readonly totalTime: number;
+    readonly percentOfTotal: number;
+}
+interface PerformanceTrends {
+    readonly reducerTimesTrend: 'improving' | 'stable' | 'degrading';
+    readonly stateSizeTrend: 'stable' | 'growing' | 'shrinking';
+    readonly actionFrequencyTrend: 'stable' | 'increasing' | 'decreasing';
+}
+declare class PerformanceAnalyzerService {
+    private previousStats;
+    private readonly performanceTracker;
+    generateReport(): PerformanceReport;
+    getQuickSummary(): {
+        score: number;
+        grade: string;
+        mainIssue: string | null;
+        actionCount: number;
+        avgReducerTime: number;
+    };
+    analyzeActionType(actionType: string): {
+        stats: ActionTypeStats | undefined;
+        isProblematic: boolean;
+        issues: string[];
+        suggestions: string[];
+    };
+    private generateRecommendations;
+    private identifyHotspots;
+    private analyzeTrends;
+    private getScoreGrade;
+    private getWarningDescription;
+    private formatBytes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceAnalyzerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PerformanceAnalyzerService>;
+}
+
+interface RenderImpactEstimate {
+    readonly score: number;
+    readonly level: 'low' | 'medium' | 'high' | 'critical';
+    readonly estimatedComponentsAffected: number;
+    readonly factors: readonly RenderImpactFactor[];
+    readonly recommendations: readonly string[];
+}
+interface RenderImpactFactor {
+    readonly name: string;
+    readonly description: string;
+    readonly impact: number;
+    readonly details?: string;
+}
+interface StateChangeAnalysis {
+    rootPropertiesChanged: number;
+    totalPropertiesChanged: number;
+    arrayChanges: ArrayChangeInfo[];
+    largeObjectChanges: LargeObjectChange[];
+    maxChangeDepth: number;
+}
+interface ArrayChangeInfo {
+    readonly path: string;
+    readonly previousLength: number;
+    readonly newLength: number;
+    readonly itemsAdded: number;
+    readonly itemsRemoved: number;
+}
+interface LargeObjectChange {
+    readonly path: string;
+    readonly size: number;
+    readonly changeType: 'added' | 'modified' | 'replaced';
+}
+declare function estimateRenderImpact(prevState: unknown, nextState: unknown): RenderImpactEstimate;
+
+interface SelectorMetrics {
+    readonly name: string;
+    invocationCount: number;
+    recomputationCount: number;
+    totalComputationTime: number;
+    avgComputationTime: number;
+    maxComputationTime: number;
+    lastComputationTime: number;
+    cacheHitRate: number;
+    lastInvoked: number;
+    triggeringActions: string[];
+}
+interface SelectorInvocation {
+    readonly selectorName: string;
+    readonly timestamp: number;
+    readonly computationTime: number;
+    readonly wasRecomputed: boolean;
+    readonly inputChanged: boolean;
+    readonly triggeringAction?: string;
+}
+interface EndToEndTiming {
+    readonly actionType: string;
+    readonly actionDispatchTime: number;
+    readonly reducerCompleteTime: number;
+    readonly selectorsCompleteTime: number;
+    readonly totalTime: number;
+    readonly reducerTime: number;
+    readonly selectorTime: number;
+    readonly affectedSelectors: readonly string[];
+}
+declare class SelectorTrackerService {
+    private readonly selectorMetrics;
+    private recentInvocations;
+    private pendingAction;
+    private endToEndTimings;
+    markActionDispatch(actionType: string): void;
+    markReducerComplete(reducerTime: number): void;
+    recordSelectorInvocation(selectorName: string, computationTime: number, wasRecomputed: boolean, inputChanged: boolean): void;
+    markSelectorsComplete(): EndToEndTiming | null;
+    getAllMetrics(): ReadonlyMap<string, SelectorMetrics>;
+    getMetrics(selectorName: string): SelectorMetrics | undefined;
+    getSlowestSelectors(limit?: number): readonly SelectorMetrics[];
+    getInefficientSelectors(cacheHitThreshold?: number): readonly SelectorMetrics[];
+    getEndToEndTimings(): readonly EndToEndTiming[];
+    getAverageEndToEndTime(): number;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectorTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectorTrackerService>;
+}
+
+declare function setSelectorTracker(tracker: SelectorTrackerService): void;
+declare function trackSelector<State, Result>(name: string, selector: MemoizedSelector<State, Result>): MemoizedSelector<State, Result>;
+declare function createTrackedSelector<State, S1, Result>(name: string, s1: Selector<State, S1>, projector: (s1: S1) => Result): MemoizedSelector<State, Result>;
+declare function createTrackedSelector<State, S1, S2, Result>(name: string, s1: Selector<State, S1>, s2: Selector<State, S2>, projector: (s1: S1, s2: S2) => Result): MemoizedSelector<State, Result>;
+declare function createTrackedSelector<State, S1, S2, S3, Result>(name: string, s1: Selector<State, S1>, s2: Selector<State, S2>, s3: Selector<State, S3>, projector: (s1: S1, s2: S2, s3: S3) => Result): MemoizedSelector<State, Result>;
+declare function createTrackedSelector<State, S1, S2, S3, S4, Result>(name: string, s1: Selector<State, S1>, s2: Selector<State, S2>, s3: Selector<State, S3>, s4: Selector<State, S4>, projector: (s1: S1, s2: S2, s3: S3, s4: S4) => Result): MemoizedSelector<State, Result>;
+declare function TrackedSelector(name: string): (target: Record<string, unknown>, propertyKey: string) => void;
+
+interface RenderPerformanceData {
+    readonly renderTime: number;
+}
+interface StateChangeMessage {
+    type: 'STATE_CHANGE';
+    action: Action;
+    prevState: unknown;
+    nextState: unknown;
+    timestamp: string;
+    renderPerformance?: RenderPerformanceData;
+}
+interface DevToolMetaReducerConfig {
+    readonly wsUrl?: string;
+    readonly enablePerformanceTracking?: boolean;
+}
+declare function createDevToolMetaReducer(wsUrlOrConfig?: string | DevToolMetaReducerConfig): <State>(reducer: ActionReducer<State>) => ActionReducer<State>;
+declare function loggerMetaReducer<State>(reducer: ActionReducer<State>): ActionReducer<State>;
+
+interface DevToolConfig {
+    readonly wsUrl?: string;
+    readonly trackEffects?: boolean;
+}
+declare function provideNgrxDevTool(config?: DevToolConfig): Provider[];
+declare function provideEffectTracking(): Provider;
+
+export { ActionsInterceptorService, DevToolsEffectSources, EffectTrackerService, PerformanceAnalyzerService, PerformanceTrackerService, PerformanceWarningType, SelectorTrackerService, TrackedSelector, WebSocketService, createDevToolMetaReducer, createTrackedSelector, estimateRenderImpact, loggerMetaReducer, provideEffectTracking, provideNgrxDevTool, setSelectorTracker, trackSelector };
+export type { ActionDispatchedPayload, ActionPerformanceEntry, ActionSource, ActionTypeStats, AggregatedPerformanceStats, ArrayChangeInfo, DevToolConfig, DevToolEffectEventPayload, DevToolMessage, DevToolMessageType, DevToolMetaReducerConfig, EffectEvent, EffectLifecycle, EffectMetadataInfo, EffectStatus, EndToEndTiming, HotspotInfo, LargeObjectChange, MemoryInfo, PerformanceMetrics, PerformanceRecommendation, PerformanceReport, PerformanceThresholds, PerformanceTrends, PerformanceWarning, RenderImpactData, RenderImpactEstimate, RenderImpactFactor, RenderImpactFactorData, RenderPerformanceData, RenderPerformanceEntry, RenderPerformanceStats, SelectorInvocation, SelectorMetrics, SelectorMetricsData, StateChangeAnalysis, StateChangeMessage, TrackedAction, TrackedEffect, WarningsSummary, WebSocketMessage };