@solidjs/router 0.16.0 → 0.17.0-next.0

package/dist/src/data/query.js

@@ -1,232 +0,0 @@
-import { createSignal, getListener, getOwner, onCleanup, sharedConfig, startTransition } from "solid-js";
-import { getRequestEvent, isServer } from "solid-js/web";
-import { useNavigate, getIntent, getInPreloadFn } from "../routing.js";
-const LocationHeader = "Location";
-const PRELOAD_TIMEOUT = 5000;
-const CACHE_TIMEOUT = 180000;
-let cacheMap = new Map();
-// cleanup forward/back cache
-if (!isServer) {
-    setInterval(() => {
-        const now = Date.now();
-        for (let [k, v] of cacheMap.entries()) {
-            if (!v[4].count && now - v[0] > CACHE_TIMEOUT) {
-                cacheMap.delete(k);
-            }
-        }
-    }, 300000);
-}
-function getCache() {
-    if (!isServer)
-        return cacheMap;
-    const req = getRequestEvent();
-    if (!req)
-        throw new Error("Cannot find cache context");
-    return (req.router || (req.router = {})).cache || (req.router.cache = new Map());
-}
-/**
- * Revalidates the given cache entry/entries.
- */
-export function revalidate(key, force = true) {
-    return startTransition(() => {
-        const now = Date.now();
-        cacheKeyOp(key, entry => {
-            force && (entry[0] = 0); //force cache miss
-            entry[4][1](now); // retrigger live signals
-        });
-    });
-}
-export function cacheKeyOp(key, fn) {
-    key && !Array.isArray(key) && (key = [key]);
-    for (let k of cacheMap.keys()) {
-        if (key === undefined || matchKey(k, key))
-            fn(cacheMap.get(k));
-    }
-}
-export function query(fn, name) {
-    // prioritize GET for server functions
-    if (fn.GET)
-        fn = fn.GET;
-    const cachedFn = ((...args) => {
-        const cache = getCache();
-        const intent = getIntent();
-        const inPreloadFn = getInPreloadFn();
-        const owner = getOwner();
-        const navigate = owner ? useNavigate() : undefined;
-        const now = Date.now();
-        const key = name + hashKey(args);
-        let cached = cache.get(key);
-        let tracking;
-        if (isServer) {
-            const e = getRequestEvent();
-            if (e) {
-                const dataOnly = (e.router || (e.router = {})).dataOnly;
-                if (dataOnly) {
-                    const data = e && (e.router.data || (e.router.data = {}));
-                    if (data && key in data)
-                        return data[key];
-                    if (Array.isArray(dataOnly) && !matchKey(key, dataOnly)) {
-                        data[key] = undefined;
-                        return Promise.resolve();
-                    }
-                }
-            }
-        }
-        if (getListener() && !isServer) {
-            tracking = true;
-            onCleanup(() => cached[4].count--);
-        }
-        if (cached &&
-            cached[0] &&
-            (isServer ||
-                intent === "native" ||
-                cached[4].count ||
-                Date.now() - cached[0] < PRELOAD_TIMEOUT)) {
-            if (tracking) {
-                cached[4].count++;
-                cached[4][0](); // track
-            }
-            if (cached[3] === "preload" && intent !== "preload") {
-                cached[0] = now;
-            }
-            let res = cached[1];
-            if (intent !== "preload") {
-                res =
-                    "then" in cached[1]
-                        ? cached[1].then(handleResponse(false), handleResponse(true))
-                        : handleResponse(false)(cached[1]);
-                !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
-            }
-            inPreloadFn && "then" in res && res.catch(() => { });
-            return res;
-        }
-        let res;
-        if (!isServer && sharedConfig.has && sharedConfig.has(key)) {
-            res = sharedConfig.load(key); // hydrating
-            // @ts-ignore at least until we add a delete method to sharedConfig
-            delete globalThis._$HY.r[key];
-        }
-        else
-            res = fn(...args);
-        if (cached) {
-            cached[0] = now;
-            cached[1] = res;
-            cached[3] = intent;
-            !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
-        }
-        else {
-            cache.set(key, (cached = [now, res, , intent, createSignal(now)]));
-            cached[4].count = 0;
-        }
-        if (tracking) {
-            cached[4].count++;
-            cached[4][0](); // track
-        }
-        if (isServer) {
-            const e = getRequestEvent();
-            if (e && e.router.dataOnly)
-                return (e.router.data[key] = res);
-        }
-        if (intent !== "preload") {
-            res =
-                "then" in res
-                    ? res.then(handleResponse(false), handleResponse(true))
-                    : handleResponse(false)(res);
-        }
-        inPreloadFn && "then" in res && res.catch(() => { });
-        // serialize on server
-        if (isServer &&
-            sharedConfig.context &&
-            sharedConfig.context.async &&
-            !sharedConfig.context.noHydrate) {
-            const e = getRequestEvent();
-            (!e || !e.serverOnly) && sharedConfig.context.serialize(key, res);
-        }
-        return res;
-        function handleResponse(error) {
-            return async (v) => {
-                if (v instanceof Response) {
-                    const e = getRequestEvent();
-                    if (e) {
-                        for (const [key, value] of v.headers) {
-                            if (key == "set-cookie")
-                                e.response.headers.append("set-cookie", value);
-                            else
-                                e.response.headers.set(key, value);
-                        }
-                    }
-                    const url = v.headers.get(LocationHeader);
-                    if (url !== null) {
-                        // client + server relative redirect
-                        if (navigate && url.startsWith("/"))
-                            startTransition(() => {
-                                navigate(url, { replace: true });
-                            });
-                        else if (!isServer)
-                            window.location.href = url;
-                        else if (e)
-                            e.response.status = 302;
-                        return;
-                    }
-                    if (v.customBody)
-                        v = await v.customBody();
-                }
-                if (error)
-                    throw v;
-                cached[2] = v;
-                return v;
-            };
-        }
-    });
-    cachedFn.keyFor = (...args) => name + hashKey(args);
-    cachedFn.key = name;
-    return cachedFn;
-}
-query.get = (key) => {
-    const cached = getCache().get(key);
-    return cached[2];
-};
-query.set = (key, value) => {
-    const cache = getCache();
-    const now = Date.now();
-    let cached = cache.get(key);
-    if (cached) {
-        cached[0] = now;
-        cached[1] = Promise.resolve(value);
-        cached[2] = value;
-        cached[3] = "preload";
-    }
-    else {
-        cache.set(key, (cached = [now, Promise.resolve(value), value, "preload", createSignal(now)]));
-        cached[4].count = 0;
-    }
-};
-query.delete = (key) => getCache().delete(key);
-query.clear = () => getCache().clear();
-/** @deprecated use query instead */
-export const cache = query;
-function matchKey(key, keys) {
-    for (let k of keys) {
-        if (k && key.startsWith(k))
-            return true;
-    }
-    return false;
-}
-// Modified from the amazing Tanstack Query library (MIT)
-// https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L168
-export function hashKey(args) {
-    return JSON.stringify(args, (_, val) => isPlainObject(val)
-        ? Object.keys(val)
-            .sort()
-            .reduce((result, key) => {
-            result[key] = val[key];
-            return result;
-        }, {})
-        : val);
-}
-function isPlainObject(obj) {
-    let proto;
-    return (obj != null &&
-        typeof obj === "object" &&
-        (!(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype));
-}

package/dist/src/data/query.spec.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,354 +0,0 @@
-import { createRoot } from "solid-js";
-import { vi } from "vitest";
-import { query, revalidate, cacheKeyOp, hashKey } from "./query.js";
-import { createMockRouter } from "../../test/helpers.js";
-const mockRouter = createMockRouter();
-vi.mock("../routing.js", () => ({
-    useRouter: () => mockRouter,
-    useNavigate: () => vi.fn(),
-    getIntent: () => "navigate",
-    getInPreloadFn: () => false,
-    createRouterContext: () => mockRouter,
-    RouterContextObj: {},
-    RouteContextObj: {},
-    useRoute: () => mockRouter.base,
-    useResolvedPath: () => "/",
-    useHref: () => "/",
-    useLocation: () => mockRouter.location,
-    useRouteData: () => undefined,
-    useMatch: () => null,
-    useParams: () => ({}),
-    useSearchParams: () => [{}, vi.fn()],
-    useIsRouting: () => false,
-    usePreloadRoute: () => vi.fn(),
-    useBeforeLeave: () => vi.fn()
-}));
-describe("query", () => {
-    beforeEach(() => {
-        query.clear();
-        vi.clearAllTimers();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.runOnlyPendingTimers();
-        vi.useRealTimers();
-    });
-    test("should create cached function with correct properties", () => {
-        return createRoot(() => {
-            const testFn = async (id) => `data-${id}`;
-            const cachedFn = query(testFn, "testQuery");
-            expect(typeof cachedFn).toBe("function");
-            expect(cachedFn.key).toBe("testQuery");
-            expect(typeof cachedFn.keyFor).toBe("function");
-            expect(cachedFn.keyFor(123)).toBe("testQuery[123]");
-        });
-    });
-    test("should cache function results", async () => {
-        return createRoot(async () => {
-            let callCount = 0;
-            const testFn = async (id) => {
-                callCount++;
-                return `data-${id}`;
-            };
-            const cachedFn = query(testFn, "testQuery");
-            const result1 = await cachedFn(123);
-            const result2 = await cachedFn(123);
-            expect(result1).toBe("data-123");
-            expect(result2).toBe("data-123");
-            expect(callCount).toBe(1);
-        });
-    });
-    test("should cache different arguments separately", async () => {
-        return createRoot(async () => {
-            let callCount = 0;
-            const testFn = async (id) => {
-                callCount++;
-                return `data-${id}`;
-            };
-            const cachedFn = query(testFn, "testQuery");
-            const result1 = await cachedFn(123);
-            const result2 = await cachedFn(456);
-            expect(result1).toBe("data-123");
-            expect(result2).toBe("data-456");
-            expect(callCount).toBe(2);
-        });
-    });
-    test("should handle synchronous functions", async () => {
-        return createRoot(async () => {
-            const testFn = (id) => Promise.resolve(`data-${id}`);
-            const cachedFn = query(testFn, "testQuery");
-            const result1 = await cachedFn(123);
-            const result2 = await cachedFn(123);
-            expect(result1).toBe("data-123");
-            expect(result2).toBe("data-123");
-        });
-    });
-    test("should prioritize GET method for server functions", async () => {
-        return createRoot(async () => {
-            const postFn = () => Promise.resolve("POST result");
-            const getFn = () => Promise.resolve("GET result");
-            postFn.GET = getFn;
-            const cachedFn = query(postFn, "serverQuery");
-            const result = await cachedFn();
-            expect(result).toBe("GET result");
-        });
-    });
-});
-describe("query.get", () => {
-    beforeEach(() => {
-        query.clear();
-    });
-    test("should retrieve cached value", async () => {
-        return createRoot(async () => {
-            const testFn = async (id) => `data-${id}`;
-            const cachedFn = query(testFn, "testQuery");
-            await cachedFn(123);
-            const cached = query.get("testQuery[123]");
-            expect(cached).toBe("data-123");
-        });
-    });
-    test("handle non-existent key gracefully", () => {
-        expect(() => query.get("nonexistent")).toThrow();
-    });
-});
-describe("query.set", () => {
-    beforeEach(() => {
-        query.clear();
-    });
-    test("should set cached value", () => {
-        query.set("testKey", "test value");
-        const cached = query.get("testKey");
-        expect(cached).toBe("test value");
-    });
-    test("should update existing cached value", async () => {
-        return createRoot(async () => {
-            const testFn = async () => "original";
-            const cachedFn = query(testFn, "testQuery");
-            await cachedFn();
-            query.set("testQuery[]", "updated");
-            const cached = query.get("testQuery[]");
-            expect(cached).toBe("updated");
-        });
-    });
-});
-describe("query.delete", () => {
-    beforeEach(() => {
-        query.clear();
-    });
-    test("should delete cached entry", async () => {
-        return createRoot(async () => {
-            const testFn = async () => "data";
-            const cachedFn = query(testFn, "testQuery");
-            await cachedFn();
-            expect(query.get("testQuery[]")).toBe("data");
-            query.delete("testQuery[]");
-            expect(() => query.get("testQuery[]")).toThrow();
-        });
-    });
-});
-describe("query.clear", () => {
-    beforeEach(() => {
-        query.clear();
-    });
-    test("should clear all cached entries", async () => {
-        return createRoot(async () => {
-            const testFn1 = async () => "data1";
-            const testFn2 = async () => "data2";
-            const cachedFn1 = query(testFn1, "query1");
-            const cachedFn2 = query(testFn2, "query2");
-            await cachedFn1();
-            await cachedFn2();
-            expect(query.get("query1[]")).toBe("data1");
-            expect(query.get("query2[]")).toBe("data2");
-            query.clear();
-            expect(() => query.get("query1[]")).toThrow();
-            expect(() => query.get("query2[]")).toThrow();
-        });
-    });
-});
-describe("revalidate", () => {
-    beforeEach(() => {
-        query.clear();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    test("should revalidate all cached entries when no key provided", async () => {
-        return createRoot(async () => {
-            let callCount = 0;
-            const testFn = async () => {
-                callCount++;
-                return `data-${callCount}`;
-            };
-            const cachedFn = query(testFn, "testQuery");
-            const result1 = await cachedFn();
-            expect(result1).toBe("data-1");
-            expect(callCount).toBe(1);
-            await revalidate(); // Force revalidation and wait for transition
-            vi.runAllTimers();
-            const result2 = await cachedFn();
-            expect(result2).toBe("data-2");
-            expect(callCount).toBe(2);
-        });
-    });
-    test("revalidate specific key", async () => {
-        return createRoot(async () => {
-            let callCount1 = 0;
-            let callCount2 = 0;
-            const testFn1 = async () => {
-                callCount1++;
-                return `data1-${callCount1}`;
-            };
-            const testFn2 = async () => {
-                callCount2++;
-                return `data2-${callCount2}`;
-            };
-            const willRevalidateFn = query(testFn1, "query1");
-            const willNotRevalidateFn = query(testFn2, "query2");
-            await willRevalidateFn();
-            await willNotRevalidateFn();
-            expect(callCount1).toBe(1);
-            expect(callCount2).toBe(1);
-            await revalidate(willRevalidateFn.key);
-            vi.runAllTimers();
-            await willRevalidateFn();
-            await willNotRevalidateFn();
-            expect(callCount1).toBe(2);
-            expect(callCount2).toBe(1);
-        });
-    });
-    test("should revalidate multiple keys", async () => {
-        return createRoot(async () => {
-            let callCount1 = 0;
-            let callCount2 = 0;
-            let callCount3 = 0;
-            const testFn1 = async () => {
-                callCount1++;
-                return `data1-${callCount1}`;
-            };
-            const testFn2 = async () => {
-                callCount2++;
-                return `data2-${callCount2}`;
-            };
-            const testFn3 = async () => {
-                callCount3++;
-                return `data3-${callCount3}`;
-            };
-            const cachedFn1 = query(testFn1, "query1");
-            const cachedFn2 = query(testFn2, "query2");
-            const cachedFn3 = query(testFn3, "query3");
-            await cachedFn1();
-            await cachedFn2();
-            await cachedFn3();
-            await revalidate([cachedFn1.key, cachedFn3.key]);
-            vi.runAllTimers();
-            await cachedFn1();
-            await cachedFn2();
-            await cachedFn3();
-            expect(callCount1).toBe(2);
-            expect(callCount2).toBe(1);
-            expect(callCount3).toBe(2);
-        });
-    });
-});
-describe("cacheKeyOp should", () => {
-    beforeEach(() => {
-        query.clear();
-    });
-    test("operate on all entries when no key provided", async () => {
-        return createRoot(async () => {
-            const testFn1 = async () => "data1";
-            const testFn2 = async () => "data2";
-            const cachedFn1 = query(testFn1, "query1");
-            const cachedFn2 = query(testFn2, "query2");
-            await cachedFn1();
-            await cachedFn2();
-            let operationCount = 0;
-            cacheKeyOp(undefined, () => {
-                operationCount++;
-            });
-            expect(operationCount).toBe(2);
-        });
-    });
-    test("operate on specific key", async () => {
-        return createRoot(async () => {
-            const testFn = async () => "data";
-            const cachedFn = query(testFn, "testQuery");
-            await cachedFn();
-            let operationCount = 0;
-            cacheKeyOp(cachedFn.key, () => {
-                operationCount++;
-            });
-            expect(operationCount).toBe(1);
-        });
-    });
-    test("operate on multiple keys", async () => {
-        return createRoot(async () => {
-            const testFn1 = async () => "data1";
-            const testFn2 = async () => "data2";
-            const testFn3 = async () => "data3";
-            const cachedFn1 = query(testFn1, "query1");
-            const cachedFn2 = query(testFn2, "query2");
-            const cachedFn3 = query(testFn3, "other");
-            await cachedFn1();
-            await cachedFn2();
-            await cachedFn3();
-            let operationCount = 0;
-            cacheKeyOp([cachedFn1.key, cachedFn2.key], () => {
-                operationCount++;
-            });
-            expect(operationCount).toBe(2);
-        });
-    });
-    test("handle partial key matches", async () => {
-        return createRoot(async () => {
-            const testFn1 = async (id) => `data1-${id}`;
-            const testFn2 = async (id) => `data2-${id}`;
-            const cachedFn1 = query(testFn1, "query1");
-            const cachedFn2 = query(testFn2, "query2");
-            await cachedFn1(1);
-            await cachedFn1(2);
-            await cachedFn2(1);
-            let operationCount = 0;
-            cacheKeyOp([cachedFn1.key], () => {
-                operationCount++;
-            });
-            expect(operationCount).toBe(2); // Should match both query1[1] and query1[2]
-        });
-    });
-});
-describe("hashKey should", () => {
-    test("generate consistent hash for same input", () => {
-        const hash1 = hashKey([1, "test", { key: "value" }]);
-        const hash2 = hashKey([1, "test", { key: "value" }]);
-        expect(hash1).toBe(hash2);
-    });
-    test("generate different hash for different input", () => {
-        const hash1 = hashKey([1, "test"]);
-        const hash2 = hashKey([2, "test"]);
-        expect(hash1).not.toBe(hash2);
-    });
-    test("handle object key ordering consistently", () => {
-        const hash1 = hashKey([{ b: 2, a: 1 }]);
-        const hash2 = hashKey([{ a: 1, b: 2 }]);
-        expect(hash1).toBe(hash2);
-    });
-    test("handle nested objects", () => {
-        const hash1 = hashKey([{ outer: { b: 2, a: 1 } }]);
-        const hash2 = hashKey([{ outer: { a: 1, b: 2 } }]);
-        expect(hash1).toBe(hash2);
-    });
-    test("handle arrays", () => {
-        const hash1 = hashKey([[1, 2, 3]]);
-        const hash2 = hashKey([[1, 2, 3]]);
-        const hash3 = hashKey([[3, 2, 1]]);
-        expect(hash1).toBe(hash2);
-        expect(hash1).not.toBe(hash3);
-    });
-    test("handle empty arguments", () => {
-        const hash = hashKey([]);
-        expect(typeof hash).toBe("string");
-        expect(hash).toBe("[]");
-    });
-});

package/dist/src/data/response.d.ts

@@ -1,4 +0,0 @@
-import type { RouterResponseInit, CustomResponse } from "../types.js";
-export declare function redirect(url: string, init?: number | RouterResponseInit): CustomResponse<never>;
-export declare function reload(init?: RouterResponseInit): CustomResponse<never>;
-export declare function json<T>(data: T, init?: RouterResponseInit): CustomResponse<T>;

package/dist/src/data/response.js

@@ -1,42 +0,0 @@
-export function redirect(url, init = 302) {
-    let responseInit;
-    let revalidate;
-    if (typeof init === "number") {
-        responseInit = { status: init };
-    }
-    else {
-        ({ revalidate, ...responseInit } = init);
-        if (typeof responseInit.status === "undefined") {
-            responseInit.status = 302;
-        }
-    }
-    const headers = new Headers(responseInit.headers);
-    headers.set("Location", url);
-    revalidate !== undefined && headers.set("X-Revalidate", revalidate.toString());
-    const response = new Response(null, {
-        ...responseInit,
-        headers: headers
-    });
-    return response;
-}
-export function reload(init = {}) {
-    const { revalidate, ...responseInit } = init;
-    const headers = new Headers(responseInit.headers);
-    revalidate !== undefined && headers.set("X-Revalidate", revalidate.toString());
-    return new Response(null, {
-        ...responseInit,
-        headers
-    });
-}
-export function json(data, init = {}) {
-    const { revalidate, ...responseInit } = init;
-    const headers = new Headers(responseInit.headers);
-    revalidate !== undefined && headers.set("X-Revalidate", revalidate.toString());
-    headers.set("Content-Type", "application/json");
-    const response = new Response(JSON.stringify(data), {
-        ...responseInit,
-        headers
-    });
-    response.customBody = () => data;
-    return response;
-}

package/dist/src/data/response.spec.d.ts

@@ -1 +0,0 @@
-export {};