@solidjs/router 1.0.0 → 2.0.0-next.12

package/dist/data/events.d.ts

@@ -1,4 +1,12 @@
 import type { RouterContext } from "../types.js";
+/**
+ * The submit delegation consults this slot instead of importing the action
+ * module: the action side installs its handler on first action creation
+ * (see data/action.ts), so an app that never creates an action never pulls
+ * the data layer into its bundle through the router's event wiring.
+ */
+export type RouterFormHandler = (evt: SubmitEvent, router: RouterContext, actionBase: string) => void;
+export declare function setRouterFormHandler(handler: RouterFormHandler | undefined): void;
 type NativeEventConfig = {
     preload?: boolean;
     explicitLinks?: boolean;

package/dist/data/events.js

@@ -1,7 +1,9 @@
-import { delegateEvents } from "solid-js/web";
+import { delegateEvents } from "@solidjs/web";
 import { onCleanup } from "solid-js";
-import { actions } from "./action.js";
-import { mockBase } from "../utils.js";
+let formHandler;
+export function setRouterFormHandler(handler) {
+    formHandler = handler;
+}
 export function setupNativeEvents({ preload = true, explicitLinks = false, actionBase = "/_server", transformUrl } = {}) {
     return (router) => {
         const basePath = router.base.path();
@@ -76,30 +78,29 @@ export function setupNativeEvents({ preload = true, explicitLinks = false, actio
             }, 20);
         }
         function handleFormSubmit(evt) {
+            if (formHandler)
+                return formHandler(evt, router, actionBase);
+            // No form handler means no action module in the client graph at all
+            // (e.g. server components binding forms straight to server functions).
+            // A POST to a url under actionBase is self-describing, so delegation
+            // is still sufficient: intercept synchronously — the no-JS treatment
+            // is reserved for clients with no JS — capture the FormData, and load
+            // the handler lazily. Apps that never submit one never load it.
             if (evt.defaultPrevented)
                 return;
-            let actionRef = evt.submitter && evt.submitter.hasAttribute("formaction")
+            const form = evt.target;
+            const ref = evt.submitter && evt.submitter.hasAttribute("formaction")
                 ? evt.submitter.getAttribute("formaction")
-                : evt.target.getAttribute("action");
-            if (!actionRef)
+                : form.getAttribute("action");
+            if (!ref || ref.startsWith("https://action/"))
                 return;
-            if (!actionRef.startsWith("https://action/")) {
-                // normalize server actions
-                const url = new URL(actionRef, mockBase);
-                actionRef = router.parsePath(url.pathname + url.search);
-                if (!actionRef.startsWith(actionBase))
-                    return;
-            }
-            if (evt.target.method.toUpperCase() !== "POST")
-                throw new Error("Only POST forms are supported for Actions");
-            const handler = actions.get(actionRef);
-            if (handler) {
-                evt.preventDefault();
-                const data = new FormData(evt.target, evt.submitter);
-                handler.call({ r: router, f: evt.target }, evt.target.enctype === "multipart/form-data"
-                    ? data
-                    : new URLSearchParams(data));
-            }
+            const url = new URL(ref, document.baseURI);
+            const path = router.parsePath(url.pathname + url.search);
+            if (!path.startsWith(actionBase) || form.method.toUpperCase() !== "POST")
+                return;
+            evt.preventDefault();
+            const data = new FormData(form, evt.submitter);
+            import("./serverForms.js").then(m => m.submitServerForm(router, path, form, data));
         }
         // ensure delegated event run first
         delegateEvents(["click", "submit"]);

package/dist/data/index.d.ts

@@ -1,4 +1,2 @@
-export { createAsync, createAsyncStore, type AccessorWithLatest } from "./createAsync.js";
-export { action, useSubmission, useSubmissions, useAction, type Action } from "./action.js";
-export { query, revalidate, cache, type CachedFunction } from "./query.js";
-export { redirect, reload, json } from "./response.js";
+export { action, useSubmissions, useAction, type Action } from "./action.js";
+export { query, revalidate, type CachedFunction } from "./query.js";

package/dist/data/index.js

@@ -1,4 +1,2 @@
-export { createAsync, createAsyncStore } from "./createAsync.js";
-export { action, useSubmission, useSubmissions, useAction } from "./action.js";
-export { query, revalidate, cache } from "./query.js";
-export { redirect, reload, json } from "./response.js";
+export { action, useSubmissions, useAction } from "./action.js";
+export { query, revalidate } from "./query.js";

package/dist/data/query.d.ts

@@ -2,7 +2,7 @@ import type { CacheEntry, NarrowResponse } from "../types.js";
 /**
  * Revalidates the given cache entry/entries.
  */
-export declare function revalidate(key?: string | string[] | void, force?: boolean): Promise<void>;
+export declare function revalidate(key?: string | string[] | void, force?: boolean): void;
 export declare function cacheKeyOp(key: string | string[] | void, fn: (cacheEntry: CacheEntry) => void): void;
 export type CachedFunction<T extends (...args: any) => any> = T extends (...args: infer A) => infer R ? ([] extends {
     [K in keyof A]-?: A[K];
@@ -18,6 +18,4 @@ export declare namespace query {
     export var clear: () => void;
     export { _a as delete };
 }
-/** @deprecated use query instead */
-export declare const cache: typeof query;
 export declare function hashKey<T extends Array<any>>(args: T): string;

package/dist/data/query.js

@@ -1,5 +1,6 @@
-import { createSignal, getListener, getOwner, onCleanup, sharedConfig, startTransition } from "solid-js";
-import { getRequestEvent, isServer } from "solid-js/web";
+import { createSignal, getObserver, getOwner, onCleanup, sharedConfig } from "solid-js";
+import { getRequestEvent, isResponseEnvelope, isServer } from "@solidjs/web";
+import { GET, decodeResponse, getServerFunctionMetadata, isServerFunction } from "@solidjs/web/server-functions";
 import { useNavigate, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
@@ -29,11 +30,9 @@ function getCache() {
  */
 export function revalidate(key, force = true) {
     const now = Date.now();
-    // force the cache miss synchronously so a `refetch` in the same tick sees it —
-    // startTransition defers its callback to a microtask (#497)
-    force && cacheKeyOp(key, entry => (entry[0] = 0));
-    return startTransition(() => {
-        cacheKeyOp(key, entry => entry[4][1](now)); // retrigger live signals
+    cacheKeyOp(key, entry => {
+        force && (entry[0] = 0); //force cache miss
+        entry[4][1](now); // retrigger live signals
     });
 }
 export function cacheKeyOp(key, fn) {
@@ -44,9 +43,16 @@ export function cacheKeyOp(key, fn) {
     }
 }
 export function query(fn, name) {
-    // prioritize GET for server functions
-    if (fn.GET)
-        fn = fn.GET;
+    // query implies GET: the router primitive is the declaration site, so a
+    // server function handed to query() is wrapped with core `GET(fn)` here,
+    // at query-creation (module scope) — the server half records the method
+    // declaration for dispatch, the client half swaps in the GET transport.
+    // An explicit `GET(fn)` already carries the declaration on the metadata
+    // channel (`getServerFunctionMetadata(fn)?.method === "GET"`) and passes
+    // through; non-server functions are untouched.
+    if (isServerFunction(fn) && !getServerFunctionMetadata(fn)?.method) {
+        fn = GET(fn);
+    }
     const cachedFn = ((...args) => {
         const cache = getCache();
         const intent = getIntent();
@@ -72,7 +78,7 @@ export function query(fn, name) {
                 }
             }
         }
-        if (getListener() && !isServer) {
+        if (getObserver() && !isServer) {
             tracking = true;
             onCleanup(() => cached[4].count--);
         }
@@ -95,7 +101,7 @@ export function query(fn, name) {
                     "then" in cached[1]
                         ? cached[1].then(handleResponse(false), handleResponse(true))
                         : handleResponse(false)(cached[1]);
-                !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
+                !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
             }
             inPreloadFn && "then" in res && res.catch(() => { });
             return res;
@@ -112,10 +118,10 @@ export function query(fn, name) {
             cached[0] = now;
             cached[1] = res;
             cached[3] = intent;
-            !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
+            !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
         }
         else {
-            cache.set(key, (cached = [now, res, , intent, createSignal(now)]));
+            cache.set(key, (cached = [now, res, , intent, createSignal(now, { ownedWrite: true })]));
             cached[4].count = 0;
         }
         if (tracking) {
@@ -145,6 +151,14 @@ export function query(fn, name) {
         return res;
         function handleResponse(error) {
             return async (v) => {
+                let enveloped;
+                let hasEnveloped = false;
+                if (isResponseEnvelope(v)) {
+                    // respond(): the value rides in memory beside the metadata
+                    enveloped = v.value;
+                    hasEnveloped = true;
+                    v = v.response;
+                }
                 if (v instanceof Response) {
                     const e = getRequestEvent();
                     if (e) {
@@ -159,17 +173,22 @@ export function query(fn, name) {
                     if (url !== null) {
                         // client + server relative redirect
                         if (navigate && url.startsWith("/"))
-                            startTransition(() => {
-                                navigate(url, { replace: true });
-                            });
+                            navigate(url, { replace: true });
                         else if (!isServer)
                             window.location.href = url;
                         else if (e)
                             e.response.status = 302;
                         return;
                     }
-                    if (v.customBody)
-                        v = await v.customBody();
+                    if (hasEnveloped)
+                        v = enveloped;
+                    else if (v.body) {
+                        // responses the transport hands over whole (revalidation) carry a
+                        // codec-encoded body; anything else (a raw user Response) stays whole
+                        const decoded = await decodeResponse(v);
+                        if (decoded !== undefined)
+                            v = decoded;
+                    }
                 }
                 if (error)
                     throw v;
@@ -197,14 +216,12 @@ query.set = (key, value) => {
         cached[3] = "preload";
     }
     else {
-        cache.set(key, (cached = [now, Promise.resolve(value), value, "preload", createSignal(now)]));
+        cache.set(key, (cached = [now, Promise.resolve(value), value, "preload", createSignal(now, { ownedWrite: true })]));
         cached[4].count = 0;
     }
 };
 query.delete = (key) => getCache().delete(key);
 query.clear = () => getCache().clear();
-/** @deprecated use query instead */
-export const cache = query;
 function matchKey(key, keys) {
     for (let k of keys) {
         if (k && key.startsWith(k))

package/dist/data/serverForms.d.ts

@@ -0,0 +1 @@
+export { submitServerForm } from "./action.js";

package/dist/data/serverForms.js

@@ -0,0 +1,5 @@
+// The delegation fallback's lazy entry (see data/events.ts). Nothing imports
+// this module statically — it exists so the dynamic import has a target that
+// bundlers can keep as a split point: router-only apps never load the action
+// machinery unless a server-action form actually submits.
+export { submitServerForm } from "./action.js";

package/dist/fs.d.ts

@@ -0,0 +1,94 @@
+import type { DefinedRouteFilters, RouteParams, RoutePreloadFunc, RoutePreloadFuncArgs, RouteInfo, RouteSectionComponent, StandardSchemaV1, TypedRouteConfig, ValidFilters } from "./types.js";
+/**
+ * The type `defineFileRoute` hands back: `matchFilters` and `search` stay
+ * literal — and only present when provided precisely, which is what the
+ * `paths` machinery keys on once the manifest spreads this into the
+ * definition — while `preload` widens back to the plain contract. The
+ * pattern rides along as a phantom brand so `RouteProps<typeof route>`
+ * can type the file's component from the same witness.
+ */
+export type FileRouteConfig<S extends string = string, T = unknown, F = undefined, Sch = undefined> = TypedRouteConfig<S> & ([F] extends [undefined] ? {} : DefinedRouteFilters<S> extends F ? {} : {
+    matchFilters: F;
+}) & ([Sch] extends [undefined] ? {} : {
+    search: Sch;
+}) & {
+    preload?: RoutePreloadFunc<T>;
+    info?: RouteInfo;
+};
+/**
+ * Identity helper for a route file's `route` export that types `preload`'s
+ * `args.params` from a pattern witness — the file's path pattern, which the
+ * manifest (not this string) still provides at runtime:
+ *
+ * ```ts
+ * // routes/blog/[id].tsx
+ * export const route = defineFileRoute("/blog/:id", {
+ *   matchFilters: { id: int },
+ *   preload: ({ params }) => getPost(params.id) // params.id: string
+ * });
+ *
+ * export default function Post(props: RouteProps<typeof route>) {} // params *and* data typed
+ * ```
+ *
+ * `matchFilters` are validated against the pattern's params, and their
+ * types (and any `search` schema) flow through the manifest into `paths`.
+ */
+export declare function defineFileRoute<S extends string, T = unknown, const F = DefinedRouteFilters<S>, Sch extends StandardSchemaV1<any, any> | undefined = undefined>(path: S, config: {
+    matchFilters?: F & ValidFilters<F, S>;
+    preload?: (args: RoutePreloadFuncArgs<RouteParams<S>>) => T;
+    /** Standard Schema validator for this route's search params; its input type flows into the typed path proxy. */
+    search?: Sch;
+    info?: RouteInfo;
+}): FileRouteConfig<S, T, F, Sch>;
+/** A code-split module ref: delivered as a dynamic import. */
+export interface FileRouteLazyRef<M = Record<string, unknown>> {
+    src: string;
+    import(): Promise<M>;
+}
+/** An eager module ref: its picked exports are imported statically. */
+export interface FileRouteEagerRef<M = Record<string, unknown>> {
+    require(): M;
+}
+/** The shape of a nested route-manifest entry the adapter consumes. */
+export interface FileRouteEntry {
+    path: string;
+    page?: boolean;
+    $component?: FileRouteLazyRef<any> | undefined;
+    $$route?: FileRouteEagerRef<any> | undefined;
+    children?: readonly FileRouteEntry[] | undefined;
+}
+type RouteConfigOf<E> = E extends {
+    $$route: {
+        require(): {
+            route: infer R;
+        };
+    };
+} ? R : {};
+/**
+ * One manifest entry as a route definition. `children` is a required key on
+ * purpose: an optional key infers as `C | undefined`, and that union
+ * distributes `RoutePaths` into an uncallable shape.
+ */
+export type FileRouteFrom<E> = RouteConfigOf<E> & {
+    path: E extends {
+        path: infer P extends string;
+    } ? P : never;
+    component: E extends {
+        $component: object;
+    } ? RouteSectionComponent : undefined;
+    children: E extends {
+        children: infer C extends readonly FileRouteEntry[];
+    } ? FileRoutesFrom<C> : undefined;
+};
+export type FileRoutesFrom<T extends readonly FileRouteEntry[]> = {
+    [K in keyof T]: FileRouteFrom<T[K]>;
+};
+/**
+ * Converts the nested page entries of a file-system route manifest into
+ * route definitions: `$component` refs become code-split `lazy` components
+ * (their `src` doubles as the `moduleUrl` core resolves assets and islands
+ * against), and each entry's `route` config export is spread into its
+ * definition. Pass the result to `createRouter({ routes })`.
+ */
+export declare function fileRoutes<const T extends readonly FileRouteEntry[]>(entries: T): FileRoutesFrom<T>;
+export {};

package/dist/fs.js

@@ -0,0 +1,51 @@
+import { lazy } from "solid-js";
+/**
+ * Identity helper for a route file's `route` export that types `preload`'s
+ * `args.params` from a pattern witness — the file's path pattern, which the
+ * manifest (not this string) still provides at runtime:
+ *
+ * ```ts
+ * // routes/blog/[id].tsx
+ * export const route = defineFileRoute("/blog/:id", {
+ *   matchFilters: { id: int },
+ *   preload: ({ params }) => getPost(params.id) // params.id: string
+ * });
+ *
+ * export default function Post(props: RouteProps<typeof route>) {} // params *and* data typed
+ * ```
+ *
+ * `matchFilters` are validated against the pattern's params, and their
+ * types (and any `search` schema) flow through the manifest into `paths`.
+ */
+export function defineFileRoute(path, config) {
+    return config;
+}
+/**
+ * Converts the nested page entries of a file-system route manifest into
+ * route definitions: `$component` refs become code-split `lazy` components
+ * (their `src` doubles as the `moduleUrl` core resolves assets and islands
+ * against), and each entry's `route` config export is spread into its
+ * definition. Pass the result to `createRouter({ routes })`.
+ */
+export function fileRoutes(entries) {
+    const components = new Map();
+    const componentOf = (ref) => {
+        let component = components.get(ref.src);
+        if (!component) {
+            component = lazy(ref.import, ref.src);
+            components.set(ref.src, component);
+        }
+        return component;
+    };
+    const toRoute = (entry) => {
+        const config = (entry.$$route?.require().route ?? {});
+        return {
+            ...config,
+            path: entry.path,
+            component: entry.$component ? componentOf(entry.$component) : undefined,
+            info: { ...config.info, filesystem: true },
+            children: entry.children ? entry.children.map(toRoute) : undefined
+        };
+    };
+    return entries.map(toRoute);
+}

package/dist/index.d.ts

@@ -1,7 +1,28 @@
+/**
+ * Arbitrary metadata attached to routes via `info`, surfaced through
+ * `useRouteMatches` and the instance's `match()`. Declared here — in the
+ * package entry — so apps can augment it for typed, discoverable metadata:
+ *
+ * ```ts
+ * declare module "@solidjs/router" {
+ *   interface RouteInfo {
+ *     breadcrumb?: string;
+ *   }
+ * }
+ * ```
+ *
+ * Declared keys are type-checked at route definitions and typed on reads;
+ * undeclared keys remain freeform.
+ */
+export interface RouteInfo {
+    [key: string]: any;
+}
 export * from "./routers/index.js";
-export * from "./components.jsx";
 export * from "./lifecycle.js";
-export { useHref, useIsRouting, useLocation, useMatch, useCurrentMatches, useNavigate, useParams, useResolvedPath, useSearchParams, useBeforeLeave, usePreloadRoute, RouterContextObj as RouterContext } from "./routing.js";
+export { useHref, useIsRouting, useLinkState, useLocation, useMatch, useNavigate, usePreloadRoute, useParams, useResolvedPath, useRouteMatches, useSearchParams, RouterContextObj as RouterContext } from "./routing.js";
+export type { LinkState } from "./routing.js";
 export { mergeSearchString as _mergeSearchString } from "./utils.js";
+export { int } from "./paths.js";
+export type { RoutePaths, PathParamsOf, PathEnd, TypedMatchFilter, DefaultSearchTypes } from "./paths.js";
 export * from "./data/index.js";
-export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, Submission, BeforeLeaveEventArgs, RouteLoadFunc, RouteLoadFuncArgs, RouterResponseInit, CustomResponse } from "./types.js";
+export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteComponent, RouteParams, RouteProps, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, SetSearchParams, Submission, BeforeLeaveEventArgs, TypedPath, TypedSearchPath, StandardSchemaV1 } from "./types.js";