@solidjs/router 1.0.0-next.9 → 2.0.0-next.12

package/dist/server.js

@@ -3,24 +3,27 @@
 // it reaches for node async context via @solidjs/web/storage — keep it out of
 // client bundles.
 //
-// Two policies live here, both previously implemented inside SolidStart and
-// now owned by the router (the vocabulary — query keys, submissions — is the
-// router's):
+// One policy lives here — the vocabulary (query keys, route trees, preloads)
+// is the router's:
 //
 // - single-flight mutations: `createFlightDataCollector` produces the
 //   `collectFlightData` hook the app hands to
-//   `configureServerFunctionsServer` (or the handler options). After a
-//   mutation it produces the route data the mutation invalidated for the
-//   page the client is on (or is being redirected to), which the handler
-//   folds into the response — mutation and fresh data in one round trip.
-// - the no-JS form convention: `createNoJSHandler` produces the
-//   `handleNoJS` hook — form posts made without the client runtime redirect
-//   back (303) carrying the outcome in a one-shot flash cookie that the
-//   router's SSR initialization reads into submission state.
+//   `configureServerFunctionsServer` (or the handler options). The runtime
+//   pre-digests the generic halves onto the outcome (target URL,
+//   revalidation keys, post-mutation cookie headers); the collector runs
+//   the matched routes' preloads for the target and returns their `query`
+//   results, which the handler folds into the response — mutation and
+//   fresh data in one round trip.
+//
+// The no-JS form convention used to live here too; the runtime now owns it
+// outright — it applies to browser form posts by default (redirect back with
+// the outcome in a one-shot flash cookie), and `createNoJSHandler` is
+// configured through @solidjs/web/server-functions/server. The router keeps
+// only its read side: SSR initialization seeds the decoded cookie into
+// submission state (routing.ts).
 import { provideRequestEvent } from "@solidjs/web/storage";
 import { createBranches, getRouteMatches, mergeParams, peekLazySubtrees, resolveLazySubtree } from "./routing.js";
 import { extractSearchParams } from "./utils.js";
-import { encodeFlashCookie } from "./data/flash.js";
 // the instance is the provider component, so it (unlike an options object) is a function
 function isRouterInstance(options) {
     return typeof options === "function";
@@ -32,13 +35,12 @@ function isRouterInstance(options) {
  * and `preload` are the single source of truth — or an options object for
  * trees not created through the factory.
  *
- * Strategy: rerun the route data for the URL the client will show
- * after the mutation — the redirect `Location` when the outcome carries
- * one, the referring page otherwise — collecting each `query` result under
- * its cache key, scoped to the outcome's `X-Revalidate` keys when present
- * (routes newly entered via redirect always collect fully). The returned
- * payload seeds the client router's cache through its registered
- * flight-data consumer.
+ * Strategy: rerun the route data for the URL the client will show after
+ * the mutation (the outcome's pre-digested `targetUrl`), collecting each
+ * `query` result under its cache key, scoped to the outcome's
+ * `revalidateKeys` when present (routes newly entered via redirect always
+ * collect fully). The returned payload seeds the client router's cache
+ * through its registered flight-data consumer.
  */
 export function createFlightDataCollector(options) {
     const { routes, rootPreload, base = "" } = isRouterInstance(options)
@@ -59,41 +61,29 @@ export function createFlightDataCollector(options) {
         return branches;
     };
     return async (sourceEvent, outcome) => {
-        // no referrer, nothing to produce data for (e.g. non-browser callers)
-        const referrer = outcome.request.headers.get("referer");
-        if (!referrer)
-            return undefined;
-        // a raw body-carrying Response is the caller's verbatim payload — there
-        // is no envelope to fold data into
-        if (outcome.value instanceof Response && outcome.value.body)
-            return undefined;
-        const origin = new URL(outcome.request.url).origin;
-        let revalidate;
-        let url = new URL(referrer).toString();
-        if (outcome.response) {
-            if (outcome.response.headers.has("X-Revalidate"))
-                revalidate = outcome.response.headers.get("X-Revalidate").split(",");
-            if (outcome.response.headers.has("Location"))
-                url = new URL(outcome.response.headers.get("Location"), origin + base).toString();
-        }
-        // redirects leaving the app can't be collected for
-        if (new URL(url).origin !== origin)
+        // The generic halves arrive pre-digested on the outcome: no target
+        // (non-browser caller without a referer, or a redirect leaving the
+        // app's origin) means nothing to produce data for.
+        const { targetUrl, revalidateKeys } = outcome;
+        if (!targetUrl)
             return undefined;
+        // a target implies a referer — it is the fallback target
+        const previousUrl = outcome.request.headers.get("referer");
         // The flight event: the source event (its `response` rides along, so
         // cookies/headers set during preloads still reach the real response)
-        // pointed at the target URL, with the mutation's own cookie mutations
-        // folded into the request, in data-only router mode.
+        // pointed at the target URL, with the mutation's cookie effects already
+        // folded in (the outcome's `foldedHeaders`), in data-only router mode.
         const event = { ...sourceEvent };
-        event.request = new Request(url, { headers: createSingleFlightHeaders(sourceEvent) });
+        event.request = new Request(targetUrl, { headers: outcome.foldedHeaders });
         event.router = {
-            dataOnly: revalidate || true,
-            previousUrl: referrer,
+            dataOnly: revalidateKeys || true,
+            previousUrl,
             data: {}
         };
         return provideRequestEvent(event, async () => {
             try {
-                await resolveLazyMatches(resolveBranches, url, referrer);
-                runPreloads(event, resolveBranches(), url, referrer, rootPreload);
+                await resolveLazyMatches(resolveBranches, targetUrl, previousUrl);
+                runPreloads(event, resolveBranches(), targetUrl, previousUrl, rootPreload);
             }
             catch (error) {
                 console.error(error);
@@ -164,101 +154,3 @@ function runPreloads(event, branches, url, previousUrl, rootPreload) {
             });
     }
 }
-/**
- * The request headers for the flight-data collection pass: the source
- * request's headers with the mutation's `Set-Cookie` mutations folded into
- * the `Cookie` header, so preloads observe the post-mutation cookie state
- * (deletions honored via Max-Age/Expires).
- */
-export function createSingleFlightHeaders(sourceEvent) {
-    const headers = new Headers(sourceEvent.request.headers);
-    const setCookies = sourceEvent.response?.headers?.getSetCookie() ?? [];
-    if (!setCookies.length)
-        return headers;
-    const cookies = {};
-    for (const pair of headers.get("cookie")?.split(";") ?? []) {
-        const eq = pair.indexOf("=");
-        if (eq > -1)
-            cookies[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
-    }
-    for (const setCookie of setCookies) {
-        const parsed = parseSetCookie(setCookie);
-        if (!parsed)
-            continue;
-        if ((parsed.maxAge != null && parsed.maxAge <= 0) ||
-            (parsed.expires != null && parsed.expires.getTime() <= Date.now())) {
-            delete cookies[parsed.name];
-        }
-        else {
-            cookies[parsed.name] = parsed.value;
-        }
-    }
-    headers.delete("cookie");
-    const serialized = Object.entries(cookies)
-        .map(([name, value]) => `${name}=${value}`)
-        .join("; ");
-    if (serialized)
-        headers.set("cookie", serialized);
-    return headers;
-}
-function parseSetCookie(setCookie) {
-    const [pair, ...attributes] = setCookie.split(";");
-    const eq = pair.indexOf("=");
-    if (eq < 0)
-        return undefined;
-    const parsed = {
-        name: pair.slice(0, eq).trim(),
-        value: pair.slice(eq + 1).trim()
-    };
-    for (const attribute of attributes) {
-        const attrEq = attribute.indexOf("=");
-        const key = (attrEq < 0 ? attribute : attribute.slice(0, attrEq)).trim().toLowerCase();
-        const value = attrEq < 0 ? "" : attribute.slice(attrEq + 1).trim();
-        if (key === "max-age")
-            parsed.maxAge = Number(value);
-        else if (key === "expires")
-            parsed.expires = new Date(value);
-    }
-    return parsed;
-}
-// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages
-const validRedirectStatuses = new Set([301, 302, 303, 307, 308]);
-/**
- * Produces the `handleNoJS` implementation for
- * `handleServerFunctionRequest` options: form posts made without the client
- * runtime redirect back to the referring page (or to the result's
- * `Location`) with the outcome riding a one-shot `flash` cookie. The
- * router's SSR initialization reads the cookie into submission state, so
- * `useSubmission()` renders the result exactly as a scripted submission
- * would — progressive enhancement with no app code.
- */
-export function createNoJSHandler(options = {}) {
-    const { base = "" } = options;
-    return function handleNoJS(result, request, args, thrown) {
-        const url = new URL(request.url);
-        const back = request.headers.get("referer") || url.origin + base;
-        // form post -> GET: 303 See Other unless the result names a redirect status
-        let status = 303;
-        let headers;
-        if (result instanceof Response) {
-            headers = new Headers(result.headers);
-            if (result.headers.has("Location")) {
-                headers.set("Location", new URL(result.headers.get("Location"), url.origin + base).toString());
-                if (validRedirectStatuses.has(result.status))
-                    status = result.status;
-            }
-            else {
-                headers.set("Location", back);
-            }
-        }
-        else {
-            headers = new Headers({ Location: back });
-        }
-        // Responses carry their meaning in their metadata; anything else flashes
-        // the outcome for the next render's submission state.
-        if (result && !(result instanceof Response)) {
-            headers.append("Set-Cookie", encodeFlashCookie(url.pathname + url.search, result, args, thrown));
-        }
-        return new Response(null, { status, headers });
-    };
-}

package/dist/types.d.ts

@@ -96,19 +96,48 @@ export interface RouterIntegration {
     utils?: Partial<RouterUtils>;
 }
 export type Intent = "initial" | "native" | "navigate" | "preload";
-export interface RoutePreloadFuncArgs {
-    params: Params;
+export interface RoutePreloadFuncArgs<P extends Params = Params> {
+    params: P;
     location: Location;
     intent: Intent;
 }
-export type RoutePreloadFunc<T = unknown> = (args: RoutePreloadFuncArgs) => T;
-export interface RouteSectionProps<T = unknown> {
-    params: Params;
+export type RoutePreloadFunc<T = unknown, P extends Params = Params> = (args: RoutePreloadFuncArgs<P>) => T;
+export interface RouteSectionProps<T = unknown, P extends Params = Params> {
+    params: P;
     location: Location;
     data: T;
     children?: JSX.Element;
 }
-export type RouteSectionComponent<T = unknown> = Component<RouteSectionProps<T>> | Component<Omit<RouteSectionProps<T>, "children">> | Component<{}>;
+export type RouteSectionComponent<T = unknown, P extends Params = Params> = Component<RouteSectionProps<T, P>> | Component<Omit<RouteSectionProps<T, P>, "children">> | Component<{}>;
+declare const ROUTE_PATTERN: unique symbol;
+export interface TypedRouteConfig<S extends string = string> {
+    readonly [ROUTE_PATTERN]: S;
+}
+type RouteDataOf<Path> = Path extends TypedRouteConfig & {
+    preload?: RoutePreloadFunc<infer T>;
+} ? T : unknown;
+/**
+ * Props for a route component declared away from its definition, typed by a
+ * path witness — the same `paths` node you navigate with, the pattern string
+ * when no instance is in scope, or a `defineFileRoute` config (which also
+ * types `data` from its `preload`):
+ *
+ * ```ts
+ * function Story(props: RouteProps<typeof Router.paths.stories>) {}
+ * function Story(props: RouteProps<"/stories/:id", StoryData>) {}
+ * function Post(props: RouteProps<typeof route>) {} // file-system route files
+ * ```
+ */
+export type RouteProps<Path, T = RouteDataOf<Path>> = RouteSectionProps<T, Path extends TypedPath<infer P> ? SimplifyRecord<P> & Params : Path extends TypedRouteConfig<infer S> ? RouteParams<S> : RouteParams<Path>>;
+/**
+ * Component-type counterpart of `RouteProps` — annotate the component itself
+ * and the props parameter infers contextually:
+ *
+ * ```ts
+ * const Post: RouteComponent<typeof route> = props => props.params.id;
+ * ```
+ */
+export type RouteComponent<Path, T = RouteDataOf<Path>> = Component<RouteProps<Path, T>>;
 /**
  * A lazy route subtree: a thunk producing the child definitions — typically
  * `() => import("./feature/routes")` (the module's `default` or `routes`
@@ -131,15 +160,41 @@ export type RouteDefinition<S extends string | string[] = any, T = any> = {
     component?: RouteSectionComponent<T>;
     /** Standard Schema validator for this route's search params; its input type flows into the typed path proxy. */
     search?: StandardSchemaV1<any, any>;
-    info?: Record<string, any>;
+    info?: RouteInfo;
 };
+import type { RouteInfo } from "./index.jsx";
+export type { RouteInfo };
 export type MatchFilter = readonly string[] | RegExp | ((s: string) => boolean);
 export type PathParams<P extends string | readonly string[]> = P extends `${infer Head}/${infer Tail}` ? [...PathParams<Head>, ...PathParams<Tail>] : P extends `:${infer S}?` ? [S] : P extends `:${infer S}` ? [S] : P extends `*${infer S}` ? [S] : [];
 export type MatchFilters<P extends string | readonly string[] = any> = P extends string ? {
     [K in PathParams<P>[number]]?: MatchFilter;
 } : Record<string, MatchFilter>;
-export interface PathMatch {
-    params: Params;
+export type DefinedRouteFilters<S> = S extends readonly (infer Member extends string)[] ? MatchFilters<Member> : S extends string | readonly string[] ? MatchFilters<S> : MatchFilters;
+type FilterKeysOf<S> = S extends readonly (infer Member extends string)[] ? PathParams<Member>[number] : S extends string ? PathParams<S>[number] : string;
+export type ValidFilters<F, S> = {
+    [K in keyof F]: string extends K ? F[K] : K extends FilterKeysOf<S> ? MatchFilter : never;
+};
+type PatternParams<P extends string> = P extends `${infer Head}/${infer Tail}` ? PatternParams<Head> & PatternParams<Tail> : P extends `:${infer Name}?` ? {
+    [K in Name]?: string;
+} : P extends `:${infer Name}` ? {
+    [K in Name]: string;
+} : P extends `*${infer Name}` ? {
+    [K in Name]: string;
+} : {};
+type SimplifyRecord<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * The params a route pattern guarantees, as a precise record — `:id` is
+ * `string`, `:tab?` is `string | undefined`, `*rest` is `string`. The record
+ * is intersected with the open `Params` shape so params inherited from
+ * parent routes stay accessible (as `string | undefined`). Array patterns
+ * yield the union of their members' records; non-literal patterns degrade
+ * to plain `Params`.
+ */
+export type RouteParams<S> = (S extends readonly (infer Member extends string)[] ? SimplifyRecord<PatternParams<Member>> : S extends string ? string extends S ? {} : SimplifyRecord<PatternParams<S>> : {}) & Params;
+export interface PathMatch<P extends Params = Params> {
+    params: P;
     path: string;
 }
 export interface RouteMatch extends PathMatch {
@@ -150,7 +205,7 @@ export interface OutputMatch {
     pattern: string;
     match: string;
     params: Params;
-    info?: Record<string, any>;
+    info?: RouteInfo;
 }
 export interface RouteDescription {
     key: unknown;
@@ -160,7 +215,7 @@ export interface RouteDescription {
     preload?: RoutePreloadFunc;
     matcher: (location: string) => PathMatch | null;
     matchFilters?: MatchFilters;
-    info?: Record<string, any>;
+    info?: RouteInfo;
     /** Present on the placeholder that stands in for an unresolved lazy subtree. */
     lazy?: LazyBoundary;
 }
@@ -250,4 +305,3 @@ export type CacheEntry = [number, Promise<any>, any, Intent | undefined, Signal<
     count: number;
 }];
 export type NarrowResponse<T> = T extends ResponseEnvelope<infer U> ? U : Exclude<T, Response>;
-export {};

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "1.0.0-next.9",
+  "version": "2.0.0-next.12",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -23,14 +23,15 @@
       "solid": "./dist/index.jsx",
       "default": "./dist/index.js"
     },
-    "./server": "./dist/server.js"
+    "./server": "./dist/server.js",
+    "./fs": "./dist/fs.js"
   },
   "files": [
     "dist"
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@solidjs/web": "2.0.0-beta.22",
+    "@solidjs/web": "2.0.0-beta.28",
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@changesets/cli": "^2.27.10",
@@ -39,19 +40,19 @@
     "@rollup/plugin-terser": "0.4.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "2.0.0-beta.22",
+    "babel-preset-solid": "2.0.0-beta.28",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "2.0.0-beta.22",
+    "solid-js": "2.0.0-beta.28",
     "typescript": "^5.7.2",
     "vite": "^6.0.0",
     "vite-plugin-solid": "3.0.0-next.10",
     "vitest": "^2.1.6"
   },
   "peerDependencies": {
-    "@solidjs/web": ">=2.0.0-beta.22 <2.0.0-experimental.0",
-    "solid-js": ">=2.0.0-beta.22 <2.0.0-experimental.0"
+    "@solidjs/web": ">=2.0.0-beta.28 <2.0.0-experimental.0",
+    "solid-js": ">=2.0.0-beta.28 <2.0.0-experimental.0"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",

package/dist/data/flash.d.ts

@@ -1,21 +0,0 @@
-export { FLASH_COOKIE, hasFlashCookie, clearFlashCookie } from "./flashCookie.js";
-/** What rides the cookie: a Submission minus its lifecycle methods. */
-export interface FlashSubmission {
-    input: any[];
-    url: string;
-    result?: any;
-    error?: any;
-}
-/**
- * Encodes the outcome of a no-JS submission as a Set-Cookie value. `url` is
- * the action url (pathname + search of the server function call) so the
- * seeded submission matches `useSubmission` filters; `thrown` errors land on
- * `error`, returned values on `result` (mirroring the scripted split).
- */
-export declare function encodeFlashCookie(url: string, result: any, input: any[], thrown?: boolean): string;
-/**
- * Decodes the flash cookie out of a request's Cookie header. Returns
- * undefined when absent or unreadable (a malformed cookie must never take
- * down SSR — it is cleared either way).
- */
-export declare function decodeFlashCookie(cookieHeader: string | null): FlashSubmission | undefined;

package/dist/data/flash.js

@@ -1,78 +0,0 @@
-// The no-JS form convention's cookie codec. When a form posts to a server
-// function without the client runtime (no instance header), the server
-// handler redirects back carrying the outcome in a one-shot "flash" cookie;
-// the next SSR pass reads it and seeds the router's submission state so
-// useSubmission() renders the result exactly as a scripted submission would.
-// Both codec halves live in this module so the write (src/server.ts, the
-// handler's handleNoJS) and the read (provided to the router core by
-// data/action.ts) can never drift apart. The cookie's name/clearing live in
-// flashCookie.ts — the only piece the router core itself consumes — so this
-// codec stays out of bundles that never load the action layer.
-import { FLASH_COOKIE, matchFlashCookie } from "./flashCookie.js";
-export { FLASH_COOKIE, hasFlashCookie, clearFlashCookie } from "./flashCookie.js";
-// Form payloads have no JSON encoding, so entries are captured as pair
-// arrays under a marker key ($f / $u) and revived to real FormData /
-// URLSearchParams on the way out. File entries cannot ride a cookie and are
-// dropped.
-function encodeInputValue(value) {
-    if (value instanceof FormData)
-        return { $f: [...value.entries()].filter(([, v]) => typeof v === "string") };
-    if (value instanceof URLSearchParams)
-        return { $u: [...value.entries()] };
-    return value;
-}
-function decodeInputValue(value) {
-    if (value && typeof value === "object") {
-        if (Array.isArray(value.$f)) {
-            const form = new FormData();
-            for (const [k, v] of value.$f)
-                form.append(k, v);
-            return form;
-        }
-        if (Array.isArray(value.$u))
-            return new URLSearchParams(value.$u);
-    }
-    return value;
-}
-/**
- * Encodes the outcome of a no-JS submission as a Set-Cookie value. `url` is
- * the action url (pathname + search of the server function call) so the
- * seeded submission matches `useSubmission` filters; `thrown` errors land on
- * `error`, returned values on `result` (mirroring the scripted split).
- */
-export function encodeFlashCookie(url, result, input, thrown) {
-    const isError = result instanceof Error;
-    const payload = {
-        url,
-        result: isError ? result.message : result,
-        error: isError,
-        thrown: !!thrown,
-        input: input.map(encodeInputValue)
-    };
-    return `${FLASH_COOKIE}=${encodeURIComponent(JSON.stringify(payload))}; Secure; HttpOnly; Path=/`;
-}
-/**
- * Decodes the flash cookie out of a request's Cookie header. Returns
- * undefined when absent or unreadable (a malformed cookie must never take
- * down SSR — it is cleared either way).
- */
-export function decodeFlashCookie(cookieHeader) {
-    const match = matchFlashCookie(cookieHeader);
-    if (!match)
-        return;
-    try {
-        const payload = JSON.parse(decodeURIComponent(match));
-        if (!payload || !payload.result)
-            return;
-        const result = payload.error ? new Error(payload.result) : payload.result;
-        return {
-            input: Array.isArray(payload.input) ? payload.input.map(decodeInputValue) : [],
-            url: payload.url,
-            result: payload.thrown ? undefined : result,
-            error: payload.thrown ? result : undefined
-        };
-    }
-    catch (error) {
-        console.error(error);
-    }
-}

package/dist/data/flashCookie.d.ts

@@ -1,7 +0,0 @@
-export declare const FLASH_COOKIE = "flash";
-/** Whether a Cookie header carries a flash cookie (readable or not). */
-export declare function hasFlashCookie(cookieHeader: string | null): boolean;
-/** The raw encoded flash payload out of a Cookie header, if present. */
-export declare function matchFlashCookie(cookieHeader: string | null): string | undefined;
-/** The Set-Cookie value clearing the flash cookie after it has been read. */
-export declare function clearFlashCookie(): string;

package/dist/data/flashCookie.js

@@ -1,20 +0,0 @@
-// The flash cookie's name and one-shot clearing — split from the codec in
-// flash.ts so the router core can consume the cookie eagerly (the clear must
-// be appended before streaming flushes the response headers, and an unread
-// outcome must not haunt a later request) without carrying the encode/decode
-// machinery into client bundles that never load the action layer.
-export const FLASH_COOKIE = "flash";
-const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
-/** Whether a Cookie header carries a flash cookie (readable or not). */
-export function hasFlashCookie(cookieHeader) {
-    return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
-}
-/** The raw encoded flash payload out of a Cookie header, if present. */
-export function matchFlashCookie(cookieHeader) {
-    const match = cookieHeader && cookieHeader.match(FLASH_MATCHER);
-    return match ? match[1] : undefined;
-}
-/** The Set-Cookie value clearing the flash cookie after it has been read. */
-export function clearFlashCookie() {
-    return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
-}