@wrikka/solid-framework 0.0.0-stage → 0.15.0

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

@@ -0,0 +1,85 @@
+export type Locale = string;
+export type LocaleMap = Record<Locale, string>;
+
+export interface LocaleConfig {
+	readonly defaultLocale: Locale;
+	readonly supportedLocales: readonly Locale[];
+	readonly localeDetection: "path" | "subdomain" | "header" | "cookie";
+	readonly localeCookieName?: string;
+	readonly localeHeaderName?: string;
+}
+
+export interface RouteTranslation {
+	readonly path: string;
+	readonly translations: LocaleMap;
+}
+
+export type I18nState = {
+	readonly config: LocaleConfig;
+	readonly routeTranslations: Readonly<Record<string, RouteTranslation>>;
+	readonly currentLocale: Locale;
+};
+
+// Pure function to create initial i18n state
+export const createI18nState = (config: LocaleConfig): I18nState => {
+	return Object.freeze({
+		config,
+		routeTranslations: Object.freeze({}),
+		currentLocale: config.defaultLocale,
+	});
+};
+
+// Pure function to set locale
+export const setLocale = (state: I18nState, locale: Locale): I18nState => {
+	if (!state.config.supportedLocales.includes(locale)) {
+		return state;
+	}
+
+	return {
+		...state,
+		currentLocale: locale,
+	};
+};
+
+// Pure function to add route translation
+export const addRouteTranslation = (
+	state: I18nState,
+	translation: RouteTranslation,
+): I18nState => {
+	return {
+		...state,
+		routeTranslations: {
+			...state.routeTranslations,
+			[translation.path]: translation,
+		},
+	};
+};
+
+// Pure function to create locale config
+export const createLocaleConfig = (
+	defaultLocale: Locale,
+	supportedLocales: Locale[],
+	options: Partial<LocaleConfig> = {},
+): LocaleConfig => {
+	const config: LocaleConfig = {
+		defaultLocale,
+		supportedLocales,
+		localeDetection: options.localeDetection || "path",
+		...(options.localeCookieName !== undefined && {
+			localeCookieName: options.localeCookieName,
+		}),
+		...(options.localeHeaderName !== undefined && {
+			localeHeaderName: options.localeHeaderName,
+		}),
+	};
+
+	return Object.freeze(config);
+};
+
+// Pure function to create route translation
+export const createRouteTranslation = (
+	path: string,
+	translations: LocaleMap,
+): RouteTranslation => {
+	return Object.freeze({ path, translations });
+};

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

@@ -0,0 +1,201 @@
+import type { I18nState, Locale } from "../models";
+
+// Pure function to get current locale
+export const getLocale = (state: I18nState): Locale => {
+	return state.currentLocale;
+};
+
+// Pure function to get default locale
+export const getDefaultLocale = (state: I18nState): Locale => {
+	return state.config.defaultLocale;
+};
+
+// Pure function to get supported locales
+export const getSupportedLocales = (state: I18nState): readonly Locale[] => {
+	return state.config.supportedLocales;
+};
+
+// Pure function to detect locale from path
+export const detectFromPath = (state: I18nState, path: string): Locale => {
+	const segments = path.split("/").filter(Boolean);
+	if (segments.length > 0) {
+		const potentialLocale = segments[0];
+		if (state.config.supportedLocales.includes(potentialLocale)) {
+			return potentialLocale;
+		}
+	}
+	return state.config.defaultLocale;
+};
+
+// Pure function to detect locale from header
+export const detectFromHeader = (
+	state: I18nState,
+	headers?: Record<string, string>,
+): Locale => {
+	if (!headers) return state.config.defaultLocale;
+
+	const acceptLanguage =
+		headers[state.config.localeHeaderName || "accept-language"];
+	if (!acceptLanguage) return state.config.defaultLocale;
+
+	const locales = acceptLanguage
+		.split(",")
+		.map((lang) => lang.split(";")[0].trim());
+
+	for (const locale of locales) {
+		if (state.config.supportedLocales.includes(locale)) {
+			return locale;
+		}
+	}
+
+	return state.config.defaultLocale;
+};
+
+// Pure function to detect locale from cookie
+export const detectFromCookie = (
+	state: I18nState,
+	headers?: Record<string, string>,
+): Locale => {
+	if (!headers || !state.config.localeCookieName)
+		return state.config.defaultLocale;
+
+	const cookie = headers.cookie;
+	if (!cookie) return state.config.defaultLocale;
+
+	const cookies = cookie.split(";").map((c) => c.trim());
+	for (const c of cookies) {
+		const [name, value] = c.split("=");
+		if (name === state.config.localeCookieName) {
+			const locale = value;
+			if (state.config.supportedLocales.includes(locale)) {
+				return locale;
+			}
+		}
+	}
+
+	return state.config.defaultLocale;
+};
+
+// Pure function to detect locale from subdomain
+export const detectFromSubdomain = (
+	state: I18nState,
+	_path: string,
+): Locale => {
+	// This would typically be handled at the server level
+	// For now, return default locale
+	return state.config.defaultLocale;
+};
+
+// Pure function to detect locale based on config
+export const detectLocale = (
+	state: I18nState,
+	path: string,
+	headers?: Record<string, string>,
+): Locale => {
+	switch (state.config.localeDetection) {
+		case "path":
+			return detectFromPath(state, path);
+		case "header":
+			return detectFromHeader(state, headers);
+		case "cookie":
+			return detectFromCookie(state, headers);
+		case "subdomain":
+			return detectFromSubdomain(state, path);
+		default:
+			return state.config.defaultLocale;
+	}
+};
+
+// Pure function to get route translation
+export const getRouteTranslation = (
+	state: I18nState,
+	path: string,
+	locale: Locale,
+): string | undefined => {
+	const translation = state.routeTranslations[path];
+	if (!translation) return undefined;
+
+	return translation.translations[locale];
+};
+
+// Pure function to localize path
+export const localizePath = (
+	state: I18nState,
+	path: string,
+	locale: Locale,
+): string => {
+	// Remove existing locale prefix if present
+	const segments = path.split("/").filter(Boolean);
+	if (
+		segments.length > 0 &&
+		state.config.supportedLocales.includes(segments[0])
+	) {
+		segments.shift();
+	}
+
+	// Add new locale prefix
+	return `/${locale}/${segments.join("/")}`;
+};
+
+// Pure function to delocalize path
+export const delocalizePath = (state: I18nState, path: string): string => {
+	const segments = path.split("/").filter(Boolean);
+	if (
+		segments.length > 0 &&
+		state.config.supportedLocales.includes(segments[0])
+	) {
+		segments.shift();
+	}
+	return `/${segments.join("/")}`;
+};
+
+// Pure function to get localized routes
+export const getLocalizedRoutes = (
+	state: I18nState,
+	routes: import("../../../../shared/types").RouteConfig[],
+	locale: Locale,
+): import("../../../../shared/types").RouteConfig[] => {
+	return routes.map((route) => {
+		const translatedPath = getRouteTranslation(state, route.path, locale);
+		const localizedPath =
+			translatedPath || localizePath(state, route.path, locale);
+
+		return {
+			...route,
+			path: localizedPath,
+		};
+	});
+};
+
+// Pure function to get all locale paths
+export const getAllLocalePaths = (
+	state: I18nState,
+	path: string,
+): Record<string, string> => {
+	const translations: Record<string, string> = {};
+
+	for (const locale of state.config.supportedLocales) {
+		const translatedPath = getRouteTranslation(state, path, locale);
+		translations[locale] = translatedPath || localizePath(state, path, locale);
+	}
+
+	return translations;
+};
+
+// Pure function to format route with params
+export const formatRoute = (
+	state: I18nState,
+	path: string,
+	params: Record<string, string>,
+	locale?: Locale,
+): string => {
+	const targetLocale = locale || state.currentLocale;
+	let localizedPath = localizePath(state, path, targetLocale);
+
+	// Replace params
+	for (const [key, value] of Object.entries(params)) {
+		localizedPath = localizedPath.replace(`:${key}`, value);
+	}
+
+	return localizedPath;
+};

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

@@ -0,0 +1,43 @@
+import type { LocaleConfig } from "../models";
+
+export const validateLocale = (locale: string): boolean => {
+	return (
+		typeof locale === "string" && locale.length >= 2 && locale.length <= 10
+	);
+};
+
+export const validateLocaleCode = (locale: string): boolean => {
+	// Validate locale code format (e.g., "en", "en-US", "th-TH")
+	const localeRegex = /^[a-z]{2}(-[A-Z]{2})?$/i;
+	return localeRegex.test(locale);
+};
+
+export const validateLocaleConfig = (config: LocaleConfig): boolean => {
+	if (!config.defaultLocale || !validateLocale(config.defaultLocale)) {
+		return false;
+	}
+
+	if (
+		!Array.isArray(config.supportedLocales) ||
+		config.supportedLocales.length === 0
+	) {
+		return false;
+	}
+
+	if (!config.supportedLocales.includes(config.defaultLocale)) {
+		return false;
+	}
+
+	const validDetectionMethods = ["path", "subdomain", "header", "cookie"];
+	if (!validDetectionMethods.includes(config.localeDetection)) {
+		return false;
+	}
+
+	return true;
+};
+
+export const validatePath = (path: string): boolean => {
+	if (!path || typeof path !== "string") return false;
+	if (!path.startsWith("/")) return false;
+	return true;
+};

package/src/router/modules/route-i18n/index.ts

@@ -0,0 +1,8 @@
+// Public API exports for route-i18n 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-i18n/ports/index.ts

@@ -0,0 +1,20 @@
+import type { Locale } from "../types";
+
+// Port for locale storage (dependency injection point)
+export interface ILocaleStorage {
+	getLocale(): Locale;
+	setLocale(locale: Locale): void;
+}
+
+// Port for translation storage (dependency injection point)
+export interface ITranslationStorage {
+	getTranslations(path: string): Record<string, string> | undefined;
+	setTranslations(path: string, translations: Record<string, string>): void;
+}
+
+// Port for locale detection (dependency injection point)
+export interface ILocaleDetector {
+	detectFromPath(path: string): Locale;
+	detectFromHeader(headers: Record<string, string>): Locale;
+	detectFromCookie(headers: Record<string, string>): Locale;
+}

package/src/router/modules/route-i18n/types/index.ts

@@ -0,0 +1,7 @@
+export type {
+	I18nState,
+	Locale,
+	LocaleConfig,
+	LocaleMap,
+	RouteTranslation,
+} from "../domain/models";

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

@@ -0,0 +1,182 @@
+import {
+	clearEvents,
+	createNavigationTimelineState,
+	recordNavigation,
+	setMaxEvents,
+	startRecording,
+	stopRecording,
+} from "../../domain";
+import {
+	exportTimeline,
+	exportTimelineAsJSON,
+	getAverageNavigationTime,
+	getEvents,
+	getEventsByPath,
+	getEventsByType,
+	getEventsInTimeRange,
+	getMostVisitedPaths,
+	getNavigationCount,
+	getNavigationPattern,
+	getUniquePaths,
+	isRecordingStatus,
+	recordNavigationEvent,
+} from "../../domain/operations";
+import type {
+	NavigationTimelineState,
+	TimelineEvent,
+	TimelineSnapshot,
+} from "../../types";
+
+// Use case: Start recording
+export const startRecordingUseCase = (
+	state: NavigationTimelineState,
+	now: number,
+): NavigationTimelineState => {
+	return startRecording(state, now);
+};
+
+// Use case: Stop recording
+export const stopRecordingUseCase = (
+	state: NavigationTimelineState,
+	now: number,
+): {
+	readonly state: NavigationTimelineState;
+	readonly snapshot: TimelineSnapshot;
+} => {
+	return stopRecording(state, now);
+};
+
+// Use case: Record navigation
+export const recordNavigationUseCase = (
+	state: NavigationTimelineState,
+	type: TimelineEvent["type"],
+	path: string,
+	now: number,
+	params?: Record<string, string>,
+	searchParams?: Record<string, unknown>,
+): NavigationTimelineState => {
+	return recordNavigation(state, type, path, now, params, searchParams);
+};
+
+// Use case: Record navigation event
+export const recordNavigationEventUseCase = (
+	state: NavigationTimelineState,
+	event: import("../../../../shared/types").NavigationEvent,
+	now: number,
+): NavigationTimelineState => {
+	return recordNavigationEvent(state, event, now);
+};
+
+// Use case: Get events
+export const getEventsUseCase = (
+	state: NavigationTimelineState,
+): readonly TimelineEvent[] => {
+	return getEvents(state);
+};
+
+// Use case: Get events by type
+export const getEventsByTypeUseCase = (
+	state: NavigationTimelineState,
+	type: TimelineEvent["type"],
+): readonly TimelineEvent[] => {
+	return getEventsByType(state, type);
+};
+
+// Use case: Get events by path
+export const getEventsByPathUseCase = (
+	state: NavigationTimelineState,
+	path: string,
+): readonly TimelineEvent[] => {
+	return getEventsByPath(state, path);
+};
+
+// Use case: Get events in time range
+export const getEventsInTimeRangeUseCase = (
+	state: NavigationTimelineState,
+	startTime: number,
+	endTime: number,
+): readonly TimelineEvent[] => {
+	return getEventsInTimeRange(state, startTime, endTime);
+};
+
+// Use case: Get navigation count
+export const getNavigationCountUseCase = (
+	state: NavigationTimelineState,
+): number => {
+	return getNavigationCount(state);
+};
+
+// Use case: Get unique paths
+export const getUniquePathsUseCase = (
+	state: NavigationTimelineState,
+): readonly string[] => {
+	return getUniquePaths(state);
+};
+
+// Use case: Get most visited paths
+export const getMostVisitedPathsUseCase = (
+	state: NavigationTimelineState,
+	limit = 10,
+): readonly {
+	readonly path: string;
+	readonly count: number;
+}[] => {
+	return getMostVisitedPaths(state, limit);
+};
+
+// Use case: Get average navigation time
+export const getAverageNavigationTimeUseCase = (
+	state: NavigationTimelineState,
+): number => {
+	return getAverageNavigationTime(state);
+};
+
+// Use case: Get navigation pattern
+export const getNavigationPatternUseCase = (
+	state: NavigationTimelineState,
+): string => {
+	return getNavigationPattern(state);
+};
+
+// Use case: Export timeline
+export const exportTimelineUseCase = (
+	state: NavigationTimelineState,
+): string => {
+	return exportTimeline(state);
+};
+
+// Use case: Export timeline as JSON
+export const exportTimelineAsJSONUseCase = (
+	state: NavigationTimelineState,
+): string => {
+	return exportTimelineAsJSON(state);
+};
+
+// Use case: Check recording status
+export const isRecordingStatusUseCase = (
+	state: NavigationTimelineState,
+): boolean => {
+	return isRecordingStatus(state);
+};
+
+// Use case: Set max events
+export const setMaxEventsUseCase = (
+	state: NavigationTimelineState,
+	max: number,
+): NavigationTimelineState => {
+	return setMaxEvents(state, max);
+};
+
+// Use case: Clear events
+export const clearEventsUseCase = (
+	state: NavigationTimelineState,
+): NavigationTimelineState => {
+	return clearEvents(state);
+};
+
+// Use case: Create navigation timeline state
+export const createNavigationTimelineStateUseCase = (
+	maxEvents = 1000,
+): NavigationTimelineState => {
+	return createNavigationTimelineState(maxEvents);
+};

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

@@ -0,0 +1,5 @@
+// Domain layer exports
+
+export * from "./models";
+export * from "./operations";
+export * from "./validators";

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

@@ -0,0 +1,143 @@
+export interface TimelineEvent {
+	readonly timestamp: number;
+	readonly type: "navigate" | "back" | "forward" | "replace";
+	readonly path: string;
+	readonly params?: Readonly<Record<string, string>>;
+	readonly searchParams?: Readonly<Record<string, unknown>>;
+	readonly duration?: number;
+}
+
+export interface TimelineSnapshot {
+	readonly events: readonly TimelineEvent[];
+	readonly startTime: number;
+	readonly endTime: number;
+	readonly totalNavigations: number;
+}
+
+export type NavigationTimelineState = {
+	readonly events: readonly TimelineEvent[];
+	readonly startTime: number;
+	readonly isRecording: boolean;
+	readonly maxEvents: number;
+};
+
+// Pure function to create initial navigation timeline state
+export const createNavigationTimelineState = (
+	maxEvents = 1000,
+): NavigationTimelineState => {
+	return Object.freeze({
+		events: Object.freeze([]),
+		startTime: 0,
+		isRecording: false,
+		maxEvents,
+	});
+};
+
+// Pure function to create timeline event
+export const createTimelineEvent = (
+	type: TimelineEvent["type"],
+	path: string,
+	now: number,
+	params?: Record<string, string>,
+	searchParams?: Record<string, unknown>,
+): TimelineEvent => {
+	return Object.freeze({
+		timestamp: now,
+		type,
+		path,
+		...(params !== undefined && { params: Object.freeze(params) }),
+		...(searchParams !== undefined && {
+			searchParams: Object.freeze(searchParams),
+		}),
+	});
+};
+
+// Pure function to start recording
+export const startRecording = (
+	state: NavigationTimelineState,
+	now: number,
+): NavigationTimelineState => {
+	return Object.freeze({
+		...state,
+		events: Object.freeze([]),
+		startTime: now,
+		isRecording: true,
+	});
+};
+
+// Pure function to stop recording
+export const stopRecording = (
+	state: NavigationTimelineState,
+	now: number,
+): {
+	readonly state: NavigationTimelineState;
+	readonly snapshot: TimelineSnapshot;
+} => {
+	const newState = {
+		...state,
+		isRecording: false,
+	};
+
+	const snapshot: TimelineSnapshot = {
+		events: state.events,
+		startTime: state.startTime,
+		endTime: now,
+		totalNavigations: state.events.length,
+	};
+
+	return {
+		state: Object.freeze(newState),
+		snapshot: Object.freeze(snapshot),
+	};
+};
+
+// Pure function to record navigation
+export const recordNavigation = (
+	state: NavigationTimelineState,
+	type: TimelineEvent["type"],
+	path: string,
+	now: number,
+	params?: Record<string, string>,
+	searchParams?: Record<string, unknown>,
+): NavigationTimelineState => {
+	if (!state.isRecording) return state;
+
+	const event = createTimelineEvent(type, path, now, params, searchParams);
+	const newEvents = [...state.events, event];
+
+	// Keep only last maxEvents
+	const trimmedEvents =
+		newEvents.length > state.maxEvents
+			? newEvents.slice(-state.maxEvents)
+			: newEvents;
+
+	return {
+		...state,
+		events: Object.freeze(trimmedEvents),
+	};
+};
+
+// Pure function to set max events
+export const setMaxEvents = (
+	state: NavigationTimelineState,
+	max: number,
+): NavigationTimelineState => {
+	const trimmedEvents =
+		state.events.length > max ? state.events.slice(-max) : state.events;
+
+	return {
+		...state,
+		events: Object.freeze(trimmedEvents),
+		maxEvents: max,
+	};
+};
+
+// Pure function to clear events
+export const clearEvents = (
+	state: NavigationTimelineState,
+): NavigationTimelineState => {
+	return {
+		...state,
+		events: Object.freeze([]),
+	};
+};