@solidjs/router 0.16.0 → 0.17.0-next.0

package/dist/src/data/response.spec.js

@@ -1,165 +0,0 @@
-import { redirect, reload, json } from "./response.js";
-describe("redirect", () => {
-    test("should create redirect response with default `302` status", () => {
-        const response = redirect("/new-path");
-        expect(response.status).toBe(302);
-        expect(response.headers.get("Location")).toBe("/new-path");
-    });
-    test("should create redirect response with custom status", () => {
-        const response = redirect("/permanent-redirect", 301);
-        expect(response.status).toBe(301);
-        expect(response.headers.get("Location")).toBe("/permanent-redirect");
-    });
-    test("should create redirect response with `RouterResponseInit` object", () => {
-        const response = redirect("/custom-redirect", {
-            status: 307,
-            headers: { "X-Custom": "header" }
-        });
-        expect(response.status).toBe(307);
-        expect(response.headers.get("Location")).toBe("/custom-redirect");
-        expect(response.headers.get("X-Custom")).toBe("header");
-    });
-    test("should include `revalidate` header when specified", () => {
-        const response = redirect("/revalidate-redirect", {
-            revalidate: ["key1", "key2"]
-        });
-        expect(response.headers.get("X-Revalidate")).toBe("key1,key2");
-    });
-    test("should include `revalidate` header with `string` value", () => {
-        const response = redirect("/single-revalidate", {
-            revalidate: "single-key"
-        });
-        expect(response.headers.get("X-Revalidate")).toBe("single-key");
-    });
-    test("should preserve custom headers while adding Location", () => {
-        const response = redirect("/with-headers", {
-            headers: {
-                "Content-Type": "application/json",
-                "X-Custom": "value"
-            }
-        });
-        expect(response.headers.get("Location")).toBe("/with-headers");
-        expect(response.headers.get("Content-Type")).toBe("application/json");
-        expect(response.headers.get("X-Custom")).toBe("value");
-    });
-    test("should handle absolute URLs", () => {
-        const response = redirect("https://external.com/path");
-        expect(response.headers.get("Location")).toBe("https://external.com/path");
-    });
-});
-describe("reload", () => {
-    test("should create reload response with default empty body", () => {
-        const response = reload();
-        expect(response.status).toBe(200);
-        expect(response.body).toBeNull();
-    });
-    test("should create reload response with custom status", () => {
-        const response = reload({ status: 204 });
-        expect(response.status).toBe(204);
-    });
-    test("should include revalidate header when specified", () => {
-        const response = reload({
-            revalidate: ["cache-key"]
-        });
-        expect(response.headers.get("X-Revalidate")).toBe("cache-key");
-    });
-    test("should include revalidate header with array of keys", () => {
-        const response = reload({
-            revalidate: ["key1", "key2", "key3"]
-        });
-        expect(response.headers.get("X-Revalidate")).toBe("key1,key2,key3");
-    });
-    test("should preserve custom headers", () => {
-        const response = reload({
-            headers: {
-                "X-Custom-Header": "custom-value",
-                "Cache-Control": "no-cache"
-            }
-        });
-        expect(response.headers.get("X-Custom-Header")).toBe("custom-value");
-        expect(response.headers.get("Cache-Control")).toBe("no-cache");
-    });
-    test("should combine custom headers with revalidate", () => {
-        const response = reload({
-            revalidate: "reload-key",
-            headers: {
-                "X-Source": "reload-action"
-            }
-        });
-        expect(response.headers.get("X-Revalidate")).toBe("reload-key");
-        expect(response.headers.get("X-Source")).toBe("reload-action");
-    });
-});
-describe("json", () => {
-    test("should create `JSON` response with data", () => {
-        const data = { message: "Hello", count: 42 };
-        const response = json(data);
-        expect(response.status).toBe(200);
-        expect(response.headers.get("Content-Type")).toBe("application/json");
-        expect(typeof response.customBody).toBe("function");
-        expect(response.customBody()).toEqual(data);
-    });
-    test("should serialize data to `JSON` in response body", async () => {
-        const data = { test: true, items: [1, 2, 3] };
-        const response = json(data);
-        const body = await response.text();
-        expect(body).toBe(JSON.stringify(data));
-    });
-    test("should create `JSON` response with custom status", () => {
-        const response = json({ error: "Not found" }, { status: 404 });
-        expect(response.status).toBe(404);
-        expect(response.headers.get("Content-Type")).toBe("application/json");
-    });
-    test("should include revalidate header when specified", () => {
-        const response = json({ updated: true }, { revalidate: ["data-key"] });
-        expect(response.headers.get("X-Revalidate")).toBe("data-key");
-    });
-    test("should preserve custom headers while adding Content-Type", () => {
-        const response = json({ data: "test" }, {
-            headers: {
-                "X-API-Version": "v1",
-                "Cache-Control": "max-age=3600"
-            }
-        });
-        expect(response.headers.get("Content-Type")).toBe("application/json");
-        expect(response.headers.get("X-API-Version")).toBe("v1");
-        expect(response.headers.get("Cache-Control")).toBe("max-age=3600");
-    });
-    test("should handle `null` data", () => {
-        const response = json(null);
-        expect(response.customBody()).toBeNull();
-    });
-    test("should handle undefined data", () => {
-        const response = json(undefined);
-        expect(response.customBody()).toBeUndefined();
-    });
-    test("should handle complex nested data", () => {
-        const complexData = {
-            user: { id: 1, name: "John" },
-            preferences: { theme: "dark", lang: "en" },
-            items: [
-                { id: 1, title: "Item 1" },
-                { id: 2, title: "Item 2" }
-            ]
-        };
-        const response = json(complexData);
-        expect(response.customBody()).toEqual(complexData);
-    });
-    test("should combine all options", () => {
-        const data = { message: "Success" };
-        const response = json(data, {
-            status: 201,
-            revalidate: ["user-data", "cache-key"],
-            headers: {
-                "X-Created": "true",
-                Location: "/new-resource"
-            }
-        });
-        expect(response.status).toBe(201);
-        expect(response.headers.get("Content-Type")).toBe("application/json");
-        expect(response.headers.get("X-Revalidate")).toBe("user-data,cache-key");
-        expect(response.headers.get("X-Created")).toBe("true");
-        expect(response.headers.get("Location")).toBe("/new-resource");
-        expect(response.customBody()).toEqual(data);
-    });
-});

package/dist/src/index.d.ts

@@ -1,7 +0,0 @@
-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 { mergeSearchString as _mergeSearchString } from "./utils.js";
-export * from "./data/index.js";
-export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, Submission, BeforeLeaveEventArgs, RouteLoadFunc, RouteLoadFuncArgs, RouterResponseInit, CustomResponse } from "./types.js";

package/dist/src/index.jsx

@@ -1,6 +0,0 @@
-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 { mergeSearchString as _mergeSearchString } from "./utils.js";
-export * from "./data/index.js";

package/dist/src/lifecycle.d.ts

@@ -1,5 +0,0 @@
-import { BeforeLeaveLifecycle, LocationChange } from "./types.js";
-export declare function createBeforeLeave(): BeforeLeaveLifecycle;
-export declare function saveCurrentDepth(): void;
-export declare function keepDepth(state: any): any;
-export declare function notifyIfNotBlocked(notify: (value?: string | LocationChange) => void, block: (delta: number | null) => boolean): () => void;

package/dist/src/lifecycle.js

@@ -1,69 +0,0 @@
-import { isServer } from "solid-js/web";
-export function createBeforeLeave() {
-    let listeners = new Set();
-    function subscribe(listener) {
-        listeners.add(listener);
-        return () => listeners.delete(listener);
-    }
-    let ignore = false;
-    function confirm(to, options) {
-        if (ignore)
-            return !(ignore = false);
-        const e = {
-            to,
-            options,
-            defaultPrevented: false,
-            preventDefault: () => (e.defaultPrevented = true)
-        };
-        for (const l of listeners)
-            l.listener({
-                ...e,
-                from: l.location,
-                retry: (force) => {
-                    force && (ignore = true);
-                    l.navigate(to, { ...options, resolve: false });
-                }
-            });
-        return !e.defaultPrevented;
-    }
-    return {
-        subscribe,
-        confirm
-    };
-}
-// The following supports browser initiated blocking (eg back/forward)
-let depth;
-export function saveCurrentDepth() {
-    if (!window.history.state || window.history.state._depth == null) {
-        window.history.replaceState({ ...window.history.state, _depth: window.history.length - 1 }, "");
-    }
-    depth = window.history.state._depth;
-}
-if (!isServer) {
-    saveCurrentDepth();
-}
-export function keepDepth(state) {
-    return {
-        ...state,
-        _depth: window.history.state && window.history.state._depth
-    };
-}
-export function notifyIfNotBlocked(notify, block) {
-    let ignore = false;
-    return () => {
-        const prevDepth = depth;
-        saveCurrentDepth();
-        const delta = prevDepth == null ? null : depth - prevDepth;
-        if (ignore) {
-            ignore = false;
-            return;
-        }
-        if (delta && block(delta)) {
-            ignore = true;
-            window.history.go(-delta);
-        }
-        else {
-            notify();
-        }
-    };
-}

package/dist/src/routers/HashRouter.d.ts

@@ -1,9 +0,0 @@
-import type { JSX } from "solid-js";
-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/src/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/src/routers/MemoryRouter.d.ts

@@ -1,24 +0,0 @@
-import type { LocationChange } from "../types.js";
-import type { BaseRouterProps } from "./components.jsx";
-import type { JSX } from "solid-js";
-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/src/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/src/routers/Router.d.ts

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

package/dist/src/routers/Router.js

@@ -1,45 +0,0 @@
-import { isServer } from "solid-js/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.replace(/^\/+/, "/") + 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/src/routers/StaticRouter.d.ts

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

package/dist/src/routers/StaticRouter.js

@@ -1,15 +0,0 @@
-import { getRequestEvent } from "solid-js/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/src/routers/components.d.ts

@@ -1,27 +0,0 @@
-import type { Component, JSX } from "solid-js";
-import type { MatchFilters, RouteDefinition, RoutePreloadFunc, RouterIntegration, RouteSectionProps } from "../types.js";
-export type BaseRouterProps = {
-    base?: string;
-    /**
-     * A component that wraps the content of every route.
-     */
-    root?: Component<RouteSectionProps>;
-    rootPreload?: RoutePreloadFunc;
-    singleFlight?: boolean;
-    children?: JSX.Element | RouteDefinition | RouteDefinition[];
-    transformUrl?: (url: string) => string;
-    /** @deprecated use rootPreload */
-    rootLoad?: RoutePreloadFunc;
-};
-export declare const createRouterComponent: (router: RouterIntegration) => (props: BaseRouterProps) => JSX.Element;
-export type RouteProps<S extends string, T = unknown> = {
-    path?: S | S[];
-    children?: JSX.Element;
-    preload?: RoutePreloadFunc<T>;
-    matchFilters?: MatchFilters<S>;
-    component?: Component<RouteSectionProps<T>>;
-    info?: Record<string, any>;
-    /** @deprecated use preload */
-    load?: RoutePreloadFunc<T>;
-};
-export declare const Route: <S extends string, T = unknown>(props: RouteProps<S, T>) => JSX.Element;

package/dist/src/routers/components.jsx

@@ -1,118 +0,0 @@
-/*@refresh skip*/
-import { children, createMemo, createRoot, getOwner, mergeProps, on, Show, untrack } from "solid-js";
-import { getRequestEvent, isServer } from "solid-js/web";
-import { createBranches, createRouteContext, createRouterContext, getIntent, getRouteMatches, RouteContextObj, RouterContextObj, setInPreloadFn } from "../routing.js";
-export const createRouterComponent = (router) => (props) => {
-    const { base } = props;
-    const routeDefs = children(() => props.children);
-    const branches = createMemo(() => createBranches(routeDefs(), props.base || ""));
-    let context;
-    const routerState = createRouterContext(router, branches, () => context, {
-        base,
-        singleFlight: props.singleFlight,
-        transformUrl: props.transformUrl,
-    });
-    router.create && router.create(routerState);
-    return (<RouterContextObj.Provider value={routerState}>
-      <Root routerState={routerState} root={props.root} preload={props.rootPreload || props.rootLoad}>
-        {(context = getOwner()) && null}
-        <Routes routerState={routerState} branches={branches()}/>
-      </Root>
-    </RouterContextObj.Provider>);
-};
-function Root(props) {
-    const location = props.routerState.location;
-    const params = props.routerState.params;
-    const data = createMemo(() => props.preload &&
-        untrack(() => {
-            setInPreloadFn(true);
-            props.preload({ params, location, intent: getIntent() || "initial" });
-            setInPreloadFn(false);
-        }));
-    return (<Show when={props.root} keyed fallback={props.children}>
-      {Root => (<Root params={params} location={location} data={data()}>
-          {props.children}
-        </Root>)}
-    </Show>);
-}
-function Routes(props) {
-    if (isServer) {
-        const e = getRequestEvent();
-        if (e && e.router && e.router.dataOnly) {
-            dataOnly(e, props.routerState, props.branches);
-            return;
-        }
-        e &&
-            ((e.router || (e.router = {})).matches ||
-                (e.router.matches = props.routerState.matches().map(({ route, path, params }) => ({
-                    path: route.originalPath,
-                    pattern: route.pattern,
-                    match: path,
-                    params,
-                    info: route.info
-                }))));
-    }
-    const disposers = [];
-    let root;
-    const routeStates = createMemo(on(props.routerState.matches, (nextMatches, prevMatches, prev) => {
-        let equal = prevMatches && nextMatches.length === prevMatches.length;
-        const next = [];
-        for (let i = 0, len = nextMatches.length; i < len; i++) {
-            const prevMatch = prevMatches && prevMatches[i];
-            const nextMatch = nextMatches[i];
-            if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
-                next[i] = prev[i];
-            }
-            else {
-                equal = false;
-                if (disposers[i]) {
-                    disposers[i]();
-                }
-                createRoot(dispose => {
-                    disposers[i] = dispose;
-                    next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()[i + 1]), () => {
-                        const routeMatches = props.routerState.matches();
-                        return routeMatches[i] ?? routeMatches[0];
-                    });
-                });
-            }
-        }
-        disposers.splice(nextMatches.length).forEach(dispose => dispose());
-        if (prev && equal) {
-            return prev;
-        }
-        root = next[0];
-        return next;
-    }));
-    return createOutlet(() => routeStates() && root)();
-}
-const createOutlet = (child) => {
-    return () => (<Show when={child()} keyed>
-      {child => <RouteContextObj.Provider value={child}>{child.outlet()}</RouteContextObj.Provider>}
-    </Show>);
-};
-export const Route = (props) => {
-    const childRoutes = children(() => props.children);
-    return mergeProps(props, {
-        get children() {
-            return childRoutes();
-        }
-    });
-};
-// for data only mode with single flight mutations
-function dataOnly(event, routerState, branches) {
-    const url = new URL(event.request.url);
-    const prevMatches = getRouteMatches(branches, new URL(event.router.previousUrl || event.request.url).pathname);
-    const matches = getRouteMatches(branches, url.pathname);
-    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: routerState.location,
-                intent: "preload"
-            });
-    }
-}

package/dist/src/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("solid-js").JSX.Element;
-export declare function bindEvent(target: EventTarget, type: string, handler: EventListener): () => void;
-export declare function scrollToHash(hash: string, fallbackTop?: boolean): void;