rask-ui 0.2.4 → 0.2.6

package/dist/tests/createAsync.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createAsync } from "../createAsync";
-describe("createAsync", () => {
-    it("should start in pending state", () => {
-        const promise = new Promise(() => { });
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        expect(async.value).toBeNull();
-        expect(async.error).toBeNull();
-    });
-    it("should resolve to value state on success", async () => {
-        const promise = Promise.resolve("success");
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        await promise;
-        // Wait for state update
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe("success");
-        expect(async.error).toBeNull();
-    });
-    it("should resolve to error state on rejection", async () => {
-        const promise = Promise.reject(new Error("failed"));
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        // Wait for state update
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBeNull();
-        expect(async.error).toContain("failed");
-    });
-    it("should handle numeric values", async () => {
-        const promise = Promise.resolve(42);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toBe(42);
-    });
-    it("should handle object values", async () => {
-        const data = { id: 1, name: "Test" };
-        const promise = Promise.resolve(data);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toEqual(data);
-    });
-    it("should handle array values", async () => {
-        const data = [1, 2, 3, 4, 5];
-        const promise = Promise.resolve(data);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toEqual(data);
-    });
-    it("should convert error to string", async () => {
-        const promise = Promise.reject("string error");
-        const async = createAsync(promise);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(typeof async.error).toBe("string");
-        expect(async.error).toBe("string error");
-    });
-    it("should handle error objects", async () => {
-        const error = new Error("Something went wrong");
-        const promise = Promise.reject(error);
-        const async = createAsync(promise);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.error).toContain("Something went wrong");
-    });
-    it("should create reactive state", async () => {
-        const promise = new Promise((resolve) => {
-            setTimeout(() => resolve("delayed"), 10);
-        });
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe("delayed");
-    });
-    it("should handle immediate resolution", async () => {
-        const async = createAsync(Promise.resolve("immediate"));
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe("immediate");
-    });
-    it("should handle immediate rejection", async () => {
-        const async = createAsync(Promise.reject("immediate error"));
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.error).toBe("immediate error");
-    });
-});

package/dist/tests/createContext.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=createContext.test.d.ts.map

package/dist/tests/createContext.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createContext.test.d.ts","sourceRoot":"","sources":["../../src/tests/createContext.test.ts"],"names":[],"mappings":""}

package/dist/tests/createContext.test.js

@@ -1,141 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createContext } from "../createContext";
-import { jsx, render } from "../vdom";
-describe("createContext", () => {
-    it("should create a context object", () => {
-        const context = createContext();
-        expect(context).toHaveProperty("inject");
-        expect(context).toHaveProperty("get");
-    });
-    it("should allow setting and getting context values", () => {
-        const ThemeContext = createContext();
-        function Parent() {
-            ThemeContext.inject({ theme: "dark" });
-            return () => jsx(Child, {});
-        }
-        function Child() {
-            const theme = ThemeContext.get();
-            return () => jsx("div", { children: theme.theme });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(jsx(Parent, {}), container);
-        expect(vnode.elm.textContent).toContain("dark");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should traverse parent components to find context", () => {
-        const ThemeContext = createContext();
-        function GrandParent() {
-            ThemeContext.inject({ theme: "light" });
-            return () => jsx(Parent, {});
-        }
-        function Parent() {
-            return () => jsx(Child, {});
-        }
-        function Child() {
-            const theme = ThemeContext.get();
-            return () => jsx("div", { children: theme.theme });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(jsx(GrandParent, {}), container);
-        expect(vnode.elm.textContent).toContain("light");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should throw error when context is not found", () => {
-        const ThemeContext = createContext();
-        function Child() {
-            expect(() => {
-                ThemeContext.get();
-            }).toThrow("Could not find context in parent components");
-            return () => jsx("div", { children: "Child" });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(jsx(Child, {}), container);
-        document.body.removeChild(vnode.elm);
-    });
-    it("should throw error when setting context outside component", () => {
-        const ThemeContext = createContext();
-        expect(() => {
-            ThemeContext.inject({ theme: "dark" });
-        }).toThrow("No current root");
-    });
-    it("should throw error when getting context outside component", () => {
-        const ThemeContext = createContext();
-        expect(() => {
-            ThemeContext.get();
-        }).toThrow("No current root");
-    });
-    it("should allow overriding context in nested components", () => {
-        const ThemeContext = createContext();
-        function GrandParent() {
-            ThemeContext.inject({ theme: "light" });
-            return () => jsx("div", {
-                children: [jsx(Parent, {}), jsx(ChildOfGrandParent, {})],
-            });
-        }
-        function Parent() {
-            ThemeContext.inject({ theme: "dark" });
-            return () => jsx(ChildOfParent, {});
-        }
-        function ChildOfParent() {
-            const theme = ThemeContext.get();
-            return () => jsx("div", { class: "child-of-parent", children: theme.theme });
-        }
-        function ChildOfGrandParent() {
-            const theme = ThemeContext.get();
-            return () => jsx("div", { class: "child-of-grandparent", children: theme.theme });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(jsx(GrandParent, {}), container);
-        const childOfParent = document.querySelector(".child-of-parent");
-        const childOfGrandParent = document.querySelector(".child-of-grandparent");
-        expect(childOfParent?.textContent).toBe("dark");
-        expect(childOfGrandParent?.textContent).toBe("light");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should support multiple different contexts", () => {
-        const ThemeContext = createContext();
-        const UserContext = createContext();
-        function Parent() {
-            ThemeContext.inject({ theme: "dark" });
-            UserContext.inject({ name: "Alice" });
-            return () => jsx(Child, {});
-        }
-        function Child() {
-            const theme = ThemeContext.get();
-            const user = UserContext.get();
-            return () => jsx("div", {
-                children: `${theme.theme} - ${user.name}`,
-            });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(jsx(Parent, {}), container);
-        expect(vnode.elm.textContent).toContain("dark - Alice");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should handle context values of different types", () => {
-        const NumberContext = createContext();
-        const ArrayContext = createContext();
-        function Parent() {
-            NumberContext.inject(42);
-            ArrayContext.inject(["a", "b", "c"]);
-            return () => jsx(Child, {});
-        }
-        function Child() {
-            const num = NumberContext.get();
-            const arr = ArrayContext.get();
-            return () => jsx("div", {
-                children: `${num} - ${arr.join(",")}`,
-            });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(jsx(Parent, {}), container);
-        expect(vnode.elm.textContent).toContain("42 - a,b,c");
-        document.body.removeChild(vnode.elm);
-    });
-});

package/dist/tests/createMutation.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=createMutation.test.d.ts.map

package/dist/tests/createMutation.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createMutation.test.d.ts","sourceRoot":"","sources":["../../src/tests/createMutation.test.ts"],"names":[],"mappings":""}

package/dist/tests/createMutation.test.js

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createMutation } from "../createMutation";
-describe("createMutation", () => {
-    it("should start in idle state", () => {
-        const mutator = vi.fn(() => Promise.resolve(null));
-        const mutation = createMutation(mutator);
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-        expect(mutation.error).toBeNull();
-        expect(mutator).not.toHaveBeenCalled();
-    });
-    it("should execute mutator when mutate is called", async () => {
-        const mutator = vi.fn((params) => Promise.resolve(params));
-        const mutation = createMutation(mutator);
-        mutation.mutate("test");
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toBe("test");
-        expect(mutator).toHaveBeenCalledWith("test");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it("should handle successful mutations", async () => {
-        const mutator = (params) => Promise.resolve(params);
-        const mutation = createMutation(mutator);
-        mutation.mutate({ id: 1 });
-        expect(mutation.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toBeNull();
-        expect(mutation.params).toBeNull();
-    });
-    it("should handle mutation errors", async () => {
-        const mutator = (params) => Promise.reject(new Error("Mutation failed"));
-        const mutation = createMutation(mutator);
-        mutation.mutate("test");
-        expect(mutation.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toContain("Mutation failed");
-        expect(mutation.params).toBeNull();
-    });
-    it("should cancel previous mutation on new mutate call", async () => {
-        let resolveFirst;
-        let resolveSecond;
-        const firstPromise = new Promise((resolve) => {
-            resolveFirst = resolve;
-        });
-        const secondPromise = new Promise((resolve) => {
-            resolveSecond = resolve;
-        });
-        const mutator = vi
-            .fn()
-            .mockReturnValueOnce(firstPromise)
-            .mockReturnValueOnce(secondPromise);
-        const mutation = createMutation(mutator);
-        mutation.mutate("first");
-        expect(mutation.params).toBe("first");
-        // Trigger second mutation before first completes
-        mutation.mutate("second");
-        expect(mutation.params).toBe("second");
-        // Resolve first (should be ignored due to cancellation)
-        resolveFirst("first");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(true); // Still pending second
-        // Resolve second
-        resolveSecond("second");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it("should handle rapid successive mutations", async () => {
-        let counter = 0;
-        const mutator = vi.fn(() => Promise.resolve(++counter));
-        const mutation = createMutation(mutator);
-        // Rapid mutations
-        mutation.mutate("1");
-        mutation.mutate("2");
-        mutation.mutate("3");
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        // Only the last mutation should complete
-        expect(mutator).toHaveBeenCalledTimes(3);
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it("should clear error on successful retry", async () => {
-        const mutator = vi
-            .fn()
-            .mockRejectedValueOnce(new Error("First error"))
-            .mockResolvedValueOnce("success");
-        const mutation = createMutation(mutator);
-        mutation.mutate("attempt1");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.error).toContain("First error");
-        mutation.mutate("attempt2");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.error).toBeNull();
-        expect(mutation.isPending).toBe(false);
-    });
-    it("should handle different parameter types", async () => {
-        const mutator = vi.fn((params) => Promise.resolve(params));
-        const mutation = createMutation(mutator);
-        // Object params
-        mutation.mutate({ id: 1, name: "test" });
-        expect(mutation.params).toEqual({ id: 1, name: "test" });
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Array params
-        const mutation2 = createMutation(mutator);
-        mutation2.mutate([1, 2, 3]);
-        expect(mutation2.params).toEqual([1, 2, 3]);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // String params
-        const mutation3 = createMutation(mutator);
-        mutation3.mutate("string");
-        expect(mutation3.params).toBe("string");
-    });
-    it("should convert errors to strings", async () => {
-        const mutator = (params) => Promise.reject("string error");
-        const mutation = createMutation(mutator);
-        mutation.mutate("test");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(typeof mutation.error).toBe("string");
-        expect(mutation.error).toBe("string error");
-    });
-    it("should handle AbortController cancellation correctly", async () => {
-        const abortedPromise = new Promise((_, reject) => {
-            const error = new Error("Aborted");
-            error.name = "AbortError";
-            setTimeout(() => reject(error), 5);
-        });
-        const successPromise = Promise.resolve("success");
-        const mutator = vi
-            .fn()
-            .mockReturnValueOnce(abortedPromise)
-            .mockReturnValueOnce(successPromise);
-        const mutation = createMutation(mutator);
-        mutation.mutate("first");
-        // Immediately trigger second mutation to abort first
-        mutation.mutate("second");
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toBeNull();
-    });
-    it("should track params during pending state", () => {
-        const mutator = () => new Promise((resolve) => setTimeout(() => resolve(null), 100));
-        const mutation = createMutation(mutator);
-        const params = { id: 123, action: "update" };
-        mutation.mutate(params);
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toEqual(params);
-    });
-    it("should expose reactive getters", async () => {
-        const mutator = () => Promise.resolve("data");
-        const mutation = createMutation(mutator);
-        // Access getters before mutation
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-        expect(mutation.error).toBeNull();
-        mutation.mutate("test");
-        // Access getters during mutation
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toBe("test");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Access getters after mutation
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-});

package/dist/tests/createQuery.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=createQuery.test.d.ts.map

package/dist/tests/createQuery.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createQuery.test.d.ts","sourceRoot":"","sources":["../../src/tests/createQuery.test.ts"],"names":[],"mappings":""}

package/dist/tests/createQuery.test.js

@@ -1,156 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createQuery } from "../createQuery";
-describe("createQuery", () => {
-    it("should start in pending state and fetch immediately", async () => {
-        const fetcher = vi.fn(() => Promise.resolve("data"));
-        const query = createQuery(fetcher);
-        expect(query.isPending).toBe(true);
-        expect(query.data).toBeNull();
-        expect(query.error).toBeNull();
-        expect(fetcher).toHaveBeenCalledTimes(1);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toBe("data");
-    });
-    it("should resolve to data state on success", async () => {
-        const fetcher = () => Promise.resolve({ id: 1, name: "Test" });
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toEqual({ id: 1, name: "Test" });
-        expect(query.error).toBeNull();
-    });
-    it("should resolve to error state on failure", async () => {
-        const fetcher = () => Promise.reject(new Error("Network error"));
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toBeNull();
-        expect(query.error).toContain("Network error");
-    });
-    it("should allow manual refetch", async () => {
-        const fetcher = vi.fn(() => Promise.resolve("data"));
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(fetcher).toHaveBeenCalledTimes(1);
-        query.fetch();
-        expect(query.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(fetcher).toHaveBeenCalledTimes(2);
-        expect(query.isPending).toBe(false);
-    });
-    it("should retain old data during refetch by default", async () => {
-        const fetcher = vi
-            .fn()
-            .mockResolvedValueOnce("data1")
-            .mockResolvedValueOnce("data2");
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe("data1");
-        query.fetch();
-        expect(query.isPending).toBe(true);
-        expect(query.data).toBe("data1"); // Old data retained
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe("data2");
-    });
-    it("should clear old data when force refetch is used", async () => {
-        const fetcher = vi
-            .fn()
-            .mockResolvedValueOnce("data1")
-            .mockResolvedValueOnce("data2");
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe("data1");
-        query.fetch(true); // Force refresh
-        expect(query.isPending).toBe(true);
-        expect(query.data).toBeNull(); // Old data cleared
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe("data2");
-    });
-    it("should cancel previous request on new fetch", async () => {
-        let resolveFirst;
-        let resolveSecond;
-        const firstPromise = new Promise((resolve) => {
-            resolveFirst = resolve;
-        });
-        const secondPromise = new Promise((resolve) => {
-            resolveSecond = resolve;
-        });
-        const fetcher = vi
-            .fn()
-            .mockReturnValueOnce(firstPromise)
-            .mockReturnValueOnce(secondPromise);
-        const query = createQuery(fetcher);
-        expect(query.isPending).toBe(true);
-        // Trigger second fetch before first completes
-        query.fetch();
-        // Resolve first (should be ignored due to cancellation)
-        resolveFirst("first");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBeNull(); // First result ignored
-        // Resolve second
-        resolveSecond("second");
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe("second");
-    });
-    it("should handle rapid successive fetches", async () => {
-        let counter = 0;
-        const fetcher = vi.fn(() => Promise.resolve(`data-${++counter}`));
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Rapid fetches
-        query.fetch();
-        query.fetch();
-        query.fetch();
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        // Only the last fetch should matter
-        expect(fetcher).toHaveBeenCalledTimes(4); // Initial + 3 fetches
-        expect(query.data).toBe("data-4");
-    });
-    it("should cancel on error and allow refetch", async () => {
-        const fetcher = vi
-            .fn()
-            .mockRejectedValueOnce(new Error("First error"))
-            .mockResolvedValueOnce("success");
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.error).toContain("First error");
-        expect(query.data).toBeNull();
-        query.fetch();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.error).toBeNull();
-        expect(query.data).toBe("success");
-    });
-    it("should handle AbortController cancellation correctly", async () => {
-        const abortedPromise = new Promise((_, reject) => {
-            const error = new Error("Aborted");
-            error.name = "AbortError";
-            setTimeout(() => reject(error), 5);
-        });
-        const successPromise = Promise.resolve("success");
-        const fetcher = vi
-            .fn()
-            .mockReturnValueOnce(abortedPromise)
-            .mockReturnValueOnce(successPromise);
-        const query = createQuery(fetcher);
-        // Immediately trigger second fetch to abort first
-        query.fetch();
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(query.data).toBe("success");
-        expect(query.error).toBeNull();
-    });
-    it("should expose reactive getters", async () => {
-        const fetcher = () => Promise.resolve("data");
-        const query = createQuery(fetcher);
-        // Access getters
-        const pending1 = query.isPending;
-        const data1 = query.data;
-        const error1 = query.error;
-        expect(pending1).toBe(true);
-        expect(data1).toBeNull();
-        expect(error1).toBeNull();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toBe("data");
-    });
-});

package/dist/tests/createRef.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=createRef.test.d.ts.map

package/dist/tests/createRef.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRef.test.d.ts","sourceRoot":"","sources":["../../src/tests/createRef.test.tsx"],"names":[],"mappings":""}