rask-ui 0.24.1 → 0.25.0

package/dist/tests/observation.test.js

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

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"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"}

package/dist/useSuspendAsync.js

@@ -1,37 +0,0 @@
-import { useEffect } from "./useEffect";
-import { useState } from "./useState";
-export function useSuspendAsync(asyncs) {
-    const state = useState({
-        isPending: false,
-        error: null,
-        values: Object.keys(asyncs).reduce((aggr, key) => ({ ...aggr, [key]: asyncs[key].value }), {}),
-    });
-    useEffect(() => {
-        let isPending = false;
-        let error = "";
-        for (const key in asyncs) {
-            if (asyncs[key].error) {
-                error += asyncs[key].error + "\n";
-                continue;
-            }
-            if (asyncs[key].isPending) {
-                isPending = true;
-                continue;
-            }
-        }
-        if (error) {
-            state.isPending = false;
-            state.error = error;
-            return;
-        }
-        if (isPending) {
-            state.isPending = false;
-            state.error = null;
-            return;
-        }
-        for (const key in asyncs) {
-            state.values[key] = asyncs[key].value;
-        }
-    });
-    return state;
-}

package/dist/useTask.d.ts

@@ -1,25 +0,0 @@
-export type TaskState<P, T> = {
-    isPending: false;
-    params: null;
-    result: null;
-    error: null;
-} | {
-    isPending: true;
-    result: T | null;
-    params: P;
-    error: null;
-} | {
-    isPending: false;
-    params: null;
-    result: T;
-    error: null;
-} | {
-    isPending: false;
-    params: null;
-    result: null;
-    error: string;
-};
-export type Task<A, B = never> = [B] extends [never] ? [TaskState<null, A>, () => void] : [TaskState<A, B>, (params: A) => void];
-export declare function useTask<T>(task: (params: undefined, signal: AbortSignal) => Promise<T>): Task<T>;
-export declare function useTask<P, T>(task: (params: P, signal: AbortSignal) => Promise<T>): Task<P, T>;
-//# sourceMappingURL=useTask.d.ts.map

package/dist/useTask.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTask.d.ts","sourceRoot":"","sources":["../src/useTask.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IACtB;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IACjB,MAAM,EAAE,CAAC,CAAC;IACV,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,CAAC,CAAC;IACV,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAChD,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,GAChC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC;AAE3C,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3D,IAAI,CAAC,CAAC,CAAC,CAAC;AACX,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GACnD,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/useTask.js

@@ -1,70 +0,0 @@
-import { useCleanup, getCurrentComponent } from "./component";
-import { assignState, useState } from "./useState";
-export function useTask(task) {
-    const currentComponent = getCurrentComponent();
-    if (!currentComponent || currentComponent.isRendering) {
-        throw new Error("Only use createTask in component setup");
-    }
-    const state = useState({
-        isPending: false,
-        result: null,
-        error: null,
-        params: null,
-    });
-    let currentAbortController;
-    const fetch = (params) => {
-        currentAbortController?.abort();
-        const abortController = (currentAbortController = new AbortController());
-        const promise = task(params, abortController.signal);
-        promise
-            .then((result) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            assignState(state, {
-                isPending: false,
-                result,
-                error: null,
-                params: null,
-            });
-        })
-            .catch((error) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            assignState(state, {
-                isPending: false,
-                result: null,
-                error: String(error),
-                params: null,
-            });
-        });
-        return promise;
-    };
-    useCleanup(() => currentAbortController?.abort());
-    return [
-        {
-            get isPending() {
-                return state.isPending;
-            },
-            get result() {
-                return state.result;
-            },
-            get error() {
-                return state.error;
-            },
-            get params() {
-                return state.params;
-            },
-        },
-        (params) => {
-            fetch(params);
-            assignState(state, {
-                isPending: true,
-                result: null,
-                error: null,
-                params: (params || null),
-            });
-        },
-    ];
-}