rask-ui 0.20.5 → 0.21.0

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.map

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

package/dist/{createView.test.js → tests/createView.test.js}

@@ -1,9 +1,9 @@
-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', () => {
+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);
@@ -11,7 +11,7 @@ describe('createView', () => {
         expect(view.y).toBe(2);
         expect(view.z).toBe(3);
     });
-    it('should allow later arguments to override earlier ones', () => {
+    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);
@@ -19,7 +19,7 @@ describe('createView', () => {
         expect(view.y).toBe(3); // b.y overrides a.y
         expect(view.z).toBe(4);
     });
-    it('should maintain reactivity with reactive objects', async () => {
+    it("should maintain reactivity with reactive objects", async () => {
         const state = createState({ count: 0 });
         const view = createView(state);
         let renderCount = 0;
@@ -42,7 +42,7 @@ describe('createView', () => {
             });
         });
     });
-    it('should merge reactive and plain objects while maintaining reactivity', () => {
+    it("should merge reactive and plain objects while maintaining reactivity", () => {
         const state = createState({ count: 0 });
         const helpers = {
             increment() {
@@ -54,36 +54,36 @@ describe('createView', () => {
         };
         const view = createView(state, helpers);
         expect(view.count).toBe(0);
-        expect(typeof view.increment).toBe('function');
-        expect(typeof view.decrement).toBe('function');
+        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', () => {
+    it("should merge multiple reactive objects", () => {
         const state1 = createState({ count: 0 });
-        const state2 = createState({ name: 'Alice' });
+        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.name).toBe("Alice");
         expect(view.age).toBe(25);
         state1.count = 10;
-        state2.name = 'Bob';
+        state2.name = "Bob";
         state3.age = 30;
         expect(view.count).toBe(10);
-        expect(view.name).toBe('Bob');
+        expect(view.name).toBe("Bob");
         expect(view.age).toBe(30);
     });
-    it('should reflect changes in source objects', () => {
+    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', () => {
+    it("should handle property override order correctly", () => {
         const a = { x: 1, y: 2, z: 3 };
         const b = { y: 20 };
         const c = { z: 30 };
@@ -92,9 +92,9 @@ describe('createView', () => {
         expect(view.y).toBe(20); // From b (overrides a)
         expect(view.z).toBe(30); // From c (overrides a)
     });
-    it('should only include enumerable properties', () => {
+    it("should only include enumerable properties", () => {
         const obj = { x: 1 };
-        Object.defineProperty(obj, 'hidden', {
+        Object.defineProperty(obj, "hidden", {
             value: 42,
             enumerable: false,
         });
@@ -102,15 +102,15 @@ describe('createView', () => {
         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' };
+    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');
+        expect(view[sym]).toBe("symbol value");
     });
-    it('should track dependencies for each property independently', async () => {
-        const state = createState({ count: 0, name: 'Alice' });
+    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;
@@ -131,7 +131,7 @@ describe('createView', () => {
             });
         });
         // Change name - should NOT trigger (not tracked)
-        state.name = 'Bob';
+        state.name = "Bob";
         await new Promise((resolve) => {
             queueMicrotask(() => {
                 expect(countRenderCount).toBe(1); // Still 1
@@ -147,7 +147,7 @@ describe('createView', () => {
         dispose2();
         expect(nameRenderCount).toBe(0);
         // Change name - should trigger name observer
-        state.name = 'Charlie';
+        state.name = "Charlie";
         await new Promise((resolve) => {
             queueMicrotask(() => {
                 expect(nameRenderCount).toBe(1);
@@ -155,25 +155,25 @@ describe('createView', () => {
             });
         });
     });
-    it('should return the same value type as source', () => {
+    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(typeof view.nested).toBe("object");
         expect(view.nested.x).toBe(1);
     });
-    it('should handle empty merge', () => {
+    it("should handle empty merge", () => {
         const view = createView({});
         expect(Object.keys(view).length).toBe(0);
     });
-    it('should merge single object', () => {
+    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', () => {
+    it("should maintain function context", () => {
         const state = createState({ count: 0 });
         const methods = {
             increment() {
@@ -186,18 +186,18 @@ describe('createView', () => {
         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' });
+    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');
+        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":""}