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

package/dist/server.js

@@ -18,13 +18,21 @@
 //   back (303) carrying the outcome in a one-shot flash cookie that the
 //   router's SSR initialization reads into submission state.
 import { provideRequestEvent } from "@solidjs/web/storage";
-import { createBranches, getRouteMatches, mergeParams, resolveRouteDefinitions } from "./routing.js";
+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";
+}
 /**
  * Produces the `collectFlightData` implementation for
  * `configureServerFunctionsServer` (or `handleServerFunctionRequest`
- * options). Strategy: rerun the route data for the URL the client will show
+ * 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 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
@@ -33,14 +41,23 @@ import { encodeFlashCookie } from "./data/flash.js";
  * flight-data consumer.
  */
 export function createFlightDataCollector(options) {
-    const { routes, rootPreload, base = "" } = 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;
-    // resolveRouteDefinitions handles every accepted shape — thunks are called
-    // during resolution, JSX <Route> elements evaluate to their definitions
-    const resolveBranches = () => branches ||
-        (branches = createBranches(resolveRouteDefinitions(routes)(), base));
+    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) => {
         // no referrer, nothing to produce data for (e.g. non-browser callers)
         const referrer = outcome.request.headers.get("referer");
@@ -67,7 +84,9 @@ export function createFlightDataCollector(options) {
         // pointed at the target URL, with the mutation's own cookie mutations
         // folded into the request, in data-only router mode.
         const event = { ...sourceEvent };
-        event.request = new Request(url, { headers: createSingleFlightHeaders(sourceEvent) });
+        event.request = new Request(url, {
+            headers: createSingleFlightHeaders(sourceEvent, outcome.response)
+        });
         event.router = {
             dataOnly: revalidate || true,
             previousUrl: referrer,
@@ -75,6 +94,7 @@ export function createFlightDataCollector(options) {
         };
         return provideRequestEvent(event, async () => {
             try {
+                await resolveLazyMatches(resolveBranches, url, referrer);
                 runPreloads(event, resolveBranches(), url, referrer, rootPreload);
             }
             catch (error) {
@@ -94,6 +114,24 @@ export function createFlightDataCollector(options) {
         });
     };
 }
+// 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
@@ -132,11 +170,18 @@ 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).
+ * (deletions honored via Max-Age/Expires). Cookies attached to the
+ * returned/thrown response itself (e.g. `redirect(to, { headers })`) never
+ * reach the event response, but a browser round trip would have sent them
+ * back with the next request — fold them in too, after the event's, so
+ * they win on conflict.
  */
-export function createSingleFlightHeaders(sourceEvent) {
+export function createSingleFlightHeaders(sourceEvent, outcomeResponse) {
     const headers = new Headers(sourceEvent.request.headers);
-    const setCookies = sourceEvent.response?.headers?.getSetCookie() ?? [];
+    const setCookies = [
+        ...(sourceEvent.response?.headers?.getSetCookie() ?? []),
+        ...(outcomeResponse?.headers?.getSetCookie() ?? [])
+    ];
     if (!setCookies.length)
         return headers;
     const cookies = {};
@@ -200,7 +245,15 @@ 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;
+        // an unusable referer (no-referrer policy, garbage) still beats leaving
+        // the browser sitting on the server function endpoint
+        let back = new URL(base || "/", url.origin).toString();
+        try {
+            const referer = request.headers.get("referer");
+            if (referer)
+                back = new URL(referer).toString();
+        }
+        catch { }
         // form post -> GET: 303 See Other unless the result names a redirect status
         let status = 303;
         let headers;
@@ -214,6 +267,9 @@ export function createNoJSHandler(options = {}) {
             else {
                 headers.set("Location", back);
             }
+            // any body is dropped from the redirect we build — don't advertise it
+            headers.delete("Content-Type");
+            headers.delete("Content-Length");
         }
         else {
             headers = new Headers({ Location: back });

package/dist/types.d.ts

@@ -25,6 +25,42 @@ declare module "@solidjs/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 {
@@ -44,7 +80,7 @@ export interface NavigateOptions<S = unknown> {
     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;
@@ -57,7 +93,6 @@ export interface LocationChange<S = unknown> {
 }
 export interface RouterIntegration {
     signal: [get: () => LocationChange, set: (next: LocationChange) => void];
-    create?: (router: RouterContext) => void;
     utils?: Partial<RouterUtils>;
 }
 export type Intent = "initial" | "native" | "navigate" | "preload";
@@ -74,12 +109,28 @@ export interface RouteSectionProps<T = unknown> {
     children?: JSX.Element;
 }
 export type RouteSectionComponent<T = unknown> = Component<RouteSectionProps<T>> | Component<Omit<RouteSectionProps<T>, "children">> | Component<{}>;
+/**
+ * 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>;
+    /** 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>;
 };
 export type MatchFilter = readonly string[] | RegExp | ((s: string) => boolean);
@@ -110,6 +161,14 @@ export interface RouteDescription {
     matcher: (location: string) => PathMatch | null;
     matchFilters?: MatchFilters;
     info?: Record<string, any>;
+    /** 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[];
@@ -129,7 +188,7 @@ 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;
 }
@@ -145,7 +204,7 @@ export interface RouterContext {
     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>[]>;
@@ -167,6 +226,15 @@ 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;
@@ -182,3 +250,4 @@ 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/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": "0.17.0-next.6",
+  "version": "1.0.0-next.10",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@solidjs/web": "2.0.0-beta.21",
+    "@solidjs/web": "2.0.0-beta.22",
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@changesets/cli": "^2.27.10",
@@ -39,19 +39,19 @@
     "@rollup/plugin-terser": "0.4.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "2.0.0-beta.21",
+    "babel-preset-solid": "2.0.0-beta.22",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "2.0.0-beta.21",
+    "solid-js": "2.0.0-beta.22",
     "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.21 <2.0.0-experimental.0",
-    "solid-js": ">=2.0.0-beta.21 <2.0.0-experimental.0"
+    "@solidjs/web": ">=2.0.0-beta.22 <2.0.0-experimental.0",
+    "solid-js": ">=2.0.0-beta.22 <2.0.0-experimental.0"
   },
   "scripts": {
     "build": "rm -rf dist && tsc && rollup -c",

package/dist/components.d.ts

@@ -1,31 +0,0 @@
-import type { JSX } from "@solidjs/web";
-import type { Location, Navigator } from "./types.js";
-declare module "@solidjs/web/jsx-runtime" {
-    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,46 +0,0 @@
-import { createMemo, merge, omit } from "solid-js";
-import { useHref, useLocation, useNavigate, useResolvedPath } from "./routing.js";
-import { normalizePath } from "./utils.js";
-function toClassName(value) {
-    if (!value)
-        return "";
-    if (typeof value === "string" || typeof value === "number")
-        return String(value);
-    if (Array.isArray(value))
-        return value.map(toClassName).filter(Boolean).join(" ");
-    if (typeof value === "object") {
-        return Object.entries(value)
-            .filter(([, enabled]) => enabled)
-            .map(([name]) => name)
-            .join(" ");
-    }
-    return "";
-}
-export function A(props) {
-    props = merge({ inactiveClass: "inactive", activeClass: "active" }, props);
-    const rest = omit(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];
-    });
-    const className = createMemo(() => [toClassName(props.class), isActive()[0] ? props.activeClass : props.inactiveClass]
-        .filter(Boolean)
-        .join(" "));
-    return (<a {...rest} href={href() || props.href} state={JSON.stringify(props.state)} class={className()} 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;
-}

package/dist/routers/HashRouter.d.ts

@@ -1,9 +0,0 @@
-import type { JSX } from "@solidjs/web";
-import type { BaseRouterProps } from "./components.jsx";
-export declare function hashParser(str: string): string;
-export type HashRouterProps = BaseRouterProps & {
-    actionBase?: string;
-    explicitLinks?: boolean;
-    preload?: boolean;
-};
-export declare function HashRouter(props: HashRouterProps): JSX.Element;

package/dist/routers/HashRouter.js

@@ -1,41 +0,0 @@
-import { setupNativeEvents } from "../data/events.js";
-import { createRouter, scrollToHash, bindEvent } from "./createRouter.js";
-import { createBeforeLeave, keepDepth, notifyIfNotBlocked, saveCurrentDepth } from "../lifecycle.js";
-export function hashParser(str) {
-    const to = str.replace(/^.*?#/, "");
-    // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
-    // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
-    // to the current path so we can handle these in-page anchors correctly.
-    if (!to.startsWith("/")) {
-        const [, path = "/"] = window.location.hash.split("#", 2);
-        return `${path}#${to}`;
-    }
-    return to;
-}
-export function HashRouter(props) {
-    const getSource = () => window.location.hash.slice(1);
-    const beforeLeave = createBeforeLeave();
-    return createRouter({
-        get: getSource,
-        set({ value, replace, scroll, state }) {
-            if (replace) {
-                window.history.replaceState(keepDepth(state), "", "#" + value);
-            }
-            else {
-                window.history.pushState(state, "", "#" + value);
-            }
-            const hashIndex = value.indexOf("#");
-            const hash = hashIndex >= 0 ? value.slice(hashIndex + 1) : "";
-            scrollToHash(hash, scroll);
-            saveCurrentDepth();
-        },
-        init: notify => bindEvent(window, "hashchange", notifyIfNotBlocked(notify, delta => !beforeLeave.confirm(delta && delta < 0 ? delta : getSource()))),
-        create: setupNativeEvents({ preload: props.preload, explicitLinks: props.explicitLinks, actionBase: props.actionBase }),
-        utils: {
-            go: delta => window.history.go(delta),
-            renderPath: path => `#${path}`,
-            parsePath: hashParser,
-            beforeLeave
-        }
-    })(props);
-}

package/dist/routers/MemoryRouter.d.ts

@@ -1,24 +0,0 @@
-import type { LocationChange } from "../types.js";
-import type { BaseRouterProps } from "./components.jsx";
-import type { JSX } from "@solidjs/web";
-export type MemoryHistory = {
-    get: () => string;
-    set: (change: LocationChange) => void;
-    go: (delta: number) => void;
-    listen: (listener: (value: string) => void) => () => void;
-};
-export declare function createMemoryHistory(): {
-    get: () => string;
-    set: ({ value, scroll, replace }: LocationChange) => void;
-    back: () => void;
-    forward: () => void;
-    go: (n: number) => void;
-    listen: (listener: (value: string) => void) => () => void;
-};
-export type MemoryRouterProps = BaseRouterProps & {
-    history?: MemoryHistory;
-    actionBase?: string;
-    explicitLinks?: boolean;
-    preload?: boolean;
-};
-export declare function MemoryRouter(props: MemoryRouterProps): JSX.Element;

package/dist/routers/MemoryRouter.js

@@ -1,57 +0,0 @@
-import { createRouter, scrollToHash } from "./createRouter.js";
-import { setupNativeEvents } from "../data/events.js";
-export function createMemoryHistory() {
-    const entries = ["/"];
-    let index = 0;
-    const listeners = [];
-    const go = (n) => {
-        // https://github.com/remix-run/react-router/blob/682810ca929d0e3c64a76f8d6e465196b7a2ac58/packages/router/history.ts#L245
-        index = Math.max(0, Math.min(index + n, entries.length - 1));
-        const value = entries[index];
-        listeners.forEach(listener => listener(value));
-    };
-    return {
-        get: () => entries[index],
-        set: ({ value, scroll, replace }) => {
-            if (replace) {
-                entries[index] = value;
-            }
-            else {
-                entries.splice(index + 1, entries.length - index, value);
-                index++;
-            }
-            listeners.forEach(listener => listener(value));
-            setTimeout(() => {
-                if (scroll) {
-                    scrollToHash(value.split("#")[1] || "", true);
-                }
-            }, 0);
-        },
-        back: () => {
-            go(-1);
-        },
-        forward: () => {
-            go(1);
-        },
-        go,
-        listen: (listener) => {
-            listeners.push(listener);
-            return () => {
-                const index = listeners.indexOf(listener);
-                listeners.splice(index, 1);
-            };
-        }
-    };
-}
-export function MemoryRouter(props) {
-    const memoryHistory = props.history || createMemoryHistory();
-    return createRouter({
-        get: memoryHistory.get,
-        set: memoryHistory.set,
-        init: memoryHistory.listen,
-        create: setupNativeEvents({ preload: props.preload, explicitLinks: props.explicitLinks, actionBase: props.actionBase }),
-        utils: {
-            go: memoryHistory.go
-        }
-    })(props);
-}

package/dist/routers/Router.d.ts

@@ -1,9 +0,0 @@
-import type { BaseRouterProps } from "./components.jsx";
-import type { JSX } from "@solidjs/web";
-export type RouterProps = BaseRouterProps & {
-    url?: string;
-    actionBase?: string;
-    explicitLinks?: boolean;
-    preload?: boolean;
-};
-export declare function Router(props: RouterProps): JSX.Element;

package/dist/routers/Router.js

@@ -1,45 +0,0 @@
-import { isServer } from "@solidjs/web";
-import { createRouter, scrollToHash, bindEvent } from "./createRouter.js";
-import { StaticRouter } from "./StaticRouter.js";
-import { setupNativeEvents } from "../data/events.js";
-import { createBeforeLeave, keepDepth, notifyIfNotBlocked, saveCurrentDepth } from "../lifecycle.js";
-export function Router(props) {
-    if (isServer)
-        return StaticRouter(props);
-    const getSource = () => {
-        const url = window.location.pathname + window.location.search;
-        const state = window.history.state && window.history.state._depth && Object.keys(window.history.state).length === 1 ? undefined : window.history.state;
-        return {
-            value: url + window.location.hash,
-            state
-        };
-    };
-    const beforeLeave = createBeforeLeave();
-    return createRouter({
-        get: getSource,
-        set({ value, replace, scroll, state }) {
-            if (replace) {
-                window.history.replaceState(keepDepth(state), "", value);
-            }
-            else {
-                window.history.pushState(state, "", value);
-            }
-            scrollToHash(decodeURIComponent(window.location.hash.slice(1)), scroll);
-            saveCurrentDepth();
-        },
-        init: notify => bindEvent(window, "popstate", notifyIfNotBlocked(notify, delta => {
-            if (delta) {
-                return !beforeLeave.confirm(delta);
-            }
-            else {
-                const s = getSource();
-                return !beforeLeave.confirm(s.value, { state: s.state });
-            }
-        })),
-        create: setupNativeEvents({ preload: props.preload, explicitLinks: props.explicitLinks, actionBase: props.actionBase, transformUrl: props.transformUrl }),
-        utils: {
-            go: delta => window.history.go(delta),
-            beforeLeave
-        }
-    })(props);
-}

package/dist/routers/StaticRouter.d.ts

@@ -1,6 +0,0 @@
-import { type BaseRouterProps } from "./components.jsx";
-import type { JSX } from "@solidjs/web";
-export type StaticRouterProps = BaseRouterProps & {
-    url?: string;
-};
-export declare function StaticRouter(props: StaticRouterProps): JSX.Element;

package/dist/routers/StaticRouter.js

@@ -1,15 +0,0 @@
-import { getRequestEvent } from "@solidjs/web";
-import { createRouterComponent } from "./components.jsx";
-function getPath(url) {
-    const u = new URL(url);
-    return u.pathname + u.search;
-}
-export function StaticRouter(props) {
-    let e;
-    const obj = {
-        value: props.url || ((e = getRequestEvent()) && getPath(e.request.url)) || "",
-    };
-    return createRouterComponent({
-        signal: [() => obj, next => Object.assign(obj, next)]
-    })(props);
-}

package/dist/routers/createRouter.d.ts

@@ -1,10 +0,0 @@
-import type { LocationChange, RouterContext, RouterUtils } from "../types.js";
-export declare function createRouter(config: {
-    get: () => string | LocationChange;
-    set: (next: LocationChange) => void;
-    init?: (notify: (value?: string | LocationChange) => void) => () => void;
-    create?: (router: RouterContext) => void;
-    utils?: Partial<RouterUtils>;
-}): (props: import("./components.jsx").BaseRouterProps) => import("@solidjs/web").JSX.Element;
-export declare function bindEvent(target: EventTarget, type: string, handler: EventListener): () => void;
-export declare function scrollToHash(hash: string, fallbackTop?: boolean): void;