@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/route-navigation-timeline/domain/operations/index.ts

@@ -0,0 +1,177 @@
+import type { NavigationTimelineState, TimelineEvent } from "../models";
+import { recordNavigation } from "../models";
+
+// Pure function to get events
+export const getEvents = (
+	state: NavigationTimelineState,
+): readonly TimelineEvent[] => {
+	return state.events;
+};
+
+// Pure function to get events by type
+export const getEventsByType = (
+	state: NavigationTimelineState,
+	type: TimelineEvent["type"],
+): readonly TimelineEvent[] => {
+	return state.events.filter((e) => e.type === type);
+};
+
+// Pure function to get events by path
+export const getEventsByPath = (
+	state: NavigationTimelineState,
+	path: string,
+): readonly TimelineEvent[] => {
+	return state.events.filter((e) => e.path === path);
+};
+
+// Pure function to get events in time range
+export const getEventsInTimeRange = (
+	state: NavigationTimelineState,
+	startTime: number,
+	endTime: number,
+): readonly TimelineEvent[] => {
+	return state.events.filter(
+		(e) => e.timestamp >= startTime && e.timestamp <= endTime,
+	);
+};
+
+// Pure function to get navigation count
+export const getNavigationCount = (state: NavigationTimelineState): number => {
+	return state.events.length;
+};
+
+// Pure function to get unique paths
+export const getUniquePaths = (
+	state: NavigationTimelineState,
+): readonly string[] => {
+	const paths = new Set(state.events.map((e) => e.path));
+	return Object.freeze(Array.from(paths));
+};
+
+// Pure function to get most visited paths
+export const getMostVisitedPaths = (
+	state: NavigationTimelineState,
+	limit = 10,
+): readonly {
+	readonly path: string;
+	readonly count: number;
+}[] => {
+	const pathCounts = new Map<string, number>();
+
+	for (const event of state.events) {
+		const count = pathCounts.get(event.path) || 0;
+		pathCounts.set(event.path, count + 1);
+	}
+
+	return Object.freeze(
+		Array.from(pathCounts.entries())
+			.map(([path, count]) => ({ path, count }))
+			.sort((a, b) => b.count - a.count)
+			.slice(0, limit),
+	);
+};
+
+// Pure function to get average navigation time
+export const getAverageNavigationTime = (
+	state: NavigationTimelineState,
+): number => {
+	if (state.events.length < 2) return 0;
+
+	let totalTime = 0;
+	for (let i = 1; i < state.events.length; i++) {
+		totalTime += state.events[i].timestamp - state.events[i - 1].timestamp;
+	}
+
+	return totalTime / (state.events.length - 1);
+};
+
+// Pure function to get navigation pattern
+export const getNavigationPattern = (
+	state: NavigationTimelineState,
+): string => {
+	if (state.events.length === 0) return "none";
+
+	const types = state.events.map((e) => e.type);
+	const navigateCount = types.filter((t) => t === "navigate").length;
+	const backCount = types.filter((t) => t === "back").length;
+	const forwardCount = types.filter((t) => t === "forward").length;
+
+	if (navigateCount > backCount && navigateCount > forwardCount) {
+		return "forward-heavy";
+	}
+	if (backCount > navigateCount && backCount > forwardCount) {
+		return "back-heavy";
+	}
+	if (forwardCount > navigateCount && forwardCount > backCount) {
+		return "forward-heavy";
+	}
+	return "balanced";
+};
+
+// Pure function to export timeline
+export const exportTimeline = (state: NavigationTimelineState): string => {
+	let output = "Navigation Timeline\n";
+	output += "==================\n\n";
+
+	for (const event of state.events) {
+		output += `[${new Date(event.timestamp).toISOString()}] ${event.type.toUpperCase()}: ${event.path}\n`;
+		if (event.params) {
+			output += `  Params: ${JSON.stringify(event.params)}\n`;
+		}
+		if (event.searchParams) {
+			output += `  Search: ${JSON.stringify(event.searchParams)}\n`;
+		}
+		output += "\n";
+	}
+
+	return output;
+};
+
+// Pure function to export timeline as JSON
+export const exportTimelineAsJSON = (
+	state: NavigationTimelineState,
+): string => {
+	return JSON.stringify(
+		{
+			startTime: state.startTime,
+			events: state.events,
+			statistics: {
+				totalNavigations: state.events.length,
+				uniquePaths: getUniquePaths(state).length,
+				mostVisited: getMostVisitedPaths(state, 5),
+				averageTime: getAverageNavigationTime(state),
+				pattern: getNavigationPattern(state),
+			},
+		},
+		null,
+		2,
+	);
+};
+
+// Pure function to check recording status
+export const isRecordingStatus = (state: NavigationTimelineState): boolean => {
+	return state.isRecording;
+};
+
+// Pure function to record navigation event from NavigationEvent
+export const recordNavigationEvent = (
+	state: NavigationTimelineState,
+	event: import("../../../../shared/types").NavigationEvent,
+	now: number,
+): NavigationTimelineState => {
+	let type: TimelineEvent["type"] = "navigate";
+
+	// Map NavigationEvent types to TimelineEvent types
+	// Note: NavigationEvent type may not have "popstate" or "push", so we handle gracefully
+	if (event.type === "back") {
+		type = "back";
+	} else if (event.type === "forward") {
+		type = "forward";
+	} else if (event.type === "replace") {
+		type = "replace";
+	} else {
+		type = "navigate";
+	}
+
+	return recordNavigation(state, type, event.to, now, event.params);
+};

package/src/router/modules/route-navigation-timeline/domain/validators/index.ts

@@ -0,0 +1,19 @@
+import type { TimelineEvent } from "../models";
+
+export const validateTimelineEvent = (event: TimelineEvent): boolean => {
+	if (typeof event.timestamp !== "number" || event.timestamp < 0) return false;
+	if (!event.path || typeof event.path !== "string") return false;
+	const validTypes = ["navigate", "back", "forward", "replace"];
+	if (!validTypes.includes(event.type)) return false;
+	return true;
+};
+
+export const validatePath = (path: string): boolean => {
+	if (!path || typeof path !== "string") return false;
+	if (!path.startsWith("/")) return false;
+	return true;
+};
+
+export const validateMaxEvents = (max: number): boolean => {
+	return typeof max === "number" && max > 0 && max <= 10000;
+};

package/src/router/modules/route-navigation-timeline/index.ts

@@ -0,0 +1,8 @@
+// Public API exports for route-navigation-timeline module
+
+export * from "./application/usecases";
+export * from "./domain/models";
+export * from "./domain/operations";
+export * from "./domain/validators";
+export * from "./ports";
+export * from "./types";

package/src/router/modules/route-navigation-timeline/ports/index.ts

@@ -0,0 +1,30 @@
+import type {
+	NavigationTimelineState,
+	TimelineEvent,
+	TimelineSnapshot,
+} from "../types";
+
+// Port for timeline storage (dependency injection point)
+export interface ITimelineStorage {
+	saveSnapshot(snapshot: TimelineSnapshot): Promise<void>;
+	getSnapshot(id: string): Promise<TimelineSnapshot | undefined>;
+	listSnapshots(): Promise<TimelineSnapshot[]>;
+	deleteSnapshot(id: string): Promise<void>;
+}
+
+// Port for timeline analytics (dependency injection point)
+export interface ITimelineAnalytics {
+	analyzeEvents(events: readonly TimelineEvent[]): Promise<{
+		readonly totalNavigations: number;
+		readonly uniquePaths: number;
+		readonly averageTime: number;
+		readonly pattern: string;
+	}>;
+	exportReport(analysis: unknown): Promise<void>;
+}
+
+// Port for timeline synchronization (dependency injection point)
+export interface ITimelineSync {
+	sync(state: NavigationTimelineState): Promise<void>;
+	getRemoteState(): Promise<NavigationTimelineState | undefined>;
+}

package/src/router/modules/route-navigation-timeline/types/index.ts

@@ -0,0 +1,5 @@
+export type {
+	NavigationTimelineState,
+	TimelineEvent,
+	TimelineSnapshot,
+} from "../domain";

package/src/router/modules/route-performance/application/usecases/index.ts

@@ -0,0 +1,166 @@
+import { setThresholds } from "../../domain/models";
+import {
+	clearAllMetrics,
+	clearMetrics,
+	endLoad,
+	generatePerformanceReport,
+	getAlerts,
+	getAllMetrics,
+	getCriticalAlerts,
+	getMetrics,
+	getPerformanceScore,
+	getRoutesByPerformance,
+	getSlowRoutes,
+	incrementNavigationCount,
+	recordCacheHit,
+	recordError,
+	recordRenderTime,
+	setBundleSize,
+	startLoad,
+} from "../../domain/operations";
+import type { PerformanceState, PerformanceThresholds } from "../../types";
+
+// Use case: Start load tracking
+export const startLoadUseCase = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	return startLoad(state, path, now);
+};
+
+// Use case: End load tracking
+export const endLoadUseCase = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	return endLoad(state, path, now);
+};
+
+// Use case: Record render time
+export const recordRenderTimeUseCase = (
+	state: PerformanceState,
+	path: string,
+	renderTime: number,
+	now: number,
+): PerformanceState => {
+	return recordRenderTime(state, path, renderTime, now);
+};
+
+// Use case: Increment navigation count
+export const incrementNavigationCountUseCase = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	return incrementNavigationCount(state, path, now);
+};
+
+// Use case: Record error
+export const recordErrorUseCase = (
+	state: PerformanceState,
+	path: string,
+	now: number,
+): PerformanceState => {
+	return recordError(state, path, now);
+};
+
+// Use case: Record cache hit
+export const recordCacheHitUseCase = (
+	state: PerformanceState,
+	path: string,
+	hit: boolean,
+): PerformanceState => {
+	return recordCacheHit(state, path, hit);
+};
+
+// Use case: Set bundle size
+export const setBundleSizeUseCase = (
+	state: PerformanceState,
+	path: string,
+	size: number,
+): PerformanceState => {
+	return setBundleSize(state, path, size);
+};
+
+// Use case: Get metrics for route
+export const getMetricsUseCase = (
+	state: PerformanceState,
+	path: string,
+): import("../../domain/models").RouteMetrics | undefined => {
+	return getMetrics(state, path);
+};
+
+// Use case: Get all metrics
+export const getAllMetricsUseCase = (
+	state: PerformanceState,
+): readonly import("../../domain/models").RouteMetrics[] => {
+	return getAllMetrics(state);
+};
+
+// Use case: Get slow routes
+export const getSlowRoutesUseCase = (
+	state: PerformanceState,
+	threshold?: number,
+): readonly import("../../domain/models").RouteMetrics[] => {
+	return getSlowRoutes(state, threshold);
+};
+
+// Use case: Get routes by performance
+export const getRoutesByPerformanceUseCase = (
+	state: PerformanceState,
+	sort: "asc" | "desc" = "asc",
+): readonly import("../../domain/models").RouteMetrics[] => {
+	return getRoutesByPerformance(state, sort);
+};
+
+// Use case: Get performance score
+export const getPerformanceScoreUseCase = (state: PerformanceState): number => {
+	return getPerformanceScore(state);
+};
+
+// Use case: Get alerts
+export const getAlertsUseCase = (
+	state: PerformanceState,
+	severity?: import("../../domain/models").PerformanceAlert["severity"],
+): readonly import("../../domain/models").PerformanceAlert[] => {
+	return getAlerts(state, severity);
+};
+
+// Use case: Get critical alerts
+export const getCriticalAlertsUseCase = (
+	state: PerformanceState,
+): readonly import("../../domain/models").PerformanceAlert[] => {
+	return getCriticalAlerts(state);
+};
+
+// Use case: Clear metrics for route
+export const clearMetricsUseCase = (
+	state: PerformanceState,
+	path: string,
+): PerformanceState => {
+	return clearMetrics(state, path);
+};
+
+// Use case: Clear all metrics
+export const clearAllMetricsUseCase = (
+	state: PerformanceState,
+): PerformanceState => {
+	return clearAllMetrics(state);
+};
+
+// Use case: Set thresholds
+export const setThresholdsUseCase = (
+	state: PerformanceState,
+	thresholds: Partial<PerformanceThresholds>,
+): PerformanceState => {
+	return setThresholds(state, thresholds);
+};
+
+// Use case: Generate performance report
+export const generatePerformanceReportUseCase = (
+	state: PerformanceState,
+): string => {
+	return generatePerformanceReport(state);
+};

package/src/router/modules/route-performance/domain/models/index.ts

@@ -0,0 +1,96 @@
+export type RouteMetrics = {
+	readonly path: string;
+	readonly loadTime: number;
+	readonly renderTime: number;
+	readonly navigationCount: number;
+	readonly lastVisited: number;
+	readonly averageLoadTime: number;
+	readonly errorCount: number;
+	readonly cacheHitRate: number;
+	readonly bundleSize?: number;
+};
+
+export interface PerformanceAlert {
+	readonly severity: "warning" | "error" | "info";
+	readonly type: string;
+	readonly message: string;
+	readonly path: string;
+	readonly timestamp: number;
+}
+
+export interface PerformanceThresholds {
+	readonly slowLoadTime: number;
+	readonly slowRenderTime: number;
+	readonly highErrorRate: number;
+}
+
+export type PerformanceState = {
+	readonly metrics: Readonly<Record<string, RouteMetrics>>;
+	readonly startTime: Readonly<Record<string, number>>;
+	readonly alerts: readonly PerformanceAlert[];
+	readonly loadTimes: Readonly<Record<string, readonly number[]>>;
+	readonly thresholds: PerformanceThresholds;
+};
+
+// Pure function to create initial performance state
+export const createPerformanceState = (
+	thresholds?: Partial<PerformanceThresholds>,
+): PerformanceState => {
+	const defaultThresholds: PerformanceThresholds = {
+		slowLoadTime: 1000,
+		slowRenderTime: 500,
+		highErrorRate: 0.1,
+	};
+
+	return Object.freeze({
+		metrics: Object.freeze({}),
+		startTime: Object.freeze({}),
+		alerts: Object.freeze([]),
+		loadTimes: Object.freeze({}),
+		thresholds: thresholds
+			? { ...defaultThresholds, ...thresholds }
+			: defaultThresholds,
+	});
+};
+
+// Pure function to create route metrics
+export const createRouteMetrics = (path: string): RouteMetrics => {
+	return Object.freeze({
+		path,
+		loadTime: 0,
+		renderTime: 0,
+		navigationCount: 0,
+		lastVisited: 0,
+		averageLoadTime: 0,
+		errorCount: 0,
+		cacheHitRate: 0,
+	});
+};
+
+// Pure function to create performance alert
+export const createPerformanceAlert = (
+	severity: PerformanceAlert["severity"],
+	type: string,
+	message: string,
+	path: string,
+	timestamp: number,
+): PerformanceAlert => {
+	return Object.freeze({
+		severity,
+		type,
+		message,
+		path,
+		timestamp,
+	});
+};
+
+// Pure function to set thresholds
+export const setThresholds = (
+	state: PerformanceState,
+	thresholds: Partial<PerformanceThresholds>,
+): PerformanceState => {
+	return {
+		...state,
+		thresholds: { ...state.thresholds, ...thresholds },
+	};
+};

package/src/router/modules/route-performance/domain/operations/index.ts

@@ -0,0 +1,5 @@
+export * from "./performance-cleanup";
+export * from "./performance-queries";
+export * from "./performance-recording";
+export * from "./performance-reporting";
+export * from "./performance-tracking";

package/src/router/modules/route-performance/domain/operations/performance-cleanup.ts

@@ -0,0 +1,29 @@
+import type { PerformanceState } from "../models";
+
+// Pure function to clear metrics
+export const clearMetrics = (
+	state: PerformanceState,
+	path: string,
+): PerformanceState => {
+	const newMetrics = { ...state.metrics };
+	delete newMetrics[path];
+
+	const newLoadTimes = { ...state.loadTimes };
+	delete newLoadTimes[path];
+
+	return {
+		...state,
+		metrics: Object.freeze(newMetrics),
+		loadTimes: Object.freeze(newLoadTimes),
+	};
+};
+
+// Pure function to clear all metrics
+export const clearAllMetrics = (state: PerformanceState): PerformanceState => {
+	return {
+		...state,
+		metrics: Object.freeze({}),
+		loadTimes: Object.freeze({}),
+		alerts: Object.freeze([]),
+	};
+};

package/src/router/modules/route-performance/domain/operations/performance-queries.ts

@@ -0,0 +1,91 @@
+import type {
+	PerformanceAlert,
+	PerformanceState,
+	RouteMetrics,
+} from "../models";
+
+// Pure function to get metrics
+export const getMetrics = (
+	state: PerformanceState,
+	path: string,
+): RouteMetrics | undefined => {
+	return state.metrics[path];
+};
+
+// Pure function to get all metrics
+export const getAllMetrics = (
+	state: PerformanceState,
+): readonly RouteMetrics[] => {
+	return Object.values(state.metrics);
+};
+
+// Pure function to get slow routes
+export const getSlowRoutes = (
+	state: PerformanceState,
+	threshold?: number,
+): readonly RouteMetrics[] => {
+	const slowThreshold = threshold || state.thresholds.slowLoadTime;
+	return getAllMetrics(state).filter((m) => m.loadTime > slowThreshold);
+};
+
+// Pure function to get routes by performance
+export const getRoutesByPerformance = (
+	state: PerformanceState,
+	sort: "asc" | "desc" = "asc",
+): readonly RouteMetrics[] => {
+	return [...getAllMetrics(state)].sort((a, b) => {
+		const scoreA = a.loadTime + a.renderTime;
+		const scoreB = b.loadTime + b.renderTime;
+		return sort === "asc" ? scoreA - scoreB : scoreB - scoreA;
+	});
+};
+
+// Pure function to get performance score
+export const getPerformanceScore = (state: PerformanceState): number => {
+	const metrics = getAllMetrics(state);
+	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 > state.thresholds.slowLoadTime) {
+			score -= (metric.loadTime - state.thresholds.slowLoadTime) / 10;
+		}
+
+		// Deduct for slow render time
+		if (metric.renderTime > state.thresholds.slowRenderTime) {
+			score -= (metric.renderTime - state.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);
+};
+
+// Pure function to get alerts
+export const getAlerts = (
+	state: PerformanceState,
+	severity?: PerformanceAlert["severity"],
+): readonly PerformanceAlert[] => {
+	if (severity) {
+		return state.alerts.filter((a) => a.severity === severity);
+	}
+	return state.alerts;
+};
+
+// Pure function to get critical alerts
+export const getCriticalAlerts = (
+	state: PerformanceState,
+): readonly PerformanceAlert[] => {
+	return getAlerts(state, "error");
+};