@lovrozagar/flare 0.1.0

package/src/router-primitives/match-id.ts

@@ -0,0 +1,111 @@
+import type { ComputeMatchIdOptions, ParsedMatchId } from "./types.ts";
+
+function sortedParams(params: Record<string, string | string[]>): Record<string, string | string[]> {
+	const sorted: Record<string, string | string[]> = {};
+	for (const key of Object.keys(params).sort()) {
+		sorted[key] = params[key];
+	}
+	return sorted;
+}
+
+/**
+ * JSON.stringify with sorted keys at every depth.
+ * Ensures objects with identical content but different insertion order
+ * produce the same string (avoids matchId cache misses).
+ * Uses WeakSet to detect circular references — emits null for cycles.
+ */
+function stableStringify(value: unknown, seen?: WeakSet<object>): string {
+	if (value === null || value === undefined) return JSON.stringify(value);
+	if (typeof value !== "object") return JSON.stringify(value);
+	const s = seen ?? new WeakSet();
+	if (s.has(value)) return "null";
+	s.add(value);
+	if (Array.isArray(value)) {
+		let arr = "[";
+		for (let i = 0; i < value.length; i++) {
+			if (i > 0) arr += ",";
+			arr += stableStringify(value[i], s);
+		}
+		return `${arr}]`;
+	}
+	const obj = value as Record<string, unknown>;
+	const keys = Object.keys(obj).sort();
+	let result = "{";
+	for (let i = 0; i < keys.length; i++) {
+		if (i > 0) result += ",";
+		result += `${JSON.stringify(keys[i])}:${stableStringify(obj[keys[i]], s)}`;
+	}
+	return `${result}}`;
+}
+
+export function computeMatchId(options: ComputeMatchIdOptions): string {
+	const params = sortedParams(options.params);
+	const deps = options.loaderDeps ? options.loaderDeps({ search: options.search }) : [];
+	return `${options.routeId}:${JSON.stringify(params)}:${stableStringify(deps)}`;
+}
+
+/**
+ * Find matching closing brace in a JSON-like string, respecting
+ * string literals and nested braces/brackets.
+ */
+function findClosingBrace(str: string, openPos: number): number {
+	const openChar = str[openPos];
+	const closeChar = openChar === "{" ? "}" : "]";
+	let depth = 0;
+	let inString = false;
+	let escape = false;
+
+	for (let i = openPos; i < str.length; i++) {
+		const ch = str[i];
+		if (escape) {
+			escape = false;
+			continue;
+		}
+		if (inString) {
+			if (ch === "\\") {
+				escape = true;
+				continue;
+			}
+			if (ch === '"') {
+				inString = false;
+			}
+			continue;
+		}
+		if (ch === '"') {
+			inString = true;
+			continue;
+		}
+		if (ch === openChar) depth++;
+		if (ch === closeChar) {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+
+export function parseMatchId(matchId: string): ParsedMatchId | null {
+	/* Format: routeId:{params}:[deps] — use brace-depth scanning to handle ":[" in values */
+	const firstBrace = matchId.indexOf(":{");
+	if (firstBrace === -1) return null;
+
+	const routeId = matchId.slice(0, firstBrace);
+	const paramsStart = firstBrace + 1;
+	const paramsEnd = findClosingBrace(matchId, paramsStart);
+	if (paramsEnd === -1) return null;
+
+	const paramsStr = matchId.slice(paramsStart, paramsEnd + 1);
+
+	/* Next char must be ":" separator, followed by "[" for deps array */
+	if (matchId[paramsEnd + 1] !== ":" || matchId[paramsEnd + 2] !== "[") return null;
+	const depsStr = matchId.slice(paramsEnd + 2);
+
+	try {
+		const rawParams: unknown = JSON.parse(paramsStr);
+		const rawDeps: unknown = JSON.parse(depsStr);
+		if (typeof rawParams !== "object" || rawParams === null || !Array.isArray(rawDeps)) return null;
+		return { deps: rawDeps, params: rawParams as Record<string, string | string[]>, routeId };
+	} catch {
+		return null;
+	}
+}

package/src/router-primitives/paths.ts

@@ -0,0 +1,109 @@
+function isGroupSegment(segment: string): boolean {
+	return segment.startsWith("(") && segment.endsWith(")");
+}
+
+export function isParamSegment(segment: string): boolean {
+	return segment.startsWith("[") && segment.endsWith("]");
+}
+
+export function isRootLayoutPath(path: string): boolean {
+	return path.length >= 3 && path.startsWith("_") && path.endsWith("_") && !path.includes("/");
+}
+
+export function stripGroups(path: string): string {
+	return path
+		.split("/")
+		.filter((s) => !isGroupSegment(s))
+		.join("/");
+}
+
+function findRootSegmentIndex(segments: string[]): number {
+	return segments.findIndex((s) => isRootLayoutPath(s));
+}
+
+export function toUrlPath(virtualPath: string): string {
+	const segments = virtualPath.split("/");
+	const rootIdx = findRootSegmentIndex(segments);
+	const filtered = segments.filter((s, i) => {
+		if (rootIdx >= 0 && i <= rootIdx) return false;
+		if (isGroupSegment(s)) return false;
+		return true;
+	});
+	if (filtered.length === 0) return "/";
+	return `/${filtered.join("/")}`;
+}
+
+export function toVirtualPath(urlPath: string, root: string): string {
+	const trimmed = urlPath.replace(/^\/+/, "");
+	if (trimmed.length === 0) return root;
+	return `${root}/${trimmed}`;
+}
+
+const PARAM_RE = /\[(?:\.\.\.)?(\w+)\](?:\])?/g;
+
+export function deriveParams(variablePath: string): string[] {
+	const matches = variablePath.matchAll(PARAM_RE);
+	const result: string[] = [];
+	for (const m of matches) {
+		result.push(m[1]);
+	}
+	return result;
+}
+
+export function extractLayoutKey(virtualPath: string): string {
+	const segments = virtualPath.split("/");
+	const virtual: string[] = [];
+	for (const segment of segments) {
+		if (isRootLayoutPath(segment) || isGroupSegment(segment) || isParamSegment(segment)) {
+			virtual.push(segment);
+		}
+	}
+	return virtual.join("/");
+}
+
+export function deriveLayouts(virtualPath: string): string[] {
+	const layoutKey = extractLayoutKey(virtualPath);
+	if (!layoutKey) return [];
+	const segments = layoutKey.split("/");
+	const layouts: string[] = [];
+	let accumulated = "";
+	let foundRoot = false;
+
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+
+		if (!foundRoot) {
+			/* Pre-root: accumulate param segments into compound key */
+			if (isRootLayoutPath(segment)) {
+				accumulated = accumulated ? `${accumulated}/${segment}` : segment;
+				layouts.push(accumulated);
+				foundRoot = true;
+			} else if (isParamSegment(segment)) {
+				accumulated = accumulated ? `${accumulated}/${segment}` : segment;
+				/* Push pre-root param segments — they can be path segments with cache config */
+				layouts.push(accumulated);
+			}
+			continue;
+		}
+
+		/* Post-root: existing logic */
+		if (isGroupSegment(segment)) {
+			accumulated = `${accumulated}/${segment}`;
+			layouts.push(accumulated);
+			/* Each trailing param segment forms its own layout boundary.
+			   Enables path-segments like (group)/[org]/[repo] to resolve independently. */
+			while (i + 1 < segments.length && isParamSegment(segments[i + 1])) {
+				i++;
+				accumulated = `${accumulated}/${segments[i]}`;
+				layouts.push(accumulated);
+			}
+		} else if (isParamSegment(segment)) {
+			/* Bare param segments (not trailing a group) also form layout boundaries.
+			   Enables [locale]/_layout_.tsx without requiring a wrapping (group). */
+			accumulated = `${accumulated}/${segment}`;
+			layouts.push(accumulated);
+		}
+	}
+
+	return layouts;
+}

package/src/router-primitives/tree.ts

@@ -0,0 +1,243 @@
+import type { MatchResult, RouteData, TreeNode } from "./types.ts";
+
+/** Constrains which decoded segment values are accepted when consuming an optional param. */
+export interface LocaleMatch {
+	paramName: string;
+	locales: readonly string[];
+}
+
+/** Builds a `LocaleMatch` from a `LocaleConfig`-shaped object. Absent cfg → greedy fallback. */
+export function toLocaleMatch(
+	cfg: { locales: readonly string[]; paramName?: string } | undefined,
+): LocaleMatch | undefined {
+	if (!cfg) return undefined;
+	return { locales: cfg.locales, paramName: cfg.paramName ?? "locale" };
+}
+
+function safeDecodeURIComponent(s: string): string | null {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return null;
+	}
+}
+
+/** True when `decoded` may be stored as `paramName` under the current locale allow-list. */
+function localeAllowsConsume(paramName: string, decoded: string, localeMatch?: LocaleMatch): boolean {
+	return !localeMatch || paramName !== localeMatch.paramName || localeMatch.locales.includes(decoded);
+}
+
+export function createTreeNode(paramName?: string): TreeNode {
+	const node: TreeNode = { s: Object.create(null) };
+	if (paramName !== undefined) {
+		node.n = paramName;
+	}
+	return node;
+}
+
+function splitSegments(path: string): string[] {
+	return path.split("/").filter((s) => s.length > 0);
+}
+
+export function insertRoute(tree: TreeNode, path: string, route: RouteData): void {
+	const segments = splitSegments(path);
+	let node = tree;
+
+	for (const segment of segments) {
+		const optionalCatchAll = segment.match(/^\[\[\.\.\.(\w+)\]\]$/);
+		if (optionalCatchAll) {
+			if (!node.o) {
+				node.o = createTreeNode(optionalCatchAll[1]);
+			}
+			node = node.o;
+			continue;
+		}
+
+		const optionalParam = segment.match(/^\[\[(\w+)\]\]$/);
+		if (optionalParam) {
+			if (!node.q) {
+				node.q = createTreeNode(optionalParam[1]);
+			}
+			node = node.q;
+			continue;
+		}
+
+		const catchAll = segment.match(/^\[\.\.\.(\w+)\]$/);
+		if (catchAll) {
+			if (!node.c) {
+				node.c = createTreeNode(catchAll[1]);
+			}
+			node = node.c;
+			continue;
+		}
+
+		const param = segment.match(/^\[(\w+)\]$/);
+		if (param) {
+			if (!node.p) {
+				node.p = createTreeNode(param[1]);
+			}
+			node = node.p;
+			continue;
+		}
+
+		/* Store lowercase key for case-insensitive lookup (default).
+		 * Generated patterns from filesystem are already lowercase by convention. */
+		const key = segment.toLowerCase();
+		let child = node.s[key];
+		if (!child) {
+			child = createTreeNode();
+			node.s[key] = child;
+		}
+		node = child;
+	}
+
+	node.r = route;
+}
+
+export function matchRoute(
+	tree: TreeNode,
+	pathname: string,
+	caseSensitive?: boolean,
+	localeMatch?: LocaleMatch,
+): MatchResult | null {
+	const segments = splitSegments(pathname);
+	const params: Record<string, string | string[]> = {};
+	const result = matchNode(tree, segments, 0, params, caseSensitive, localeMatch);
+	if (result) {
+		return { params, route: result };
+	}
+	return null;
+}
+
+export function matchRoutePartial(
+	tree: TreeNode,
+	pathname: string,
+	caseSensitive?: boolean,
+	localeMatch?: LocaleMatch,
+): MatchResult | null {
+	const segments = splitSegments(pathname);
+	for (let len = segments.length - 1; len >= 1; len--) {
+		const prefix = `/${segments.slice(0, len).join("/")}`;
+		const result = matchRoute(tree, prefix, caseSensitive, localeMatch);
+		if (result) return result;
+	}
+	/* Skip "/" fallback when localeMatch is set and the first segment is neither a declared
+	 * locale nor a static child — returning root for a cross-worker path like /docs/x/y
+	 * would falsely imply ownership and hijack the navigation. */
+	if (localeMatch && segments.length > 0) {
+		const first = safeDecodeURIComponent(segments[0]);
+		const isValidLocale = first !== null && localeMatch.locales.includes(first);
+		const staticKey = caseSensitive ? segments[0] : segments[0].toLowerCase();
+		const hasStaticChild = staticKey in tree.s;
+		if (!isValidLocale && !hasStaticChild) return null;
+	}
+	return matchRoute(tree, "/", caseSensitive, localeMatch);
+}
+
+function matchNode(
+	node: TreeNode,
+	segments: string[],
+	index: number,
+	params: Record<string, string | string[]>,
+	caseSensitive?: boolean,
+	localeMatch?: LocaleMatch,
+): RouteData | null {
+	if (index === segments.length) {
+		if (node.r) {
+			return node.r;
+		}
+		/* optional single param skipped — try matching descendants directly */
+		if (node.q) {
+			const result = matchNode(node.q, segments, index, params, caseSensitive, localeMatch);
+			if (result) return result;
+		}
+		/* optional catch-all at terminal */
+		if (node.o?.r && node.o.n) {
+			params[node.o.n] = [];
+			return node.o.r;
+		}
+		return null;
+	}
+
+	const segment = segments[index];
+
+	/* static — s is always null-prototype (createTreeNode / generated S helper) */
+	const key = caseSensitive ? segment : segment.toLowerCase();
+	const staticChild = node.s[key];
+	if (staticChild) {
+		const result = matchNode(staticChild, segments, index + 1, params, caseSensitive, localeMatch);
+		if (result) return result;
+	}
+
+	/* param */
+	if (node.p) {
+		const paramName = node.p.n;
+		if (paramName) {
+			const decoded = safeDecodeURIComponent(segment);
+			if (decoded === null) return null;
+			/* locale allow-list: reject consume when segment is not a declared locale —
+			 * required [locale] must not swallow unknown first segments as a locale index */
+			if (localeAllowsConsume(paramName, decoded, localeMatch)) {
+				const hadKey = paramName in params;
+				const prevVal = params[paramName];
+				params[paramName] = decoded;
+				const result = matchNode(node.p, segments, index + 1, params, caseSensitive, localeMatch);
+				if (result) return result;
+				/* backtrack — restore only the single key we changed */
+				if (hadKey) {
+					params[paramName] = prevVal;
+				} else {
+					delete params[paramName];
+				}
+			}
+		} else {
+			const result = matchNode(node.p, segments, index + 1, params, caseSensitive, localeMatch);
+			if (result) return result;
+		}
+	}
+
+	/* optional single param — try skipping first (static children win), then consuming */
+	if (node.q) {
+		/* skip — match descendants without consuming segment */
+		const skipResult = matchNode(node.q, segments, index, params, caseSensitive, localeMatch);
+		if (skipResult) return skipResult;
+
+		/* consume — use segment as param value */
+		const paramName = node.q.n;
+		if (paramName) {
+			const decoded = safeDecodeURIComponent(segment);
+			/* locale allow-list: reject consume when segment is not a declared locale —
+			 * prevents /[[locale]] from greedily matching cross-worker path segments like /docs */
+			if (decoded !== null && localeAllowsConsume(paramName, decoded, localeMatch)) {
+				const hadKey = paramName in params;
+				const prevVal = params[paramName];
+				params[paramName] = decoded;
+				const result = matchNode(node.q, segments, index + 1, params, caseSensitive, localeMatch);
+				if (result) return result;
+				if (hadKey) {
+					params[paramName] = prevVal;
+				} else {
+					delete params[paramName];
+				}
+			}
+		}
+	}
+
+	/* catch-all */
+	if (node.c?.r && node.c.n) {
+		const decoded = segments.slice(index).map(safeDecodeURIComponent);
+		if (decoded.some((d) => d === null)) return null;
+		params[node.c.n] = decoded as string[];
+		return node.c.r;
+	}
+
+	/* optional catch-all */
+	if (node.o?.r && node.o.n) {
+		const decoded = segments.slice(index).map(safeDecodeURIComponent);
+		if (decoded.some((d) => d === null)) return null;
+		params[node.o.n] = decoded as string[];
+		return node.o.r;
+	}
+
+	return null;
+}

package/src/router-primitives/types.ts

@@ -0,0 +1,74 @@
+import type { SearchParams } from "../url/index.ts";
+
+export type PrefetchStrategy = false | "intent" | "render" | "viewport";
+
+export type RouteMetaClient = {
+	cacheDeferred?: boolean;
+	gcTime?: number;
+	prefetch?: PrefetchStrategy;
+	prefetchGcTime?: number;
+	prefetchStaleTime?: number;
+	staleTime?: number;
+};
+
+export type RouteMetaStatic = {
+	defer?: "resolve" | "stream";
+	dynamicParams?: boolean;
+	mode: "isr" | "static";
+	revalidate?: number;
+};
+
+export type RouteMeta = {
+	authenticate?: boolean;
+	client?: RouteMetaClient;
+	intercept?: { from: readonly string[]; render: string };
+	static?: RouteMetaStatic;
+};
+
+export type RouteData = {
+	e: string;
+	f?: string;
+	o: RouteMeta;
+	p: () => Promise<{ default: unknown }>;
+	t: "r" | "x";
+	v: string;
+	x: string;
+};
+
+export type TreeNode = {
+	c?: TreeNode;
+	n?: string;
+	o?: TreeNode;
+	p?: TreeNode;
+	q?: TreeNode;
+	r?: RouteData;
+	s: Record<string, TreeNode>;
+};
+
+export type MatchResult = {
+	params: Record<string, string | string[]>;
+	route: RouteData;
+};
+
+export interface Location<TParams = Record<string, string | string[]>, TSearch = SearchParams, THash = string> {
+	hash: THash;
+	params: TParams;
+	pathname: string;
+	search: TSearch;
+	url: URL;
+	variablePath: string;
+	virtualPath: string;
+}
+
+export interface ComputeMatchIdOptions {
+	loaderDeps?: (ctx: { search: SearchParams }) => unknown[];
+	params: Record<string, string | string[]>;
+	routeId: string;
+	search: SearchParams;
+}
+
+export interface ParsedMatchId {
+	deps: unknown[];
+	params: Record<string, string | string[]>;
+	routeId: string;
+}

package/src/router.ts

@@ -0,0 +1,31 @@
+export {
+	useBlocker,
+	useLoaderData,
+	useLoaderT,
+	useLocation,
+	useMatch,
+	useNavigate,
+	useParams,
+	usePreloaderContext,
+	usePreloaderT,
+	useSearch,
+} from "./hooks.ts";
+export type {
+	BlockerState,
+	FlareRouter,
+	LocationChangeInfo,
+	NavigateOptions,
+	PrefetchOptions,
+	ViewTransitionConfig,
+	ViewTransitionDirection,
+	ViewTransitionOptions,
+} from "./outlet/index.tsx";
+export { useRouter } from "./outlet/index.tsx";
+export type {
+	PrefetchStrategy,
+	RouterCacheConfig,
+	RouterConfig,
+	TrailingSlashMode,
+	ViewTransitionDefaults,
+} from "./router-config/index.ts";
+export { createRouter } from "./router-config/index.ts";

package/src/search-engine/bing.ts

@@ -0,0 +1,32 @@
+/* ── Types ────────────────────────────────────────────────────────────── */
+
+export interface BingSubmitConfig {
+	apiKey: string;
+	siteUrl: string;
+	urls: string[];
+}
+
+interface SubmitResult {
+	error?: string;
+	ok: boolean;
+}
+
+/* ── Bing Webmaster URL submission ────────────────────────────────────── */
+
+export async function submitUrlsToBing(config: BingSubmitConfig): Promise<SubmitResult> {
+	const url = `https://ssl.bing.com/webmaster/api.svc/json/SubmitUrlbatch?apikey=${encodeURIComponent(config.apiKey)}`;
+
+	const response = await fetch(url, {
+		body: JSON.stringify({ siteUrl: config.siteUrl, urlList: config.urls }),
+		headers: { "Content-Type": "application/json" },
+		method: "POST",
+	});
+
+	if (!response.ok) {
+		await response.body?.cancel();
+		return { error: `Bing submit failed (${response.status})`, ok: false };
+	}
+
+	await response.body?.cancel();
+	return { ok: true };
+}

package/src/search-engine/google-jwt.ts

@@ -0,0 +1,95 @@
+/* ── Types ────────────────────────────────────────────────────────────── */
+
+export interface ServiceAccountCredentials {
+	clientEmail: string;
+	privateKey: string;
+}
+
+interface TokenResponse {
+	access_token: string;
+	expires_in: number;
+	token_type: string;
+}
+
+/* ── Base64url ────────────────────────────────────────────────────────── */
+
+function base64url(buffer: ArrayBuffer): string {
+	const bytes = new Uint8Array(buffer);
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) {
+		binary += String.fromCharCode(bytes[i] ?? 0);
+	}
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+function base64urlEncode(str: string): string {
+	const encoder = new TextEncoder();
+	return base64url(encoder.encode(str).buffer as ArrayBuffer);
+}
+
+/* ── PEM parsing ──────────────────────────────────────────────────────── */
+
+function parsePemKey(pem: string): Uint8Array {
+	const lines = pem
+		.replace(/-----BEGIN [\w\s]+-----/, "")
+		.replace(/-----END [\w\s]+-----/, "")
+		.replace(/\s+/g, "");
+	const binary = atob(lines);
+	const buffer = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) {
+		buffer[i] = binary.charCodeAt(i);
+	}
+	return buffer;
+}
+
+/* ── JWT signing ──────────────────────────────────────────────────────── */
+
+export async function signJwt(payload: Record<string, unknown>, privateKeyPem: string): Promise<string> {
+	const keyBytes = parsePemKey(privateKeyPem);
+	const keyBuffer = new ArrayBuffer(keyBytes.length);
+	new Uint8Array(keyBuffer).set(keyBytes);
+	const key = await crypto.subtle.importKey("pkcs8", keyBuffer, { hash: "SHA-256", name: "RSASSA-PKCS1-v1_5" }, false, [
+		"sign",
+	]);
+
+	const header = base64urlEncode(JSON.stringify({ alg: "RS256", typ: "JWT" }));
+	const claims = base64urlEncode(JSON.stringify(payload));
+	const input = `${header}.${claims}`;
+
+	const encoder = new TextEncoder();
+	const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", key, encoder.encode(input));
+
+	return `${input}.${base64url(signature)}`;
+}
+
+/* ── Token exchange ───────────────────────────────────────────────────── */
+
+const JWT_EXPIRY_SECONDS = 3600;
+
+export async function getGoogleAccessToken(credentials: ServiceAccountCredentials, scope: string): Promise<string> {
+	const now = Math.floor(Date.now() / 1000);
+	const jwt = await signJwt(
+		{
+			aud: "https://oauth2.googleapis.com/token",
+			exp: now + JWT_EXPIRY_SECONDS,
+			iat: now,
+			iss: credentials.clientEmail,
+			scope,
+		},
+		credentials.privateKey,
+	);
+
+	const response = await fetch("https://oauth2.googleapis.com/token", {
+		body: `grant_type=${encodeURIComponent("urn:ietf:params:oauth:grant-type:jwt-bearer")}&assertion=${encodeURIComponent(jwt)}`,
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		method: "POST",
+	});
+
+	if (!response.ok) {
+		await response.body?.cancel();
+		throw new Error(`Google token exchange failed (${response.status})`);
+	}
+
+	const data = (await response.json()) as TokenResponse;
+	return data.access_token;
+}