@wrikka/solid-framework 0.0.0-stage → 0.15.0

package/src/router/shared/types/result.ts

@@ -0,0 +1,34 @@
+// Result type for error handling
+export type Result<T, E = Error> =
+	| { success: true; data: T }
+	| { success: false; error: E };
+
+export const success = <T>(data: T): Result<T> => ({
+	success: true,
+	data,
+});
+
+export const failure = <E = Error>(error: E): Result<never, E> => ({
+	success: false,
+	error,
+});
+
+export const mapResult = <T, U, E>(
+	result: Result<T, E>,
+	fn: (data: T) => U,
+): Result<U, E> => {
+	if (result.success) {
+		return success(fn(result.data)) as Result<U, E>;
+	}
+	return result;
+};
+
+export const chain = <T, U, E>(
+	result: Result<T, E>,
+	fn: (data: T) => Result<U, E>,
+): Result<U, E> => {
+	if (result.success) {
+		return fn(result.data);
+	}
+	return result;
+};

package/src/router/shared/types/route-inference.ts

@@ -0,0 +1,49 @@
+import type { RouteConfig } from "./routing";
+
+export type RouteParamsFor<T extends string> =
+	T extends `${string}:${infer Param}/${infer Rest}`
+		? { [K in Param]: string } & RouteParamsFor<Rest>
+		: T extends `${string}:${infer Param}`
+			? { [K in Param]: string }
+			: Record<string, never>;
+
+export type SearchParamsFor<T extends string> =
+	T extends `${string}?${infer Query}`
+		? Query extends `${string}&${infer Rest}`
+			? SearchParamsFor<Rest>
+			: Query extends `${string}=${infer Value}`
+				? { [K in Value]: string }
+				: Record<string, never>
+		: Record<string, never>;
+
+export type InferredRoutePath<T extends string> = T;
+
+export type RoutePathParams<T extends RouteConfig> = T extends { path: infer P }
+	? RouteParamsFor<P & string>
+	: Record<string, never>;
+
+export type CreateRoute<T extends string> = {
+	path: T;
+	params?: RouteParamsFor<T>;
+};
+
+export type NavigateTo<T extends string> = (
+	to: T,
+	params?: RouteParamsFor<T>,
+) => void;
+
+export type LinkTo<T extends string> = {
+	to: T;
+	params?: RouteParamsFor<T>;
+};
+
+// Helper type to extract route paths from route config
+export type RoutePaths<T extends RouteConfig[]> = T[number]["path"];
+
+// Type-safe route matcher
+export type MatchRoute<T extends RouteConfig[], P extends string> =
+	T extends Array<{
+		path: P;
+	}>
+		? RouteParamsFor<P>
+		: never;

package/src/router/shared/types/routing.ts

@@ -0,0 +1,31 @@
+// Routing-specific types
+export type RoutePath = string;
+export type RouteParams = Record<string, string>;
+export type SearchParams = Record<string, unknown>;
+
+export type RouteMatch = {
+	path: RoutePath;
+	params: RouteParams;
+	searchParams: SearchParams;
+};
+
+export type RouteConfig = {
+	path: RoutePath;
+	component?: () => unknown;
+	loaders?: () => Promise<unknown>;
+	meta?: Record<string, unknown>;
+};
+
+export type RouterState = {
+	currentRoute: RouteMatch | null;
+	isLoading: boolean;
+	error: Error | null;
+};
+
+export type NavigationEvent = {
+	type: "navigate" | "replace" | "back" | "forward";
+	to: RoutePath;
+	params?: RouteParams;
+};
+
+export type Validator<T> = (value: unknown) => T;

package/src/router/shared/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./path";
+export * from "./result";
+export * from "./time-condition";

package/src/router/shared/utils/path.ts

@@ -0,0 +1,43 @@
+export const joinPath = (...segments: string[]): string => {
+	return segments
+		.filter(Boolean)
+		.map((s) => s.replace(/^\/+|\/+$/g, ""))
+		.join("/");
+};
+
+export const normalizePath = (path: string): string => {
+	return path.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+};
+
+export const parsePathParams = (path: string): string[] => {
+	const matches = path.match(/:([a-zA-Z0-9_]+)/g);
+	return matches ? matches.map((m) => m.slice(1)) : [];
+};
+
+export const matchPath = (
+	pattern: string,
+	path: string,
+): Record<string, string> | null => {
+	const patternSegments = pattern.split("/").filter(Boolean);
+	const pathSegments = path.split("/").filter(Boolean);
+
+	if (patternSegments.length !== pathSegments.length) {
+		return null;
+	}
+
+	const params: Record<string, string> = {};
+
+	for (let i = 0; i < patternSegments.length; i++) {
+		const patternSeg = patternSegments[i];
+		const pathSeg = pathSegments[i];
+
+		if (patternSeg.startsWith(":")) {
+			const paramName = patternSeg.slice(1);
+			params[paramName] = pathSeg;
+		} else if (patternSeg !== pathSeg) {
+			return null;
+		}
+	}
+
+	return params;
+};

package/src/router/shared/utils/result.ts

@@ -0,0 +1,5 @@
+import { failure, mapResult, success } from "../types/result";
+
+export const ok = success;
+export const err = failure;
+export const map = mapResult;

package/src/router/shared/utils/time-condition.ts

@@ -0,0 +1,53 @@
+export interface TimeCondition {
+	readonly start?: string;
+	readonly end?: string;
+	readonly days?: readonly number[];
+}
+
+const parseTime = (time: string): number => {
+	const [hours = 0, minutes = 0, seconds = 0] = time
+		.split(":")
+		.map((part) => Number.parseInt(part, 10));
+	if (
+		Number.isNaN(hours) ||
+		Number.isNaN(minutes) ||
+		Number.isNaN(seconds) ||
+		hours < 0 ||
+		hours > 23 ||
+		minutes < 0 ||
+		minutes > 59 ||
+		seconds < 0 ||
+		seconds > 59
+	) {
+		return 0;
+	}
+	return (hours * 3600 + minutes * 60 + seconds) * 1000;
+};
+
+export const evaluateTimeCondition = (value: unknown, now: Date): boolean => {
+	if (typeof value !== "object" || value === null) return false;
+
+	const condition = value as Partial<TimeCondition>;
+
+	if (condition.days && Array.isArray(condition.days)) {
+		if (!condition.days.includes(now.getDay())) {
+			return false;
+		}
+	}
+
+	const currentTime =
+		(now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds()) * 1000;
+
+	if (condition.start || condition.end) {
+		const start = condition.start ? parseTime(condition.start) : 0;
+		const end = condition.end ? parseTime(condition.end) : 24 * 3600 * 1000 - 1;
+
+		if (start <= end) {
+			return currentTime >= start && currentTime <= end;
+		}
+		// Overnight range (e.g. 22:00 -> 06:00)
+		return currentTime >= start || currentTime <= end;
+	}
+
+	return true;
+};

package/src/router/vite-plugin/index.ts

@@ -0,0 +1,2 @@
+export { solidRouterPlugin } from "./vite-plugin-core";
+export type { SolidRouterPluginOptions } from "./vite-plugin-options";

package/src/router/vite-plugin/vite-plugin-core.ts

@@ -0,0 +1,79 @@
+import type { Plugin } from "vite";
+import type { SolidRouterPluginOptions } from "./vite-plugin-options";
+
+export function solidRouterPlugin(
+	options: SolidRouterPluginOptions = {},
+): Plugin {
+	const {
+		routesDir = "src/routes",
+		routeExtensions: _routeExtensions = [".tsx", ".ts", ".jsx", ".js"],
+		autoImport: _autoImport = true,
+		devTools = true,
+		performanceMonitoring = false,
+		codeSplitting = true,
+		i18n = false,
+		featureFlags = false,
+		securityScanning = false,
+		caching = true,
+		predictivePreloading = false,
+		errorTracking = false,
+		generateTypes = true,
+		typesOutputDir = "src/types",
+		hmr = true,
+		logger,
+	} = options;
+
+	return {
+		name: "solid-framework:app-router",
+
+		config(_config, { command }) {
+			const isDev = command === "serve";
+
+			return {
+				resolve: {
+					alias: {
+						"@wrikka/solid-framework/router": new URL(
+							"../src/index.ts",
+							import.meta.url,
+						).href,
+					},
+				},
+				define: {
+					__SOLID_ROUTER_DEVTOOLS__: JSON.stringify(
+						isDev && (devTools ?? true),
+					),
+					__SOLID_ROUTER_PERFORMANCE__: JSON.stringify(performanceMonitoring),
+					__SOLID_ROUTER_CODE_SPLITTING__: JSON.stringify(codeSplitting),
+					__SOLID_ROUTER_I18N__: JSON.stringify(i18n),
+					__SOLID_ROUTER_FEATURE_FLAGS__: JSON.stringify(featureFlags),
+					__SOLID_ROUTER_SECURITY__: JSON.stringify(securityScanning),
+					__SOLID_ROUTER_CACHING__: JSON.stringify(caching),
+					__SOLID_ROUTER_PRELOADING__: JSON.stringify(predictivePreloading),
+					__SOLID_ROUTER_ERROR_TRACKING__: JSON.stringify(errorTracking),
+					__SOLID_ROUTER_HMR__: JSON.stringify(isDev && hmr),
+				},
+			};
+		},
+
+		async buildStart() {
+			if (generateTypes) {
+				logger?.log(
+					`Route types generation enabled for ${routesDir} -> ${typesOutputDir}`,
+				);
+			}
+		},
+
+		configureServer(server) {
+			if (hmr) {
+				server.watcher.on("change", async (file) => {
+					if (file.startsWith(routesDir)) {
+						server.ws.send({
+							type: "full-reload",
+							path: "*",
+						});
+					}
+				});
+			}
+		},
+	};
+}

package/src/router/vite-plugin/vite-plugin-options-advanced.ts

@@ -0,0 +1,127 @@
+import type { RouteConfig } from "../shared/types";
+
+export interface SolidRouterPluginAdvancedOptions {
+	/**
+	 * Enable caching
+	 * @default true
+	 */
+	caching?: boolean;
+
+	/**
+	 * Caching configuration
+	 */
+	cachingConfig?: {
+		/**
+		 * Cache strategy
+		 * @default "swr"
+		 */
+		strategy?: "swr" | "stale-while-revalidate" | "network-first";
+		/**
+		 * Max cache size
+		 * @default 100
+		 */
+		maxSize?: number;
+		/**
+		 * Eviction policy
+		 * @default "lru"
+		 */
+		evictionPolicy?: "lru" | "fifo" | "lfu";
+		/**
+		 * Default TTL (ms)
+		 * @default 5000
+		 */
+		defaultTtl?: number;
+	};
+
+	/**
+	 * Enable predictive preloading
+	 * @default false
+	 */
+	predictivePreloading?: boolean;
+
+	/**
+	 * Predictive preloading configuration
+	 */
+	preloadingConfig?: {
+		/**
+		 * Preload threshold (probability)
+		 * @default 0.5
+		 */
+		threshold?: number;
+		/**
+		 * Max routes to preload
+		 * @default 3
+		 */
+		maxRoutes?: number;
+		/**
+		 * History length for predictions
+		 * @default 100
+		 */
+		historyLength?: number;
+	};
+
+	/**
+	 * Enable error tracking
+	 * @default false
+	 */
+	errorTracking?: boolean;
+
+	/**
+	 * Error tracking configuration
+	 */
+	errorTrackingConfig?: {
+		/**
+		 * Error tracking endpoint
+		 */
+		endpoint?: string;
+		/**
+		 * Max errors to store
+		 * @default 1000
+		 */
+		maxErrors?: number;
+		/**
+		 * Enable error aggregation
+		 * @default true
+		 */
+		aggregation?: boolean;
+	};
+
+	/**
+	 * Custom routes
+	 */
+	routes?: RouteConfig[];
+
+	/**
+	 * Generate TypeScript types for routes
+	 * @default true
+	 */
+	generateTypes?: boolean;
+
+	/**
+	 * Output directory for generated types
+	 * @default "src/types"
+	 */
+	typesOutputDir?: string;
+
+	/**
+	 * Enable HMR for routes
+	 * @default true
+	 */
+	hmr?: boolean;
+
+	/**
+	 * HMR configuration
+	 */
+	hmrConfig?: {
+		/**
+		 * Enable overlay
+		 * @default true
+		 */
+		overlay?: boolean;
+		/**
+		 * HMR timeout (ms)
+		 * @default 1000
+		 */
+		timeout?: number;
+	};
+}

package/src/router/vite-plugin/vite-plugin-options-features.ts

@@ -0,0 +1,117 @@
+export interface SolidRouterPluginFeatureOptions {
+	/**
+	 * Enable code splitting
+	 * @default true
+	 */
+	codeSplitting?: boolean;
+
+	/**
+	 * Code splitting configuration
+	 */
+	codeSplittingConfig?: {
+		/**
+		 * Splitting strategy
+		 * @default "auto"
+		 */
+		strategy?: "auto" | "manual" | "aggressive";
+		/**
+		 * Enable device-specific splitting
+		 * @default false
+		 */
+		deviceSpecific?: boolean;
+		/**
+		 * Bundle size threshold for splitting (KB)
+		 * @default 100
+		 */
+		bundleSizeThreshold?: number;
+	};
+
+	/**
+	 * Enable i18n support
+	 * @default false
+	 */
+	i18n?: boolean;
+
+	/**
+	 * i18n configuration
+	 */
+	i18nConfig?: {
+		/**
+		 * Default locale
+		 * @default "en"
+		 */
+		defaultLocale?: string;
+		/**
+		 * Supported locales
+		 */
+		supportedLocales?: string[];
+		/**
+		 * Locale detection methods
+		 * @default ["path", "header"]
+		 */
+		detection?: Array<"path" | "header" | "cookie" | "query">;
+		/**
+		 * Directory containing locale files
+		 * @default "src/locales"
+		 */
+		localesDir?: string;
+	};
+
+	/**
+	 * Enable feature flags
+	 * @default false
+	 */
+	featureFlags?: boolean;
+
+	/**
+	 * Feature flags configuration
+	 */
+	featureFlagsConfig?: {
+		/**
+		 * API endpoint for feature flags
+		 */
+		apiEndpoint?: string;
+		/**
+		 * Enable local feature flags
+		 * @default true
+		 */
+		localFlags?: boolean;
+		/**
+		 * Enable audit logging
+		 * @default false
+		 */
+		auditLogging?: boolean;
+	};
+
+	/**
+	 * Enable security scanning
+	 * @default false
+	 */
+	securityScanning?: boolean;
+
+	/**
+	 * Security scanning configuration
+	 */
+	securityConfig?: {
+		/**
+		 * Enable specific security rules
+		 */
+		rules?: Array<
+			| "open-redirect"
+			| "path-traversal"
+			| "missing-auth"
+			| "sensitive-data"
+			| "parameter-injection"
+		>;
+		/**
+		 * Severity threshold for reporting
+		 * @default "medium"
+		 */
+		severityThreshold?: "low" | "medium" | "high";
+		/**
+		 * Auto-fix issues
+		 * @default false
+		 */
+		autoFix?: boolean;
+	};
+}

package/src/router/vite-plugin/vite-plugin-options-routing.ts

@@ -0,0 +1,70 @@
+export interface SolidRouterPluginRoutingOptions {
+	/**
+	 * Directory containing route files
+	 * @default "src/routes"
+	 */
+	routesDir?: string;
+
+	/**
+	 * File extensions to scan for routes
+	 * @default [".tsx", ".ts", ".jsx", ".js"]
+	 */
+	routeExtensions?: string[];
+
+	/**
+	 * Enable auto-import of router components
+	 * @default true
+	 */
+	autoImport?: boolean;
+
+	/**
+	 * Auto-import configuration
+	 */
+	autoImportConfig?: {
+		/**
+		 * Components to auto-import
+		 */
+		components?: string[];
+		/**
+		 * Composables to auto-import
+		 */
+		composables?: string[];
+		/**
+		 * Directories to scan for auto-imports
+		 */
+		dirs?: string[];
+	};
+
+	/**
+	 * Enable DevTools integration
+	 * @default true in development
+	 */
+	devTools?: boolean;
+
+	/**
+	 * Enable performance monitoring
+	 * @default false
+	 */
+	performanceMonitoring?: boolean;
+
+	/**
+	 * Performance monitoring configuration
+	 */
+	performanceConfig?: {
+		/**
+		 * Threshold for slow load time (ms)
+		 * @default 1000
+		 */
+		slowLoadThreshold?: number;
+		/**
+		 * Threshold for slow render time (ms)
+		 * @default 500
+		 */
+		slowRenderThreshold?: number;
+		/**
+		 * Enable performance alerts
+		 * @default true
+		 */
+		alerts?: boolean;
+	};
+}

package/src/router/vite-plugin/vite-plugin-options.ts

@@ -0,0 +1,23 @@
+import type { SolidRouterPluginAdvancedOptions } from "./vite-plugin-options-advanced";
+import type { SolidRouterPluginFeatureOptions } from "./vite-plugin-options-features";
+import type { SolidRouterPluginRoutingOptions } from "./vite-plugin-options-routing";
+
+export interface PluginLogger {
+	log: (message: string) => void;
+}
+
+export interface SolidRouterPluginOptions
+	extends SolidRouterPluginRoutingOptions,
+		SolidRouterPluginFeatureOptions,
+		SolidRouterPluginAdvancedOptions {
+	/**
+	 * Optional logger for plugin messages. When omitted, plugin logs are silent.
+	 */
+	logger?: PluginLogger;
+}
+
+export type {
+	SolidRouterPluginAdvancedOptions,
+	SolidRouterPluginFeatureOptions,
+	SolidRouterPluginRoutingOptions,
+};

package/src/server/adapters/index.ts

@@ -0,0 +1,2 @@
+export * from "./platforms";
+export * from "./web-server";