@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/modules/routing/domain/code-splitting.ts

@@ -0,0 +1,226 @@
+import type { RouteConfig } from "../../../shared/types";
+
+export type SplitStrategy =
+	| "lazy"
+	| "eager"
+	| "prefetch"
+	| "viewport"
+	| "intent";
+
+export interface DeviceType {
+	type: "mobile" | "tablet" | "desktop";
+	bandwidth: "low" | "medium" | "high";
+}
+
+export interface BundleAnalysis {
+	size: number;
+	gzipSize: number;
+	dependencies: string[];
+	imports: string[];
+}
+
+export class SmartCodeSplitter {
+	private splitStrategies: Map<string, SplitStrategy> = new Map();
+	private routeWeights: Map<string, number> = new Map();
+	private deviceType: DeviceType = { type: "desktop", bandwidth: "high" };
+	private bundleCache: Map<string, BundleAnalysis> = new Map();
+
+	constructor(private routes: RouteConfig[]) {
+		this.calculateWeights();
+	}
+
+	setDeviceType(device: DeviceType): void {
+		this.deviceType = device;
+		this.splitStrategies.clear();
+	}
+
+	private calculateWeights(): void {
+		for (const route of this.routes) {
+			const weight = this.calculateRouteWeight(route);
+			this.routeWeights.set(route.path, weight);
+		}
+	}
+
+	private calculateRouteWeight(route: RouteConfig): number {
+		let weight = 0;
+
+		// Deep routes have higher weight
+		weight += route.path.split("/").length * 10;
+
+		// Routes with params have higher weight
+		if (route.path.includes(":")) {
+			weight += 20;
+		}
+
+		// Routes with loaders have higher weight
+		if (route.loaders) {
+			weight += 30;
+		}
+
+		// Routes with meta have higher weight
+		if (route.meta) {
+			weight += 10;
+		}
+
+		// Consider device type
+		if (this.deviceType.type === "mobile") {
+			weight *= 1.5;
+		}
+
+		// Consider bandwidth
+		if (this.deviceType.bandwidth === "low") {
+			weight *= 2.0;
+		}
+
+		return weight;
+	}
+
+	setSplitStrategy(path: string, strategy: SplitStrategy): void {
+		this.splitStrategies.set(path, strategy);
+	}
+
+	getSplitStrategy(path: string): SplitStrategy {
+		return this.splitStrategies.get(path) || this.determineStrategy(path);
+	}
+
+	private determineStrategy(path: string): SplitStrategy {
+		const weight = this.routeWeights.get(path) || 0;
+		const bundle = this.bundleCache.get(path);
+
+		// Consider bundle size if available
+		if (bundle && bundle.size > 100000) {
+			return "lazy";
+		}
+
+		// Device-specific strategies
+		if (this.deviceType.type === "mobile") {
+			if (weight > 40) return "lazy";
+			if (weight > 25) return "viewport";
+			return "prefetch";
+		}
+
+		if (this.deviceType.bandwidth === "low") {
+			if (weight > 30) return "lazy";
+			if (weight > 20) return "viewport";
+			return "intent";
+		}
+
+		// Default strategies
+		if (weight > 50) {
+			return "lazy";
+		}
+		if (weight > 30) {
+			return "prefetch";
+		}
+		if (weight > 20) {
+			return "viewport";
+		}
+		return "eager";
+	}
+
+	analyzeBundle(path: string, analysis: BundleAnalysis): void {
+		this.bundleCache.set(path, analysis);
+		this.splitStrategies.delete(path);
+	}
+
+	getBundleAnalysis(path: string): BundleAnalysis | undefined {
+		return this.bundleCache.get(path);
+	}
+
+	getSplitRoutes(): {
+		eager: RouteConfig[];
+		lazy: RouteConfig[];
+		prefetch: RouteConfig[];
+		viewport: RouteConfig[];
+		intent: RouteConfig[];
+	} {
+		const eager: RouteConfig[] = [];
+		const lazy: RouteConfig[] = [];
+		const prefetch: RouteConfig[] = [];
+		const viewport: RouteConfig[] = [];
+		const intent: RouteConfig[] = [];
+
+		for (const route of this.routes) {
+			const strategy = this.getSplitStrategy(route.path);
+			if (strategy === "eager") {
+				eager.push(route);
+			} else if (strategy === "lazy") {
+				lazy.push(route);
+			} else if (strategy === "prefetch") {
+				prefetch.push(route);
+			} else if (strategy === "viewport") {
+				viewport.push(route);
+			} else {
+				intent.push(route);
+			}
+		}
+
+		return { eager, lazy, prefetch, viewport, intent };
+	}
+
+	getOptimizationSuggestions(): Array<{
+		path: string;
+		currentStrategy: SplitStrategy;
+		suggestedStrategy: SplitStrategy;
+		reason: string;
+	}> {
+		const suggestions: Array<{
+			path: string;
+			currentStrategy: SplitStrategy;
+			suggestedStrategy: SplitStrategy;
+			reason: string;
+		}> = [];
+
+		for (const route of this.routes) {
+			const currentStrategy = this.getSplitStrategy(route.path);
+			const weight = this.routeWeights.get(route.path) || 0;
+			const bundle = this.bundleCache.get(route.path);
+
+			// Suggest lazy loading for large bundles
+			if (bundle && bundle.size > 150000 && currentStrategy !== "lazy") {
+				suggestions.push({
+					path: route.path,
+					currentStrategy,
+					suggestedStrategy: "lazy",
+					reason: `Bundle size (${Math.round(bundle.size / 1024)}KB) exceeds threshold`,
+				});
+			}
+
+			// Suggest viewport loading for medium-weight routes on mobile
+			if (
+				this.deviceType.type === "mobile" &&
+				weight > 30 &&
+				currentStrategy === "eager"
+			) {
+				suggestions.push({
+					path: route.path,
+					currentStrategy,
+					suggestedStrategy: "viewport",
+					reason: "Route weight is high for mobile device",
+				});
+			}
+
+			// Suggest intent loading for low bandwidth
+			if (
+				this.deviceType.bandwidth === "low" &&
+				weight > 20 &&
+				currentStrategy === "eager"
+			) {
+				suggestions.push({
+					path: route.path,
+					currentStrategy,
+					suggestedStrategy: "intent",
+					reason: "Route weight is high for low bandwidth connection",
+				});
+			}
+		}
+
+		return suggestions;
+	}
+}
+
+export const createSmartCodeSplitter = (
+	routes: RouteConfig[],
+): SmartCodeSplitter => {
+	return new SmartCodeSplitter(routes);
+};

package/src/router/modules/routing/domain/contract-factory.ts

@@ -0,0 +1,37 @@
+import type { ParamSchema, RouteContract, RouteParams } from "./contract-types";
+import { RouteContractTester } from "./contract-validator";
+
+export const createRouteContractTester = (): RouteContractTester => {
+	return new RouteContractTester();
+};
+
+// Helper function to create param schemas
+export function createParamSchema(
+	type: ParamSchema["type"],
+	options: Partial<ParamSchema> = {},
+): ParamSchema {
+	return {
+		type,
+		required: options.required ?? true,
+		...(options.pattern !== undefined && { pattern: options.pattern }),
+		...(options.enum !== undefined && { enum: options.enum }),
+	};
+}
+
+// Helper function to create route contracts
+export function createRouteContract<TParams extends RouteParams>(
+	path: string,
+	paramsSchema: Record<keyof TParams, ParamSchema>,
+	options: Partial<RouteContract<TParams>> = {},
+): RouteContract<TParams> {
+	return {
+		path,
+		paramsSchema,
+		...(options.searchParamsSchema !== undefined && {
+			searchParamsSchema: options.searchParamsSchema,
+		}),
+		...(options.loaderSchema !== undefined && {
+			loaderSchema: options.loaderSchema,
+		}),
+	};
+}

package/src/router/modules/routing/domain/contract-testing.ts

@@ -0,0 +1,13 @@
+export {
+	createParamSchema,
+	createRouteContract,
+	createRouteContractTester,
+} from "./contract-factory";
+export type {
+	ContractTestResult,
+	ContractViolation,
+	LoaderSchema,
+	ParamSchema,
+	RouteContract,
+} from "./contract-types";
+export { RouteContractTester } from "./contract-validator";

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

@@ -0,0 +1,32 @@
+export type RouteParams = Record<string, string | number | boolean>;
+
+export interface RouteContract<TParams extends RouteParams = RouteParams> {
+	path: string;
+	paramsSchema: Record<keyof TParams, ParamSchema>;
+	searchParamsSchema?: Record<string, ParamSchema>;
+	loaderSchema?: LoaderSchema;
+}
+
+export interface ParamSchema {
+	type: "string" | "number" | "boolean" | "uuid" | "email";
+	required: boolean;
+	pattern?: RegExp;
+	enum?: string[];
+}
+
+export interface LoaderSchema {
+	returnType: string;
+	requiredFields: string[];
+}
+
+export interface ContractViolation {
+	field: string;
+	expected: string;
+	received: unknown;
+	message: string;
+}
+
+export interface ContractTestResult {
+	valid: boolean;
+	violations: ContractViolation[];
+}

package/src/router/modules/routing/domain/contract-validator.ts

@@ -0,0 +1,246 @@
+import type { RouteMatch } from "../../../shared/types";
+import type {
+	ContractTestResult,
+	ContractViolation,
+	ParamSchema,
+	RouteContract,
+	RouteParams,
+} from "./contract-types";
+export class RouteContractTester {
+	validateParams<TParams extends RouteParams>(
+		contract: RouteContract<TParams>,
+		params: TParams,
+	): ContractTestResult {
+		const violations: ContractViolation[] = [];
+
+		for (const [key, schema] of Object.entries(contract.paramsSchema)) {
+			const value = params[key as keyof TParams];
+
+			// Check required
+			if (schema.required && value === undefined) {
+				violations.push({
+					field: key,
+					expected: `${schema.type} (required)`,
+					received: value,
+					message: `Parameter '${key}' is required but was not provided`,
+				});
+				continue;
+			}
+
+			// Skip validation if not required and not provided
+			if (!schema.required && value === undefined) {
+				continue;
+			}
+
+			// Type validation
+			const typeError = this.validateType(key, schema, value);
+			if (typeError) {
+				violations.push(typeError);
+			}
+
+			// Pattern validation
+			if (schema.pattern && typeof value === "string") {
+				if (!schema.pattern.test(value)) {
+					violations.push({
+						field: key,
+						expected: schema.pattern.toString(),
+						received: value,
+						message: `Parameter '${key}' does not match required pattern`,
+					});
+				}
+			}
+
+			// Enum validation
+			if (schema.enum && typeof value === "string") {
+				if (!schema.enum.includes(value)) {
+					violations.push({
+						field: key,
+						expected: schema.enum.join(" | "),
+						received: value,
+						message: `Parameter '${key}' must be one of: ${schema.enum.join(", ")}`,
+					});
+				}
+			}
+		}
+
+		return {
+			valid: violations.length === 0,
+			violations,
+		};
+	}
+
+	validateSearchParams(
+		contract: RouteContract,
+		searchParams: Record<string, string>,
+	): ContractTestResult {
+		const violations: ContractViolation[] = [];
+
+		if (!contract.searchParamsSchema) {
+			return { valid: true, violations: [] };
+		}
+
+		for (const [key, schema] of Object.entries(contract.searchParamsSchema)) {
+			const value = searchParams[key];
+
+			// Check required
+			if (schema.required && value === undefined) {
+				violations.push({
+					field: key,
+					expected: `${schema.type} (required)`,
+					received: value,
+					message: `Search parameter '${key}' is required but was not provided`,
+				});
+				continue;
+			}
+
+			// Skip validation if not required and not provided
+			if (!schema.required && value === undefined) {
+				continue;
+			}
+
+			// Type validation
+			const typeError = this.validateType(key, schema, value);
+			if (typeError) {
+				violations.push(typeError);
+			}
+		}
+
+		return {
+			valid: violations.length === 0,
+			violations,
+		};
+	}
+
+	validateLoader(
+		contract: RouteContract,
+		loaderData: unknown,
+	): ContractTestResult {
+		const violations: ContractViolation[] = [];
+
+		if (!contract.loaderSchema) {
+			return { valid: true, violations: [] };
+		}
+
+		// Check if loader data is an object
+		if (typeof loaderData !== "object" || loaderData === null) {
+			violations.push({
+				field: "loader",
+				expected: "object",
+				received: typeof loaderData,
+				message: "Loader data must be an object",
+			});
+			return { valid: false, violations };
+		}
+
+		// Check required fields
+		for (const field of contract.loaderSchema.requiredFields) {
+			if (!(field in loaderData)) {
+				violations.push({
+					field,
+					expected: "present",
+					received: undefined,
+					message: `Required field '${field}' is missing from loader data`,
+				});
+			}
+		}
+
+		return {
+			valid: violations.length === 0,
+			violations,
+		};
+	}
+
+	validateMatch<TParams extends RouteParams>(
+		contract: RouteContract<TParams>,
+		match: RouteMatch,
+	): ContractTestResult {
+		const violations: ContractViolation[] = [];
+
+		// Validate params
+		const paramsResult = this.validateParams(contract, match.params as TParams);
+		violations.push(...paramsResult.violations);
+
+		// Validate search params
+		if (match.searchParams) {
+			const searchResult = this.validateSearchParams(
+				contract,
+				match.searchParams as Record<string, string>,
+			);
+			violations.push(...searchResult.violations);
+		}
+
+		return {
+			valid: violations.length === 0,
+			violations,
+		};
+	}
+
+	private validateType(
+		field: string,
+		schema: ParamSchema,
+		value: unknown,
+	): ContractViolation | null {
+		switch (schema.type) {
+			case "string":
+				if (typeof value !== "string") {
+					return {
+						field,
+						expected: "string",
+						received: typeof value,
+						message: `Field '${field}' must be a string`,
+					};
+				}
+				break;
+			case "number":
+				if (typeof value !== "number" || Number.isNaN(value)) {
+					return {
+						field,
+						expected: "number",
+						received: typeof value,
+						message: `Field '${field}' must be a number`,
+					};
+				}
+				break;
+			case "boolean":
+				if (typeof value !== "boolean") {
+					return {
+						field,
+						expected: "boolean",
+						received: typeof value,
+						message: `Field '${field}' must be a boolean`,
+					};
+				}
+				break;
+			case "uuid":
+				if (
+					typeof value !== "string" ||
+					!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+						value,
+					)
+				) {
+					return {
+						field,
+						expected: "uuid",
+						received: value,
+						message: `Field '${field}' must be a valid UUID`,
+					};
+				}
+				break;
+			case "email":
+				if (
+					typeof value !== "string" ||
+					!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+				) {
+					return {
+						field,
+						expected: "email",
+						received: value,
+						message: `Field '${field}' must be a valid email address`,
+					};
+				}
+				break;
+		}
+
+		return null;
+	}
+}

package/src/router/modules/routing/domain/dynamic-imports.ts

@@ -0,0 +1,67 @@
+import { failure, type Result, success } from "../../../shared/types";
+
+export type DynamicImportConfig = {
+	pattern: string;
+	importFn: () => Promise<unknown>;
+};
+
+export class DynamicRouteLoader {
+	private loadedRoutes: Map<string, unknown> = new Map();
+	private loadingPromises: Map<string, Promise<unknown>> = new Map();
+
+	async loadRoute(
+		path: string,
+		config: DynamicImportConfig,
+	): Promise<Result<unknown>> {
+		// Check if already loaded
+		if (this.loadedRoutes.has(path)) {
+			return success(this.loadedRoutes.get(path));
+		}
+
+		// Check if currently loading
+		if (this.loadingPromises.has(path)) {
+			const component = await this.loadingPromises.get(path);
+			return success(component);
+		}
+
+		// Load the route
+		try {
+			const promise = config.importFn();
+			this.loadingPromises.set(path, promise);
+			const component = await promise;
+			this.loadedRoutes.set(path, component);
+			this.loadingPromises.delete(path);
+			return success(component);
+		} catch (error) {
+			this.loadingPromises.delete(path);
+			return failure(error as Error);
+		}
+	}
+
+	unloadRoute(path: string): void {
+		this.loadedRoutes.delete(path);
+		this.loadingPromises.delete(path);
+	}
+
+	preloadRoute(path: string, config: DynamicImportConfig): void {
+		this.loadRoute(path, config);
+	}
+
+	getLoadedRoutes(): string[] {
+		return Array.from(this.loadedRoutes.keys());
+	}
+}
+
+export const createDynamicRouteLoader = (): DynamicRouteLoader => {
+	return new DynamicRouteLoader();
+};
+
+export const createDynamicRouteConfig = (
+	pattern: string,
+	importFn: () => Promise<unknown>,
+): DynamicImportConfig => {
+	return {
+		pattern,
+		importFn,
+	};
+};