rask-ui 0.23.0 → 0.24.0

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

package/dist/tests/error.test.js

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

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

package/dist/tests/observation.test.js

@@ -0,0 +1,341 @@
+import { describe, it, expect, vi } from "vitest";
+import { Signal, Observer, getCurrentObserver } from "../observation";
+describe("Signal-Observer System (Optimized)", () => {
+    describe("Observer", () => {
+        it("should track signals during observation", () => {
+            const callback = vi.fn();
+            const observer = new Observer(callback);
+            const signal = new Signal();
+            const dispose = observer.observe();
+            observer.subscribeSignal(signal);
+            dispose();
+            signal.notify();
+            return new Promise((resolve) => {
+                queueMicrotask(() => {
+                    expect(callback).toHaveBeenCalledTimes(1);
+                    resolve(undefined);
+                });
+            });
+        });
+        it("should handle multiple signals", async () => {
+            const callback = vi.fn();
+            const observer = new Observer(callback);
+            const signal1 = new Signal();
+            const signal2 = new Signal();
+            const dispose = observer.observe();
+            observer.subscribeSignal(signal1);
+            observer.subscribeSignal(signal2);
+            dispose();
+            signal1.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).toHaveBeenCalledTimes(1);
+            signal2.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).toHaveBeenCalledTimes(2);
+        });
+        it("should clear signals when observing again", async () => {
+            let callCount = 0;
+            const observer = new Observer(() => {
+                callCount++;
+            });
+            const signal1 = new Signal();
+            const signal2 = new Signal();
+            // First observation
+            let dispose = observer.observe();
+            observer.subscribeSignal(signal1);
+            dispose();
+            // Second observation - should clear previous signals
+            dispose = observer.observe();
+            observer.subscribeSignal(signal2);
+            dispose();
+            // Notify first signal - should not trigger observer
+            signal1.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callCount).toBe(0);
+            // Notify second signal - should trigger observer
+            signal2.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callCount).toBe(1);
+        });
+        it("should dispose of all signal subscriptions", async () => {
+            const callback = vi.fn();
+            const observer = new Observer(callback);
+            const signal = new Signal();
+            const dispose = observer.observe();
+            observer.subscribeSignal(signal);
+            dispose();
+            observer.dispose();
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).not.toHaveBeenCalled();
+        });
+        it("should not notify after disposal", async () => {
+            const callback = vi.fn();
+            const observer = new Observer(callback);
+            const signal = new Signal();
+            const dispose = observer.observe();
+            observer.subscribeSignal(signal);
+            dispose();
+            observer.dispose();
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).not.toHaveBeenCalled();
+        });
+        it("should set current observer during observation", () => {
+            const observer = new Observer(() => { });
+            expect(getCurrentObserver()).toBeUndefined();
+            const dispose = observer.observe();
+            expect(getCurrentObserver()).toBe(observer);
+            dispose();
+            expect(getCurrentObserver()).toBeUndefined();
+        });
+        it("should handle nested observations with stack", () => {
+            const observer1 = new Observer(() => { });
+            const observer2 = new Observer(() => { });
+            const dispose1 = observer1.observe();
+            expect(getCurrentObserver()).toBe(observer1);
+            const dispose2 = observer2.observe();
+            expect(getCurrentObserver()).toBe(observer2);
+            dispose2();
+            expect(getCurrentObserver()).toBe(observer1);
+            dispose1();
+            expect(getCurrentObserver()).toBeUndefined();
+        });
+    });
+    describe("Signal", () => {
+        it("should notify all subscribed observers", async () => {
+            const signal = new Signal();
+            const callback1 = vi.fn();
+            const callback2 = vi.fn();
+            const observer1 = new Observer(callback1);
+            const observer2 = new Observer(callback2);
+            const dispose1 = observer1.observe();
+            observer1.subscribeSignal(signal);
+            dispose1();
+            const dispose2 = observer2.observe();
+            observer2.subscribeSignal(signal);
+            dispose2();
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback1).toHaveBeenCalledTimes(1);
+            expect(callback2).toHaveBeenCalledTimes(1);
+        });
+        it("should handle empty signal (no subscribers)", () => {
+            const signal = new Signal();
+            // Should not throw
+            expect(() => signal.notify()).not.toThrow();
+        });
+    });
+    describe("Optimization: Epoch Barrier", () => {
+        it("should NOT notify new subscriptions created during notify", async () => {
+            const signal = new Signal();
+            const callback1 = vi.fn();
+            const callback2 = vi.fn();
+            const observer1 = new Observer(callback1);
+            const observer2 = new Observer(() => {
+                callback2();
+                // Subscribe a new observer DURING notification
+                const dispose = observer3.observe();
+                observer3.subscribeSignal(signal);
+                dispose();
+            });
+            const observer3 = new Observer(vi.fn());
+            const dispose1 = observer1.observe();
+            observer1.subscribeSignal(signal);
+            dispose1();
+            const dispose2 = observer2.observe();
+            observer2.subscribeSignal(signal);
+            dispose2();
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            // observer1 and observer2 should fire
+            expect(callback1).toHaveBeenCalledTimes(1);
+            expect(callback2).toHaveBeenCalledTimes(1);
+            // observer3 should NOT fire in the same notify pass (added during notify)
+            // This is tested implicitly - if it fired, we'd see 3 calls above
+        });
+        it("should notify new subscriptions on NEXT notify", async () => {
+            const signal = new Signal();
+            let observer3Created = false;
+            const callback3 = vi.fn();
+            const observer3 = new Observer(callback3);
+            const observer1 = new Observer(() => {
+                if (!observer3Created) {
+                    observer3Created = true;
+                    const dispose = observer3.observe();
+                    observer3.subscribeSignal(signal);
+                    dispose();
+                }
+            });
+            const dispose1 = observer1.observe();
+            observer1.subscribeSignal(signal);
+            dispose1();
+            // First notify - observer3 gets created but should not fire
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback3).toHaveBeenCalledTimes(0);
+            // Second notify - observer3 should now fire
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback3).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("Optimization: Safe Unsubscribe During Notify", () => {
+        it("should handle observer disposing itself during notification", async () => {
+            const signal = new Signal();
+            const callback1 = vi.fn();
+            const callback2 = vi.fn();
+            const observer1 = new Observer(() => {
+                callback1();
+                observer1.dispose(); // Dispose itself during notification
+            });
+            const observer2 = new Observer(callback2);
+            const dispose1 = observer1.observe();
+            observer1.subscribeSignal(signal);
+            dispose1();
+            const dispose2 = observer2.observe();
+            observer2.subscribeSignal(signal);
+            dispose2();
+            // First notify - both should fire, observer1 disposes itself
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback1).toHaveBeenCalledTimes(1);
+            expect(callback2).toHaveBeenCalledTimes(1);
+            // Second notify - only observer2 should fire
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback1).toHaveBeenCalledTimes(1); // Still 1
+            expect(callback2).toHaveBeenCalledTimes(2); // Incremented
+        });
+        it("should handle observer clearing signals during notification", async () => {
+            const signal1 = new Signal();
+            const signal2 = new Signal();
+            const callback = vi.fn();
+            const observer = new Observer(() => {
+                callback();
+                // Re-observe, which clears all signals
+                const dispose = observer.observe();
+                observer.subscribeSignal(signal2);
+                dispose();
+            });
+            const dispose = observer.observe();
+            observer.subscribeSignal(signal1);
+            dispose();
+            signal1.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).toHaveBeenCalledTimes(1);
+            // Should not respond to signal1 anymore
+            signal1.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).toHaveBeenCalledTimes(1);
+            // Should respond to signal2
+            signal2.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("Optimization: Memory Efficiency", () => {
+        it("should clean up subscriptions when observer is disposed", async () => {
+            const signal = new Signal();
+            const observers = Array.from({ length: 100 }, () => new Observer(() => { }));
+            // Subscribe all observers
+            observers.forEach((observer) => {
+                const dispose = observer.observe();
+                observer.subscribeSignal(signal);
+                dispose();
+            });
+            // Dispose half of them
+            observers.slice(0, 50).forEach((observer) => observer.dispose());
+            // Notify - should not throw or have issues
+            expect(() => signal.notify()).not.toThrow();
+            // Cleanup
+            observers.slice(50).forEach((observer) => observer.dispose());
+        });
+        it("should handle multiple observe/clearSignals cycles", () => {
+            const observer = new Observer(() => { });
+            const signal1 = new Signal();
+            const signal2 = new Signal();
+            const signal3 = new Signal();
+            // First cycle
+            let dispose = observer.observe();
+            observer.subscribeSignal(signal1);
+            dispose();
+            // Second cycle - clears signal1
+            dispose = observer.observe();
+            observer.subscribeSignal(signal2);
+            dispose();
+            // Third cycle - clears signal2
+            dispose = observer.observe();
+            observer.subscribeSignal(signal3);
+            dispose();
+            // Should not throw
+            expect(() => {
+                signal1.notify();
+                signal2.notify();
+                signal3.notify();
+            }).not.toThrow();
+        });
+    });
+    describe("Edge Cases", () => {
+        it("should handle rapid consecutive notifies", async () => {
+            const signal = new Signal();
+            const callback = vi.fn();
+            const observer = new Observer(callback);
+            const dispose = observer.observe();
+            observer.subscribeSignal(signal);
+            dispose();
+            // Rapid notifies
+            signal.notify();
+            signal.notify();
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            // Due to batching, exact count depends on implementation
+            // But should have been called at least once
+            expect(callback).toHaveBeenCalled();
+        });
+        it("should not notify after subscribeSignal on disposed observer", async () => {
+            const signal = new Signal();
+            const callback = vi.fn();
+            const observer = new Observer(callback);
+            observer.dispose();
+            const dispose = observer.observe();
+            observer.subscribeSignal(signal);
+            dispose();
+            signal.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            expect(callback).not.toHaveBeenCalled();
+        });
+        it("should handle complex subscription graph", async () => {
+            // Create a diamond dependency pattern
+            const signal1 = new Signal();
+            const signal2 = new Signal();
+            const signal3 = new Signal();
+            const calls = [];
+            const observer1 = new Observer(() => {
+                calls.push("o1");
+                signal2.notify();
+                signal3.notify();
+            });
+            const observer2 = new Observer(() => calls.push("o2"));
+            const observer3 = new Observer(() => calls.push("o3"));
+            // observer1 listens to signal1
+            let dispose = observer1.observe();
+            observer1.subscribeSignal(signal1);
+            dispose();
+            // observer2 listens to signal2
+            dispose = observer2.observe();
+            observer2.subscribeSignal(signal2);
+            dispose();
+            // observer3 listens to signal3
+            dispose = observer3.observe();
+            observer3.subscribeSignal(signal3);
+            dispose();
+            signal1.notify();
+            await new Promise((resolve) => queueMicrotask(() => resolve()));
+            // All should have been called
+            expect(calls).toContain("o1");
+            expect(calls).toContain("o2");
+            expect(calls).toContain("o3");
+        });
+    });
+});

package/dist/useComputed.d.ts

@@ -0,0 +1,5 @@
+export type Computed<T extends Record<string, () => any>> = {
+    [K in keyof T]: ReturnType<T[K]>;
+};
+export declare function useComputed<T extends Record<string, () => any>>(computed: T): Computed<T>;
+//# sourceMappingURL=useComputed.d.ts.map

package/dist/useComputed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useComputed.d.ts","sourceRoot":"","sources":["../src/useComputed.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI;KACzD,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC;AAEF,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,EAC7D,QAAQ,EAAE,CAAC,GACV,QAAQ,CAAC,CAAC,CAAC,CA0Eb"}

package/dist/useComputed.js

@@ -0,0 +1,69 @@
+import { getCurrentComponent, useCleanup } from "./component";
+import { INSPECT_MARKER, INSPECTOR_ENABLED } from "./inspect";
+import { getCurrentObserver, Observer, Signal } from "./observation";
+export function useComputed(computed) {
+    const currentComponent = getCurrentComponent();
+    const proxy = {};
+    let notifyInspectorRef = {};
+    for (const prop in computed) {
+        let isDirty = true;
+        let value;
+        const signal = new Signal();
+        const computedObserver = new Observer(() => {
+            isDirty = true;
+            signal.notify();
+            if (INSPECTOR_ENABLED) {
+                notifyInspectorRef.current?.notify({
+                    type: "computed",
+                    path: notifyInspectorRef.current.path.concat(prop),
+                    isDirty: true,
+                    value,
+                });
+            }
+        });
+        useCleanup(() => computedObserver.dispose());
+        Object.defineProperty(proxy, prop, {
+            enumerable: true,
+            configurable: true,
+            get() {
+                const currentObserver = getCurrentObserver();
+                if (currentObserver) {
+                    currentObserver.subscribeSignal(signal);
+                }
+                if (isDirty) {
+                    const stopObserving = computedObserver.observe();
+                    value = computed[prop]();
+                    stopObserving();
+                    isDirty = false;
+                    if (INSPECTOR_ENABLED) {
+                        notifyInspectorRef.current?.notify({
+                            type: "computed",
+                            path: notifyInspectorRef.current.path.concat(prop),
+                            isDirty: false,
+                            value,
+                        });
+                    }
+                    return value;
+                }
+                return value;
+            },
+        });
+    }
+    if (INSPECTOR_ENABLED) {
+        Object.defineProperty(proxy, INSPECT_MARKER, {
+            enumerable: false,
+            configurable: false,
+            get() {
+                return !notifyInspectorRef.current;
+            },
+            set: (value) => {
+                Object.defineProperty(notifyInspectorRef, "current", {
+                    get() {
+                        return value.current;
+                    },
+                });
+            },
+        });
+    }
+    return proxy;
+}

package/dist/useQuery.d.ts

@@ -0,0 +1,25 @@
+type QueryState<T, I = null> = {
+    isPending: true;
+    error: null;
+    value: I;
+} | {
+    isPending: false;
+    error: null;
+    value: T;
+} | {
+    isPending: false;
+    error: string;
+    value: I | null;
+};
+export type Query<T, P, I = null> = [
+    QueryState<T, I>,
+    [
+        P
+    ] extends [never] ? (params: P) => void : () => void
+];
+export declare function useQuery<T>(query: () => Promise<T>): Query<T, never>;
+export declare function useQuery<T>(query: () => Promise<T>, initialValue: T): Query<T, never, T>;
+export declare function useQuery<T, P>(query: (params: P) => Promise<T>): Query<T, never>;
+export declare function useQuery<T, P>(query: (params: P) => Promise<T>, initialValue: T): Query<T, never, T>;
+export {};
+//# sourceMappingURL=useQuery.d.ts.map

package/dist/useQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuery.d.ts","sourceRoot":"","sources":["../src/useQuery.ts"],"names":[],"mappings":"AAGA,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,IACvB;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,CAAC,CAAC;CACV,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,CAAC,CAAC;CACV,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACjB,CAAC;AAEN,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI;IAClC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC;IAChB;QAAC,CAAC;KAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;CACvD,CAAC;AAEF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACtE,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACvB,YAAY,EAAE,CAAC,GACd,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AACtB,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAC/B,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACnB,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAChC,YAAY,EAAE,CAAC,GACd,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC"}

package/dist/useQuery.js

@@ -0,0 +1,25 @@
+import { useEffect } from "./useEffect";
+import { useTask } from "./useTask";
+export function useQuery(query, initialValue) {
+    const [taskState, runTask] = useTask(query);
+    let lastValue = initialValue === undefined ? null : initialValue;
+    useEffect(() => {
+        if (taskState.result) {
+            lastValue = taskState.result;
+        }
+    });
+    return [
+        {
+            get value() {
+                return taskState.result || lastValue;
+            },
+            get isPending() {
+                return taskState.isPending;
+            },
+            get error() {
+                return taskState.error;
+            },
+        },
+        runTask,
+    ];
+}

package/dist/useSuspendAsync.d.ts

@@ -0,0 +1,18 @@
+import { AsyncState } from "./useAsync";
+type SuspendAsyncState<T extends Record<string, AsyncState<any>>> = {
+    values: {
+        [K in keyof T]: T[K]["value"];
+    };
+} & ({
+    isPending: true;
+    error: null;
+} | {
+    isPending: false;
+    error: string;
+} | {
+    isPending: false;
+    error: null;
+});
+export declare function useSuspendAsync<T extends Record<string, AsyncState<any>>>(asyncs: T): SuspendAsyncState<T>;
+export {};
+//# sourceMappingURL=useSuspendAsync.d.ts.map

package/dist/useSuspendAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSuspendAsync.d.ts","sourceRoot":"","sources":["../src/useSuspendAsync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAIxC,KAAK,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI;IAClE,MAAM,EAAE;SACL,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;KAC9B,CAAC;CACH,GAAG,CACA;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC;CACb,CACJ,CAAC;AAEF,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,EACvE,MAAM,EAAE,CAAC,wBAyCV"}