@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/routing/domain/performance-monitoring.ts

@@ -0,0 +1,287 @@
+import { RoutePerformanceAlertManager } from "./performance-alert-manager";
+import { generateRoutePerformanceReport } from "./performance-report";
+import type { PerformanceAlert, RouteMetrics } from "./performance-types";
+
+export class RoutePerformanceMonitor {
+	private metrics: Map<string, RouteMetrics> = new Map();
+	private startTime: Map<string, number> = new Map();
+	private loadTimes: Map<string, number[]> = new Map();
+	private alertManager = new RoutePerformanceAlertManager();
+	private thresholds = {
+		slowLoadTime: 1000,
+		slowRenderTime: 500,
+		highErrorRate: 0.1,
+	};
+
+	startLoad(path: string, now: number): void {
+		this.startTime.set(path, now);
+	}
+
+	endLoad(path: string, now: number): void {
+		const start = this.startTime.get(path);
+		if (start) {
+			const loadTime = now - start;
+			const existing = this.metrics.get(path) || {
+				path,
+				loadTime: 0,
+				renderTime: 0,
+				navigationCount: 0,
+				lastVisited: 0,
+				averageLoadTime: 0,
+				errorCount: 0,
+				cacheHitRate: 0,
+			};
+
+			// Track load times for average calculation
+			const times = this.loadTimes.get(path) || [];
+			times.push(loadTime);
+			this.loadTimes.set(path, times);
+
+			const averageLoadTime =
+				times.reduce((sum, t) => sum + t, 0) / times.length;
+
+			this.metrics.set(path, {
+				...existing,
+				loadTime,
+				averageLoadTime,
+				lastVisited: now,
+			});
+
+			// Check for slow routes
+			if (loadTime > this.thresholds.slowLoadTime) {
+				this.alertManager.addAlert({
+					severity: "warning",
+					type: "slow-load",
+					message: `Route ${path} took ${loadTime.toFixed(2)}ms to load`,
+					path,
+					timestamp: now,
+				});
+			}
+
+			this.startTime.delete(path);
+		}
+	}
+
+	recordRenderTime(path: string, renderTime: number, now: number): void {
+		const existing = this.metrics.get(path) || {
+			path,
+			loadTime: 0,
+			renderTime: 0,
+			navigationCount: 0,
+			lastVisited: 0,
+			averageLoadTime: 0,
+			errorCount: 0,
+			cacheHitRate: 0,
+		};
+
+		this.metrics.set(path, {
+			...existing,
+			renderTime,
+		});
+
+		// Check for slow render
+		if (renderTime > this.thresholds.slowRenderTime) {
+			this.alertManager.addAlert({
+				severity: "warning",
+				type: "slow-render",
+				message: `Route ${path} took ${renderTime.toFixed(2)}ms to render`,
+				path,
+				timestamp: now,
+			});
+		}
+	}
+
+	incrementNavigationCount(path: string, now: number): void {
+		const existing = this.metrics.get(path) || {
+			path,
+			loadTime: 0,
+			renderTime: 0,
+			navigationCount: 0,
+			lastVisited: 0,
+			averageLoadTime: 0,
+			errorCount: 0,
+			cacheHitRate: 0,
+		};
+
+		this.metrics.set(path, {
+			...existing,
+			navigationCount: existing.navigationCount + 1,
+			lastVisited: now,
+		});
+	}
+
+	recordError(
+		path: string,
+		now: number,
+		userContext?: Record<string, unknown>,
+		metadata?: Record<string, unknown>,
+	): void {
+		const existing = this.metrics.get(path) || {
+			path,
+			loadTime: 0,
+			renderTime: 0,
+			navigationCount: 0,
+			lastVisited: 0,
+			averageLoadTime: 0,
+			errorCount: 0,
+			cacheHitRate: 0,
+		};
+
+		const errorCount = existing.errorCount + 1;
+		const errorRate = errorCount / (existing.navigationCount + 1);
+
+		this.metrics.set(path, {
+			...existing,
+			errorCount,
+		});
+
+		// Check for high error rate
+		if (errorRate > this.thresholds.highErrorRate) {
+			this.alertManager.addAlert({
+				severity: "error",
+				type: "high-error-rate",
+				message: `Route ${path} has ${(errorRate * 100).toFixed(1)}% error rate`,
+				path,
+				timestamp: now,
+			});
+		}
+
+		// userContext and metadata are part of the public API but not currently stored
+		if (userContext) {
+			// Reserved for future analytics
+		}
+		if (metadata) {
+			// Reserved for future analytics
+		}
+	}
+
+	recordCacheHit(path: string, hit: boolean): void {
+		const existing = this.metrics.get(path) || {
+			path,
+			loadTime: 0,
+			renderTime: 0,
+			navigationCount: 0,
+			lastVisited: 0,
+			averageLoadTime: 0,
+			errorCount: 0,
+			cacheHitRate: 0,
+		};
+
+		const totalAccesses = existing.navigationCount + 1;
+		const hits =
+			existing.cacheHitRate * existing.navigationCount + (hit ? 1 : 0);
+		const newHitRate = hits / totalAccesses;
+
+		this.metrics.set(path, {
+			...existing,
+			cacheHitRate: newHitRate,
+		});
+	}
+
+	setBundleSize(path: string, size: number): void {
+		const existing = this.metrics.get(path) || {
+			path,
+			loadTime: 0,
+			renderTime: 0,
+			navigationCount: 0,
+			lastVisited: 0,
+			averageLoadTime: 0,
+			errorCount: 0,
+			cacheHitRate: 0,
+		};
+
+		this.metrics.set(path, {
+			...existing,
+			bundleSize: size,
+		});
+	}
+
+	getMetrics(path: string): RouteMetrics | undefined {
+		return this.metrics.get(path);
+	}
+
+	getAllMetrics(): RouteMetrics[] {
+		return Array.from(this.metrics.values());
+	}
+
+	getSlowRoutes(threshold?: number): RouteMetrics[] {
+		const slowThreshold = threshold || this.thresholds.slowLoadTime;
+		return this.getAllMetrics().filter((m) => m.loadTime > slowThreshold);
+	}
+
+	getRoutesByPerformance(sort: "asc" | "desc" = "asc"): RouteMetrics[] {
+		return this.getAllMetrics().sort((a, b) => {
+			const scoreA = a.loadTime + a.renderTime;
+			const scoreB = b.loadTime + b.renderTime;
+			return sort === "asc" ? scoreA - scoreB : scoreB - scoreA;
+		});
+	}
+
+	getPerformanceScore(): number {
+		const metrics = this.getAllMetrics();
+		if (metrics.length === 0) return 100;
+
+		let totalScore = 0;
+		for (const metric of metrics) {
+			let score = 100;
+
+			// Deduct for slow load time
+			if (metric.loadTime > this.thresholds.slowLoadTime) {
+				score -= (metric.loadTime - this.thresholds.slowLoadTime) / 10;
+			}
+
+			// Deduct for slow render time
+			if (metric.renderTime > this.thresholds.slowRenderTime) {
+				score -= (metric.renderTime - this.thresholds.slowRenderTime) / 5;
+			}
+
+			// Deduct for errors
+			const errorRate = metric.errorCount / (metric.navigationCount || 1);
+			score -= errorRate * 50;
+
+			// Add for cache hits
+			score += metric.cacheHitRate * 10;
+
+			totalScore += Math.max(0, score);
+		}
+
+		return Math.min(100, totalScore / metrics.length);
+	}
+
+	clearMetrics(path: string): void {
+		this.metrics.delete(path);
+		this.loadTimes.delete(path);
+	}
+
+	clearAllMetrics(): void {
+		this.metrics.clear();
+		this.loadTimes.clear();
+		this.alertManager.clearAlerts();
+	}
+
+	setThresholds(thresholds: Partial<typeof this.thresholds>): void {
+		this.thresholds = { ...this.thresholds, ...thresholds };
+	}
+
+	getAlerts(severity?: PerformanceAlert["severity"]): PerformanceAlert[] {
+		return this.alertManager.getAlerts(severity);
+	}
+
+	getCriticalAlerts(): PerformanceAlert[] {
+		return this.alertManager.getCriticalAlerts();
+	}
+
+	generatePerformanceReport(): string {
+		return generateRoutePerformanceReport(
+			this.getAllMetrics(),
+			this.getPerformanceScore(),
+			this.getCriticalAlerts(),
+		);
+	}
+}
+
+export type { PerformanceAlert, RouteMetrics } from "./performance-types";
+
+export const createRoutePerformanceMonitor = (): RoutePerformanceMonitor => {
+	return new RoutePerformanceMonitor();
+};

package/src/router/modules/routing/domain/performance-report.ts

@@ -0,0 +1,29 @@
+import type { PerformanceAlert, RouteMetrics } from "./performance-types";
+
+export const generateRoutePerformanceReport = (
+	metrics: RouteMetrics[],
+	performanceScore: number,
+	criticalAlerts: PerformanceAlert[],
+): string => {
+	let report = "Route Performance Report\n";
+	report += "========================\n\n";
+	report += `Total Routes: ${metrics.length}\n`;
+	report += `Performance Score: ${performanceScore.toFixed(2)}/100\n`;
+	report += `Critical Alerts: ${criticalAlerts.length}\n\n`;
+
+	report += "Route Metrics:\n";
+	for (const metric of metrics) {
+		report += `\n${metric.path}\n`;
+		report += `  Load Time: ${metric.loadTime.toFixed(2)}ms\n`;
+		report += `  Render Time: ${metric.renderTime.toFixed(2)}ms\n`;
+		report += `  Avg Load Time: ${metric.averageLoadTime.toFixed(2)}ms\n`;
+		report += `  Navigation Count: ${metric.navigationCount}\n`;
+		report += `  Error Count: ${metric.errorCount}\n`;
+		report += `  Cache Hit Rate: ${(metric.cacheHitRate * 100).toFixed(1)}%\n`;
+		if (metric.bundleSize) {
+			report += `  Bundle Size: ${(metric.bundleSize / 1024).toFixed(2)}KB\n`;
+		}
+	}
+
+	return report;
+};

package/src/router/modules/routing/domain/performance-types.ts

@@ -0,0 +1,19 @@
+export type RouteMetrics = {
+	path: string;
+	loadTime: number;
+	renderTime: number;
+	navigationCount: number;
+	lastVisited: number;
+	averageLoadTime: number;
+	errorCount: number;
+	cacheHitRate: number;
+	bundleSize?: number;
+};
+
+export interface PerformanceAlert {
+	severity: "warning" | "error" | "info";
+	type: string;
+	message: string;
+	path: string;
+	timestamp: number;
+}

package/src/router/modules/routing/domain/predictive-preloading.ts

@@ -0,0 +1,296 @@
+import type { RouteConfig } from "../../../shared/types";
+
+export interface PreloadPrediction {
+	route: string;
+	probability: number;
+	reason: string;
+	priority: number;
+}
+
+export interface UserBehaviorPattern {
+	clickPattern: string[];
+	timeOfDay: number[];
+	sequence: string[];
+}
+
+export class PredictiveRoutePreloader {
+	private routes: RouteConfig[] = [];
+	private userHistory: string[] = [];
+	private predictions: PreloadPrediction[] = [];
+	private maxHistoryLength = 100;
+	private preloadThreshold = 0.5;
+
+	constructor(routes: RouteConfig[]) {
+		this.routes = routes;
+	}
+
+	recordNavigation(route: string): void {
+		this.userHistory.push(route);
+
+		// Keep only last maxHistoryLength entries
+		if (this.userHistory.length > this.maxHistoryLength) {
+			this.userHistory = this.userHistory.slice(-this.maxHistoryLength);
+		}
+
+		// Update predictions after each navigation
+		this.updatePredictions();
+	}
+
+	private updatePredictions(): void {
+		this.predictions = [];
+
+		if (this.userHistory.length < 2) return;
+
+		const currentRoute = this.userHistory[this.userHistory.length - 1];
+		const previousRoute = this.userHistory[this.userHistory.length - 2];
+
+		// Analyze patterns from history
+		const patterns = this.analyzePatterns();
+
+		// Predict next routes based on patterns
+		for (const route of this.routes) {
+			if (route.path === currentRoute) continue;
+
+			const probability = this.calculateProbability(
+				route.path,
+				patterns,
+				currentRoute,
+				previousRoute,
+			);
+
+			if (probability >= this.preloadThreshold) {
+				this.predictions.push({
+					route: route.path,
+					probability,
+					reason: this.getReason(route.path, patterns),
+					priority: this.calculatePriority(route.path, probability),
+				});
+			}
+		}
+
+		// Sort by priority
+		this.predictions.sort((a, b) => b.priority - a.priority);
+	}
+
+	private analyzePatterns(): Map<string, number> {
+		const patterns = new Map<string, number>();
+
+		// Count transitions between routes
+		for (let i = 0; i < this.userHistory.length - 1; i++) {
+			const from = this.userHistory[i];
+			const to = this.userHistory[i + 1];
+			const key = `${from}->${to}`;
+
+			const count = patterns.get(key) || 0;
+			patterns.set(key, count + 1);
+		}
+
+		return patterns;
+	}
+
+	private calculateProbability(
+		route: string,
+		patterns: Map<string, number>,
+		currentRoute: string,
+		previousRoute: string,
+	): number {
+		let probability = 0;
+
+		// Check direct transition from current route
+		const directKey = `${currentRoute}->${route}`;
+		const directCount = patterns.get(directKey) || 0;
+		const totalFromCurrent = this.getTotalFromRoute(currentRoute, patterns);
+
+		if (totalFromCurrent > 0) {
+			probability += (directCount / totalFromCurrent) * 0.6;
+		}
+
+		// Check for common sequences
+		if (previousRoute) {
+			const sequenceKey = `${previousRoute}->${currentRoute}->${route}`;
+			const sequenceCount = this.countSequence(sequenceKey);
+			const totalSequences = this.countSequencesStartingWith(
+				`${previousRoute}->${currentRoute}`,
+			);
+
+			if (totalSequences > 0) {
+				probability += (sequenceCount / totalSequences) * 0.3;
+			}
+		}
+
+		// Add base probability for frequently visited routes
+		const visitCount = this.userHistory.filter((r) => r === route).length;
+		const visitProbability = visitCount / this.userHistory.length;
+		probability += visitProbability * 0.1;
+
+		return Math.min(1, probability);
+	}
+
+	private getTotalFromRoute(
+		route: string,
+		patterns: Map<string, number>,
+	): number {
+		let total = 0;
+		for (const [key, count] of patterns) {
+			if (key.startsWith(`${route}->`)) {
+				total += count;
+			}
+		}
+		return total;
+	}
+
+	private countSequence(sequence: string): number {
+		let count = 0;
+		const sequenceParts = sequence.split("->");
+
+		for (let i = 0; i <= this.userHistory.length - sequenceParts.length; i++) {
+			let match = true;
+			for (let j = 0; j < sequenceParts.length; j++) {
+				if (this.userHistory[i + j] !== sequenceParts[j]) {
+					match = false;
+					break;
+				}
+			}
+			if (match) count++;
+		}
+
+		return count;
+	}
+
+	private countSequencesStartingWith(prefix: string): number {
+		const prefixParts = prefix.split("->");
+		let count = 0;
+
+		for (let i = 0; i <= this.userHistory.length - prefixParts.length; i++) {
+			let match = true;
+			for (let j = 0; j < prefixParts.length; j++) {
+				if (this.userHistory[i + j] !== prefixParts[j]) {
+					match = false;
+					break;
+				}
+			}
+			if (match) count++;
+		}
+
+		return count;
+	}
+
+	private getReason(route: string, patterns: Map<string, number>): string {
+		const currentRoute = this.userHistory[this.userHistory.length - 1];
+		const directKey = `${currentRoute}->${route}`;
+		const directCount = patterns.get(directKey) || 0;
+
+		if (directCount > 0) {
+			return `Frequently navigated from ${currentRoute}`;
+		}
+
+		const visitCount = this.userHistory.filter((r) => r === route).length;
+		if (visitCount > 5) {
+			return "Frequently visited route";
+		}
+
+		return "Based on navigation patterns";
+	}
+
+	private calculatePriority(route: string, probability: number): number {
+		let priority = probability * 100;
+
+		// Boost priority for routes with parameters (likely dynamic content)
+		if (route.includes(":")) {
+			priority += 10;
+		}
+
+		// Boost priority for routes that are children of current route
+		const currentRoute = this.userHistory[this.userHistory.length - 1];
+		if (route.startsWith(currentRoute) && route !== currentRoute) {
+			priority += 20;
+		}
+
+		return Math.min(100, priority);
+	}
+
+	getPredictions(): PreloadPrediction[] {
+		return [...this.predictions];
+	}
+
+	getTopPredictions(limit = 5): PreloadPrediction[] {
+		return this.predictions.slice(0, limit);
+	}
+
+	getRoutesToPreload(limit = 3): string[] {
+		return this.getTopPredictions(limit).map((p) => p.route);
+	}
+
+	clearHistory(): void {
+		this.userHistory = [];
+		this.predictions = [];
+	}
+
+	setPreloadThreshold(threshold: number): void {
+		this.preloadThreshold = Math.max(0, Math.min(1, threshold));
+		this.updatePredictions();
+	}
+
+	setMaxHistoryLength(length: number): void {
+		this.maxHistoryLength = length;
+		if (this.userHistory.length > length) {
+			this.userHistory = this.userHistory.slice(-length);
+		}
+	}
+
+	getStatistics(): {
+		totalNavigations: number;
+		uniqueRoutes: number;
+		predictionCount: number;
+		averageProbability: number;
+	} {
+		const uniqueRoutes = new Set(this.userHistory).size;
+		const averageProbability =
+			this.predictions.length > 0
+				? this.predictions.reduce((sum, p) => sum + p.probability, 0) /
+					this.predictions.length
+				: 0;
+
+		return {
+			totalNavigations: this.userHistory.length,
+			uniqueRoutes,
+			predictionCount: this.predictions.length,
+			averageProbability,
+		};
+	}
+
+	exportPredictions(): string {
+		let output = "Preload Predictions\n";
+		output += "===================\n\n";
+
+		for (const prediction of this.predictions) {
+			output += `Route: ${prediction.route}\n`;
+			output += `Probability: ${(prediction.probability * 100).toFixed(1)}%\n`;
+			output += `Reason: ${prediction.reason}\n`;
+			output += `Priority: ${prediction.priority.toFixed(1)}\n\n`;
+		}
+
+		return output;
+	}
+}
+
+export const createPredictiveRoutePreloader = (
+	routes: RouteConfig[],
+): PredictiveRoutePreloader => {
+	return new PredictiveRoutePreloader(routes);
+};
+
+// Helper function to create a preload prediction
+export function createPreloadPrediction(
+	route: string,
+	probability: number,
+	reason: string,
+	priority: number,
+): PreloadPrediction {
+	return {
+		route,
+		probability,
+		reason,
+		priority,
+	};
+}