rask-ui 0.24.1 → 0.25.0

package/dist/tests/createTask.test.js

@@ -1,322 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createTask } from "../createTask";
-describe("createTask", () => {
-    describe("without parameters", () => {
-        it("should auto-run on creation and start in idle state", () => {
-            const promise = new Promise(() => { });
-            const task = createTask(() => promise);
-            // Initial fetch() doesn't set isRunning, only run()/rerun() do
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBeNull();
-            expect(task.error).toBeNull();
-            expect(task.params).toBeNull();
-        });
-        it("should resolve to result state on success", async () => {
-            const task = createTask(() => Promise.resolve("success"));
-            // Task doesn't auto-run anymore
-            expect(task.isRunning).toBe(false);
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBe("success");
-            expect(task.error).toBeNull();
-            expect(task.params).toBeNull();
-        });
-        it("should resolve to error state on rejection", async () => {
-            const task = createTask(() => Promise.reject(new Error("failed")));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBeNull();
-            expect(task.error).toContain("failed");
-            expect(task.params).toBeNull();
-        });
-        it("should handle run() method", async () => {
-            const fetcher = vi.fn(() => Promise.resolve("data"));
-            const task = createTask(fetcher);
-            // Tasks no longer auto-run, so fetcher hasn't been called yet
-            expect(fetcher).toHaveBeenCalledTimes(0);
-            task.run();
-            expect(task.isRunning).toBe(true);
-            expect(task.result).toBeNull(); // Cleared on run
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(fetcher).toHaveBeenCalledTimes(1);
-            expect(task.result).toBe("data");
-        });
-        it("should handle rerun() method", async () => {
-            const fetcher = vi
-                .fn()
-                .mockResolvedValueOnce("data1")
-                .mockResolvedValueOnce("data2");
-            const task = createTask(fetcher);
-            // First run
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe("data1");
-            task.rerun();
-            expect(task.isRunning).toBe(true);
-            expect(task.result).toBe("data1"); // Kept during rerun
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe("data2");
-        });
-    });
-    describe("with parameters", () => {
-        it("should not auto-run on creation", () => {
-            const fetcher = vi.fn((page) => Promise.resolve(`page-${page}`));
-            const task = createTask(fetcher);
-            // Tasks no longer auto-run
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBeNull();
-            expect(task.error).toBeNull();
-            expect(task.params).toBeNull();
-            expect(fetcher).toHaveBeenCalledTimes(0);
-        });
-        it("should run when run() is called with params", async () => {
-            const fetcher = vi.fn((page) => Promise.resolve(`page-${page}`));
-            const task = createTask(fetcher);
-            task.run(1);
-            expect(task.isRunning).toBe(true);
-            expect(task.params).toBe(1);
-            expect(task.result).toBeNull();
-            expect(fetcher).toHaveBeenCalledWith(1);
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBe("page-1");
-            expect(task.params).toBeNull();
-        });
-        it("should handle error state with params", async () => {
-            const task = createTask((id) => Promise.reject(new Error(`failed-${id}`)));
-            task.run(42);
-            expect(task.isRunning).toBe(true);
-            expect(task.params).toBe(42);
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBeNull();
-            expect(task.error).toContain("failed-42");
-            expect(task.params).toBeNull();
-        });
-        it("should handle rerun with params", async () => {
-            const fetcher = vi
-                .fn()
-                .mockResolvedValueOnce("data1")
-                .mockResolvedValueOnce("data2");
-            const task = createTask((page) => fetcher());
-            // First run
-            task.run(1);
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe("data1");
-            task.rerun(1);
-            expect(task.isRunning).toBe(true);
-            expect(task.result).toBe("data1"); // Kept during rerun
-            expect(task.params).toBe(1);
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe("data2");
-        });
-        it("should update params when running with different values", async () => {
-            const task = createTask((page) => Promise.resolve(`page-${page}`));
-            task.run(1);
-            expect(task.params).toBe(1);
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            task.run(2);
-            expect(task.params).toBe(2);
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe("page-2");
-        });
-    });
-    describe("cancellation", () => {
-        it("should cancel previous request when run again", 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 task = createTask(fetcher);
-            // First run
-            task.run();
-            expect(task.isRunning).toBe(true);
-            // Trigger second run before first completes - this cancels the first run
-            task.run();
-            expect(task.isRunning).toBe(true);
-            // Resolve first (should be ignored due to cancellation)
-            resolveFirst("first");
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBeNull(); // First result ignored
-            // Resolve second
-            resolveSecond("second");
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe("second");
-        });
-        it("should cancel previous request with params", 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 task = createTask((page) => fetcher());
-            task.run(1);
-            expect(task.params).toBe(1);
-            // Trigger second run before first completes
-            task.run(2);
-            expect(task.params).toBe(2);
-            // Resolve first (should be ignored due to cancellation)
-            resolveFirst("first");
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBeNull(); // First result ignored
-            // Resolve second
-            resolveSecond("second");
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe("second");
-        });
-        it("should handle rapid successive runs", async () => {
-            let counter = 0;
-            const fetcher = vi.fn(() => Promise.resolve(`data-${++counter}`));
-            const task = createTask(fetcher);
-            // Rapid runs
-            task.run();
-            task.run();
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 20));
-            // Only the last run should complete
-            expect(fetcher).toHaveBeenCalledTimes(3); // 3 runs
-            expect(task.result).toBe("data-3");
-        });
-    });
-    describe("type handling", () => {
-        it("should handle numeric values", async () => {
-            const task = createTask(() => Promise.resolve(42));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toBe(42);
-        });
-        it("should handle object values", async () => {
-            const data = { id: 1, name: "Test" };
-            const task = createTask(() => Promise.resolve(data));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toEqual(data);
-        });
-        it("should handle array values", async () => {
-            const data = [1, 2, 3, 4, 5];
-            const task = createTask(() => Promise.resolve(data));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.result).toEqual(data);
-        });
-        it("should convert error to string", async () => {
-            const task = createTask(() => Promise.reject("string error"));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(typeof task.error).toBe("string");
-            expect(task.error).toBe("string error");
-        });
-        it("should handle error objects", async () => {
-            const error = new Error("Something went wrong");
-            const task = createTask(() => Promise.reject(error));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.error).toContain("Something went wrong");
-        });
-        it("should handle different parameter types", async () => {
-            const fetcher = vi.fn((params) => Promise.resolve(params));
-            // Object params
-            const task1 = createTask(fetcher);
-            task1.run({ id: 1, name: "test" });
-            expect(task1.params).toEqual({ id: 1, name: "test" });
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            // Array params
-            const task2 = createTask(fetcher);
-            task2.run([1, 2, 3]);
-            expect(task2.params).toEqual([1, 2, 3]);
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            // String params
-            const task3 = createTask((str) => Promise.resolve(str));
-            task3.run("test");
-            expect(task3.params).toBe("test");
-        });
-    });
-    describe("edge cases", () => {
-        it("should handle immediate resolution", async () => {
-            const task = createTask(() => Promise.resolve("immediate"));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBe("immediate");
-        });
-        it("should handle immediate rejection", async () => {
-            const task = createTask(() => Promise.reject("immediate error"));
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.isRunning).toBe(false);
-            expect(task.error).toBe("immediate error");
-        });
-        it("should handle delayed resolution", async () => {
-            const task = createTask(() => new Promise((resolve) => {
-                setTimeout(() => resolve("delayed"), 10);
-            }));
-            task.run();
-            expect(task.isRunning).toBe(true);
-            await new Promise((resolve) => setTimeout(resolve, 20));
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBe("delayed");
-        });
-        it("should clear error on successful retry", async () => {
-            const fetcher = vi
-                .fn()
-                .mockRejectedValueOnce(new Error("First error"))
-                .mockResolvedValueOnce("success");
-            const task = createTask(fetcher);
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.error).toContain("First error");
-            expect(task.result).toBeNull();
-            task.run();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(task.error).toBeNull();
-            expect(task.result).toBe("success");
-        });
-    });
-    describe("reactive getters", () => {
-        it("should expose reactive getters", async () => {
-            const task = createTask(() => Promise.resolve("data"));
-            task.run();
-            // Access getters before completion
-            const running1 = task.isRunning;
-            const result1 = task.result;
-            const error1 = task.error;
-            const params1 = task.params;
-            expect(running1).toBe(true);
-            expect(result1).toBeNull();
-            expect(error1).toBeNull();
-            expect(params1).toBeNull();
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            // Access getters after completion
-            expect(task.isRunning).toBe(false);
-            expect(task.result).toBe("data");
-            expect(task.error).toBeNull();
-            expect(task.params).toBeNull();
-        });
-        it("should track params during execution", async () => {
-            const task = createTask((id) => new Promise((resolve) => setTimeout(() => resolve(`result-${id}`), 20)));
-            task.run(123);
-            expect(task.isRunning).toBe(true);
-            expect(task.params).toBe(123);
-            await new Promise((resolve) => setTimeout(resolve, 30));
-            expect(task.isRunning).toBe(false);
-            expect(task.params).toBeNull();
-        });
-    });
-});

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

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

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

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

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

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

package/dist/tests/error.test.js

@@ -1,168 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "./jsx-runtime";
-import { describe, it, expect } from "vitest";
-import { ErrorBoundary } from "../error";
-import { render } from "../";
-describe("ErrorBoundary", () => {
-    it("should render children when no error occurs", async () => {
-        function SafeChild() {
-            return () => _jsx("div", { children: "Safe content" });
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(SafeChild, {}) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(container.textContent).toContain("Safe content");
-        expect(container.textContent).not.toContain("Error:");
-        document.body.removeChild(container);
-    });
-    it("should catch errors thrown in child components", async () => {
-        function ThrowingChild() {
-            return () => {
-                throw new Error("Child component error");
-                return _jsx("div", {});
-            };
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(ThrowingChild, {}) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(container.textContent).toContain("Error:");
-        expect(container.textContent).toContain("Child component error");
-        document.body.removeChild(container);
-    });
-    it("should render custom error UI", async () => {
-        function ThrowingChild() {
-            return () => {
-                throw new Error("Something went wrong");
-                return _jsx("div", {});
-            };
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => (_jsxs("div", { class: "error-ui", children: [_jsx("h1", { children: "Oops!" }), _jsx("p", { children: String(error) })] })), children: _jsx(ThrowingChild, {}) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const errorUI = document.querySelector(".error-ui");
-        expect(errorUI).not.toBeNull();
-        expect(errorUI?.querySelector("h1")?.textContent).toBe("Oops!");
-        expect(errorUI?.textContent).toContain("Something went wrong");
-        document.body.removeChild(container);
-    });
-    it("should handle multiple children", async () => {
-        function SafeChild1() {
-            return () => _jsx("div", { children: "Child 1" });
-        }
-        function SafeChild2() {
-            return () => _jsx("div", { children: "Child 2" });
-        }
-        function TestComponent() {
-            return () => (_jsxs(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: [_jsx(SafeChild1, {}), _jsx(SafeChild2, {})] }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(container.textContent).toContain("Child 1");
-        expect(container.textContent).toContain("Child 2");
-        document.body.removeChild(container);
-    });
-    it("should catch errors from nested children", async () => {
-        function DeepChild() {
-            return () => {
-                throw new Error("Deep error");
-                return _jsx("div", {});
-            };
-        }
-        function MiddleChild() {
-            return () => _jsx(DeepChild, {});
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Caught: ", String(error)] }), children: _jsx(MiddleChild, {}) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(container.textContent).toContain("Caught:");
-        expect(container.textContent).toContain("Deep error");
-        document.body.removeChild(container);
-    });
-    it("should allow nested error boundaries", async () => {
-        function ThrowingChild() {
-            return () => {
-                throw new Error("Inner error");
-                return _jsx("div", {});
-            };
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Outer: ", String(error)] }), children: _jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Inner: ", String(error)] }), children: _jsx(ThrowingChild, {}) }) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Inner boundary should catch the error
-        expect(container.textContent).toContain("Inner:");
-        expect(container.textContent).not.toContain("Outer:");
-        document.body.removeChild(container);
-    });
-    it("should handle string errors", async () => {
-        function ThrowingChild() {
-            return () => {
-                throw "String error";
-                return _jsx("div", {});
-            };
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(ThrowingChild, {}) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(container.textContent).toContain("String error");
-        document.body.removeChild(container);
-    });
-    it("should handle object errors", async () => {
-        function ThrowingChild() {
-            return () => {
-                throw { message: "Custom error object", code: 500 };
-                return _jsx("div", {});
-            };
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => (_jsxs("div", { children: ["Error: ", error.message, " (Code: ", error.code, ")"] })), children: _jsx(ThrowingChild, {}) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(container.textContent).toContain("Custom error object");
-        expect(container.textContent).toContain("500");
-        document.body.removeChild(container);
-    });
-    it("should switch back to children if error is cleared", async () => {
-        // Note: This test demonstrates the current behavior
-        // In practice, error clearing would require additional implementation
-        function SafeChild() {
-            return () => _jsx("div", { children: "Safe content" });
-        }
-        function TestComponent() {
-            return () => (_jsx(ErrorBoundary, { error: (error) => _jsxs("div", { children: ["Error: ", String(error)] }), children: _jsx(SafeChild, {}) }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        render(_jsx(TestComponent, {}), container);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(container.textContent).toContain("Safe content");
-        document.body.removeChild(container);
-    });
-});

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

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