@solidjs/router 1.0.0 → 2.0.0-next.13

package/dist/server.d.ts

@@ -0,0 +1,47 @@
+import type { JSX } from "@solidjs/web";
+import type { CollectFlightDataHook, ServerFunctionOutcome } from "@solidjs/web/server-functions/server";
+import type { RouteDefinition, RoutePreloadFunc } from "./types.js";
+export type { CollectFlightDataHook, ServerFunctionOutcome };
+export interface FlightDataCollectorOptions {
+    /**
+     * The app's route tree — the same config objects the `createRouter`
+     * factory receives, an array of them, or a thunk producing either (for
+     * lazily/per-request built trees). Flight data is produced by the pure
+     * preload runner: the target URL is matched against the tree and the
+     * matched routes' `preload` functions run in data-only mode.
+     */
+    routes: RouteDefinition | readonly RouteDefinition[] | (() => RouteDefinition | readonly RouteDefinition[]);
+    /**
+     * The root layout's preload — the same function the app passes to the
+     * `createRouter` factory's `preload` option. Runs before the matched
+     * routes' preloads with the semantics the root gets during a real server
+     * render: the merged params of every match and `intent: "initial"`.
+     */
+    rootPreload?: RoutePreloadFunc;
+    /** The app's base path, for compiling the route tree's matchers. */
+    base?: string;
+}
+/** A `createRouter` instance carries everything the collector needs. */
+interface RouterInstanceLike {
+    (props: any): JSX.Element;
+    readonly routes: readonly RouteDefinition[];
+    readonly config: {
+        base?: string;
+        preload?: RoutePreloadFunc;
+    };
+}
+/**
+ * Produces the `collectFlightData` implementation for
+ * `configureServerFunctionsServer` (or `handleServerFunctionRequest`
+ * options). Accepts a `createRouter` instance directly — its routes, base,
+ * 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 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 declare function createFlightDataCollector(options: FlightDataCollectorOptions | RouterInstanceLike): CollectFlightDataHook;

package/dist/server.js

@@ -0,0 +1,156 @@
+// The router's server-side integration with the server function runtime
+// (@solidjs/web/server-functions). Server-only entry (`@solidjs/router/server`):
+// it reaches for node async context via @solidjs/web/storage — keep it out of
+// client bundles.
+//
+// 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). 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";
+// the instance is the provider component, so it (unlike an options object) is a function
+function isRouterInstance(options) {
+    return typeof options === "function";
+}
+/**
+ * Produces the `collectFlightData` implementation for
+ * `configureServerFunctionsServer` (or `handleServerFunctionRequest`
+ * options). Accepts a `createRouter` instance directly — its routes, base,
+ * 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 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)
+        ? { routes: options.routes, rootPreload: options.config.preload, base: options.config.base }
+        : options;
+    if (!routes)
+        throw new Error("createFlightDataCollector requires `routes`");
+    let branches;
+    let compiledVersion = -1;
+    // thunks are called at first collection so per-request trees build lazily;
+    // recompiled when a lazy subtree resolves (shared, append-only state)
+    const resolveBranches = () => {
+        const version = peekLazySubtrees();
+        if (!branches || compiledVersion !== version) {
+            branches = createBranches(typeof routes === "function" ? routes() : routes, base);
+            compiledVersion = version;
+        }
+        return branches;
+    };
+    return async (sourceEvent, outcome) => {
+        // 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 cookie effects already
+        // folded in (the outcome's `foldedHeaders`), in data-only router mode.
+        const event = { ...sourceEvent };
+        event.request = new Request(targetUrl, { headers: outcome.foldedHeaders });
+        event.router = {
+            dataOnly: revalidateKeys || true,
+            previousUrl,
+            data: {}
+        };
+        return provideRequestEvent(event, async () => {
+            try {
+                await resolveLazyMatches(resolveBranches, targetUrl, previousUrl);
+                runPreloads(event, resolveBranches(), targetUrl, previousUrl, rootPreload);
+            }
+            catch (error) {
+                console.error(error);
+            }
+            const data = event.router.data;
+            if (!data)
+                return undefined;
+            let containsKey = false;
+            for (const key in data) {
+                if (data[key] === undefined)
+                    delete data[key];
+                else
+                    containsKey = true;
+            }
+            return containsKey ? data : undefined;
+        });
+    };
+}
+// Lazy subtrees matched by the target (or previous) URL must resolve before
+// the preload pass — the collector would otherwise be blind to inner routes'
+// data. Resolution is shared with the client-side machinery (append-only,
+// cached per thunk); the loop handles boundaries nested inside boundaries.
+async function resolveLazyMatches(resolveBranches, url, previousUrl) {
+    for (;;) {
+        const branches = resolveBranches();
+        const target = new URL(url);
+        const matches = [
+            ...getRouteMatches(branches, target.pathname),
+            ...getRouteMatches(branches, new URL(previousUrl, target).pathname)
+        ];
+        const pending = matches.filter(m => m.route.lazy && !m.route.lazy.resolved);
+        if (!pending.length)
+            return;
+        await Promise.all(pending.map(m => resolveLazySubtree(m.route.lazy)));
+    }
+}
+// The pure preload runner: the same collection loop the router's <Routes>
+// component runs when it detects a data-only render (routers/components.tsx),
+// driven directly off the route tree — matched routes' preloads run and
+// their `query` calls store results on `event.router.data`. Routes not
+// matched by the previous URL flip collection from the revalidation-key
+// filter to everything (their queries have no client cache yet).
+function runPreloads(event, branches, url, previousUrl, rootPreload) {
+    const target = new URL(url);
+    const prevMatches = getRouteMatches(branches, new URL(previousUrl, target).pathname);
+    const matches = getRouteMatches(branches, target.pathname);
+    const location = {
+        pathname: target.pathname,
+        search: target.search,
+        hash: target.hash,
+        query: extractSearchParams(target),
+        state: null,
+        key: ""
+    };
+    // the root layout preloads first, exactly as <Root> would during a real
+    // server render: merged params of every match, intent "initial" (there is
+    // no navigation intent on the server), before any dataOnly-filter flip
+    rootPreload && rootPreload({ params: mergeParams(matches), location, intent: "initial" });
+    for (let match = 0; match < matches.length; match++) {
+        if (!prevMatches[match] || matches[match].route !== prevMatches[match].route)
+            event.router.dataOnly = true;
+        const { route, params } = matches[match];
+        route.preload &&
+            route.preload({
+                params,
+                location,
+                intent: "preload"
+            });
+    }
+}

package/dist/types.d.ts

@@ -1,5 +1,6 @@
-import type { Component, JSX, Signal } from "solid-js";
-declare module "solid-js/web" {
+import type { Component, Signal } from "solid-js";
+import type { JSX, ResponseEnvelope } from "@solidjs/web";
+declare module "@solidjs/web" {
     interface RequestEvent {
         response: {
             status?: number;
@@ -11,7 +12,8 @@ declare module "solid-js/web" {
             cache?: Map<string, CacheEntry>;
             submission?: {
                 input: any;
-                result: any;
+                result?: any;
+                error?: any;
                 url: string;
             };
             dataOnly?: boolean | string[];
@@ -23,6 +25,42 @@ declare module "solid-js/web" {
 }
 export type Params = Record<string, string | undefined>;
 export type SearchParams = Record<string, string | string[] | undefined>;
+declare const PATH_PARAMS: unique symbol;
+export interface TypedPath<P extends Params = Params> extends JSX.SerializableAttributeValue {
+    readonly [PATH_PARAMS]: P;
+    toString(): string;
+}
+declare const PATH_SEARCH: unique symbol;
+export interface TypedSearchPath<In = SetSearchParams, Out = SearchParams> {
+    readonly [PATH_SEARCH]: {
+        input: In;
+        output: Out;
+    };
+}
+/**
+ * The Standard Schema interface (https://standardschema.dev) — vendored as a
+ * type so any conforming validator (Valibot, Zod, ArkType, ...) can type a
+ * route's `search` without the router depending on a validation library.
+ */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+export type StandardSchemaResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<{
+        readonly message: string;
+    }>;
+};
 export type SetParams = Record<string, string | number | boolean | null | undefined>;
 export type SetSearchParams = Record<string, string | string[] | number | number[] | boolean | boolean[] | null | undefined>;
 export interface Path {
@@ -36,13 +74,19 @@ export interface Location<S = unknown> extends Path {
     key: string;
 }
 export interface NavigateOptions<S = unknown> {
+    /**
+     * Resolve the target like an href: leading-`/` paths are prefixed with the
+     * router base, anything else resolves URL-style against the current
+     * location (`..` collapses, `?`/`#`-only strings keep the path). `false`
+     * takes the string as the final path. Defaults to `true`.
+     */
     resolve: boolean;
     replace: boolean;
     scroll: boolean;
     state: S;
 }
 export interface Navigator {
-    (to: string | number, options?: Partial<NavigateOptions>): void;
+    (to: string | TypedPath | number, options?: Partial<NavigateOptions>): void;
     (delta: number): void;
 }
 export type NavigatorFactory = (route?: RouteContext) => Navigator;
@@ -54,41 +98,109 @@ export interface LocationChange<S = unknown> {
     rawPath?: string;
 }
 export interface RouterIntegration {
-    signal: Signal<LocationChange>;
-    create?: (router: RouterContext) => void;
+    signal: [get: () => LocationChange, set: (next: LocationChange) => void];
     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`
+ * export is used). The subtree's code loads on demand (hover intent or
+ * navigation kicks it, and the load folds into the navigation transition)
+ * but its *types* still flow into `paths` through the import's promise type.
+ * Thunks must be deterministic — resolution is cached append-only and shared
+ * by every mount, request, and the server's flight collector.
+ */
+export type LazyRouteChildren = () => readonly RouteDefinition[] | Promise<readonly RouteDefinition[] | {
+    default: readonly RouteDefinition[];
+} | {
+    routes: readonly RouteDefinition[];
+}>;
 export type RouteDefinition<S extends string | string[] = any, T = any> = {
     path?: S;
     matchFilters?: MatchFilters<S>;
     preload?: RoutePreloadFunc<T>;
-    children?: RouteDefinition | RouteDefinition[];
+    children?: RouteDefinition | readonly RouteDefinition[] | LazyRouteChildren;
     component?: RouteSectionComponent<T>;
-    info?: Record<string, any>;
-    /** @deprecated use preload */
-    load?: RoutePreloadFunc;
+    /** Standard Schema validator for this route's search params; its input type flows into the typed path proxy. */
+    search?: StandardSchemaV1<any, 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 {
@@ -99,7 +211,7 @@ export interface OutputMatch {
     pattern: string;
     match: string;
     params: Params;
-    info?: Record<string, any>;
+    info?: RouteInfo;
 }
 export interface RouteDescription {
     key: unknown;
@@ -109,7 +221,15 @@ 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;
+}
+/** Resolution state for a lazy subtree boundary, shared per thunk. */
+export interface LazyBoundary {
+    thunk: LazyRouteChildren;
+    promise?: Promise<readonly RouteDefinition[]>;
+    resolved?: readonly RouteDefinition[];
 }
 export interface Branch {
     routes: RouteDescription[];
@@ -120,15 +240,18 @@ export interface RouteContext {
     parent?: RouteContext;
     child?: RouteContext;
     pattern: string;
+    params: Params;
     path: () => string;
     outlet: () => JSX.Element;
     resolvePath(to: string): string | undefined;
+    /** Whether this route section still matches `target` (same matched path), i.e. survives a navigation there. Absent on the base route, which always survives. */
+    retained?(target: string): boolean;
 }
 export interface RouterUtils {
     renderPath(path: string): string;
     parsePath(str: string): string;
     go(delta: number): void;
-    beforeLeave: BeforeLeaveLifecycle;
+    beforeLeave: BeforeLeaveSlot;
     paramsWrapper: (getParams: () => Params, branches: () => Branch[]) => Params;
     queryWrapper: (getQuery: () => SearchParams) => SearchParams;
 }
@@ -136,14 +259,17 @@ export interface RouterContext {
     base: RouteContext;
     location: Location;
     params: Params;
+    wrapParams: (getParams: () => Params) => Params;
     navigatorFactory: NavigatorFactory;
     isRouting: () => boolean;
     /** The target of the in-flight navigation transition, if any. Not reactive. */
     readonly pendingTarget?: LocationChange;
+    /** Whether `route` is a section the in-flight navigation is leaving. False when no navigation is pending. */
+    leaving?(route: RouteContext): boolean;
     matches: () => RouteMatch[];
     renderPath(path: string): string;
     parsePath(str: string): string;
-    beforeLeave: BeforeLeaveLifecycle;
+    beforeLeave: BeforeLeaveSlot;
     preloadRoute: (url: URL, preloadData?: boolean) => void;
     singleFlight: boolean;
     submissions: Signal<Submission<any, any>[]>;
@@ -165,39 +291,27 @@ export interface BeforeLeaveLifecycle {
     subscribe(listener: BeforeLeaveListener): () => void;
     confirm(to: string | number, options?: Partial<NavigateOptions>): boolean;
 }
+/**
+ * Lazily-filled holder for the beforeLeave guard. The router and history
+ * adapters only carry this empty object; `useBeforeLeave` installs the actual
+ * lifecycle on first use so its machinery tree-shakes out of apps that never
+ * block navigation.
+ */
+export interface BeforeLeaveSlot {
+    current?: BeforeLeaveLifecycle;
+}
 export type Submission<T, U> = {
     readonly input: T;
     readonly result?: U;
     readonly error: any;
-    readonly pending: boolean;
     readonly url: string;
     clear: () => void;
     retry: () => void;
 };
-export type SubmissionStub = {
-    readonly input: undefined;
-    readonly result: undefined;
-    readonly error: undefined;
-    readonly pending: undefined;
-    readonly url: undefined;
-    clear: () => void;
-    retry: () => void;
-};
 export interface MaybePreloadableComponent extends Component {
     preload?: () => void;
 }
 export type CacheEntry = [number, Promise<any>, any, Intent | undefined, Signal<number> & {
     count: number;
 }];
-export type NarrowResponse<T> = T extends CustomResponse<infer U> ? U : Exclude<T, Response>;
-export type RouterResponseInit = Omit<ResponseInit, "body"> & {
-    revalidate?: string | string[];
-};
-export type CustomResponse<T> = Omit<Response, "clone"> & {
-    customBody: () => T;
-    clone(...args: readonly unknown[]): CustomResponse<T>;
-};
-/** @deprecated */
-export type RouteLoadFunc = RoutePreloadFunc;
-/** @deprecated */
-export type RouteLoadFuncArgs = RoutePreloadFuncArgs;
+export type NarrowResponse<T> = T extends ResponseEnvelope<infer U> ? U : Exclude<T, Response>;

package/dist/utils.d.ts

@@ -1,6 +1,8 @@
 import type { MatchFilters, PathMatch, RouteDescription, SearchParams, SetSearchParams } from "./types.js";
 export declare const mockBase = "http://sr";
 export declare function normalizePath(path: string, omitSlash?: boolean): string;
+/** Pathname stripped of search/hash and trailing slash, lowercased — the form link matching compares. */
+export declare const comparablePath: (path: string) => string;
 export declare function resolvePath(base: string, path: string, from?: string): string | undefined;
 export declare function invariant<T>(value: T | null | undefined, message: string): T;
 export declare function joinPaths(from: string, to: string): string;

package/dist/utils.js

@@ -6,6 +6,8 @@ export function normalizePath(path, omitSlash = false) {
     const s = path.replace(trimPathRegex, "$1");
     return s ? (omitSlash || /^[?#]/.test(s) ? s : "/" + s) : "";
 }
+/** Pathname stripped of search/hash and trailing slash, lowercased — the form link matching compares. */
+export const comparablePath = (path) => normalizePath(path.split(/[?#]/, 1)[0]).toLowerCase().replace(/\/$/, "");
 export function resolvePath(base, path, from) {
     if (hasSchemeRegex.test(path)) {
         return undefined;

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "1.0.0",
+  "version": "2.0.0-next.13",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -22,13 +22,16 @@
     ".": {
       "solid": "./dist/index.jsx",
       "default": "./dist/index.js"
-    }
+    },
+    "./server": "./dist/server.js",
+    "./fs": "./dist/fs.js"
   },
   "files": [
     "dist"
   ],
   "sideEffects": false,
   "devDependencies": {
+    "@solidjs/web": "2.0.0-beta.28",
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@changesets/cli": "^2.27.10",
@@ -37,23 +40,25 @@
     "@rollup/plugin-terser": "0.4.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "^1.9.3",
+    "babel-preset-solid": "2.0.0-beta.28",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "^1.9.3",
+    "solid-js": "2.0.0-beta.28",
     "typescript": "^5.7.2",
     "vite": "^6.0.0",
-    "vite-plugin-solid": "^2.11.0",
+    "vite-plugin-solid": "3.0.0-next.10",
     "vitest": "^2.1.6"
   },
   "peerDependencies": {
-    "solid-js": "^1.8.6"
+    "@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",
-    "test": "vitest run && npm run test:types",
+    "test": "vitest run && vitest run --config vitest.config.server.ts && npm run test:types",
     "test:watch": "vitest",
+    "test:server": "vitest run --config vitest.config.server.ts",
     "test:types": "tsc --project tsconfig.test.json",
     "pretty": "prettier --write \"{src,test}/**/*.{ts,tsx}\"",
     "release": "pnpm build && changeset publish"

package/dist/components.d.ts

@@ -1,31 +0,0 @@
-import type { JSX } from "solid-js";
-import type { Location, Navigator } from "./types.js";
-declare module "solid-js" {
-    namespace JSX {
-        interface AnchorHTMLAttributes<T> {
-            state?: string;
-            noScroll?: boolean;
-            replace?: boolean;
-            preload?: boolean;
-            link?: boolean;
-        }
-    }
-}
-export interface AnchorProps extends Omit<JSX.AnchorHTMLAttributes<HTMLAnchorElement>, "state"> {
-    href: string;
-    replace?: boolean | undefined;
-    noScroll?: boolean | undefined;
-    state?: unknown | undefined;
-    inactiveClass?: string | undefined;
-    activeClass?: string | undefined;
-    end?: boolean | undefined;
-}
-export declare function A(props: AnchorProps): JSX.Element;
-export interface NavigateProps {
-    href: ((args: {
-        navigate: Navigator;
-        location: Location;
-    }) => string) | string;
-    state?: unknown;
-}
-export declare function Navigate(props: NavigateProps): null;

package/dist/components.jsx

@@ -1,40 +0,0 @@
-import { createMemo, mergeProps, splitProps } from "solid-js";
-import { useHref, useLocation, useNavigate, useResolvedPath } from "./routing.js";
-import { normalizePath } from "./utils.js";
-export function A(props) {
-    props = mergeProps({ inactiveClass: "inactive", activeClass: "active" }, props);
-    const [, rest] = splitProps(props, [
-        "href",
-        "state",
-        "class",
-        "activeClass",
-        "inactiveClass",
-        "end"
-    ]);
-    const to = useResolvedPath(() => props.href);
-    const href = useHref(to);
-    const location = useLocation();
-    const isActive = createMemo(() => {
-        const to_ = to();
-        if (to_ === undefined)
-            return [false, false];
-        // trailing slashes are ignored so `/route` and `/route/` share active state
-        const path = normalizePath(to_.split(/[?#]/, 1)[0]).toLowerCase().replace(/\/$/, "");
-        const loc = decodeURI(normalizePath(location.pathname).toLowerCase().replace(/\/$/, ""));
-        return [props.end ? path === loc : loc.startsWith(path + "/") || loc === path, path === loc];
-    });
-    return (<a {...rest} href={href() || props.href} state={JSON.stringify(props.state)} classList={{
-            ...(props.class && { [props.class]: true }),
-            [props.inactiveClass]: !isActive()[0],
-            [props.activeClass]: isActive()[0],
-            ...rest.classList
-        }} link aria-current={isActive()[1] ? "page" : undefined}/>);
-}
-export function Navigate(props) {
-    const navigate = useNavigate();
-    const location = useLocation();
-    const { href, state } = props;
-    const path = typeof href === "function" ? href({ navigate, location }) : href;
-    navigate(path, { replace: true, state });
-    return null;
-}