rask-ui 0.21.0 → 0.23.0

package/dist/asyncState.d.ts

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

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

@@ -0,0 +1,24 @@
+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/component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,EACL,SAAS,EACT,KAAK,EACL,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAsB,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIrE,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,IAC3D,CAAC,MAAM,KAAK,CAAC,GACb,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC;AAE1B,qBAAa,sBAAuB,SAAQ,SAAS;IAC3C,QAAQ,EAAE,8BAA8B,CAAC,GAAG,CAAC,CAAC;IACtD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;IAC9B,QAAQ,WAML;IACH,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAC1C,OAAO,CAAC,aAAa,CAAc;IAEnC,qBAAqB,IAAI,OAAO;IAMhC,kBAAkB,IAAI,IAAI;IAG1B,yBAAyB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI;IAe/C,MAAM;CAoBP;AAID,wBAAgB,mBAAmB,2CAElC;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,QAM5C;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,QAMxC;AAED,MAAM,MAAM,6BAA6B,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,IAC1D,CAAC,MAAM,MAAM,KAAK,CAAC,GACnB,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,KAAK,CAAC,CAAC;AAEhC,qBAAa,qBAAqB,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IACnE,KAAK,EAAE,6BAA6B,CAAC,CAAC,CAAC,CAAC;IAChD,OAAO,CAAC,QAAQ,CAAC,CAAc;IAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAC1C,OAAO,CAAC,aAAa,CAAc;IAwBnC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;IAE9B,QAAQ,WAOL;IAEH,WAAW,UAAS;IACpB,OAAO,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC,CAAM;IAC3D,QAAQ,gBAAa;IACrB,eAAe;IAUf,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAM;IACjC,UAAU,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAM;IAEnC,iBAAiB,IAAI,IAAI;IAGzB,oBAAoB,IAAI,IAAI;IAI5B,yBAAyB,CACvB,SAAS,EAAE,QAAQ,CAAC;QAAE,QAAQ,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,CAAC,CAAC,GAClD,IAAI;IAcP,qBAAqB,IAAI,OAAO;IAMhC,MAAM;CA6CP;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,SAO9D"}
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,EACL,SAAS,EACT,KAAK,EACL,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAsB,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIrE,MAAM,MAAM,8BAA8B,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,IAC3D,CAAC,MAAM,KAAK,CAAC,GACb,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC;AAE1B,qBAAa,sBAAuB,SAAQ,SAAS;IAC3C,QAAQ,EAAE,8BAA8B,CAAC,GAAG,CAAC,CAAC;IACtD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;IAC9B,QAAQ,WAML;IACH,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAC1C,OAAO,CAAC,aAAa,CAAc;IAEnC,qBAAqB,IAAI,OAAO;IAMhC,kBAAkB,IAAI,IAAI;IAG1B,yBAAyB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI;IAe/C,MAAM;CAoBP;AAID,wBAAgB,mBAAmB,2CAElC;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,QAM5C;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,QAMxC;AAED,MAAM,MAAM,6BAA6B,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,IAC1D,CAAC,MAAM,MAAM,KAAK,CAAC,GACnB,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,KAAK,CAAC,CAAC;AAEhC,qBAAa,qBAAqB,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IACnE,KAAK,EAAE,6BAA6B,CAAC,CAAC,CAAC,CAAC;IAChD,OAAO,CAAC,QAAQ,CAAC,CAAc;IAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAC1C,OAAO,CAAC,aAAa,CAAc;IAwBnC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;IAE9B,QAAQ,WAOL;IAEH,WAAW,UAAS;IACpB,OAAO,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC,CAAM;IAC3D,QAAQ,gBAAa;IACrB,eAAe;IAcf,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAM;IACjC,UAAU,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAM;IAEnC,iBAAiB,IAAI,IAAI;IAGzB,oBAAoB,IAAI,IAAI;IAI5B,yBAAyB,CACvB,SAAS,EAAE,QAAQ,CAAC;QAAE,QAAQ,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,CAAC,CAAC,GAClD,IAAI;IAcP,qBAAqB,IAAI,OAAO;IAMhC,MAAM;CA2CP;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,SAO9D"}

package/dist/component.js

@@ -44,7 +44,7 @@ export class RaskStatelessComponent extends Component {
             result = this.renderFn(this.reactiveProps);
         }
         catch (error) {
-            const notifyError = this.context.getContext?.(CatchErrorContext);
+            const notifyError = CatchErrorContext.use();
             if (typeof notifyError !== "function") {
                 throw error;
             }
@@ -112,7 +112,10 @@ export class RaskStatefulComponent extends Component {
     effects = [];
     contexts = new Map();
     getChildContext() {
-        const parentGetContext = this.context.getContext;
+        const parentGetContext = this.context.getContext ||
+            (() => {
+                throw new Error("No context available");
+            });
         return {
             ...this.context,
             getContext: (context) => {
@@ -173,8 +176,7 @@ export class RaskStatefulComponent extends Component {
             this.isRendering = false;
         }
         catch (error) {
-            const notifyError = this.contexts.get(CatchErrorContext) ||
-                this.context.getContext?.(CatchErrorContext);
+            const notifyError = CatchErrorContext.use();
             if (typeof notifyError !== "function") {
                 throw error;
             }

package/dist/context.d.ts

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

package/dist/context.d.ts.map

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

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

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

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

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

package/dist/createAsync.test.js

@@ -0,0 +1,110 @@
+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/createContext.d.ts

@@ -1,33 +1,49 @@
 /**
- * Creates a context object for providing and consuming values across component trees.
+ * Creates a context that provides two methods: `use()` to consume context values and
+ * `inject()` to provide context values to child components.
  *
- * @warning **Do not destructure context values returned by context.get()!** The returned
- * value may be a reactive object, and destructuring breaks reactivity.
+ * @warning **Do not destructure context values!** The returned value may be a reactive
+ * object, and destructuring breaks reactivity.
  *
  * @example
- * // ❌ Bad - destructuring context value
- * const ThemeContext = createContext<{ color: string }>();
+ * // Create a context
+ * const ThemeContext = createContext(() => {
+ *   return useState({ color: "blue" });
+ * });
  *
- * function Consumer() {
- *   const theme = ThemeContext.get();
- *   const { color } = theme; // Don't do this!
- *   return () => <div style={{ color }}>Text</div>; // Won't update!
+ * // Provider component
+ * function App() {
+ *   const theme = ThemeContext.inject();
+ *   // theme is now available to all children
+ *   return () => <Child />;
  * }
  *
- * // ✅ Good - access properties directly
- * function Consumer() {
- *   const theme = ThemeContext.get();
+ * // Consumer component
+ * function Child() {
+ *   const theme = ThemeContext.use();
  *   return () => <div style={{ color: theme.color }}>Text</div>;
  * }
  *
- * @returns Context object with inject() and get() methods
+ * @param hook - A function that will be used as the context identifier
+ * @returns An object with `use()` and `inject()` methods
  */
-declare const Type: unique symbol;
-export type Context<T> = symbol & {
-    readonly [Type]: T;
+export declare function createContext<T, P extends any[]>(hook: (...params: P) => T): {
+    /**
+     * Consumes the context value from the nearest parent component that called `inject()`.
+     * Must be called during component setup.
+     *
+     * @returns The context value provided by the nearest parent
+     * @throws Error if called outside component setup, if no parent context exists, or if the specific context was not provided
+     */
+    use(): any;
+    /**
+     * Injects a context value by calling the hook function and making it available to all child components.
+     * Must be called during component setup.
+     *
+     * @param params - Parameters to pass to the hook function
+     * @returns The context value created by the hook
+     * @throws Error if called outside component setup
+     */
+    inject(...params: P): T;
 };
-export declare function createContext<T>(): Context<T>;
-export declare function useContext<T>(context: Context<T>): T;
-export declare function useInjectContext<T>(context: Context<T>): (value: T) => void;
-export {};
 //# sourceMappingURL=createContext.d.ts.map

package/dist/createContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createContext.d.ts","sourceRoot":"","sources":["../src/createContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,CAAC,MAAM,IAAI,EAAE,OAAO,MAAM,CAAC;AAElC,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,MAAM,GAAG;IAChC,QAAQ,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;CACpB,CAAC;AAEF,wBAAgB,aAAa,CAAC,CAAC,KACV,OAAO,CAAC,CAAC,CAAC,CAC9B;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAkBpD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,IAC7C,OAAO,CAAC,UASjB"}
+{"version":3,"file":"createContext.d.ts","sourceRoot":"","sources":["../src/createContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,wBAAgB,aAAa,CAAC,CAAC,EAAE,CAAC,SAAS,GAAG,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC;IAEvE;;;;;;OAMG;;IAsBH;;;;;;;OAOG;sBACe,CAAC;EActB"}

package/dist/createContext.js

@@ -1,51 +1,72 @@
 /**
- * Creates a context object for providing and consuming values across component trees.
+ * Creates a context that provides two methods: `use()` to consume context values and
+ * `inject()` to provide context values to child components.
  *
- * @warning **Do not destructure context values returned by context.get()!** The returned
- * value may be a reactive object, and destructuring breaks reactivity.
+ * @warning **Do not destructure context values!** The returned value may be a reactive
+ * object, and destructuring breaks reactivity.
  *
  * @example
- * // ❌ Bad - destructuring context value
- * const ThemeContext = createContext<{ color: string }>();
+ * // Create a context
+ * const ThemeContext = createContext(() => {
+ *   return useState({ color: "blue" });
+ * });
  *
- * function Consumer() {
- *   const theme = ThemeContext.get();
- *   const { color } = theme; // Don't do this!
- *   return () => <div style={{ color }}>Text</div>; // Won't update!
+ * // Provider component
+ * function App() {
+ *   const theme = ThemeContext.inject();
+ *   // theme is now available to all children
+ *   return () => <Child />;
  * }
  *
- * // ✅ Good - access properties directly
- * function Consumer() {
- *   const theme = ThemeContext.get();
+ * // Consumer component
+ * function Child() {
+ *   const theme = ThemeContext.use();
  *   return () => <div style={{ color: theme.color }}>Text</div>;
  * }
  *
- * @returns Context object with inject() and get() methods
+ * @param hook - A function that will be used as the context identifier
+ * @returns An object with `use()` and `inject()` methods
  */
 import { getCurrentComponent } from "./component";
-export function createContext() {
-    return Symbol();
-}
-export function useContext(context) {
-    let currentComponent = getCurrentComponent();
-    if (!currentComponent) {
-        throw new Error("Only use useContext in component setup");
-    }
-    if (typeof currentComponent.context.getContext !== "function") {
-        throw new Error("There is no parent context");
-    }
-    const contextValue = currentComponent.context.getContext(context);
-    if (!contextValue) {
-        throw new Error("There is a parent context, but not the one you are using");
-    }
-    return contextValue;
-}
-export function useInjectContext(context) {
-    return (value) => {
-        const currentComponent = getCurrentComponent();
-        if (!currentComponent) {
-            throw new Error("Only use useInjectContext in component setup");
-        }
-        currentComponent.contexts.set(context, value);
+export function createContext(hook) {
+    return {
+        /**
+         * Consumes the context value from the nearest parent component that called `inject()`.
+         * Must be called during component setup.
+         *
+         * @returns The context value provided by the nearest parent
+         * @throws Error if called outside component setup, if no parent context exists, or if the specific context was not provided
+         */
+        use() {
+            let currentComponent = getCurrentComponent();
+            if (!currentComponent) {
+                throw new Error("Only use useContext in component setup");
+            }
+            if (typeof currentComponent.context.getContext !== "function") {
+                throw new Error("There is no parent context");
+            }
+            const contextValue = currentComponent.context.getContext(hook);
+            if (!contextValue) {
+                throw new Error("There is a parent context, but not the one you are using");
+            }
+            return contextValue;
+        },
+        /**
+         * Injects a context value by calling the hook function and making it available to all child components.
+         * Must be called during component setup.
+         *
+         * @param params - Parameters to pass to the hook function
+         * @returns The context value created by the hook
+         * @throws Error if called outside component setup
+         */
+        inject(...params) {
+            const currentComponent = getCurrentComponent();
+            if (!currentComponent) {
+                throw new Error("Only use useInjectContext in component setup");
+            }
+            const value = hook(...params);
+            currentComponent.contexts.set(hook, value);
+            return value;
+        },
     };
 }

package/dist/createMutation.test.d.ts

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

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

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

package/dist/createMutation.test.js

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

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

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

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