@solidjs/router 0.16.0 → 0.16.1

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

@@ -1,297 +0,0 @@
-import { createRoot } from "solid-js";
-import { vi } from "vitest";
-import { action, useAction, useSubmission, useSubmissions, actions } from "./action.js";
-import { createMockRouter } from "../../test/helpers.js";
-vi.mock("../src/utils.js", () => ({
-    mockBase: "https://action"
-}));
-let mockRouterContext;
-vi.mock("../routing.js", () => ({
-    useRouter: () => mockRouterContext,
-    createRouterContext: () => createMockRouter(),
-    RouterContextObj: {},
-    RouteContextObj: {},
-    useRoute: () => mockRouterContext.base,
-    useResolvedPath: () => "/",
-    useHref: () => "/",
-    useNavigate: () => vi.fn(),
-    useLocation: () => mockRouterContext.location,
-    useRouteData: () => undefined,
-    useMatch: () => null,
-    useParams: () => ({}),
-    useSearchParams: () => [{}, vi.fn()],
-    useIsRouting: () => false,
-    usePreloadRoute: () => vi.fn(),
-    useBeforeLeave: () => vi.fn()
-}));
-describe("action", () => {
-    beforeEach(() => {
-        actions.clear();
-        mockRouterContext = createMockRouter();
-    });
-    test("should create an action function with `url` property", () => {
-        const testAction = action(async (data) => {
-            return `processed: ${data}`;
-        }, "test-action");
-        expect(typeof testAction).toBe("function");
-        expect(testAction.url).toBe("https://action/test-action");
-    });
-    test("should create action with auto-generated hash when no `name` provided", () => {
-        const testFn = async (data) => `result: ${data}`;
-        const testAction = action(testFn);
-        expect(testAction.url).toMatch(/^https:\/\/action\/-?\d+$/);
-        expect(testAction.name).toMatch(/^-?\d+$/);
-    });
-    test("should use it as `name` when `options` are provided as a string", () => {
-        const testFn = async (data) => `result: ${data}`;
-        const testAction = action(testFn, "test-action");
-        expect(testAction.url).toMatch("https://action/test-action");
-        expect(testAction.name).toBe("test-action");
-    });
-    test("should use `name` when provided in object options", () => {
-        const testFn = async (data) => `result: ${data}`;
-        const testAction = action(testFn, { name: "test-action" });
-        expect(testAction.url).toMatch("https://action/test-action");
-        expect(testAction.name).toBe("test-action");
-    });
-    test("should register action in actions map", () => {
-        const testAction = action(async () => "result", "register-test");
-        expect(actions.has(testAction.url)).toBe(true);
-        expect(actions.get(testAction.url)).toBe(testAction);
-    });
-    test("should support `.with` method for currying arguments", () => {
-        const baseAction = action(async (prefix, data) => {
-            return `${prefix}: ${data}`;
-        }, "with-test");
-        const curriedAction = baseAction.with("PREFIX");
-        expect(typeof curriedAction).toBe("function");
-        expect(curriedAction.url).toMatch(/with-test\?args=/);
-    });
-    test("should execute action and create submission", async () => {
-        return createRoot(async () => {
-            const testAction = action(async (data) => {
-                return `processed: ${data}`;
-            }, "execute-test");
-            const boundAction = useAction(testAction);
-            const promise = boundAction("test-data");
-            const submissions = mockRouterContext.submissions[0]();
-            expect(submissions).toHaveLength(1);
-            expect(submissions[0].input).toEqual(["test-data"]);
-            expect(submissions[0].pending).toBe(true);
-            const result = await promise;
-            expect(result).toBe("processed: test-data");
-        });
-    });
-    test("should handle action errors", async () => {
-        return createRoot(async () => {
-            const errorAction = action(async () => {
-                throw new Error("Test error");
-            }, "error-test");
-            const boundAction = useAction(errorAction);
-            try {
-                await boundAction();
-            }
-            catch (error) {
-                expect(error.message).toBe("Test error");
-            }
-            const submissions = mockRouterContext.submissions[0]();
-            expect(submissions[0].error.message).toBe("Test error");
-        });
-    });
-    test("should support `onComplete` callback", async () => {
-        return createRoot(async () => {
-            const onComplete = vi.fn();
-            const testAction = action(async (data) => `result: ${data}`, {
-                name: "callback-test",
-                onComplete
-            });
-            const boundAction = useAction(testAction);
-            await boundAction("test");
-            expect(onComplete).toHaveBeenCalledWith(expect.objectContaining({
-                result: "result: test",
-                error: undefined,
-                pending: false
-            }));
-        });
-    });
-});
-describe("useSubmissions", () => {
-    beforeEach(() => {
-        mockRouterContext = createMockRouter();
-    });
-    test("should return submissions for specific action", () => {
-        return createRoot(() => {
-            const testAction = action(async () => "result", "submissions-test");
-            mockRouterContext.submissions[1](submissions => [
-                ...submissions,
-                {
-                    input: ["data1"],
-                    url: testAction.url,
-                    result: "result1",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                },
-                {
-                    input: ["data2"],
-                    url: testAction.url,
-                    result: undefined,
-                    error: undefined,
-                    pending: true,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                }
-            ]);
-            const submissions = useSubmissions(testAction);
-            expect(submissions).toHaveLength(2);
-            expect(submissions[0].input).toEqual(["data1"]);
-            expect(submissions[1].input).toEqual(["data2"]);
-            expect(submissions.pending).toBe(true);
-        });
-    });
-    test("should filter submissions when filter function provided", () => {
-        return createRoot(() => {
-            const testAction = action(async (data) => data, "filter-test");
-            mockRouterContext.submissions[1](submissions => [
-                ...submissions,
-                {
-                    input: ["keep"],
-                    url: testAction.url,
-                    result: "result1",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                },
-                {
-                    input: ["skip"],
-                    url: testAction.url,
-                    result: "result2",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                }
-            ]);
-            const submissions = useSubmissions(testAction, input => input[0] === "keep");
-            expect(submissions).toHaveLength(1);
-            expect(submissions[0].input).toEqual(["keep"]);
-        });
-    });
-    test("should return pending false when no pending submissions", () => {
-        return createRoot(() => {
-            const testAction = action(async () => "result", "no-pending-test");
-            mockRouterContext.submissions[1](submissions => [
-                ...submissions,
-                {
-                    input: ["data"],
-                    url: testAction.url,
-                    result: "result",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                }
-            ]);
-            const submissions = useSubmissions(testAction);
-            expect(submissions.pending).toBe(false);
-        });
-    });
-});
-describe("useSubmission", () => {
-    beforeEach(() => {
-        mockRouterContext = createMockRouter();
-    });
-    test("should return latest submission for action", () => {
-        return createRoot(() => {
-            const testAction = action(async () => "result", "latest-test");
-            mockRouterContext.submissions[1](submissions => [
-                ...submissions,
-                {
-                    input: ["data1"],
-                    url: testAction.url,
-                    result: "result1",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                },
-                {
-                    input: ["data2"],
-                    url: testAction.url,
-                    result: "result2",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                }
-            ]);
-            const submission = useSubmission(testAction);
-            expect(submission.input).toEqual(["data2"]);
-            expect(submission.result).toBe("result2");
-        });
-    });
-    test("should return stub when no submissions exist", () => {
-        return createRoot(() => {
-            const testAction = action(async () => "result", "stub-test");
-            const submission = useSubmission(testAction);
-            expect(submission.clear).toBeDefined();
-            expect(submission.retry).toBeDefined();
-            expect(typeof submission.clear).toBe("function");
-            expect(typeof submission.retry).toBe("function");
-        });
-    });
-    test("should filter submissions when filter function provided", () => {
-        return createRoot(() => {
-            const testAction = action(async (data) => data, "filter-submission-test");
-            mockRouterContext.submissions[1](submissions => [
-                ...submissions,
-                {
-                    input: ["skip"],
-                    url: testAction.url,
-                    result: "result1",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                },
-                {
-                    input: ["keep"],
-                    url: testAction.url,
-                    result: "result2",
-                    error: undefined,
-                    pending: false,
-                    clear: vi.fn(),
-                    retry: vi.fn()
-                }
-            ]);
-            const submission = useSubmission(testAction, input => input[0] === "keep");
-            expect(submission.input).toEqual(["keep"]);
-            expect(submission.result).toBe("result2");
-        });
-    });
-});
-describe("useAction", () => {
-    beforeEach(() => {
-        mockRouterContext = createMockRouter();
-    });
-    test("should return bound action function", () => {
-        return createRoot(() => {
-            const testAction = action(async (data) => `result: ${data}`, "bound-test");
-            const boundAction = useAction(testAction);
-            expect(typeof boundAction).toBe("function");
-        });
-    });
-    test("should execute action through useAction", async () => {
-        return createRoot(async () => {
-            const testAction = action(async (data) => {
-                await new Promise(resolve => setTimeout(resolve, 1));
-                return `result: ${data}`;
-            }, "context-test");
-            const boundAction = useAction(testAction);
-            const result = await boundAction("test-data");
-            expect(result).toBe("result: test-data");
-        });
-    });
-});

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

@@ -1,32 +0,0 @@
-import { type ReconcileOptions } from "solid-js/store";
-/**
- * As `createAsync` and `createAsyncStore` are wrappers for `createResource`,
- * this type allows to support `latest` field for these primitives.
- * It will be removed in the future.
- */
-export type AccessorWithLatest<T> = {
-    (): T;
-    latest: T;
-};
-export declare function createAsync<T>(fn: (prev: T) => Promise<T>, options: {
-    name?: string;
-    initialValue: T;
-    deferStream?: boolean;
-}): AccessorWithLatest<T>;
-export declare function createAsync<T>(fn: (prev: T | undefined) => Promise<T>, options?: {
-    name?: string;
-    initialValue?: T;
-    deferStream?: boolean;
-}): AccessorWithLatest<T | undefined>;
-export declare function createAsyncStore<T>(fn: (prev: T) => Promise<T>, options: {
-    name?: string;
-    initialValue: T;
-    deferStream?: boolean;
-    reconcile?: ReconcileOptions;
-}): AccessorWithLatest<T>;
-export declare function createAsyncStore<T>(fn: (prev: T | undefined) => Promise<T>, options?: {
-    name?: string;
-    initialValue?: T;
-    deferStream?: boolean;
-    reconcile?: ReconcileOptions;
-}): AccessorWithLatest<T | undefined>;

package/dist/src/data/createAsync.js

@@ -1,96 +0,0 @@
-/**
- * This is mock of the eventual Solid 2.0 primitive. It is not fully featured.
- */
-import { createResource, sharedConfig, untrack, catchError } from "solid-js";
-import { createStore, reconcile, unwrap } from "solid-js/store";
-import { isServer } from "solid-js/web";
-import { setFunctionName } from "../utils.js";
-export function createAsync(fn, options) {
-    let resource;
-    let prev = () => !resource || resource.state === "unresolved" ? undefined : resource.latest;
-    [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, options);
-    const resultAccessor = (() => resource());
-    if (options?.name)
-        setFunctionName(resultAccessor, options.name);
-    Object.defineProperty(resultAccessor, "latest", {
-        get() {
-            return resource.latest;
-        }
-    });
-    return resultAccessor;
-}
-export function createAsyncStore(fn, options = {}) {
-    let resource;
-    let prev = () => !resource || resource.state === "unresolved"
-        ? undefined
-        : unwrap(resource.latest);
-    [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, {
-        ...options,
-        storage: (init) => createDeepSignal(init, options.reconcile)
-    });
-    const resultAccessor = (() => resource());
-    Object.defineProperty(resultAccessor, "latest", {
-        get() {
-            return resource.latest;
-        }
-    });
-    return resultAccessor;
-}
-function createDeepSignal(value, options) {
-    const [store, setStore] = createStore({
-        value: structuredClone(value)
-    });
-    return [
-        () => store.value,
-        (v) => {
-            typeof v === "function" && (v = v());
-            setStore("value", reconcile(structuredClone(v), options));
-            return store.value;
-        }
-    ];
-}
-// mock promise while hydrating to prevent fetching
-class MockPromise {
-    static all() {
-        return new MockPromise();
-    }
-    static allSettled() {
-        return new MockPromise();
-    }
-    static any() {
-        return new MockPromise();
-    }
-    static race() {
-        return new MockPromise();
-    }
-    static reject() {
-        return new MockPromise();
-    }
-    static resolve() {
-        return new MockPromise();
-    }
-    catch() {
-        return new MockPromise();
-    }
-    then() {
-        return new MockPromise();
-    }
-    finally() {
-        return new MockPromise();
-    }
-}
-function subFetch(fn, prev) {
-    if (isServer || !sharedConfig.context)
-        return fn(prev);
-    const ogFetch = fetch;
-    const ogPromise = Promise;
-    try {
-        window.fetch = () => new MockPromise();
-        Promise = MockPromise;
-        return fn(prev);
-    }
-    finally {
-        window.fetch = ogFetch;
-        Promise = ogPromise;
-    }
-}

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

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

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

@@ -1,196 +0,0 @@
-import { createRoot } from "solid-js";
-import { vi } from "vitest";
-import { createAsync, createAsyncStore } from "./createAsync.js";
-vi.mock("solid-js", async () => {
-    const actual = await vi.importActual("solid-js");
-    return {
-        ...actual,
-        sharedConfig: { context: null }
-    };
-});
-let mockSharedConfig;
-describe("createAsync", () => {
-    beforeAll(async () => {
-        const { sharedConfig } = await import("solid-js");
-        mockSharedConfig = sharedConfig;
-    });
-    test("should create async resource with `initialValue`", async () => {
-        return createRoot(async () => {
-            const resource = createAsync(async (prev) => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return prev ? prev + 1 : 1;
-            }, { initialValue: 0 });
-            expect(resource()).toBe(0);
-            expect(resource.latest).toBe(0);
-        });
-    });
-    test("should create async resource without `initialValue`", async () => {
-        return createRoot(async () => {
-            const resource = createAsync(async () => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return "loaded data";
-            });
-            expect(resource()).toBeUndefined();
-            expect(resource.latest).toBeUndefined();
-            await new Promise(resolve => setTimeout(resolve, 20));
-            expect(resource()).toBe("loaded data");
-            expect(resource.latest).toBe("loaded data");
-        });
-    });
-    test("should update resource with new data", async () => {
-        return createRoot(async () => {
-            let counter = 0;
-            const resource = createAsync(async () => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return ++counter;
-            });
-            await new Promise(resolve => setTimeout(resolve, 20));
-            expect(resource()).toBe(1);
-            // Trigger re-fetch - this would typically happen through some reactive source
-            // Since we can't easily trigger refetch in this test environment,
-            // we verify the structure is correct
-            expect(typeof resource).toBe("function");
-            expect(resource.latest).toBe(1);
-        });
-    });
-    test("should handle async errors", async () => {
-        return createRoot(async () => {
-            const resource = createAsync(async () => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                throw new Error("Async error");
-            });
-            await new Promise(resolve => setTimeout(resolve, 20));
-            /*
-             * @note Resource should handle the error gracefully
-             * The exact error handling depends on `createResource` implementation
-             */
-            expect(typeof resource).toBe("function");
-        });
-    });
-    test("should support `deferStream` option", () => {
-        return createRoot(() => {
-            const resource = createAsync(async () => "deferred data", { deferStream: true });
-            expect(typeof resource).toBe("function");
-            expect(resource.latest).toBeUndefined();
-        });
-    });
-    test("should support `name` option for debugging", () => {
-        return createRoot(() => {
-            const resource = createAsync(async () => "named resource", { name: "test-resource" });
-            expect(typeof resource).toBe("function");
-            expect(resource.name).toBe("test-resource");
-        });
-    });
-    test("should pass previous value to fetch function", async () => {
-        return createRoot(async () => {
-            let callCount = 0;
-            let lastPrev;
-            const resource = createAsync(async (prev) => {
-                lastPrev = prev;
-                return `call-${++callCount}-prev-${prev}`;
-            }, { initialValue: "initial" });
-            expect(resource()).toBe("initial");
-            await new Promise(resolve => setTimeout(resolve, 20));
-            expect(lastPrev).toBeUndefined();
-        });
-    });
-});
-describe("createAsyncStore", () => {
-    test("should create async store with `initialValue`", async () => {
-        return createRoot(async () => {
-            const store = createAsyncStore(async (prev) => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return { count: prev?.count ? prev.count + 1 : 1, data: "test" };
-            }, { initialValue: { count: 0, data: "initial" } });
-            expect(store()).toEqual({ count: 0, data: "initial" });
-            expect(store.latest).toEqual({ count: 0, data: "initial" });
-        });
-    });
-    test("should create async store without `initialValue`", async () => {
-        return createRoot(async () => {
-            const store = createAsyncStore(async () => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return { loaded: true, message: "success" };
-            });
-            expect(store()).toBeUndefined();
-            expect(store.latest).toBeUndefined();
-            await new Promise(resolve => setTimeout(resolve, 20));
-            expect(store()).toEqual({ loaded: true, message: "success" });
-            expect(store.latest).toEqual({ loaded: true, message: "success" });
-        });
-    });
-    test("should support `reconcile` options", () => {
-        return createRoot(() => {
-            const store = createAsyncStore(async () => ({ items: [1, 2, 3] }), {
-                reconcile: { key: "id" }
-            });
-            expect(typeof store).toBe("function");
-        });
-    });
-    test("should handle complex object updates", async () => {
-        return createRoot(async () => {
-            let updateCount = 0;
-            const store = createAsyncStore(async (prev) => {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return {
-                    ...prev,
-                    updateCount: ++updateCount,
-                    timestamp: Date.now(),
-                    nested: { value: `update-${updateCount}` }
-                };
-            }, { initialValue: { updateCount: 0, timestamp: 0, nested: { value: "initial" } } });
-            const initial = store();
-            expect(initial.updateCount).toBe(0);
-            expect(initial.nested.value).toBe("initial");
-        });
-    });
-    test("should support all `createAsync` options", () => {
-        return createRoot(() => {
-            const store = createAsyncStore(async () => ({ data: "test" }), {
-                name: "test-store",
-                deferStream: true,
-                reconcile: { merge: true }
-            });
-            expect(typeof store).toBe("function");
-        });
-    });
-});
-describe("MockPromise", () => {
-    test("should mock fetch during hydration", async () => {
-        mockSharedConfig.context = {};
-        return createRoot(async () => {
-            const originalFetch = window.fetch;
-            // Set up a fetch that should be mocked
-            window.fetch = () => {
-                return Promise.resolve(new Response("real fetch"));
-            };
-            const resource = createAsync(async () => {
-                const response = await fetch("/api/data");
-                return await response.text();
-            });
-            // During hydration, fetch should be mocked
-            expect(resource()).toBeUndefined();
-            window.fetch = originalFetch;
-            mockSharedConfig.context = null;
-        });
-    });
-    test("should allow real fetch outside hydration", async () => {
-        // Ensure we're not in hydration context
-        mockSharedConfig.context = null;
-        return createRoot(async () => {
-            let fetchCalled = false;
-            const originalFetch = window.fetch;
-            window.fetch = vi.fn().mockImplementation(() => {
-                fetchCalled = true;
-                return Promise.resolve(new Response("real data"));
-            });
-            createAsync(async () => {
-                const response = await fetch("/api/data");
-                return await response.text();
-            });
-            await new Promise(resolve => setTimeout(resolve, 20));
-            expect(fetchCalled).toBe(true);
-            window.fetch = originalFetch;
-        });
-    });
-});

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

@@ -1,9 +0,0 @@
-import type { RouterContext } from "../types.js";
-type NativeEventConfig = {
-    preload?: boolean;
-    explicitLinks?: boolean;
-    actionBase?: string;
-    transformUrl?: (url: string) => string;
-};
-export declare function setupNativeEvents({ preload, explicitLinks, actionBase, transformUrl }?: NativeEventConfig): (router: RouterContext) => void;
-export {};