rask-ui 0.21.0 → 0.22.0

package/dist/tests/createState.test.js

@@ -1,144 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createState } from "../createState";
-import { Observer } from "../observation";
-describe("createState", () => {
-    it("should create a reactive proxy from an object", () => {
-        const state = createState({ count: 0 });
-        expect(state.count).toBe(0);
-    });
-    it("should allow mutations", () => {
-        const state = createState({ count: 0 });
-        state.count = 5;
-        expect(state.count).toBe(5);
-    });
-    it("should return the same proxy for the same object", () => {
-        const obj = { count: 0 };
-        const proxy1 = createState(obj);
-        const proxy2 = createState(obj);
-        expect(proxy1).toBe(proxy2);
-    });
-    it("should create nested proxies for nested objects", () => {
-        const state = createState({ user: { name: "Alice", age: 30 } });
-        state.user.name = "Bob";
-        expect(state.user.name).toBe("Bob");
-    });
-    it("should handle arrays reactively", () => {
-        const state = createState({ items: [1, 2, 3] });
-        state.items.push(4);
-        expect(state.items).toEqual([1, 2, 3, 4]);
-    });
-    it("should track property access in observers", async () => {
-        const state = createState({ count: 0 });
-        let renderCount = 0;
-        const observer = new Observer(() => {
-            renderCount++;
-        });
-        const dispose = observer.observe();
-        state.count; // Access property to track it
-        dispose();
-        expect(renderCount).toBe(0);
-        // Mutate after observation setup
-        const dispose2 = observer.observe();
-        const value = state.count; // Track
-        dispose2(); // Stop observing, subscriptions are now active
-        state.count = 1;
-        // Wait for microtasks to complete
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(renderCount).toBeGreaterThan(0);
-    });
-    it("should handle property deletion", () => {
-        const state = createState({ count: 0, temp: "value" });
-        delete state.temp;
-        expect(state.temp).toBeUndefined();
-        expect("temp" in state).toBe(false);
-    });
-    it("should not create proxies for functions", () => {
-        const fn = () => "hello";
-        const state = createState({ method: fn });
-        expect(state.method).toBe(fn);
-        expect(state.method()).toBe("hello");
-    });
-    it("should handle symbol properties", () => {
-        const sym = Symbol("test");
-        const state = createState({ [sym]: "value" });
-        expect(state[sym]).toBe("value");
-    });
-    it("should notify observers only on actual changes", async () => {
-        const state = createState({ count: 0 });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count; // Track
-        dispose();
-        state.count = 0; // Same value - should still notify per current implementation
-        state.count = 0;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        // The implementation notifies even for same value, except for optimization cases
-        observer.dispose();
-    });
-    it("should handle deeply nested objects", () => {
-        const state = createState({
-            level1: {
-                level2: {
-                    level3: {
-                        value: "deep",
-                    },
-                },
-            },
-        });
-        state.level1.level2.level3.value = "modified";
-        expect(state.level1.level2.level3.value).toBe("modified");
-    });
-    it("should handle array mutations correctly", () => {
-        const state = createState({ items: [1, 2, 3] });
-        state.items.pop();
-        expect(state.items).toEqual([1, 2]);
-        state.items.unshift(0);
-        expect(state.items).toEqual([0, 1, 2]);
-        state.items.splice(1, 1, 99);
-        expect(state.items).toEqual([0, 99, 2]);
-    });
-    it("should cache proxies for array elements to prevent double-wrapping", () => {
-        const state = createState({
-            data: [
-                { id: 1, label: "Item 1" },
-                { id: 2, label: "Item 2" },
-                { id: 3, label: "Item 3" },
-            ],
-        });
-        // Access the same array element multiple times
-        const firstAccess = state.data[0];
-        const secondAccess = state.data[0];
-        // Should return the exact same proxy reference
-        expect(firstAccess).toBe(secondAccess);
-        // Test with array iteration methods
-        const mapped = state.data.map((item) => item);
-        const firstItem = mapped[0];
-        const directAccess = state.data[0];
-        // The proxy returned from iteration should be the same as direct access
-        expect(firstItem).toBe(directAccess);
-        // Test that we don't double-wrap when iterating multiple times
-        const mapped2 = state.data.map((item) => item);
-        expect(mapped[0]).toBe(mapped2[0]);
-    });
-    it("should maintain proxy identity after filter operations", () => {
-        const state = createState({
-            data: [
-                { id: 1, label: "Item 1" },
-                { id: 2, label: "Item 2" },
-                { id: 3, label: "Item 3" },
-            ],
-        });
-        // Get reference to an item before filtering
-        const originalItem = state.data[0];
-        // Simulate the remove operation: filter creates a new array but reuses proxies
-        state.data = state.data.filter((row) => row.id !== 2);
-        // After filter, the first item should still be the same proxy reference
-        const afterFilter = state.data[0];
-        expect(afterFilter).toBe(originalItem);
-        // And accessing it multiple times should return the same reference
-        expect(state.data[0]).toBe(state.data[0]);
-    });
-});

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

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

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

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

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":""}