rask-ui 0.20.5 → 0.21.0

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

package/dist/useSuspendAsync.js

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

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

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

@@ -0,0 +1,70 @@
+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),
+            });
+        },
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rask-ui",
-  "version": "0.20.5",
+  "version": "0.21.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/asyncState.d.ts

@@ -1,16 +0,0 @@
-type AsyncState<T> = {
-    isPending: true;
-    value: null;
-    error: null;
-} | {
-    isPending: false;
-    value: T;
-    error: null;
-} | {
-    isPending: false;
-    value: null;
-    error: string;
-};
-export declare function createAsyncState<T>(promise: Promise<T>): AsyncState<T>;
-export {};
-//# sourceMappingURL=asyncState.d.ts.map

package/dist/asyncState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncState.d.ts","sourceRoot":"","sources":["../src/asyncState.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,CAAC,IACb;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,iBAwBtD"}

package/dist/asyncState.js

@@ -1,24 +0,0 @@
-import { createState } from "./createState";
-export function createAsyncState(promise) {
-    const state = createState({
-        isPending: true,
-        error: null,
-        value: null,
-    });
-    promise
-        .then((value) => {
-        Object.assign(state, {
-            value,
-            error: null,
-            isPending: false,
-        });
-    })
-        .catch((error) => {
-        Object.assign(state, {
-            value: null,
-            error: String(error),
-            isPending: false,
-        });
-    });
-    return state;
-}

package/dist/context.d.ts

@@ -1,5 +0,0 @@
-export declare function createContext<T extends object>(): {
-    set(value: T): void;
-    get(): T;
-};
-//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM;eAE/B,CAAC;WAaL,CAAC;EAmBX"}

package/dist/context.js

@@ -1,29 +0,0 @@
-import { getCurrentComponent } from "./component";
-export function createContext() {
-    const context = {
-        set(value) {
-            const currentComponent = getCurrentComponent();
-            if (!currentComponent) {
-                throw new Error("You can not set context out component setup");
-            }
-            if (!currentComponent.contexts) {
-                currentComponent.contexts = new Map();
-            }
-            currentComponent.contexts.set(context, value);
-        },
-        get() {
-            let currentComponent = getCurrentComponent();
-            if (!currentComponent) {
-                throw new Error("You can not set context out component setup");
-            }
-            while (currentComponent) {
-                if (currentComponent.contexts?.has(context)) {
-                    return currentComponent.contexts.get(context);
-                }
-                currentComponent = currentComponent.parent;
-            }
-            throw new Error("Could not find context in parent components");
-        },
-    };
-    return context;
-}

package/dist/createAsync.test.d.ts

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

package/dist/createAsync.test.d.ts.map

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

package/dist/createAsync.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createAsync } from './createAsync';
-describe('createAsync', () => {
-    it('should start in pending state', () => {
-        const promise = new Promise(() => { });
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        expect(async.value).toBeNull();
-        expect(async.error).toBeNull();
-    });
-    it('should resolve to value state on success', async () => {
-        const promise = Promise.resolve('success');
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        await promise;
-        // Wait for state update
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe('success');
-        expect(async.error).toBeNull();
-    });
-    it('should resolve to error state on rejection', async () => {
-        const promise = Promise.reject(new Error('failed'));
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        // Wait for state update
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBeNull();
-        expect(async.error).toContain('failed');
-    });
-    it('should handle numeric values', async () => {
-        const promise = Promise.resolve(42);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toBe(42);
-    });
-    it('should handle object values', async () => {
-        const data = { id: 1, name: 'Test' };
-        const promise = Promise.resolve(data);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toEqual(data);
-    });
-    it('should handle array values', async () => {
-        const data = [1, 2, 3, 4, 5];
-        const promise = Promise.resolve(data);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toEqual(data);
-    });
-    it('should convert error to string', async () => {
-        const promise = Promise.reject('string error');
-        const async = createAsync(promise);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(typeof async.error).toBe('string');
-        expect(async.error).toBe('string error');
-    });
-    it('should handle error objects', async () => {
-        const error = new Error('Something went wrong');
-        const promise = Promise.reject(error);
-        const async = createAsync(promise);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.error).toContain('Something went wrong');
-    });
-    it('should create reactive state', async () => {
-        const promise = new Promise((resolve) => {
-            setTimeout(() => resolve('delayed'), 10);
-        });
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe('delayed');
-    });
-    it('should handle immediate resolution', async () => {
-        const async = createAsync(Promise.resolve('immediate'));
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe('immediate');
-    });
-    it('should handle immediate rejection', async () => {
-        const async = createAsync(Promise.reject('immediate error'));
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.error).toBe('immediate error');
-    });
-});

package/dist/createMutation.test.d.ts

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

package/dist/createMutation.test.d.ts.map

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

package/dist/createMutation.test.js

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createMutation } from './createMutation';
-describe('createMutation', () => {
-    it('should start in idle state', () => {
-        const mutator = vi.fn(() => Promise.resolve(null));
-        const mutation = createMutation(mutator);
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-        expect(mutation.error).toBeNull();
-        expect(mutator).not.toHaveBeenCalled();
-    });
-    it('should execute mutator when mutate is called', async () => {
-        const mutator = vi.fn((params) => Promise.resolve(params));
-        const mutation = createMutation(mutator);
-        mutation.mutate('test');
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toBe('test');
-        expect(mutator).toHaveBeenCalledWith('test');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it('should handle successful mutations', async () => {
-        const mutator = (params) => Promise.resolve(params);
-        const mutation = createMutation(mutator);
-        mutation.mutate({ id: 1 });
-        expect(mutation.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toBeNull();
-        expect(mutation.params).toBeNull();
-    });
-    it('should handle mutation errors', async () => {
-        const mutator = (params) => Promise.reject(new Error('Mutation failed'));
-        const mutation = createMutation(mutator);
-        mutation.mutate('test');
-        expect(mutation.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toContain('Mutation failed');
-        expect(mutation.params).toBeNull();
-    });
-    it('should cancel previous mutation on new mutate call', async () => {
-        let resolveFirst;
-        let resolveSecond;
-        const firstPromise = new Promise((resolve) => {
-            resolveFirst = resolve;
-        });
-        const secondPromise = new Promise((resolve) => {
-            resolveSecond = resolve;
-        });
-        const mutator = vi
-            .fn()
-            .mockReturnValueOnce(firstPromise)
-            .mockReturnValueOnce(secondPromise);
-        const mutation = createMutation(mutator);
-        mutation.mutate('first');
-        expect(mutation.params).toBe('first');
-        // Trigger second mutation before first completes
-        mutation.mutate('second');
-        expect(mutation.params).toBe('second');
-        // Resolve first (should be ignored due to cancellation)
-        resolveFirst('first');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(true); // Still pending second
-        // Resolve second
-        resolveSecond('second');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it('should handle rapid successive mutations', async () => {
-        let counter = 0;
-        const mutator = vi.fn(() => Promise.resolve(++counter));
-        const mutation = createMutation(mutator);
-        // Rapid mutations
-        mutation.mutate('1');
-        mutation.mutate('2');
-        mutation.mutate('3');
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        // Only the last mutation should complete
-        expect(mutator).toHaveBeenCalledTimes(3);
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it('should clear error on successful retry', async () => {
-        const mutator = vi
-            .fn()
-            .mockRejectedValueOnce(new Error('First error'))
-            .mockResolvedValueOnce('success');
-        const mutation = createMutation(mutator);
-        mutation.mutate('attempt1');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.error).toContain('First error');
-        mutation.mutate('attempt2');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.error).toBeNull();
-        expect(mutation.isPending).toBe(false);
-    });
-    it('should handle different parameter types', async () => {
-        const mutator = vi.fn((params) => Promise.resolve(params));
-        const mutation = createMutation(mutator);
-        // Object params
-        mutation.mutate({ id: 1, name: 'test' });
-        expect(mutation.params).toEqual({ id: 1, name: 'test' });
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Array params
-        const mutation2 = createMutation(mutator);
-        mutation2.mutate([1, 2, 3]);
-        expect(mutation2.params).toEqual([1, 2, 3]);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // String params
-        const mutation3 = createMutation(mutator);
-        mutation3.mutate('string');
-        expect(mutation3.params).toBe('string');
-    });
-    it('should convert errors to strings', async () => {
-        const mutator = (params) => Promise.reject('string error');
-        const mutation = createMutation(mutator);
-        mutation.mutate('test');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(typeof mutation.error).toBe('string');
-        expect(mutation.error).toBe('string error');
-    });
-    it('should handle AbortController cancellation correctly', async () => {
-        const abortedPromise = new Promise((_, reject) => {
-            const error = new Error('Aborted');
-            error.name = 'AbortError';
-            setTimeout(() => reject(error), 5);
-        });
-        const successPromise = Promise.resolve('success');
-        const mutator = vi
-            .fn()
-            .mockReturnValueOnce(abortedPromise)
-            .mockReturnValueOnce(successPromise);
-        const mutation = createMutation(mutator);
-        mutation.mutate('first');
-        // Immediately trigger second mutation to abort first
-        mutation.mutate('second');
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toBeNull();
-    });
-    it('should track params during pending state', () => {
-        const mutator = () => new Promise((resolve) => setTimeout(() => resolve(null), 100));
-        const mutation = createMutation(mutator);
-        const params = { id: 123, action: 'update' };
-        mutation.mutate(params);
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toEqual(params);
-    });
-    it('should expose reactive getters', async () => {
-        const mutator = () => Promise.resolve('data');
-        const mutation = createMutation(mutator);
-        // Access getters before mutation
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-        expect(mutation.error).toBeNull();
-        mutation.mutate('test');
-        // Access getters during mutation
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toBe('test');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Access getters after mutation
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-});

package/dist/createQuery.test.d.ts

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

package/dist/createQuery.test.d.ts.map

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