@solidjs/router 0.17.0-next.5 → 1.0.0-next.10

package/dist/data/flash.js

@@ -0,0 +1,78 @@
+// 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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,20 @@
+// 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=/`;
+}

package/dist/data/query.js

@@ -1,6 +1,6 @@
 import { createSignal, getObserver, getOwner, onCleanup, sharedConfig } from "solid-js";
 import { getRequestEvent, isResponseEnvelope, isServer } from "@solidjs/web";
-import { decodeResponse } from "@solidjs/web/server-functions";
+import { GET, decodeResponse, getServerFunctionMetadata, isServerFunction } from "@solidjs/web/server-functions";
 import { useNavigate, getIntent, getInPreloadFn } from "../routing.js";
 const LocationHeader = "Location";
 const PRELOAD_TIMEOUT = 5000;
@@ -43,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();

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/index.d.ts

@@ -1,7 +1,9 @@
 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 } from "./types.js";
+export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, SetSearchParams, Submission, BeforeLeaveEventArgs, TypedPath, TypedSearchPath, StandardSchemaV1 } from "./types.js";