@lovrozagar/flare 0.1.0

package/src/hydration/index.ts

@@ -0,0 +1,187 @@
+import { batch } from "solid-js";
+import type { GlobalBoundaries } from "../boundaries/index.ts";
+import type { CachedMatch, MatchCache } from "../caches/index.ts";
+import { applyPerRouteHeads, initRouteHierarchy } from "../head-client/index.ts";
+import { isRenderFn, retryImport } from "../internal.ts";
+import type { LoadedRouteModule, LoadedRouteModules } from "../navigation/types.ts";
+import type { ClientMatch, FlareProviderContext } from "../outlet/types.ts";
+import type { HeadConfig } from "../route-builder/types.ts";
+import { computeMatchId, deriveLayouts, matchRoute, toLocaleMatch } from "../router-primitives/index.ts";
+import type { MatchResult, TreeNode } from "../router-primitives/types.ts";
+import type { LocaleConfig } from "../locale.ts";
+import { parseSearchParams, type SearchParams } from "../url/index.ts";
+
+export async function loadRouteModules(
+	pathname: string,
+	routeTree: TreeNode,
+	layouts: Record<string, () => Promise<{ default: unknown }>>,
+	caseSensitive?: boolean,
+	localeConfig?: LocaleConfig,
+): Promise<LoadedRouteModules | null> {
+	const match: MatchResult | null = matchRoute(routeTree, pathname, caseSensitive, toLocaleMatch(localeConfig));
+	if (!match) return null;
+
+	const layoutKeys = deriveLayouts(match.route.x);
+
+	const promises: Promise<{ default: unknown } | null>[] = [
+		retryImport(() => match.route.p() as Promise<{ default: unknown }>),
+		...layoutKeys.map((key) => {
+			const loader = layouts[key];
+			if (!loader) return Promise.resolve(null);
+			return retryImport(() => loader());
+		}),
+	];
+
+	const [pageResult, ...layoutResults] = await Promise.all(promises);
+
+	const rawPage = (pageResult?.default ?? pageResult) as LoadedRouteModule;
+	const page: LoadedRouteModule = { ...rawPage, variablePath: match.route.v };
+	const loadedLayouts: LoadedRouteModule[] = layoutResults
+		.filter((r): r is { default: unknown } => r !== null)
+		.map((r) => {
+			const raw = (r.default ?? r) as LoadedRouteModule;
+			return { ...raw, variablePath: "" };
+		});
+
+	return {
+		layouts: loadedLayouts,
+		page,
+		params: match.params,
+	};
+}
+
+export function buildMatches(ctx: FlareProviderContext, modules: LoadedRouteModules): void {
+	const search: SearchParams =
+		typeof window !== "undefined" ? parseSearchParams(new URL(window.location.href).searchParams) : {};
+	const allModules: LoadedRouteModule[] = [...modules.layouts, modules.page];
+
+	const clientMatches: ClientMatch[] = allModules.map((mod) => {
+		const deps = mod.effectsConfig?.loaderDeps?.({ search }) ?? [];
+		const matchId = computeMatchId({
+			loaderDeps: () => deps,
+			params: modules.params,
+			routeId: mod.virtualPath,
+			search,
+		});
+		const cached: CachedMatch | undefined = ctx.matchCache.get(matchId);
+
+		return {
+			_type: mod._type,
+			error: cached?.error,
+			errorRender: isRenderFn(mod.errorRender) ? mod.errorRender : undefined,
+			loaderData: cached?.data,
+			notFoundRender: isRenderFn(mod.notFoundRender) ? mod.notFoundRender : undefined,
+			preloaderContext: cached?.preloaderContext,
+			render: mod.render,
+			unauthenticatedRender: isRenderFn(mod.unauthenticatedRender) ? mod.unauthenticatedRender : undefined,
+			unauthorizedRender: isRenderFn(mod.unauthorizedRender) ? mod.unauthorizedRender : undefined,
+			variablePath: mod.variablePath,
+			virtualPath: mod.virtualPath,
+		};
+	});
+
+	batch(() => {
+		ctx.setMatches(clientMatches);
+		ctx.setParams(modules.params);
+	});
+}
+
+export function extractRootBoundaries(rootLayout: LoadedRouteModule | undefined): GlobalBoundaries {
+	const boundaries: GlobalBoundaries = {};
+	if (!rootLayout) return boundaries;
+	if (isRenderFn(rootLayout.errorRender)) boundaries.error = rootLayout.errorRender;
+	if (isRenderFn(rootLayout.notFoundRender)) boundaries.notFound = rootLayout.notFoundRender;
+	if (isRenderFn(rootLayout.unauthenticatedRender)) {
+		boundaries.unauthenticated = rootLayout.unauthenticatedRender;
+	}
+	if (isRenderFn(rootLayout.unauthorizedRender)) {
+		boundaries.unauthorized = rootLayout.unauthorizedRender;
+	}
+	return boundaries;
+}
+
+export function buildInitialMatches(
+	modules: LoadedRouteModule[],
+	matchCache: MatchCache,
+	params: Record<string, string | string[]>,
+	search: SearchParams,
+	errorMap?: Map<string, Error>,
+): ClientMatch[] {
+	return modules.map((mod) => {
+		const deps = mod.effectsConfig?.loaderDeps?.({ search }) ?? [];
+		const matchId = computeMatchId({
+			loaderDeps: () => deps,
+			params,
+			routeId: mod.virtualPath,
+			search,
+		});
+		const cached = matchCache.get(matchId);
+		return {
+			_type: mod._type,
+			error: errorMap?.get(mod.virtualPath),
+			errorRender: isRenderFn(mod.errorRender) ? mod.errorRender : undefined,
+			loaderData: cached?.data,
+			notFoundRender: isRenderFn(mod.notFoundRender) ? mod.notFoundRender : undefined,
+			preloaderContext: cached?.preloaderContext,
+			render: mod.render,
+			unauthenticatedRender: isRenderFn(mod.unauthenticatedRender) ? mod.unauthenticatedRender : undefined,
+			unauthorizedRender: isRenderFn(mod.unauthorizedRender) ? mod.unauthorizedRender : undefined,
+			variablePath: mod.variablePath,
+			virtualPath: mod.virtualPath,
+		};
+	});
+}
+
+export interface HydrationState {
+	e?: Array<{ message: string; name: string; source?: string; stack?: string }>;
+	matches: Array<{
+		loaderData: unknown;
+		matchId: string;
+		preloaderContext?: Record<string, unknown>;
+	}>;
+	params: Record<string, string | string[]>;
+	pathname: string;
+	ph?: Array<{ head: HeadConfig; matchId: string }>;
+	q?: Array<{ data: unknown; key: unknown[]; staleTime?: number }>;
+	resolvers: Map<string, { reject: (e: Error) => void; resolve: (d: unknown) => void }>;
+	search: SearchParams;
+}
+
+export function populateMatchCache(
+	matchCache: MatchCache,
+	matches: HydrationState["matches"],
+	perRouteHeads?: HydrationState["ph"],
+): void {
+	const headMap = new Map<string, HeadConfig>();
+	if (perRouteHeads) {
+		for (const h of perRouteHeads) {
+			headMap.set(h.matchId, h.head);
+		}
+	}
+	const now = Date.now();
+	for (const m of matches) {
+		matchCache.set({
+			data: m.loaderData,
+			headConfig: headMap.get(m.matchId),
+			invalid: false,
+			matchId: m.matchId,
+			preloaderContext: m.preloaderContext,
+			updatedAt: now,
+		});
+	}
+}
+
+export function hydrateHeadState(state: Pick<HydrationState, "ph">): void {
+	if (state.ph) {
+		/* First entry is root layout — its title is the fallback when pages don't define .head() */
+		const rootTitle = state.ph[0]?.head.title;
+		const matchIds: string[] = [];
+		const headEntries: Array<{ head: (typeof state.ph)[number]["head"]; matchId: string }> = [];
+		for (const h of state.ph) {
+			matchIds.push(h.matchId);
+			headEntries.push({ head: h.head, matchId: h.matchId });
+		}
+		initRouteHierarchy(matchIds, rootTitle);
+		applyPerRouteHeads(headEntries);
+	}
+}

package/src/i18n/index.ts

@@ -0,0 +1,250 @@
+import { parseRichText } from "./jsx.tsx";
+import { formatMessage } from "./message-format.ts";
+
+export { parseRichText } from "./jsx.tsx";
+export { formatMessage } from "./message-format.ts";
+
+/* ── createTranslations ────────────────────────────────────────────── */
+
+type TranslationDict = Record<string, string>;
+
+/**
+ * Static import: () => import("./en/common.json")  → { default: T }
+ * Dynamic fetch: () => fetchTranslations("en", "common") → T directly
+ */
+type TranslationLoader<T extends TranslationDict = TranslationDict> =
+	| (() => Promise<T>)
+	| (() => Promise<{ default: T }>);
+
+type TranslationNamespaces = Record<string, Record<string, TranslationLoader>>;
+
+/**
+ * Extract the resolved dict type for a namespace.
+ * Unwraps both { default: D } (static import) and D (dynamic fetch).
+ */
+type UnwrapLoader<TLoader> = TLoader extends () => Promise<{ default: infer D }>
+	? D
+	: TLoader extends () => Promise<infer D>
+		? D
+		: TranslationDict;
+
+type ResolvedDict<TLoaders extends Record<string, TranslationLoader>> = UnwrapLoader<TLoaders[keyof TLoaders]>;
+
+type LoadResult<T extends TranslationNamespaces, K extends keyof T & string> = {
+	[N in K]: ResolvedDict<T[N]>;
+};
+
+interface TranslationsConfig<T extends TranslationNamespaces> {
+	load: <K extends keyof T & string>(locale: string, namespaces: K[]) => Promise<LoadResult<T, K>>;
+}
+
+function unwrapModule(mod: unknown): TranslationDict {
+	if (
+		mod !== null &&
+		typeof mod === "object" &&
+		"default" in (mod as Record<string, unknown>) &&
+		typeof (mod as Record<string, unknown>).default === "object"
+	) {
+		return (mod as { default: TranslationDict }).default;
+	}
+	return mod as TranslationDict;
+}
+
+export function createTranslations<const T extends TranslationNamespaces>(namespaces: T): TranslationsConfig<T> {
+	return {
+		async load<K extends keyof T & string>(locale: string, nsKeys: K[]): Promise<LoadResult<T, K>> {
+			const entries = await Promise.all(
+				nsKeys.map(async (ns) => {
+					const loaders = namespaces[ns];
+					if (!loaders) throw new Error(`Unknown namespace: ${ns}`);
+					const loader = loaders[locale];
+					if (!loader) throw new Error(`Missing locale "${locale}" for namespace "${ns}"`);
+					const result = await loader();
+					return [ns, unwrapModule(result)] as const;
+				}),
+			);
+
+			return Object.fromEntries(entries) as LoadResult<T, K>;
+		},
+	};
+}
+
+/* ── createTranslator ──────────────────────────────────────────────── */
+
+type PrefixKeys<
+	T extends Record<string, Record<string, string>>,
+	NS extends keyof T & string,
+> = `${NS}.${string & keyof T[NS]}`;
+
+export type FlatKeys<T extends Record<string, Record<string, string>>> = [T] extends [never]
+	? never
+	: {
+			[NS in keyof T & string]: PrefixKeys<T, NS>;
+		}[keyof T & string];
+
+/** Extract `t` property from loader data or preloader context */
+export type ExtractT<TData> = TData extends {
+	t: infer T extends Record<string, Record<string, string>>;
+}
+	? T
+	: never;
+
+/* ── ICU variable extraction (type-level) ─────────────────────────── */
+
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type Alpha =
+	| "A"
+	| "B"
+	| "C"
+	| "D"
+	| "E"
+	| "F"
+	| "G"
+	| "H"
+	| "I"
+	| "J"
+	| "K"
+	| "L"
+	| "M"
+	| "N"
+	| "O"
+	| "P"
+	| "Q"
+	| "R"
+	| "S"
+	| "T"
+	| "U"
+	| "V"
+	| "W"
+	| "X"
+	| "Y"
+	| "Z"
+	| "a"
+	| "b"
+	| "c"
+	| "d"
+	| "e"
+	| "f"
+	| "g"
+	| "h"
+	| "i"
+	| "j"
+	| "k"
+	| "l"
+	| "m"
+	| "n"
+	| "o"
+	| "p"
+	| "q"
+	| "r"
+	| "s"
+	| "t"
+	| "u"
+	| "v"
+	| "w"
+	| "x"
+	| "y"
+	| "z";
+type WordChar = Alpha | Digit | "_";
+
+type EndsWithWordChar<S extends string> = S extends `${string}${WordChar}` ? true : false;
+
+type IsIdent<S extends string> = S extends `${Alpha | "_"}${string}`
+	? S extends `${string} ${string}`
+		? false
+		: true
+	: false;
+
+/**
+ * Extract ICU variable names from a template string at the type level.
+ * Handles `{var}`, `{var, plural, ...}`, `{var, select, ...}`, `{var, number}`.
+ * Filters out branch content (e.g. `one{# item}`) by checking if `{` is
+ * preceded by a word character (ICU branch syntax, not a variable reference).
+ */
+export type ExtractICUVars<S extends string> = S extends `${infer Before}{${infer After}`
+	?
+			| (EndsWithWordChar<Before> extends true
+					? never
+					: After extends `${infer Word},${string}`
+						? Word extends `${infer Clean}}${string}`
+							? IsIdent<Clean> extends true
+								? Clean
+								: never
+							: IsIdent<Word> extends true
+								? Word
+								: never
+						: After extends `${infer Word}}${string}`
+							? IsIdent<Word> extends true
+								? Word
+								: never
+							: never)
+			| ExtractICUVars<After>
+	: never;
+
+/** Resolve flat key `"ns.key"` back to the template string type */
+type LookupTemplate<
+	TDict extends Record<string, Record<string, string>>,
+	K extends string,
+> = K extends `${infer NS}.${infer Key}`
+	? NS extends keyof TDict
+		? Key extends keyof TDict[NS]
+			? TDict[NS][Key]
+			: string
+		: string
+	: string;
+
+/** Required typed values when template has ICU vars, optional otherwise */
+type TranslatorArgs<Template extends string> = [ExtractICUVars<Template>] extends [never]
+	? [values?: Record<string, unknown>]
+	: [values: { [K in ExtractICUVars<Template>]: number | string }];
+
+export interface Translator<
+	TDict extends Record<string, Record<string, string>> = Record<string, Record<string, string>>,
+> {
+	<K extends FlatKeys<TDict>>(key: K, ...args: TranslatorArgs<LookupTemplate<TDict, K>>): string;
+	rich: <K extends FlatKeys<TDict>>(
+		key: K,
+		components: Record<string, (children: string) => unknown>,
+		...args: TranslatorArgs<LookupTemplate<TDict, K>>
+	) => unknown;
+}
+
+export function createTranslator<T extends Record<string, Record<string, string>>>(
+	loaded: T,
+	locale?: string,
+): Translator<T> {
+	/* Flatten: { ns: { "key": "val" } } → { "ns.key": "val" } */
+	const flat: Record<string, string> = {};
+	for (const [ns, entries] of Object.entries(loaded)) {
+		for (const [key, val] of Object.entries(entries)) {
+			flat[`${ns}.${key}`] = val;
+		}
+	}
+
+	const t = (key: string, values?: Record<string, unknown>): string => {
+		const template = flat[key];
+		if (template === undefined) return key;
+		return formatMessage(template, values, locale);
+	};
+
+	t.rich = (
+		key: string,
+		components: Record<string, (children: string) => unknown>,
+		values?: Record<string, unknown>,
+	): unknown => {
+		const template = flat[key];
+		if (template === undefined) return key;
+
+		/* First apply ICU formatting if values provided */
+		const formatted = values ? formatMessage(template, values, locale) : template;
+
+		/* Then parse rich text components */
+		const parts = parseRichText(formatted, components);
+
+		/* If single element, return it directly */
+		if (parts.length === 1) return parts[0];
+		return parts;
+	};
+
+	return t as Translator<T>;
+}

package/src/i18n/jsx.tsx

@@ -0,0 +1,42 @@
+/**
+ * Rich text parsing for JSX interpolation
+ * Parses [[component:content]] syntax into component calls
+ */
+
+const RICH_RE = /\[\[([a-zA-Z0-9_-]+):([^\]]*)\]\]/g;
+
+export function parseRichText(text: string, components: Record<string, (children: string) => unknown>): unknown[] {
+	const parts: unknown[] = [];
+	let lastIndex = 0;
+
+	RICH_RE.lastIndex = 0;
+	let match = RICH_RE.exec(text);
+
+	while (match !== null) {
+		const before = text.slice(lastIndex, match.index);
+		parts.push(before);
+
+		const componentName = match[1] ?? "";
+		const content = match[2] ?? "";
+		const component = components[componentName];
+
+		if (component) {
+			parts.push(component(content));
+		} else {
+			parts.push(content);
+		}
+
+		lastIndex = match.index + match[0].length;
+		match = RICH_RE.exec(text);
+	}
+
+	if (lastIndex < text.length) {
+		parts.push(text.slice(lastIndex));
+	}
+
+	if (parts.length === 0) {
+		parts.push(text);
+	}
+
+	return parts;
+}

package/src/i18n/message-format.ts

@@ -0,0 +1,174 @@
+/**
+ * Minimal ICU MessageFormat parser
+ * Handles: {var}, {var, plural, ...}, {var, select, ...}, {var, number}
+ */
+
+type PluralCategory = "few" | "many" | "one" | "other" | "two" | "zero";
+
+function getPluralCategory(n: number, _locale?: string): PluralCategory {
+	if (n === 1) return "one";
+	return "other";
+}
+
+interface ParsedBlock {
+	branches: Record<string, string>;
+	type: "plural" | "select";
+	varName: string;
+}
+
+interface ParsedNumber {
+	type: "number";
+	varName: string;
+}
+
+interface ParsedSimple {
+	type: "simple";
+	varName: string;
+}
+
+type ParsedToken = ParsedBlock | ParsedNumber | ParsedSimple | string;
+
+function findMatchingBrace(str: string, start: number): number {
+	let depth = 0;
+	for (let i = start; i < str.length; i++) {
+		if (str[i] === "{") depth++;
+		else if (str[i] === "}") {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+
+function parseBranches(content: string): Record<string, string> {
+	const branches: Record<string, string> = {};
+	let i = 0;
+	while (i < content.length) {
+		/* skip whitespace */
+		while (i < content.length && /\s/.test(content[i] ?? "")) i++;
+		if (i >= content.length) break;
+
+		/* read category name (e.g. "one", "other", "=0") */
+		let category = "";
+		while (i < content.length && content[i] !== "{" && !/\s/.test(content[i] ?? "")) {
+			category += content[i];
+			i++;
+		}
+		if (!category) break;
+
+		/* skip whitespace before { */
+		while (i < content.length && /\s/.test(content[i] ?? "")) i++;
+		if (i >= content.length || content[i] !== "{") break;
+
+		/* find matching } */
+		const end = findMatchingBrace(content, i);
+		if (end === -1) break;
+
+		branches[category] = content.slice(i + 1, end);
+		i = end + 1;
+	}
+	return branches;
+}
+
+function tokenize(message: string): ParsedToken[] {
+	const tokens: ParsedToken[] = [];
+	let i = 0;
+
+	while (i < message.length) {
+		const braceIdx = message.indexOf("{", i);
+		if (braceIdx === -1) {
+			tokens.push(message.slice(i));
+			break;
+		}
+
+		if (braceIdx > i) {
+			tokens.push(message.slice(i, braceIdx));
+		}
+
+		const endBrace = findMatchingBrace(message, braceIdx);
+		if (endBrace === -1) {
+			tokens.push(message.slice(braceIdx));
+			break;
+		}
+
+		const inner = message.slice(braceIdx + 1, endBrace);
+		const commaIdx = inner.indexOf(",");
+
+		if (commaIdx === -1) {
+			/* simple interpolation: {varName} */
+			tokens.push({ type: "simple", varName: inner.trim() });
+		} else {
+			const varName = inner.slice(0, commaIdx).trim();
+			const rest = inner.slice(commaIdx + 1).trim();
+			const secondComma = rest.indexOf(",");
+
+			if (secondComma === -1) {
+				/* {var, number} or similar */
+				const formatType = rest.trim();
+				if (formatType === "number") {
+					tokens.push({ type: "number", varName });
+				} else {
+					tokens.push({ type: "simple", varName });
+				}
+			} else {
+				/* {var, plural/select, branches} */
+				const formatType = rest.slice(0, secondComma).trim();
+				const branchContent = rest.slice(secondComma + 1).trim();
+				const branches = parseBranches(branchContent);
+
+				if (formatType === "plural" || formatType === "select") {
+					tokens.push({ branches, type: formatType, varName });
+				} else {
+					tokens.push({ type: "simple", varName });
+				}
+			}
+		}
+
+		i = endBrace + 1;
+	}
+
+	return tokens;
+}
+
+function resolveToken(token: ParsedToken, values: Record<string, unknown>, locale?: string): string {
+	if (typeof token === "string") return token;
+
+	if (token.type === "simple") {
+		const val = values[token.varName];
+		return val !== undefined && val !== null ? String(val) : `{${token.varName}}`;
+	}
+
+	if (token.type === "number") {
+		const val = values[token.varName];
+		if (val === undefined || val === null) return `{${token.varName}}`;
+		try {
+			return new Intl.NumberFormat(locale).format(Number(val));
+		} catch {
+			return String(val);
+		}
+	}
+
+	/* plural or select */
+	const val = values[token.varName];
+
+	if (token.type === "plural") {
+		const num = Number(val ?? 0);
+		const exactKey = `=${num}`;
+		const category = getPluralCategory(num, locale);
+		const template = token.branches[exactKey] ?? token.branches[category] ?? token.branches.other ?? "";
+		const resolved = template.replace(/#/g, String(num));
+		return formatMessage(resolved, values, locale);
+	}
+
+	/* select */
+	const strVal = val !== undefined && val !== null ? String(val) : "";
+	const template = token.branches[strVal] ?? token.branches.other ?? "";
+	return formatMessage(template, values, locale);
+}
+
+export function formatMessage(message: string, values?: Record<string, unknown>, locale?: string): string {
+	if (!message) return message;
+	const safeValues = values ?? {};
+	const tokens = tokenize(message);
+	return tokens.map((t) => resolveToken(t, safeValues, locale)).join("");
+}