rask-ui 0.27.0 → 0.28.1

package/dist/tests/createTask.test.js

@@ -0,0 +1,322 @@
+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

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

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

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

package/dist/tests/createView.test.js

@@ -0,0 +1,203 @@
+import { describe, it, expect } from "vitest";
+import { createView } from "../createView";
+import { createState } from "../createState";
+import { Observer } from "../observation";
+describe("createView", () => {
+    it("should merge two plain objects", () => {
+        const a = { x: 1, y: 2 };
+        const b = { z: 3 };
+        const view = createView(a, b);
+        expect(view.x).toBe(1);
+        expect(view.y).toBe(2);
+        expect(view.z).toBe(3);
+    });
+    it("should allow later arguments to override earlier ones", () => {
+        const a = { x: 1, y: 2 };
+        const b = { y: 3, z: 4 };
+        const view = createView(a, b);
+        expect(view.x).toBe(1);
+        expect(view.y).toBe(3); // b.y overrides a.y
+        expect(view.z).toBe(4);
+    });
+    it("should maintain reactivity with reactive objects", async () => {
+        const state = createState({ count: 0 });
+        const view = createView(state);
+        let renderCount = 0;
+        let lastValue = 0;
+        const observer = new Observer(() => {
+            renderCount++;
+        });
+        const dispose = observer.observe();
+        lastValue = view.count; // Track the property
+        dispose();
+        expect(renderCount).toBe(0);
+        state.count = 5;
+        // Wait for microtask to process notification
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(renderCount).toBe(1);
+                lastValue = view.count;
+                expect(lastValue).toBe(5);
+                resolve(undefined);
+            });
+        });
+    });
+    it("should merge reactive and plain objects while maintaining reactivity", () => {
+        const state = createState({ count: 0 });
+        const helpers = {
+            increment() {
+                state.count++;
+            },
+            decrement() {
+                state.count--;
+            },
+        };
+        const view = createView(state, helpers);
+        expect(view.count).toBe(0);
+        expect(typeof view.increment).toBe("function");
+        expect(typeof view.decrement).toBe("function");
+        view.increment();
+        expect(view.count).toBe(1);
+        view.decrement();
+        expect(view.count).toBe(0);
+    });
+    it("should merge multiple reactive objects", () => {
+        const state1 = createState({ count: 0 });
+        const state2 = createState({ name: "Alice" });
+        const state3 = createState({ age: 25 });
+        const view = createView(state1, state2, state3);
+        expect(view.count).toBe(0);
+        expect(view.name).toBe("Alice");
+        expect(view.age).toBe(25);
+        state1.count = 10;
+        state2.name = "Bob";
+        state3.age = 30;
+        expect(view.count).toBe(10);
+        expect(view.name).toBe("Bob");
+        expect(view.age).toBe(30);
+    });
+    it("should reflect changes in source objects", () => {
+        const source = { x: 1 };
+        const view = createView(source);
+        expect(view.x).toBe(1);
+        source.x = 2;
+        expect(view.x).toBe(2);
+    });
+    it("should handle property override order correctly", () => {
+        const a = { x: 1, y: 2, z: 3 };
+        const b = { y: 20 };
+        const c = { z: 30 };
+        const view = createView(a, b, c);
+        expect(view.x).toBe(1); // From a
+        expect(view.y).toBe(20); // From b (overrides a)
+        expect(view.z).toBe(30); // From c (overrides a)
+    });
+    it("should only include enumerable properties", () => {
+        const obj = { x: 1 };
+        Object.defineProperty(obj, "hidden", {
+            value: 42,
+            enumerable: false,
+        });
+        const view = createView(obj);
+        expect(view.x).toBe(1);
+        expect(view.hidden).toBeUndefined();
+    });
+    it("should handle symbol keys", () => {
+        const sym = Symbol("test");
+        const obj = { x: 1, [sym]: "symbol value" };
+        const view = createView(obj);
+        expect(view.x).toBe(1);
+        expect(view[sym]).toBe("symbol value");
+    });
+    it("should track dependencies for each property independently", async () => {
+        const state = createState({ count: 0, name: "Alice" });
+        const view = createView(state);
+        let countRenderCount = 0;
+        let nameRenderCount = 0;
+        // Observer that only accesses count
+        const countObserver = new Observer(() => {
+            countRenderCount++;
+        });
+        const dispose1 = countObserver.observe();
+        view.count; // Track count
+        dispose1();
+        expect(countRenderCount).toBe(0);
+        // Change count - should trigger
+        state.count = 1;
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(countRenderCount).toBe(1);
+                resolve(undefined);
+            });
+        });
+        // Change name - should NOT trigger (not tracked)
+        state.name = "Bob";
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(countRenderCount).toBe(1); // Still 1
+                resolve(undefined);
+            });
+        });
+        // Now track name with a different observer
+        const nameObserver = new Observer(() => {
+            nameRenderCount++;
+        });
+        const dispose2 = nameObserver.observe();
+        view.name; // Track name
+        dispose2();
+        expect(nameRenderCount).toBe(0);
+        // Change name - should trigger name observer
+        state.name = "Charlie";
+        await new Promise((resolve) => {
+            queueMicrotask(() => {
+                expect(nameRenderCount).toBe(1);
+                resolve(undefined);
+            });
+        });
+    });
+    it("should return the same value type as source", () => {
+        const obj = { nums: [1, 2, 3], nested: { x: 1 } };
+        const view = createView(obj);
+        expect(Array.isArray(view.nums)).toBe(true);
+        expect(view.nums).toEqual([1, 2, 3]);
+        expect(typeof view.nested).toBe("object");
+        expect(view.nested.x).toBe(1);
+    });
+    it("should handle empty merge", () => {
+        const view = createView({});
+        expect(Object.keys(view).length).toBe(0);
+    });
+    it("should merge single object", () => {
+        const obj = { x: 1, y: 2 };
+        const view = createView(obj);
+        expect(view.x).toBe(1);
+        expect(view.y).toBe(2);
+    });
+    it("should maintain function context", () => {
+        const state = createState({ count: 0 });
+        const methods = {
+            increment() {
+                state.count++;
+            },
+        };
+        const view = createView(state, methods);
+        expect(view.count).toBe(0);
+        view.increment();
+        expect(view.count).toBe(1);
+        expect(state.count).toBe(1);
+    });
+    it("should work with reactive state and computed-like patterns", () => {
+        const state = createState({ firstName: "John", lastName: "Doe" });
+        const computed = {
+            get fullName() {
+                return `${state.firstName} ${state.lastName}`;
+            },
+        };
+        const view = createView(state, computed);
+        expect(view.firstName).toBe("John");
+        expect(view.lastName).toBe("Doe");
+        expect(view.fullName).toBe("John Doe");
+        state.firstName = "Jane";
+        expect(view.fullName).toBe("Jane Doe");
+    });
+});

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

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

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

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