rask-ui 0.21.0 → 0.23.0

package/dist/observation.test.js

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Signal, Observer, getCurrentObserver } from './observation';
+describe('Signal', () => {
+    it('should allow subscribing to notifications', () => {
+        const signal = new Signal();
+        const callback = vi.fn();
+        signal.subscribe(callback);
+        signal.notify();
+        expect(callback).toHaveBeenCalledTimes(1);
+    });
+    it('should return a disposer function', () => {
+        const signal = new Signal();
+        const callback = vi.fn();
+        const dispose = signal.subscribe(callback);
+        dispose();
+        signal.notify();
+        expect(callback).not.toHaveBeenCalled();
+    });
+    it('should handle multiple subscribers', () => {
+        const signal = new Signal();
+        const callback1 = vi.fn();
+        const callback2 = vi.fn();
+        signal.subscribe(callback1);
+        signal.subscribe(callback2);
+        signal.notify();
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(1);
+    });
+    it('should allow unsubscribing individual callbacks', () => {
+        const signal = new Signal();
+        const callback1 = vi.fn();
+        const callback2 = vi.fn();
+        const dispose1 = signal.subscribe(callback1);
+        signal.subscribe(callback2);
+        dispose1();
+        signal.notify();
+        expect(callback1).not.toHaveBeenCalled();
+        expect(callback2).toHaveBeenCalledTimes(1);
+    });
+});
+describe('Observer', () => {
+    it('should queue notifications in microtasks', async () => {
+        let callCount = 0;
+        const observer = new Observer(() => {
+            callCount++;
+        });
+        const signal = new Signal();
+        const dispose = observer.observe();
+        observer.subscribeSignal(signal);
+        dispose();
+        // Trigger multiple notifications
+        signal.notify();
+        signal.notify();
+        signal.notify();
+        // Should not be called synchronously
+        expect(callCount).toBe(0);
+        // Wait for microtask
+        await new Promise((resolve) => queueMicrotask(() => resolve()));
+        // Should be called only once due to queuing
+        expect(callCount).toBe(1);
+    });
+    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 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 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();
+    });
+    it('should prevent duplicate notifications while queued', async () => {
+        let callCount = 0;
+        const observer = new Observer(() => {
+            callCount++;
+        });
+        const signal = new Signal();
+        const dispose = observer.observe();
+        observer.subscribeSignal(signal);
+        dispose();
+        // Rapid-fire notifications
+        for (let i = 0; i < 100; i++) {
+            signal.notify();
+        }
+        await new Promise((resolve) => queueMicrotask(() => resolve()));
+        // Should only be called once
+        expect(callCount).toBe(1);
+    });
+});

package/dist/suspense.d.ts

@@ -0,0 +1,25 @@
+import { VNode } from "snabbdom";
+export declare function createSuspense<T extends Record<string, Promise<any>>>(promises: T): {
+    [K in keyof T]: Awaited<T[K]>;
+};
+export declare function Suspense(props: {
+    fallback: VNode;
+    children: VNode | VNode[];
+}): () => VNode | VNode[];
+type SuspensePromiseState<T> = {
+    status: "pending";
+    value: null;
+    error: null;
+} | {
+    status: "resolved";
+    value: T;
+    error: null;
+} | {
+    status: "rejected";
+    value: null;
+    error: string;
+};
+export type SuspensePromise<T> = Promise<T> & SuspensePromiseState<T>;
+export declare function createSuspensePromise<T>(promise: Promise<T>): SuspensePromise<T>;
+export {};
+//# sourceMappingURL=suspense.d.ts.map

package/dist/suspense.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense.d.ts","sourceRoot":"","sources":["../src/suspense.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAKjC,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EACnE,QAAQ,EAAE,CAAC,GACV;KACA,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC9B,CAuBA;AAQD,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAC9B,QAAQ,EAAE,KAAK,CAAC;IAChB,QAAQ,EAAE,KAAK,GAAG,KAAK,EAAE,CAAC;CAC3B,yBAmBA;AAED,KAAK,oBAAoB,CAAC,CAAC,IACvB;IACE,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAEtE,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAClB,eAAe,CAAC,CAAC,CAAC,CAgEpB"}

package/dist/suspense.js

@@ -0,0 +1,97 @@
+import { getCurrentComponent } from "./component";
+import { createState } from "./createState";
+import { getCurrentObserver, Signal } from "./observation";
+export function createSuspense(promises) {
+    let currentComponent = getCurrentComponent();
+    if (!currentComponent) {
+        throw new Error("createSuspense must be used in the setup of a component");
+    }
+    const proxy = {};
+    for (const key in promises) {
+        const promise = promises[key];
+        const suspensePromise = isSuspensePromise(promise)
+            ? promise
+            : createSuspensePromise(promise);
+        currentComponent.notifyAsync(suspensePromise);
+        Object.defineProperty(proxy, key, {
+            get() {
+                return suspensePromise.value;
+            },
+        });
+    }
+    return proxy;
+}
+function isSuspensePromise(promise) {
+    return "status" in promise;
+}
+export function Suspense(props) {
+    const currentComponent = getCurrentComponent();
+    const state = createState({
+        suspendingPromises: [],
+    });
+    currentComponent.onAsync((promise) => {
+        state.suspendingPromises = state.suspendingPromises.concat(promise);
+    });
+    return () => {
+        const isAllResolved = state.suspendingPromises.every((promise) => promise.status === "resolved");
+        console.log(isAllResolved);
+        return isAllResolved ? props.children : props.fallback;
+    };
+}
+export function createSuspensePromise(promise) {
+    const signal = new Signal();
+    const state = {
+        error: null,
+        status: "pending",
+        value: null,
+    };
+    Object.defineProperty(promise, "value", {
+        get() {
+            const observer = getCurrentObserver();
+            if (observer) {
+                observer.subscribeSignal(signal);
+            }
+            return state.value;
+        },
+        set(newValue) {
+            state.value = newValue;
+            signal.notify();
+        },
+    });
+    Object.defineProperty(promise, "error", {
+        get() {
+            const observer = getCurrentObserver();
+            if (observer) {
+                observer.subscribeSignal(signal);
+            }
+            return state.error;
+        },
+    });
+    Object.defineProperty(promise, "status", {
+        get() {
+            const observer = getCurrentObserver();
+            if (observer) {
+                observer.subscribeSignal(signal);
+            }
+            return state.status;
+        },
+    });
+    promise
+        .then((value) => {
+        Object.assign(state, {
+            value,
+            error: null,
+            status: "resolved",
+        });
+        signal.notify();
+    })
+        .catch((error) => {
+        Object.assign(state, {
+            value: null,
+            error: String(error),
+            status: "rejected",
+        });
+        signal.notify();
+    });
+    return promise;
+}

package/dist/test-setup.d.ts

@@ -0,0 +1,16 @@
+import type { VNode } from 'snabbdom';
+/**
+ * Test helper to render a component and provide easy cleanup
+ *
+ * @example
+ * const { container, unmount } = renderComponent(<MyComponent />);
+ * expect(container.textContent).toBe('hello');
+ * unmount();
+ */
+export declare function renderComponent(vnode: VNode): {
+    container: HTMLElement;
+    vnode: VNode;
+    unmount: () => void;
+    rerender: (newVnode: VNode) => VNode;
+};
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../src/test-setup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAUtC;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK;;;;yBAmBnB,KAAK;EAK7B"}

package/dist/test-setup.js

@@ -0,0 +1,40 @@
+// Test setup file for vitest
+import { afterEach } from 'vitest';
+import { render, patch } from './render';
+// Clean up after each test
+afterEach(() => {
+    document.body.innerHTML = '';
+    // Remove any style tags added by render function
+    document.querySelectorAll('style').forEach(style => style.remove());
+});
+/**
+ * Test helper to render a component and provide easy cleanup
+ *
+ * @example
+ * const { container, unmount } = renderComponent(<MyComponent />);
+ * expect(container.textContent).toBe('hello');
+ * unmount();
+ */
+export function renderComponent(vnode) {
+    const container = document.createElement('div');
+    document.body.appendChild(container);
+    let currentVnode = render(vnode, container);
+    const actualElement = currentVnode.elm;
+    return {
+        // The actual rendered DOM element (after patch replaces container)
+        container: actualElement,
+        // The vnode returned by render
+        vnode: currentVnode,
+        // Cleanup function
+        unmount: () => {
+            if (actualElement && actualElement.parentNode) {
+                actualElement.parentNode.removeChild(actualElement);
+            }
+        },
+        // Re-render with new vnode
+        rerender: (newVnode) => {
+            currentVnode = patch(currentVnode, newVnode);
+            return currentVnode;
+        }
+    };
+}

package/dist/test.d.ts

@@ -0,0 +1,2 @@
+export declare function test(container: any): void;
+//# sourceMappingURL=test.d.ts.map

package/dist/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAiBA,wBAAgB,IAAI,CAAC,SAAS,EAAE,GAAG,QA4BlC"}

package/dist/test.js

@@ -0,0 +1,24 @@
+import { init, classModule, propsModule, styleModule, eventListenersModule, h, } from "snabbdom";
+const patch = init([
+    // Init patch function with chosen modules
+    classModule, // makes it easy to toggle classes
+    propsModule, // for setting properties on DOM elements
+    styleModule, // handles styling on elements with support for animations
+    eventListenersModule, // attaches event listeners
+]);
+export function test(container) {
+    const vnode = h("div#container.two.classes", { on: { click: () => console.log("div clicked") } }, [
+        h("span", { style: { fontWeight: "bold" } }, "This is bold"),
+        " and this is just normal text",
+        h("a", { props: { href: "/foo" } }, "I'll take you places!"),
+    ]);
+    // Patch into empty DOM element – this modifies the DOM as a side effect
+    patch(container, vnode);
+    const newVnode = h("div#container.two.classes", { on: { click: () => console.log("updated div clicked") } }, [
+        h("span", { style: { fontWeight: "normal", fontStyle: "italic" } }, "This is now italic type"),
+        " and this is still just normal text",
+        h("a", { props: { href: "/bar" } }, "I'll take you places!"),
+    ]);
+    // Second `patch` invocation
+    patch(vnode, newVnode); // Snabbdom efficiently updates the old view to the new state
+}

package/dist/useCatchError.d.ts

@@ -1,4 +1,9 @@
-export declare const CatchErrorContext: import("./createContext").Context<(error: unknown) => void>;
+export declare const CatchErrorContext: {
+    use(): any;
+    inject(state: {
+        error: unknown;
+    }): (error: unknown) => unknown;
+};
 export declare function useCatchError(): {
     error: unknown;
 };

package/dist/useCatchError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCatchError.d.ts","sourceRoot":"","sources":["../src/useCatchError.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB,4CAAyB,OAAO,KAAK,IAAI,CAAG,CAAC;AAE3E,wBAAgB,aAAa;WAQK,OAAO;EAOxC"}
+{"version":3,"file":"useCatchError.d.ts","sourceRoot":"","sources":["../src/useCatchError.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB;;;eAAkC,OAAO;gBACtD,OAAO;CACtB,CAAC;AAEH,wBAAgB,aAAa;WAMK,OAAO;EAOxC"}

package/dist/useCatchError.js

@@ -1,16 +1,17 @@
 import { useState } from "./useState";
-import { createContext, useInjectContext } from "./createContext";
+import { createContext } from "./createContext";
 import { getCurrentComponent } from "./component";
-export const CatchErrorContext = createContext();
+export const CatchErrorContext = createContext((state) => {
+    return (error) => (state.error = error);
+});
 export function useCatchError() {
     const currentComponent = getCurrentComponent();
     if (!currentComponent || currentComponent.isRendering) {
         throw new Error("Only use the useCatchError hook in setup");
     }
-    const inject = useInjectContext(CatchErrorContext);
     const state = useState({
         error: null,
     });
-    inject((error) => (state.error = error));
+    CatchErrorContext.inject(state);
     return state;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rask-ui",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "npm run build:plugin && tsc --project tsconfig.build.json && cp ../../README.md . && cp ../../logo.png .",
+    "build": "npm run build:plugin && tsc --project tsconfig.build.json && cpx ../../README.md . && cpx ../../logo.png .",
     "build:plugin": "cd swc-plugin && cargo build --release --target wasm32-wasip1",
     "dev": "tsc --watch",
     "test": "vitest",

package/dist/createComputed.d.ts

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

package/dist/createComputed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createComputed.d.ts","sourceRoot":"","sources":["../src/createComputed.ts"],"names":[],"mappings":"AAIA,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,EAChE,QAAQ,EAAE,CAAC,GACV;KACA,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACjC,CA0EA"}

package/dist/createComputed.js

@@ -1,69 +0,0 @@
-import { getCurrentComponent, createCleanup } from "./component";
-import { INSPECT_MARKER, INSPECTOR_ENABLED } from "./inspect";
-import { getCurrentObserver, Observer, Signal } from "./observation";
-export function createComputed(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,
-                });
-            }
-        });
-        createCleanup(() => 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/createEffect.d.ts

@@ -1,2 +0,0 @@
-export declare function createEffect(cb: () => void | (() => void)): void;
-//# sourceMappingURL=createEffect.d.ts.map

package/dist/createEffect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createEffect.d.ts","sourceRoot":"","sources":["../src/createEffect.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,QA2BzD"}

package/dist/createEffect.js

@@ -1,29 +0,0 @@
-import { syncBatch } from "./batch";
-import { createCleanup, getCurrentComponent } from "./component";
-import { Observer } from "./observation";
-export function createEffect(cb) {
-    const component = getCurrentComponent();
-    if (!component || component.isRendering) {
-        throw new Error("Only use createEffect in component setup");
-    }
-    let disposer;
-    const observer = new Observer(() => {
-        syncBatch(runEffect);
-    });
-    const runEffect = () => {
-        try {
-            disposer?.();
-        }
-        catch (error) {
-            console.error("Error in effect dispose function:", error);
-        }
-        const stopObserving = observer.observe();
-        disposer = cb();
-        stopObserving();
-    };
-    createCleanup(() => {
-        observer.dispose();
-        disposer?.();
-    });
-    runEffect();
-}

package/dist/createRouter.d.ts

@@ -1,8 +0,0 @@
-import { RoutesConfig, TRouter, TRoutes } from "typed-client-router";
-export type Router<T extends RoutesConfig> = Omit<TRouter<T>, "current" | "listen" | "pathname"> & {
-    route?: TRoutes<T>;
-};
-export declare function createRouter<const T extends RoutesConfig>(config: T, options?: {
-    base?: string;
-}): Router<T>;
-//# sourceMappingURL=createRouter.d.ts.map

package/dist/createRouter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRouter.d.ts","sourceRoot":"","sources":["../src/createRouter.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EACZ,OAAO,EACP,OAAO,EACR,MAAM,qBAAqB,CAAC;AAI7B,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,YAAY,IAAI,IAAI,CAC/C,OAAO,CAAC,CAAC,CAAC,EACV,SAAS,GAAG,QAAQ,GAAG,UAAU,CAClC,GAAG;IACF,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CACpB,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,YAAY,EACvD,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GACA,MAAM,CAAC,CAAC,CAAC,CA4BX"}

package/dist/createRouter.js

@@ -1,27 +0,0 @@
-import { createRouter as internalCreateRouter, } from "typed-client-router";
-import { getCurrentObserver, Signal } from "./observation";
-import { createCleanup, getCurrentComponent } from "./component";
-export function createRouter(config, options) {
-    if (!getCurrentComponent()) {
-        throw new Error("Only use createRouter in component setup");
-    }
-    const router = internalCreateRouter(config, options);
-    const signal = new Signal();
-    createCleanup(router.listen(() => signal.notify()));
-    return {
-        get route() {
-            const observer = getCurrentObserver();
-            if (observer) {
-                observer.subscribeSignal(signal);
-            }
-            return router.current;
-        },
-        get queries() {
-            return router.queries;
-        },
-        setQuery: router.setQuery,
-        push: router.push,
-        replace: router.replace,
-        url: router.url,
-    };
-}

package/dist/createTask.d.ts

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

package/dist/createTask.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createTask.d.ts","sourceRoot":"","sources":["../src/createTask.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,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG;IACnB,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IAClB,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;CACrB,GACD,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IAChB,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3B,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9B,CAAC;AAEN,wBAAgB,UAAU,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3D,IAAI,CAAC,CAAC,CAAC,CAAC;AACX,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GACnD,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}