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

package/dist/server.js

@@ -0,0 +1,264 @@
+// 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.
+//
+// Two policies live here, both previously implemented inside SolidStart and
+// now owned by the router (the vocabulary — query keys, submissions — 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.
+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";
+}
+/**
+ * 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 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.
+ */
+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) => {
+        // 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)
+            return undefined;
+        // 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.
+        const event = { ...sourceEvent };
+        event.request = new Request(url, { headers: createSingleFlightHeaders(sourceEvent) });
+        event.router = {
+            dataOnly: revalidate || true,
+            previousUrl: referrer,
+            data: {}
+        };
+        return provideRequestEvent(event, async () => {
+            try {
+                await resolveLazyMatches(resolveBranches, url, referrer);
+                runPreloads(event, resolveBranches(), url, referrer, 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"
+            });
+    }
+}
+/**
+ * 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

@@ -12,7 +12,7 @@ declare module "@solidjs/web" {
             cache?: Map<string, CacheEntry>;
             submission?: {
                 input: any;
-                result: any;
+                result?: any;
                 error?: any;
                 url: string;
             };
@@ -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.5",
+  "version": "1.0.0-next.7",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -22,14 +22,15 @@
     ".": {
       "solid": "./dist/index.jsx",
       "default": "./dist/index.js"
-    }
+    },
+    "./server": "./dist/server.js"
   },
   "files": [
     "dist"
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@solidjs/web": "2.0.0-beta.19",
+    "@solidjs/web": "2.0.0-beta.22",
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@changesets/cli": "^2.27.10",
@@ -38,24 +39,25 @@
     "@rollup/plugin-terser": "0.4.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
-    "babel-preset-solid": "2.0.0-beta.19",
+    "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.19",
+    "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.19 <2.0.0-experimental.0",
-    "solid-js": ">=2.0.0-beta.19 <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",
-    "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 "@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;