@lovrozagar/flare 0.1.0

package/src/route-builder/register.ts

@@ -0,0 +1,242 @@
+import type { AuthenticateMode } from "./types.ts";
+
+/**
+ * Module augmentation target. Apps extend via:
+ *
+ * declare module "@lovrozagar/flare" {
+ *   interface FlareRegister {
+ *     auth: AppAuth
+ *   }
+ * }
+ */
+export interface FlareRegister {}
+
+/* ── Path param extraction ────────────────────────────────── */
+
+type _ExtractSegment<T extends string> = T extends `[[...${infer N}]]`
+	? { [K in N]: string[] | undefined }
+	: T extends `[[${infer N}]]`
+		? { [K in N]: string | undefined }
+		: T extends `[...${infer N}]`
+			? { [K in N]: string[] }
+			: T extends `[${infer N}]`
+				? { [K in N]: string }
+				: {};
+
+type _ExtractPathParams<T extends string> = T extends `${infer Head}/${infer Tail}`
+	? _ExtractSegment<Head> & _ExtractPathParams<Tail>
+	: _ExtractSegment<T>;
+
+export type ExtractPathParams<T extends string> =
+	_ExtractPathParams<T> extends infer R ? { [K in keyof R]: R[K] } : never;
+
+/* resolve env type: user-augmented when set, unknown fallback otherwise */
+export type ResolvedEnv = FlareRegister extends { env: infer E } ? E : unknown;
+
+/* resolve serverContext type: user-augmented when set, loose fallback otherwise */
+export type ResolvedServerContext = FlareRegister extends { serverContext: infer SC } ? SC : Record<string, unknown>;
+
+/* resolve queryClient: present when hasQueryClient is true, absent otherwise */
+export type ResolvedQueryClient = FlareRegister extends { hasQueryClient: true }
+	? { queryClient: import("@tanstack/solid-query").QueryClient }
+	: {};
+
+/* resolve auth type: Auth when required, Auth|null when optional, null when false */
+type RegisteredAuth = FlareRegister extends { auth: infer A } ? A : null;
+
+export type ResolvedAuth<TAuth extends AuthenticateMode> = TAuth extends true
+	? RegisteredAuth
+	: TAuth extends "optional"
+		? RegisteredAuth | null
+		: null;
+
+/* ── Auth mode utilities ───────────────────────────────────── */
+
+/* registered auth modes map — virtualPath → AuthenticateMode */
+type RegisteredAuthModes = FlareRegister extends { authModes: infer M } ? M : {};
+
+/** Infer auth mode from a route module result type */
+export type InferAuthMode<T> = T extends { authenticateMode: infer M extends AuthenticateMode } ? M : false;
+
+/** Auth mode for a route by virtualPath — reads from generated authModes map */
+export type RouteAuthMode<TPath extends string> = TPath extends keyof RegisteredAuthModes
+	? RegisteredAuthModes[TPath] extends AuthenticateMode
+		? RegisteredAuthModes[TPath]
+		: false
+	: false;
+
+/** Resolve effective auth from parent chain — strictest wins: true > "optional" > false */
+type StrictestAuth<A extends AuthenticateMode, B extends AuthenticateMode> = A extends true
+	? true
+	: B extends true
+		? true
+		: A extends "optional"
+			? "optional"
+			: B extends "optional"
+				? "optional"
+				: false;
+
+type AuthChain<TPaths extends readonly string[]> = TPaths extends readonly [
+	infer First extends string,
+	...infer Rest extends readonly string[],
+]
+	? StrictestAuth<RouteAuthMode<First>, AuthChain<Rest>>
+	: false;
+
+/** Initial auth for a route based on parent chain */
+export type ParentAuthResolution<TPath extends string> = TPath extends keyof RegisteredRouteParents
+	? RegisteredRouteParents[TPath] extends readonly string[]
+		? AuthChain<RegisteredRouteParents[TPath]>
+		: false
+	: false;
+
+/* ── Route type utilities ──────────────────────────────────── */
+
+/* registered maps — resolve to empty when not augmented */
+type RegisteredRoutes = FlareRegister extends { routes: infer R } ? R : {};
+type RegisteredRouteModules = FlareRegister extends { routeModules: infer M } ? M : {};
+type RegisteredRouteParents = FlareRegister extends { routeParents: infer P } ? P : {};
+
+/** All registered URL paths (e.g. "/about", "/blog/[slug]") — string when not registered */
+export type RoutePaths = "routes" extends keyof FlareRegister ? keyof RegisteredRoutes & string : string;
+
+/** All registered virtualPaths (e.g. "_root_/about") — string when not registered */
+export type RouteVirtualPaths = "routeModules" extends keyof FlareRegister
+	? keyof RegisteredRouteModules & string
+	: string;
+
+/** Resolve the route module type for a given virtualPath */
+export type RouteModule<TPath extends string> = TPath extends keyof RegisteredRouteModules
+	? RegisteredRouteModules[TPath]
+	: never;
+
+/** Extract loaderData type from a route module's render props */
+export type InferLoaderData<T> = T extends { render: (props: infer P) => unknown }
+	? P extends { loaderData: infer L }
+		? L
+		: void
+	: void;
+
+/** Extract own preloader context from a route module's render props */
+export type InferPreloaderContext<T> = T extends { render: (props: infer P) => unknown }
+	? P extends { preloaderContext: infer C }
+		? C
+		: {}
+	: {};
+
+/** Extract params type from a route module's render props */
+export type InferParams<T> = T extends { render: (props: infer P) => unknown }
+	? P extends { location: { params: infer Params } }
+		? Params
+		: Record<string, string | string[]>
+	: Record<string, string | string[]>;
+
+/** Extract search params type from a route module's render props */
+export type InferSearchParams<T> = T extends { render: (props: infer P) => unknown }
+	? P extends { location: { search: infer S } }
+		? S
+		: Record<string, string>
+	: Record<string, string>;
+
+/** Recursively intersect preloader contexts from a tuple of virtualPaths */
+export type PreloaderChain<TPaths extends readonly string[]> = TPaths extends readonly [
+	infer First extends string,
+	...infer Rest extends readonly string[],
+]
+	? InferPreloaderContext<RouteModule<First>> & PreloaderChain<Rest>
+	: {};
+
+/* ── Route search params utilities ────────────────────────── */
+
+type RegisteredRouteSearchParams = FlareRegister extends { routeSearchParams: infer S } ? S : {};
+
+/** Resolved search param type for a URL path — specific when registered, loose otherwise */
+export type RouteSearchType<TPath extends string> = "routeSearchParams" extends keyof FlareRegister
+	? TPath extends keyof RegisteredRouteSearchParams
+		? RegisteredRouteSearchParams[TPath]
+		: Record<string, unknown>
+	: Record<string, unknown>;
+
+/** Optional search prop — typed when route has .input(), loose otherwise */
+export type RouteSearchProps<TPath extends string> = { search?: RouteSearchType<TPath> };
+
+/* ── Route params utilities ──────────────────────────────── */
+
+type RegisteredRouteParams = FlareRegister extends { routeParams: infer P } ? P : {};
+
+/** Extract params shape — prefers routeParams (validator-inferred) over routes (URL-derived) */
+export type RouteParams<TPath extends string> = "routeParams" extends keyof FlareRegister
+	? TPath extends keyof RegisteredRouteParams
+		? RegisteredRouteParams[TPath]
+		: "routes" extends keyof FlareRegister
+			? TPath extends keyof RegisteredRoutes
+				? RegisteredRoutes[TPath] extends { params: infer P }
+					? P
+					: {}
+				: {}
+			: ExtractPathParams<TPath>
+	: "routes" extends keyof FlareRegister
+		? TPath extends keyof RegisteredRoutes
+			? RegisteredRoutes[TPath] extends { params: infer P }
+				? P
+				: {}
+			: {}
+		: ExtractPathParams<TPath>;
+
+/** Conditional params prop — required when route has params, forbidden otherwise */
+export type RouteParamsProps<TPath extends string> = "routeParams" extends keyof FlareRegister
+	? _ParamsFromInferred<TPath>
+	: "routes" extends keyof FlareRegister
+		? _ParamsForRoute<TPath>
+		: _ParamsFromPath<TPath>;
+
+type _ParamsFromInferred<TPath extends string> = TPath extends keyof RegisteredRouteParams
+	? [keyof RegisteredRouteParams[TPath]] extends [never]
+		? { params?: never }
+		: { params: RegisteredRouteParams[TPath] }
+	: "routes" extends keyof FlareRegister
+		? _ParamsForRoute<TPath>
+		: _ParamsFromPath<TPath>;
+
+type _ParamsForRoute<TPath extends string> = TPath extends keyof RegisteredRoutes
+	? RegisteredRoutes[TPath] extends { params: infer P }
+		? [keyof P] extends [never]
+			? { params?: never }
+			: { params: P }
+		: { params?: never }
+	: { params?: never };
+
+type _ParamsFromPath<TPath extends string> = [keyof ExtractPathParams<TPath>] extends [never]
+	? { params?: never }
+	: { params: ExtractPathParams<TPath> };
+
+/** Loader data type for a route by virtualPath — falls back to unknown for unregistered paths */
+export type RouteLoaderData<TPath extends string> = [RouteModule<TPath>] extends [never]
+	? unknown
+	: InferLoaderData<RouteModule<TPath>>;
+
+/** Path params type for a route by virtualPath — falls back to ExtractPathParams for unregistered paths */
+export type RoutePathParams<TPath extends string> = [RouteModule<TPath>] extends [never]
+	? ExtractPathParams<TPath>
+	: InferParams<RouteModule<TPath>>;
+
+/** Search params type for a route by virtualPath — falls back to unknown for unregistered paths */
+export type RouteSearchParams<TPath extends string> = [RouteModule<TPath>] extends [never]
+	? unknown
+	: InferSearchParams<RouteModule<TPath>>;
+
+/** Parent preloader context for a route (parents only, excludes self) — used by builders */
+export type ParentPreloaderContext<TPath extends string> = TPath extends keyof RegisteredRouteParents
+	? RegisteredRouteParents[TPath] extends readonly string[]
+		? PreloaderChain<RegisteredRouteParents[TPath]>
+		: {}
+	: {};
+
+/** Accumulated preloader context for a route (includes all parent layouts) — falls back to unknown */
+export type RoutePreloaderContext<TPath extends string> = [RouteModule<TPath>] extends [never]
+	? unknown
+	: TPath extends keyof RegisteredRouteParents
+		? RegisteredRouteParents[TPath] extends readonly string[]
+			? PreloaderChain<[...RegisteredRouteParents[TPath], TPath]>
+			: InferPreloaderContext<RouteModule<TPath>>
+		: InferPreloaderContext<RouteModule<TPath>>;

package/src/route-builder/types.ts

@@ -0,0 +1,294 @@
+import type { Duration } from "../duration/index.ts";
+import type { RedirectOptions } from "../errors/index.ts";
+import type { Location } from "../router-primitives/index.ts";
+import type { FlareStore, FlareStoreEntry, StaticEntryData } from "../store/index.ts";
+import type { RouteParamsProps, RoutePaths, RouteSearchProps } from "./register.ts";
+
+export type { FlareStore, FlareStoreEntry, StaticEntryData };
+
+export type AuthenticateMode = false | "optional" | true;
+
+/**
+ * Symbol marker for route builder chain methods that look like render fns
+ * but return builder objects. Used to filter them out in SSR/hydration/navigation
+ * so Outlet doesn't try to call them as component render fns.
+ */
+export const BUILDER_MARKER = Symbol("flare-builder");
+
+/* server-only throw helpers — attached to preloader/authorize/loader contexts */
+export interface ServerThrowHelpers {
+	notFound: (message?: string) => never;
+	redirect: <TPath extends RoutePaths>(options: RedirectOptions<TPath>) => never;
+	unauthenticated: (message?: string) => never;
+	unauthorized: (message?: string) => never;
+}
+
+/* cache config */
+export type PrefetchStrategy = false | "intent" | "render" | "viewport";
+
+export interface ClientCacheConfig {
+	cacheDeferred?: boolean;
+	gcTime?: Duration;
+	prefetch?: PrefetchStrategy;
+	prefetchGcTime?: Duration;
+	prefetchStaleTime?: Duration;
+	staleTime?: Duration;
+}
+
+export interface SsrCacheConfig {
+	key?: (ctx: { params: Record<string, string | string[]> }) => string;
+	staleTime?: Duration;
+	tags?: string[] | ((ctx: { params: Record<string, string | string[]> }) => string[]);
+	ttl?: Duration;
+}
+
+export interface CdnCacheConfig {
+	maxAge?: Duration;
+	private?: boolean;
+	swr?: Duration;
+	tags?: string[] | ((ctx: { params: Record<string, string | string[]> }) => string[]);
+	vary?: string[];
+}
+
+/* static/ISR route cache — conditional on path params */
+type _Segment<T extends string> = T extends `[[...${infer N}]]`
+	? { [K in N]: string[] | undefined }
+	: T extends `[[${infer N}]]`
+		? { [K in N]: string | undefined }
+		: T extends `[...${infer N}]`
+			? { [K in N]: string[] }
+			: T extends `[${infer N}]`
+				? { [K in N]: string }
+				: {};
+
+type _PathParams<T extends string> = T extends `${infer H}/${infer R}` ? _Segment<H> & _PathParams<R> : _Segment<T>;
+
+type FlatPathParams<T extends string> = _PathParams<T> extends infer R ? { [K in keyof R]: R[K] } : never;
+
+type HasDynamicSegments<T extends string> = T extends `${string}[${string}]${string}` ? true : false;
+
+export type StaticDeferMode = "resolve" | "stream";
+
+type ParamsFn<TPath extends string> = (ctx: {
+	params: Record<string, string | string[]>;
+}) => FlatPathParams<TPath>[] | Promise<FlatPathParams<TPath>[]>;
+
+/**
+ * SSG config — fully static at build time, no revalidation.
+ *
+ * - `true` — static, inherits params from parent layouts
+ * - `{ defer?: ... }` — static with defer mode
+ * - `(ctx) => Params[]` — static with dynamic segments (shorthand)
+ * - `{ params, defer? }` — static with dynamic segments + options
+ */
+type SsgCacheConfig<TPath extends string> =
+	| true
+	| { defer?: StaticDeferMode }
+	| (HasDynamicSegments<TPath> extends true
+			? ParamsFn<TPath> | { defer?: StaticDeferMode; params: ParamsFn<TPath> }
+			: never);
+
+/**
+ * ISR config — incremental static regeneration.
+ *
+ * - `true` — on-demand ISR, no build-time prerender, tag-invalidated only
+ * - `{ revalidate?, defer? }` — time-based ISR, inherits params from parent layouts
+ * - `{ revalidate?, params, defer?, dynamicParams? }` — ISR with dynamic segments
+ *
+ * When `revalidate` is omitted, pages are cached forever and only
+ * refreshed via on-demand revalidation (tags/keys).
+ *
+ * `dynamicParams` (default `true`): when `false`, unlisted param values return 404.
+ * When `true`, unlisted values fall through to on-demand SSR.
+ */
+type IsrCacheConfig<TPath extends string> =
+	| true
+	| { defer?: StaticDeferMode; revalidate?: Duration }
+	| (HasDynamicSegments<TPath> extends true
+			? {
+					defer?: StaticDeferMode;
+					dynamicParams?: boolean;
+					params: ParamsFn<TPath>;
+					revalidate?: Duration;
+				}
+			: never);
+
+interface BaseCacheConfig {
+	cdn?: CdnCacheConfig | false;
+	client?: ClientCacheConfig | false;
+}
+
+/* ssg, isr, ssr are mutually exclusive rendering strategies via discriminated union */
+export type CacheConfig<TPath extends string = string> = BaseCacheConfig &
+	(
+		| { isr: IsrCacheConfig<TPath>; ssg?: never; ssr?: never }
+		| { isr?: never; ssg: SsgCacheConfig<TPath>; ssr?: never }
+		| { isr?: never; ssg?: never; ssr: SsrCacheConfig }
+		| { isr?: never; ssg?: never; ssr?: never }
+	);
+
+/* input validation — uses unified Validator<T> from validation module */
+import type { StandardSchemaV1 } from "../validation/index.ts";
+
+export type { Validator } from "../validation/index.ts";
+
+/* Params validators receive Record<string, string | string[]> at runtime.
+ * Standard Schema validators work directly on the plain object. */
+export type ParamsValidator<T> =
+	| StandardSchemaV1<T>
+	| { parse: (raw: Record<string, string | string[]>) => T }
+	| ((raw: Record<string, string | string[]>) => T);
+
+/* Search params validators receive URLSearchParams at runtime.
+ * Standard Schema validators get auto-converted to plain object in the pipeline. */
+export type SearchParamsValidator<T> =
+	| StandardSchemaV1<T>
+	| { parse: (raw: URLSearchParams) => T }
+	| ((raw: URLSearchParams) => T);
+
+export interface InputConfig<TParams, TSearch> {
+	params?: ParamsValidator<TParams>;
+	searchParams?: SearchParamsValidator<TSearch>;
+}
+
+/* effects */
+export interface EffectsContext<TParams, TSearch> {
+	location: {
+		current: { hash: string; params: TParams; pathname: string; search: TSearch };
+		next: { hash: string; params: TParams; pathname: string; search: TSearch };
+	};
+	trigger: "initial" | "navigation" | "revalidation";
+}
+
+export interface EffectsConfig<TParams, TSearch> {
+	loaderDeps?: (ctx: { search: TSearch }) => unknown[];
+	shouldRefetch?: (ctx: EffectsContext<TParams, TSearch>) => boolean;
+}
+
+/* loader */
+export type LoaderCause = "enter" | "prefetch" | "stay";
+
+export interface Deferred<T> {
+	__deferred: true;
+	key: string;
+	prerender?: StaticDeferMode;
+	promise: Promise<T>;
+}
+
+export type DeferFn = <T>(fn: () => Promise<T>, options?: { key?: string; prerender?: StaticDeferMode }) => Deferred<T>;
+
+/* head */
+export interface SeoImage {
+	alt?: string;
+	height?: number;
+	type?: string;
+	url: string;
+	width?: number;
+}
+
+export interface FaviconConfig {
+	"96x96"?: string;
+	"192x192"?: string;
+	"512x512"?: string;
+	appleTouchIcon?: string;
+	ico?: string;
+	svg?: string;
+}
+
+export interface RobotsConfig {
+	follow?: boolean;
+	index?: boolean;
+	"max-image-preview"?: "large" | "none" | "standard";
+	"max-snippet"?: number;
+	"max-video-preview"?: number;
+	noarchive?: boolean;
+	noimageindex?: boolean;
+}
+
+export interface OpenGraphConfig {
+	alternateLocale?: string[];
+	audio?: Array<{ secureUrl?: string; type?: string; url: string }>;
+	description?: string;
+	images?: SeoImage[];
+	locale?: string;
+	siteName?: string;
+	title?: string;
+	type?: "article" | "product" | "profile" | "website";
+	url?: string;
+	videos?: Array<{
+		height?: number;
+		secureUrl?: string;
+		type?: string;
+		url: string;
+		width?: number;
+	}>;
+}
+
+export interface TwitterConfig {
+	card?: "app" | "player" | "summary" | "summary_large_image";
+	creator?: string;
+	description?: string;
+	images?: Array<{ alt?: string; url: string }>;
+	site?: string;
+	title?: string;
+}
+
+export interface MetaConfig {
+	applicationName?: string;
+	appleMobileWebAppCapable?: "no" | "yes";
+	appleMobileWebAppStatusBarStyle?: "black" | "black-translucent" | "default";
+	appleMobileWebAppTitle?: string;
+	author?: string;
+	charset?: string;
+	creator?: string;
+	generator?: string;
+	manifest?: string;
+	mobileWebAppCapable?: "no" | "yes";
+	publisher?: string;
+	viewport?: false | string;
+}
+
+export interface CustomHeadConfig {
+	links?: Array<Record<string, string>>;
+	meta?: Array<Record<string, string>>;
+	scripts?: Array<{ async?: boolean; children?: string; extra?: Record<string, string>; src?: string; type?: string }>;
+	styles?: Array<{ children: string }>;
+}
+
+export interface HeadConfig {
+	canonical?: string;
+	css?: string | string[];
+	custom?: CustomHeadConfig;
+	description?: string;
+	favicons?: FaviconConfig;
+	images?: SeoImage[];
+	jsonLd?: Array<Record<string, unknown>>;
+	keywords?: string;
+	languages?: Record<string, string>;
+	meta?: MetaConfig;
+	openGraph?: OpenGraphConfig;
+	robots?: RobotsConfig;
+	title?: string;
+	twitter?: TwitterConfig;
+}
+
+export interface HeadOptions {
+	replace?: boolean;
+}
+
+export type ResponseHeaders = Record<string, string | string[]>;
+
+/* type-safe URL building — shared by FlareRouter (client) and server contexts */
+export type BuildUrlOptions<TPath extends RoutePaths = RoutePaths> = {
+	hash?: string;
+	to: TPath;
+} & RouteParamsProps<TPath> &
+	RouteSearchProps<TPath>;
+
+/* server-only URL helpers — attached to preloader/authorize/loader/head/headers contexts */
+export interface ServerUrlHelpers {
+	buildUrl: <TPath extends RoutePaths>(options: BuildUrlOptions<TPath>) => string;
+}
+
+/* re-export Location for convenience */
+export type { Location };

package/src/router-config/index.ts

@@ -0,0 +1,91 @@
+import type { DirectionConfig } from "../direction.ts";
+import type { LocaleConfig } from "../locale/index.tsx";
+import type { LocationRewrite } from "../rewrite/index.ts";
+import type { ClientCacheConfig } from "../route-builder/types.ts";
+import type { Location, TreeNode } from "../router-primitives/types.ts";
+import { parseFlareState as _parseFlareState } from "../state-parser/index.ts";
+import type { ThemeConfig } from "../theme.ts";
+
+export type PrefetchStrategy = false | "intent" | "render" | "viewport";
+export type TrailingSlashMode = "always" | "never" | "preserve";
+export type ViewTransitionDefaults = boolean | { types: string[] };
+
+export interface RouterCacheConfig {
+	client?: ClientCacheConfig | false;
+}
+
+export interface RouterConfig {
+	basePath?: string;
+	cache?: RouterCacheConfig;
+	caseSensitive?: boolean;
+	direction?: DirectionConfig;
+	getScrollRestorationKey?: (location: Location) => string;
+	layouts: Record<string, () => Promise<{ default: unknown }>>;
+	locale?: LocaleConfig;
+	notFoundMode?: "fuzzy" | "root";
+	queryClientGetter?: () => unknown;
+	rewrite?: LocationRewrite;
+	routeCacheMaxEntries?: number;
+	routeTree: TreeNode;
+	scrollRestoration?: boolean;
+	scrollRestorationBehavior?: "auto" | "smooth";
+	scrollRestorationMaxEntries?: number;
+	theme?: ThemeConfig;
+	trailingSlash?: TrailingSlashMode;
+	viewTransitions?: ViewTransitionDefaults;
+}
+
+export interface SerializableRouterConfig {
+	basePath?: string;
+	cache?: RouterCacheConfig;
+	caseSensitive?: boolean;
+	direction?: DirectionConfig;
+	keepalive?: false | number;
+	locale?: LocaleConfig;
+	notFoundMode?: "fuzzy" | "root";
+	routeCacheMaxEntries?: number;
+	scrollRestoration?: boolean;
+	scrollRestorationBehavior?: "auto" | "smooth";
+	scrollRestorationMaxEntries?: number;
+	theme?: ThemeConfig;
+	trailingSlash?: TrailingSlashMode;
+	viewTransitions?: ViewTransitionDefaults;
+}
+
+const MARKER = Symbol.for("flare/router-config");
+
+export interface MarkedRouterConfig extends RouterConfig {
+	[key: symbol]: true;
+}
+
+export function createRouter(config: RouterConfig): MarkedRouterConfig {
+	return { ...config, [MARKER]: true } as MarkedRouterConfig;
+}
+
+export function isRouterConfig(value: unknown): value is MarkedRouterConfig {
+	return (
+		value !== null &&
+		value !== undefined &&
+		typeof value === "object" &&
+		MARKER in (value as Record<symbol, unknown>) &&
+		(value as Record<symbol, unknown>)[MARKER] === true
+	);
+}
+
+export function extractSerializable(router: MarkedRouterConfig): SerializableRouterConfig {
+	const {
+		getScrollRestorationKey: _gsr,
+		layouts: _l,
+		queryClientGetter: _q,
+		rewrite: _rw,
+		routeTree: _rt,
+		...clean
+	} = router;
+
+	/* remove symbol marker */
+	const result = { ...clean } as Record<string | symbol, unknown>;
+	delete result[MARKER];
+	return result as SerializableRouterConfig;
+}
+
+export const parseFlareState = _parseFlareState;

package/src/router-primitives/index.ts

@@ -0,0 +1,25 @@
+export { buildLocation } from "./location.ts";
+export { computeMatchId, parseMatchId } from "./match-id.ts";
+export {
+	deriveLayouts,
+	deriveParams,
+	extractLayoutKey,
+	isParamSegment,
+	isRootLayoutPath,
+	stripGroups,
+	toUrlPath,
+	toVirtualPath,
+} from "./paths.ts";
+export { createTreeNode, insertRoute, matchRoute, matchRoutePartial, toLocaleMatch } from "./tree.ts";
+export type { LocaleMatch } from "./tree.ts";
+export type {
+	ComputeMatchIdOptions,
+	Location,
+	MatchResult,
+	ParsedMatchId,
+	PrefetchStrategy,
+	RouteData,
+	RouteMeta,
+	RouteMetaClient,
+	TreeNode,
+} from "./types.ts";

package/src/router-primitives/location.ts

@@ -0,0 +1,29 @@
+import type { SearchParams } from "../url/index.ts";
+import { parseSearchParams } from "../url/index.ts";
+import type { Location } from "./types.ts";
+
+export function buildLocation<
+	TParams extends Record<string, string | string[]>,
+	TSearch = SearchParams,
+	THash = string,
+>(
+	url: URL,
+	params: TParams,
+	virtualPath: string,
+	variablePath: string,
+	search?: TSearch,
+	hash?: THash,
+): Location<TParams, TSearch, THash> {
+	const resolvedSearch = search ?? (parseSearchParams(url.searchParams) as TSearch);
+	const resolvedHash = hash ?? (url.hash as THash);
+
+	return {
+		hash: resolvedHash,
+		params,
+		pathname: url.pathname,
+		search: resolvedSearch,
+		url,
+		variablePath,
+		virtualPath,
+	};
+}