unwrapped 0.1.7 → 0.1.9

package/dist/vue/index.d.ts

@@ -1,5 +1,5 @@
 import * as unwrapped_core from 'unwrapped/core';
-import { ErrorBase, AsyncResult, Result, FlatChainStep, Action, AsyncResultGenerator, AsyncResultList } from 'unwrapped/core';
+import { ErrorBase, AsyncResult, Result, FlatChainStep, Action, AsyncResultGenerator, AsyncResultCollection } from 'unwrapped/core';
 import * as vue from 'vue';
 import { Ref, WatchSource, VNode, SlotsType } from 'vue';
 
@@ -80,14 +80,14 @@ declare function useLazyGenerator<T>(generatorFunc: () => AsyncResultGenerator<T
  */
 declare function useReactiveGenerator<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, generatorFunc: (args: Inputs) => AsyncResultGenerator<T>, options?: ReactiveProcessOptions): Ref<AsyncResult<T, E>>;
 /**
- * Creates a reactive AsyncResultList wrapped in a Vue ref.
- * The AsyncResultList notifies Vue's reactivity system whenever its state changes.
+ * Creates a reactive AsyncResultCollection wrapped in a Vue ref.
+ * The AsyncResultCollection notifies Vue's reactivity system whenever its state changes.
  *
- * @template T - The type of the values in the AsyncResultList.
+ * @template T - The type of the values in the AsyncResultCollection.
  * @template E - The type of the error, extending ErrorBase (default is ErrorBase).
- * @returns a ref to the AsyncResultList
+ * @returns a ref to the AsyncResultCollection
  */
-declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>(): Ref<{
+declare function useAsyncResultCollection<T = any, E extends ErrorBase = ErrorBase>(): Ref<{
     readonly tasks: Map<string, {
         key: string;
         result: {
@@ -125,6 +125,10 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
             updateFromResultPromise: (promise: Promise<Result<T, E>>) => AsyncResult<T, E>;
             listen: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
             listenUntilSettled: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+            onSuccessOnce: (callback: (value: T) => void) => () => void;
+            onSuccessPerpetual: (callback: (value: T) => void) => () => void;
+            onErrorOnce: (callback: (error: E) => void) => () => void;
+            onErrorPerpetual: (callback: (error: E) => void) => () => void;
             mirror: (other: AsyncResult<T, E>) => () => void;
             mirrorUntilSettled: (other: AsyncResult<T, E>) => () => void;
             chain: <O, E2 extends ErrorBase = ErrorBase>(fn: unwrapped_core.ChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
@@ -135,7 +139,7 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
             [Symbol.iterator]: () => Generator<AsyncResult<T, E>, T, any>;
         };
         unsub: () => void;
-    }> & Omit<Map<string, unwrapped_core.AsyncResultListItem<T, E>>, keyof Map<any, any>>;
+    }> & Omit<Map<string, unwrapped_core.AsyncResultCollectionItem<T, E>>, keyof Map<any, any>>;
     readonly length: number;
     readonly items: {
         state: {
@@ -172,6 +176,10 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
         updateFromResultPromise: (promise: Promise<Result<T, E>>) => AsyncResult<T, E>;
         listen: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
         listenUntilSettled: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+        onSuccessOnce: (callback: (value: T) => void) => () => void;
+        onSuccessPerpetual: (callback: (value: T) => void) => () => void;
+        onErrorOnce: (callback: (error: E) => void) => () => void;
+        onErrorPerpetual: (callback: (error: E) => void) => () => void;
         mirror: (other: AsyncResult<T, E>) => () => void;
         mirrorUntilSettled: (other: AsyncResult<T, E>) => () => void;
         chain: <O, E2 extends ErrorBase = ErrorBase>(fn: unwrapped_core.ChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
@@ -181,9 +189,60 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
         debug: (name?: string) => () => void;
         [Symbol.iterator]: () => Generator<AsyncResult<T, E>, T, any>;
     }[];
-    state: unwrapped_core.AsyncResultListState;
-    listen: (listener: (taskQueue: AsyncResultList<T, E>) => void) => () => void;
+    readonly entries: [string, {
+        state: {
+            status: "idle";
+        } | {
+            status: "loading";
+            promise: {
+                then: <TResult1 = Result<T, E>, TResult2 = never>(onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+                catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<Result<T, E> | TResult>;
+                finally: (onfinally?: (() => void) | null | undefined) => Promise<Result<T, E>>;
+                readonly [Symbol.toStringTag]: string;
+            };
+        } | {
+            status: "success";
+            value: vue.UnwrapRef<T>;
+        } | {
+            status: "error";
+            error: vue.UnwrapRef<E>;
+        };
+        isSuccess: () => boolean;
+        isError: () => boolean;
+        isIdle: () => boolean;
+        isLoading: () => boolean;
+        unwrapOrNull: () => T | null;
+        unwrapOrThrow: () => T;
+        unwrapErrorOrNull: () => E | null;
+        updateFromValue: (value: T) => AsyncResult<T, E>;
+        updateFromError: (error: E) => AsyncResult<T, E>;
+        updateFromValuePromise: (promise: Promise<T>) => AsyncResult<T, E>;
+        waitForSettled: () => Promise<AsyncResult<T, E>>;
+        toResultPromise: () => Promise<Result<T, E>>;
+        toValueOrThrowPromise: () => Promise<T>;
+        toValueOrNullPromise: () => Promise<T | null>;
+        updateFromResultPromise: (promise: Promise<Result<T, E>>) => AsyncResult<T, E>;
+        listen: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+        listenUntilSettled: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+        onSuccessOnce: (callback: (value: T) => void) => () => void;
+        onSuccessPerpetual: (callback: (value: T) => void) => () => void;
+        onErrorOnce: (callback: (error: E) => void) => () => void;
+        onErrorPerpetual: (callback: (error: E) => void) => () => void;
+        mirror: (other: AsyncResult<T, E>) => () => void;
+        mirrorUntilSettled: (other: AsyncResult<T, E>) => () => void;
+        chain: <O, E2 extends ErrorBase = ErrorBase>(fn: unwrapped_core.ChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
+        flatChain: <O, E2 extends ErrorBase = ErrorBase>(fn: FlatChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
+        runInPlace: (generatorFunc: () => AsyncResultGenerator<T>) => AsyncResult<T, E>;
+        log: (name?: string) => void;
+        debug: (name?: string) => () => void;
+        [Symbol.iterator]: () => Generator<AsyncResult<T, E>, T, any>;
+    }][];
+    state: unwrapped_core.AsyncResultCollectionState;
+    listen: (listener: (taskQueue: AsyncResultCollection<T, E>) => void) => () => void;
+    onItemSuccess: (listener: (task: AsyncResult<T, E>, key: string) => void) => () => void;
+    onItemError: (listener: (task: AsyncResult<T, E>, key: string) => void) => () => void;
     add: (key: string, task: AsyncResult<T, E>, removeOnSettle?: boolean) => AsyncResult<T, E>;
+    remove: (key: string) => boolean;
     clear: () => void;
     anyLoading: () => boolean;
     getAllFiltered: (predicate: (task: AsyncResult<T, E>) => boolean) => AsyncResult<T, E>[];
@@ -196,7 +255,7 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
     getAllLoadingPromises: () => Promise<Result<T, E>>[];
     log: (name?: string) => void;
     debug: (name?: string) => () => void;
-}, AsyncResultList<T, E> | {
+}, AsyncResultCollection<T, E> | {
     readonly tasks: Map<string, {
         key: string;
         result: {
@@ -234,6 +293,10 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
             updateFromResultPromise: (promise: Promise<Result<T, E>>) => AsyncResult<T, E>;
             listen: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
             listenUntilSettled: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+            onSuccessOnce: (callback: (value: T) => void) => () => void;
+            onSuccessPerpetual: (callback: (value: T) => void) => () => void;
+            onErrorOnce: (callback: (error: E) => void) => () => void;
+            onErrorPerpetual: (callback: (error: E) => void) => () => void;
             mirror: (other: AsyncResult<T, E>) => () => void;
             mirrorUntilSettled: (other: AsyncResult<T, E>) => () => void;
             chain: <O, E2 extends ErrorBase = ErrorBase>(fn: unwrapped_core.ChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
@@ -244,7 +307,7 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
             [Symbol.iterator]: () => Generator<AsyncResult<T, E>, T, any>;
         };
         unsub: () => void;
-    }> & Omit<Map<string, unwrapped_core.AsyncResultListItem<T, E>>, keyof Map<any, any>>;
+    }> & Omit<Map<string, unwrapped_core.AsyncResultCollectionItem<T, E>>, keyof Map<any, any>>;
     readonly length: number;
     readonly items: {
         state: {
@@ -281,6 +344,10 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
         updateFromResultPromise: (promise: Promise<Result<T, E>>) => AsyncResult<T, E>;
         listen: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
         listenUntilSettled: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+        onSuccessOnce: (callback: (value: T) => void) => () => void;
+        onSuccessPerpetual: (callback: (value: T) => void) => () => void;
+        onErrorOnce: (callback: (error: E) => void) => () => void;
+        onErrorPerpetual: (callback: (error: E) => void) => () => void;
         mirror: (other: AsyncResult<T, E>) => () => void;
         mirrorUntilSettled: (other: AsyncResult<T, E>) => () => void;
         chain: <O, E2 extends ErrorBase = ErrorBase>(fn: unwrapped_core.ChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
@@ -290,9 +357,60 @@ declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>():
         debug: (name?: string) => () => void;
         [Symbol.iterator]: () => Generator<AsyncResult<T, E>, T, any>;
     }[];
-    state: unwrapped_core.AsyncResultListState;
-    listen: (listener: (taskQueue: AsyncResultList<T, E>) => void) => () => void;
+    readonly entries: [string, {
+        state: {
+            status: "idle";
+        } | {
+            status: "loading";
+            promise: {
+                then: <TResult1 = Result<T, E>, TResult2 = never>(onfulfilled?: ((value: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+                catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<Result<T, E> | TResult>;
+                finally: (onfinally?: (() => void) | null | undefined) => Promise<Result<T, E>>;
+                readonly [Symbol.toStringTag]: string;
+            };
+        } | {
+            status: "success";
+            value: vue.UnwrapRef<T>;
+        } | {
+            status: "error";
+            error: vue.UnwrapRef<E>;
+        };
+        isSuccess: () => boolean;
+        isError: () => boolean;
+        isIdle: () => boolean;
+        isLoading: () => boolean;
+        unwrapOrNull: () => T | null;
+        unwrapOrThrow: () => T;
+        unwrapErrorOrNull: () => E | null;
+        updateFromValue: (value: T) => AsyncResult<T, E>;
+        updateFromError: (error: E) => AsyncResult<T, E>;
+        updateFromValuePromise: (promise: Promise<T>) => AsyncResult<T, E>;
+        waitForSettled: () => Promise<AsyncResult<T, E>>;
+        toResultPromise: () => Promise<Result<T, E>>;
+        toValueOrThrowPromise: () => Promise<T>;
+        toValueOrNullPromise: () => Promise<T | null>;
+        updateFromResultPromise: (promise: Promise<Result<T, E>>) => AsyncResult<T, E>;
+        listen: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+        listenUntilSettled: (listener: unwrapped_core.AsyncResultListener<T, E>, immediate?: boolean) => () => void;
+        onSuccessOnce: (callback: (value: T) => void) => () => void;
+        onSuccessPerpetual: (callback: (value: T) => void) => () => void;
+        onErrorOnce: (callback: (error: E) => void) => () => void;
+        onErrorPerpetual: (callback: (error: E) => void) => () => void;
+        mirror: (other: AsyncResult<T, E>) => () => void;
+        mirrorUntilSettled: (other: AsyncResult<T, E>) => () => void;
+        chain: <O, E2 extends ErrorBase = ErrorBase>(fn: unwrapped_core.ChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
+        flatChain: <O, E2 extends ErrorBase = ErrorBase>(fn: FlatChainStep<T, O, E | E2>) => AsyncResult<O, E | E2>;
+        runInPlace: (generatorFunc: () => AsyncResultGenerator<T>) => AsyncResult<T, E>;
+        log: (name?: string) => void;
+        debug: (name?: string) => () => void;
+        [Symbol.iterator]: () => Generator<AsyncResult<T, E>, T, any>;
+    }][];
+    state: unwrapped_core.AsyncResultCollectionState;
+    listen: (listener: (taskQueue: AsyncResultCollection<T, E>) => void) => () => void;
+    onItemSuccess: (listener: (task: AsyncResult<T, E>, key: string) => void) => () => void;
+    onItemError: (listener: (task: AsyncResult<T, E>, key: string) => void) => () => void;
     add: (key: string, task: AsyncResult<T, E>, removeOnSettle?: boolean) => AsyncResult<T, E>;
+    remove: (key: string) => boolean;
     clear: () => void;
     anyLoading: () => boolean;
     getAllFiltered: (predicate: (task: AsyncResult<T, E>) => boolean) => AsyncResult<T, E>[];
@@ -355,4 +473,4 @@ declare function makeAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots
     };
 }>, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-export { type LazyActionRef, makeAsyncResultLoader, useAction, useAsyncResultList, useAsyncResultRef, useAsyncResultRefFromPromise, useGenerator, useLazyAction, useLazyGenerator, useReactiveChain, useReactiveGenerator };
+export { type LazyActionRef, makeAsyncResultLoader, useAction, useAsyncResultCollection, useAsyncResultRef, useAsyncResultRefFromPromise, useGenerator, useLazyAction, useLazyGenerator, useReactiveChain, useReactiveGenerator };

package/dist/vue/index.js

@@ -22,7 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   makeAsyncResultLoader: () => makeAsyncResultLoader,
   useAction: () => useAction,
-  useAsyncResultList: () => useAsyncResultList,
+  useAsyncResultCollection: () => useAsyncResultCollection,
   useAsyncResultRef: () => useAsyncResultRef,
   useAsyncResultRefFromPromise: () => useAsyncResultRefFromPromise,
   useGenerator: () => useGenerator,
@@ -92,8 +92,8 @@ function useReactiveGenerator(source, generatorFunc, options = { immediate: true
   }, { immediate: options.immediate });
   return resultRef;
 }
-function useAsyncResultList() {
-  const list = new import_core.AsyncResultList();
+function useAsyncResultCollection() {
+  const list = new import_core.AsyncResultCollection();
   const listRef = (0, import_vue.ref)(list);
   list.listen(() => {
     (0, import_vue.triggerRef)(listRef);

package/dist/vue/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/vue/index.ts","../../src/vue/composables.ts","../../src/vue/components/asyncResultLoader.ts"],"sourcesContent":["export * from \"./composables\"\nexport * from \"./components/asyncResultLoader\"","import { onUnmounted, ref, triggerRef, watch, type Ref, type WatchSource } from \"vue\";\nimport { AsyncResult, AsyncResultList, ErrorBase, type Action, type AsyncResultGenerator, type FlatChainStep, type Result } from \"unwrapped/core\";\n\n\n// === Vue specific types ===\n\ninterface ReactiveProcessOptions {\n    immediate: boolean;\n}\n\n\n\n// === Vue Composables for AsyncResult ===\n\n/**\n * Makes a ref to the given AsyncResult. Whenever the state of the AsyncResult changes,\n * the ref gets retriggered, making those changes visible to Vue's reactivity system.\n * \n * @param asyncResult the result to make reactive\n * @returns the ref to the result\n */\nexport function useAsyncResultRef<T, E extends ErrorBase = ErrorBase>(asyncResult?: AsyncResult<T, E>) {\n    if (!asyncResult) {\n        asyncResult = new AsyncResult<T, E>();\n    }\n    const state = ref<AsyncResult<T, E>>(asyncResult) as Ref<AsyncResult<T, E>>;\n\n    const unsub = asyncResult.listen(() => {\n        triggerRef(state);\n    });\n\n    onUnmounted(() => {\n        unsub();\n    });\n\n    return state;\n}\n\n/**\n * Creates an AsyncResult ref from a promise returning a Result.\n * @param promise the promise returning a Result\n * @returns the ref to the AsyncResult\n */\nexport function useAsyncResultRefFromPromise<T, E extends ErrorBase = ErrorBase>(promise: Promise<Result<T, E>>) {\n    return useAsyncResultRef(AsyncResult.fromResultPromise(promise));\n}\n\n\n\n// === Vue Composables for Chains ===\n\n/**\n * Watches a source, gives it as inputs to the function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param pipe the function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveChain<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, pipe: FlatChainStep<Inputs, T, E>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const result = new AsyncResult<T, E>();\n    const resultRef = useAsyncResultRef(result);\n\n    let unsub: (() => void) | null = null;\n\n    watch(source, (newInputs) => {\n        unsub?.();\n        unsub = result.mirror(pipe(newInputs));\n    }, { immediate: options.immediate });\n\n    onUnmounted(() => {\n        unsub?.();\n    });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for Actions ===\n\n/**\n * The return type of useLazyAction.\n */\nexport interface LazyActionRef<T, E extends ErrorBase = ErrorBase> {\n    resultRef: Ref<AsyncResult<T, E>>;\n    trigger: () => void;\n}\n\n/**\n * Executes an action immediately and returns a ref to the AsyncResult representing the action's state.\n * \n * Same as useAsyncResultRefFromPromise(action()).\n * \n * @param action the action to execute immediately\n * @returns a ref to the AsyncResult representing the action's state\n */\nexport function useAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): Ref<AsyncResult<T, E>> {\n    return useAsyncResultRefFromPromise(action());\n}\n\n/**\n * Creates a lazy action that can be triggered manually.\n * \n * Same as AsyncResult.makeLazyAction(action), but the AsyncResult is wrapped in a ref for Vue reactivity.\n * \n * @param action the action to execute when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): LazyActionRef<T, E> {\n    const lazyAction = AsyncResult.makeLazyAction<T, E>(action);\n    const resultRef = useAsyncResultRef(lazyAction.result);\n\n    return { resultRef, trigger: lazyAction.trigger };\n}\n\n\n// === Vue Composables for Generators ===\n\n/**\n * Runs a generator function immediately and returns a ref to the AsyncResult representing the generator's state.\n * @param generatorFunc the generator function to run immediately\n * @returns a ref to the AsyncResult representing the generator's state\n */\nexport function useGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): Ref<AsyncResult<T, any>> {\n    const resultRef = useAsyncResultRef(AsyncResult.run(generatorFunc));\n    return resultRef;\n}\n\n/**\n * Creates a lazy generator that can be triggered manually.\n * \n * @param generatorFunc the generator function to run when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): { resultRef: Ref<AsyncResult<T, any>>, trigger: () => void } {\n    const result = new AsyncResult<T, any>();\n    const resultRef = useAsyncResultRef(result);\n\n    const trigger = () => {\n        result.runInPlace(generatorFunc);\n    }\n\n    return { resultRef, trigger };\n}\n\n/**\n * Watches a source, gives it as inputs to the generator function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param generatorFunc the generator function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveGenerator<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, generatorFunc: (args: Inputs) => AsyncResultGenerator<T>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const resultRef = useAsyncResultRef(new AsyncResult<T, E>());\n\n    watch(source, (newInputs) => {\n        resultRef.value.runInPlace(() => generatorFunc(newInputs));\n    }, { immediate: options.immediate });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for AsyncResultList ===\n\n/**\n * Creates a reactive AsyncResultList wrapped in a Vue ref.\n * The AsyncResultList notifies Vue's reactivity system whenever its state changes.\n * \n * @template T - The type of the values in the AsyncResultList.\n * @template E - The type of the error, extending ErrorBase (default is ErrorBase).\n * @returns a ref to the AsyncResultList\n */\nexport function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>() {\n    const list = new AsyncResultList<T, E>();\n    const listRef = ref(list);\n\n    list.listen(() => {\n        triggerRef(listRef);\n    });\n\n    return listRef;\n}","import { defineComponent, watch, h, type VNode, type SlotsType } from \"vue\"\nimport { ErrorBase, type AsyncResult } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n    idle?: () => VNode;\n}\n\n/**\n * Factory function to create a component that displays different content based on an AsyncResult's state. Provides slots for loading, error, idle, and success states and passes the relevant data to each slot, and are typed appropriately.\n * @param slots predefined slots for loading, error, and idle states. Useful for not having to repeat the same template for displaying a framework-specific spinner while in loading state, or a custom error message.\n * @param name Optional internal name for the component\n * @returns An instantiable component that accepts an AsyncResult prop and a default slot for the success state.\n * \n * @example\n * // loaders.ts - Create reusable loader with default loading/error UI\n * const MyLoader = makeAsyncResultLoader({\n *   loading: () => h(Spinner),\n *   error: ({ error }) => h(ErrorDisplay, { error }),\n *   idle: () => h('div', 'Ready')\n * });\n * \n * // MyPage.vue - Use the loader with custom success content\n * <MyLoader :result=\"myAsyncResult\">\n *   <template #default=\"{ value }\">\n *     <UserProfile :user=\"value\" />\n *   </template>\n * </MyLoader>\n */\nexport function makeAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>, name = \"AsyncResultLoader\") {\n    return defineComponent({\n        name,\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        slots: Object as SlotsType<CustomSlots<E> & { default: { value: T } }>,\n        setup(props, context) {\n            let resultRef = useAsyncResultRef(props.result);\n\n            // Watch for prop changes & update listener\n            watch(\n                () => props.result,\n                (newResult, oldResult) => {\n                    if (newResult === oldResult) return;\n                    resultRef = useAsyncResultRef(newResult);\n                },\n                { immediate: true }\n            )\n\n            return () => {\n                const s = resultRef.value.state;\n\n                const renderDefault = context.slots.default ?? (() => h(\"div\", { class: \"success\" }, \"Success\"));\n                const renderError = context.slots.error ?? slots.error ?? (() => h(\"div\", { class: \"error\" }, \"Error\"));\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => h(\"div\", { class: \"loading\" }, \"Loading…\"));\n                const renderIdle = context.slots.idle ?? slots.idle ?? (() => h(\"div\", { class: \"idle\" }, \"Idle\"));\n\n                // Choose what to render based on status\n                switch (s.status) {\n                    case \"loading\":\n                        return renderLoading();\n\n                    case \"error\":\n                        return renderError({ error: s.error });\n\n                    case \"success\":\n                        return renderDefault({ value: s.value });\n\n                    default:\n                        return renderIdle();\n                }\n            }\n        }\n    })\n}"],"mappings":"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","names":["import_vue","import_core"]}
+{"version":3,"sources":["../../src/vue/index.ts","../../src/vue/composables.ts","../../src/vue/components/asyncResultLoader.ts"],"sourcesContent":["export * from \"./composables\"\nexport * from \"./components/asyncResultLoader\"","import { onUnmounted, ref, triggerRef, watch, type Ref, type WatchSource } from \"vue\";\nimport { AsyncResult, AsyncResultCollection, ErrorBase, type Action, type AsyncResultGenerator, type FlatChainStep, type Result } from \"unwrapped/core\";\n\n\n// === Vue specific types ===\n\ninterface ReactiveProcessOptions {\n    immediate: boolean;\n}\n\n\n\n// === Vue Composables for AsyncResult ===\n\n/**\n * Makes a ref to the given AsyncResult. Whenever the state of the AsyncResult changes,\n * the ref gets retriggered, making those changes visible to Vue's reactivity system.\n * \n * @param asyncResult the result to make reactive\n * @returns the ref to the result\n */\nexport function useAsyncResultRef<T, E extends ErrorBase = ErrorBase>(asyncResult?: AsyncResult<T, E>) {\n    if (!asyncResult) {\n        asyncResult = new AsyncResult<T, E>();\n    }\n    const state = ref<AsyncResult<T, E>>(asyncResult) as Ref<AsyncResult<T, E>>;\n\n    const unsub = asyncResult.listen(() => {\n        triggerRef(state);\n    });\n\n    onUnmounted(() => {\n        unsub();\n    });\n\n    return state;\n}\n\n/**\n * Creates an AsyncResult ref from a promise returning a Result.\n * @param promise the promise returning a Result\n * @returns the ref to the AsyncResult\n */\nexport function useAsyncResultRefFromPromise<T, E extends ErrorBase = ErrorBase>(promise: Promise<Result<T, E>>) {\n    return useAsyncResultRef(AsyncResult.fromResultPromise(promise));\n}\n\n\n\n// === Vue Composables for Chains ===\n\n/**\n * Watches a source, gives it as inputs to the function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param pipe the function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveChain<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, pipe: FlatChainStep<Inputs, T, E>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const result = new AsyncResult<T, E>();\n    const resultRef = useAsyncResultRef(result);\n\n    let unsub: (() => void) | null = null;\n\n    watch(source, (newInputs) => {\n        unsub?.();\n        unsub = result.mirror(pipe(newInputs));\n    }, { immediate: options.immediate });\n\n    onUnmounted(() => {\n        unsub?.();\n    });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for Actions ===\n\n/**\n * The return type of useLazyAction.\n */\nexport interface LazyActionRef<T, E extends ErrorBase = ErrorBase> {\n    resultRef: Ref<AsyncResult<T, E>>;\n    trigger: () => void;\n}\n\n/**\n * Executes an action immediately and returns a ref to the AsyncResult representing the action's state.\n * \n * Same as useAsyncResultRefFromPromise(action()).\n * \n * @param action the action to execute immediately\n * @returns a ref to the AsyncResult representing the action's state\n */\nexport function useAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): Ref<AsyncResult<T, E>> {\n    return useAsyncResultRefFromPromise(action());\n}\n\n/**\n * Creates a lazy action that can be triggered manually.\n * \n * Same as AsyncResult.makeLazyAction(action), but the AsyncResult is wrapped in a ref for Vue reactivity.\n * \n * @param action the action to execute when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): LazyActionRef<T, E> {\n    const lazyAction = AsyncResult.makeLazyAction<T, E>(action);\n    const resultRef = useAsyncResultRef(lazyAction.result);\n\n    return { resultRef, trigger: lazyAction.trigger };\n}\n\n\n// === Vue Composables for Generators ===\n\n/**\n * Runs a generator function immediately and returns a ref to the AsyncResult representing the generator's state.\n * @param generatorFunc the generator function to run immediately\n * @returns a ref to the AsyncResult representing the generator's state\n */\nexport function useGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): Ref<AsyncResult<T, any>> {\n    const resultRef = useAsyncResultRef(AsyncResult.run(generatorFunc));\n    return resultRef;\n}\n\n/**\n * Creates a lazy generator that can be triggered manually.\n * \n * @param generatorFunc the generator function to run when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): { resultRef: Ref<AsyncResult<T, any>>, trigger: () => void } {\n    const result = new AsyncResult<T, any>();\n    const resultRef = useAsyncResultRef(result);\n\n    const trigger = () => {\n        result.runInPlace(generatorFunc);\n    }\n\n    return { resultRef, trigger };\n}\n\n/**\n * Watches a source, gives it as inputs to the generator function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param generatorFunc the generator function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveGenerator<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, generatorFunc: (args: Inputs) => AsyncResultGenerator<T>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const resultRef = useAsyncResultRef(new AsyncResult<T, E>());\n\n    watch(source, (newInputs) => {\n        resultRef.value.runInPlace(() => generatorFunc(newInputs));\n    }, { immediate: options.immediate });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for AsyncResultCollection ===\n\n/**\n * Creates a reactive AsyncResultCollection wrapped in a Vue ref.\n * The AsyncResultCollection notifies Vue's reactivity system whenever its state changes.\n * \n * @template T - The type of the values in the AsyncResultCollection.\n * @template E - The type of the error, extending ErrorBase (default is ErrorBase).\n * @returns a ref to the AsyncResultCollection\n */\nexport function useAsyncResultCollection<T = any, E extends ErrorBase = ErrorBase>() {\n    const list = new AsyncResultCollection<T, E>();\n    const listRef = ref(list);\n\n    list.listen(() => {\n        triggerRef(listRef);\n    });\n\n    return listRef;\n}","import { defineComponent, watch, h, type VNode, type SlotsType } from \"vue\"\nimport { ErrorBase, type AsyncResult } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n    idle?: () => VNode;\n}\n\n/**\n * Factory function to create a component that displays different content based on an AsyncResult's state. Provides slots for loading, error, idle, and success states and passes the relevant data to each slot, and are typed appropriately.\n * @param slots predefined slots for loading, error, and idle states. Useful for not having to repeat the same template for displaying a framework-specific spinner while in loading state, or a custom error message.\n * @param name Optional internal name for the component\n * @returns An instantiable component that accepts an AsyncResult prop and a default slot for the success state.\n * \n * @example\n * // loaders.ts - Create reusable loader with default loading/error UI\n * const MyLoader = makeAsyncResultLoader({\n *   loading: () => h(Spinner),\n *   error: ({ error }) => h(ErrorDisplay, { error }),\n *   idle: () => h('div', 'Ready')\n * });\n * \n * // MyPage.vue - Use the loader with custom success content\n * <MyLoader :result=\"myAsyncResult\">\n *   <template #default=\"{ value }\">\n *     <UserProfile :user=\"value\" />\n *   </template>\n * </MyLoader>\n */\nexport function makeAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>, name = \"AsyncResultLoader\") {\n    return defineComponent({\n        name,\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        slots: Object as SlotsType<CustomSlots<E> & { default: { value: T } }>,\n        setup(props, context) {\n            let resultRef = useAsyncResultRef(props.result);\n\n            // Watch for prop changes & update listener\n            watch(\n                () => props.result,\n                (newResult, oldResult) => {\n                    if (newResult === oldResult) return;\n                    resultRef = useAsyncResultRef(newResult);\n                },\n                { immediate: true }\n            )\n\n            return () => {\n                const s = resultRef.value.state;\n\n                const renderDefault = context.slots.default ?? (() => h(\"div\", { class: \"success\" }, \"Success\"));\n                const renderError = context.slots.error ?? slots.error ?? (() => h(\"div\", { class: \"error\" }, \"Error\"));\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => h(\"div\", { class: \"loading\" }, \"Loading…\"));\n                const renderIdle = context.slots.idle ?? slots.idle ?? (() => h(\"div\", { class: \"idle\" }, \"Idle\"));\n\n                // Choose what to render based on status\n                switch (s.status) {\n                    case \"loading\":\n                        return renderLoading();\n\n                    case \"error\":\n                        return renderError({ error: s.error });\n\n                    case \"success\":\n                        return renderDefault({ value: s.value });\n\n                    default:\n                        return renderIdle();\n                }\n            }\n        }\n    })\n}"],"mappings":"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","names":["import_vue","import_core"]}

package/dist/vue/index.mjs

@@ -1,6 +1,6 @@
 // src/vue/composables.ts
 import { onUnmounted, ref, triggerRef, watch } from "vue";
-import { AsyncResult, AsyncResultList } from "unwrapped/core";
+import { AsyncResult, AsyncResultCollection } from "unwrapped/core";
 function useAsyncResultRef(asyncResult) {
   if (!asyncResult) {
     asyncResult = new AsyncResult();
@@ -57,8 +57,8 @@ function useReactiveGenerator(source, generatorFunc, options = { immediate: true
   }, { immediate: options.immediate });
   return resultRef;
 }
-function useAsyncResultList() {
-  const list = new AsyncResultList();
+function useAsyncResultCollection() {
+  const list = new AsyncResultCollection();
   const listRef = ref(list);
   list.listen(() => {
     triggerRef(listRef);
@@ -112,7 +112,7 @@ function makeAsyncResultLoader(slots, name = "AsyncResultLoader") {
 export {
   makeAsyncResultLoader,
   useAction,
-  useAsyncResultList,
+  useAsyncResultCollection,
   useAsyncResultRef,
   useAsyncResultRefFromPromise,
   useGenerator,

package/dist/vue/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/vue/composables.ts","../../src/vue/components/asyncResultLoader.ts"],"sourcesContent":["import { onUnmounted, ref, triggerRef, watch, type Ref, type WatchSource } from \"vue\";\nimport { AsyncResult, AsyncResultList, ErrorBase, type Action, type AsyncResultGenerator, type FlatChainStep, type Result } from \"unwrapped/core\";\n\n\n// === Vue specific types ===\n\ninterface ReactiveProcessOptions {\n    immediate: boolean;\n}\n\n\n\n// === Vue Composables for AsyncResult ===\n\n/**\n * Makes a ref to the given AsyncResult. Whenever the state of the AsyncResult changes,\n * the ref gets retriggered, making those changes visible to Vue's reactivity system.\n * \n * @param asyncResult the result to make reactive\n * @returns the ref to the result\n */\nexport function useAsyncResultRef<T, E extends ErrorBase = ErrorBase>(asyncResult?: AsyncResult<T, E>) {\n    if (!asyncResult) {\n        asyncResult = new AsyncResult<T, E>();\n    }\n    const state = ref<AsyncResult<T, E>>(asyncResult) as Ref<AsyncResult<T, E>>;\n\n    const unsub = asyncResult.listen(() => {\n        triggerRef(state);\n    });\n\n    onUnmounted(() => {\n        unsub();\n    });\n\n    return state;\n}\n\n/**\n * Creates an AsyncResult ref from a promise returning a Result.\n * @param promise the promise returning a Result\n * @returns the ref to the AsyncResult\n */\nexport function useAsyncResultRefFromPromise<T, E extends ErrorBase = ErrorBase>(promise: Promise<Result<T, E>>) {\n    return useAsyncResultRef(AsyncResult.fromResultPromise(promise));\n}\n\n\n\n// === Vue Composables for Chains ===\n\n/**\n * Watches a source, gives it as inputs to the function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param pipe the function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveChain<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, pipe: FlatChainStep<Inputs, T, E>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const result = new AsyncResult<T, E>();\n    const resultRef = useAsyncResultRef(result);\n\n    let unsub: (() => void) | null = null;\n\n    watch(source, (newInputs) => {\n        unsub?.();\n        unsub = result.mirror(pipe(newInputs));\n    }, { immediate: options.immediate });\n\n    onUnmounted(() => {\n        unsub?.();\n    });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for Actions ===\n\n/**\n * The return type of useLazyAction.\n */\nexport interface LazyActionRef<T, E extends ErrorBase = ErrorBase> {\n    resultRef: Ref<AsyncResult<T, E>>;\n    trigger: () => void;\n}\n\n/**\n * Executes an action immediately and returns a ref to the AsyncResult representing the action's state.\n * \n * Same as useAsyncResultRefFromPromise(action()).\n * \n * @param action the action to execute immediately\n * @returns a ref to the AsyncResult representing the action's state\n */\nexport function useAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): Ref<AsyncResult<T, E>> {\n    return useAsyncResultRefFromPromise(action());\n}\n\n/**\n * Creates a lazy action that can be triggered manually.\n * \n * Same as AsyncResult.makeLazyAction(action), but the AsyncResult is wrapped in a ref for Vue reactivity.\n * \n * @param action the action to execute when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): LazyActionRef<T, E> {\n    const lazyAction = AsyncResult.makeLazyAction<T, E>(action);\n    const resultRef = useAsyncResultRef(lazyAction.result);\n\n    return { resultRef, trigger: lazyAction.trigger };\n}\n\n\n// === Vue Composables for Generators ===\n\n/**\n * Runs a generator function immediately and returns a ref to the AsyncResult representing the generator's state.\n * @param generatorFunc the generator function to run immediately\n * @returns a ref to the AsyncResult representing the generator's state\n */\nexport function useGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): Ref<AsyncResult<T, any>> {\n    const resultRef = useAsyncResultRef(AsyncResult.run(generatorFunc));\n    return resultRef;\n}\n\n/**\n * Creates a lazy generator that can be triggered manually.\n * \n * @param generatorFunc the generator function to run when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): { resultRef: Ref<AsyncResult<T, any>>, trigger: () => void } {\n    const result = new AsyncResult<T, any>();\n    const resultRef = useAsyncResultRef(result);\n\n    const trigger = () => {\n        result.runInPlace(generatorFunc);\n    }\n\n    return { resultRef, trigger };\n}\n\n/**\n * Watches a source, gives it as inputs to the generator function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param generatorFunc the generator function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveGenerator<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, generatorFunc: (args: Inputs) => AsyncResultGenerator<T>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const resultRef = useAsyncResultRef(new AsyncResult<T, E>());\n\n    watch(source, (newInputs) => {\n        resultRef.value.runInPlace(() => generatorFunc(newInputs));\n    }, { immediate: options.immediate });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for AsyncResultList ===\n\n/**\n * Creates a reactive AsyncResultList wrapped in a Vue ref.\n * The AsyncResultList notifies Vue's reactivity system whenever its state changes.\n * \n * @template T - The type of the values in the AsyncResultList.\n * @template E - The type of the error, extending ErrorBase (default is ErrorBase).\n * @returns a ref to the AsyncResultList\n */\nexport function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>() {\n    const list = new AsyncResultList<T, E>();\n    const listRef = ref(list);\n\n    list.listen(() => {\n        triggerRef(listRef);\n    });\n\n    return listRef;\n}","import { defineComponent, watch, h, type VNode, type SlotsType } from \"vue\"\nimport { ErrorBase, type AsyncResult } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n    idle?: () => VNode;\n}\n\n/**\n * Factory function to create a component that displays different content based on an AsyncResult's state. Provides slots for loading, error, idle, and success states and passes the relevant data to each slot, and are typed appropriately.\n * @param slots predefined slots for loading, error, and idle states. Useful for not having to repeat the same template for displaying a framework-specific spinner while in loading state, or a custom error message.\n * @param name Optional internal name for the component\n * @returns An instantiable component that accepts an AsyncResult prop and a default slot for the success state.\n * \n * @example\n * // loaders.ts - Create reusable loader with default loading/error UI\n * const MyLoader = makeAsyncResultLoader({\n *   loading: () => h(Spinner),\n *   error: ({ error }) => h(ErrorDisplay, { error }),\n *   idle: () => h('div', 'Ready')\n * });\n * \n * // MyPage.vue - Use the loader with custom success content\n * <MyLoader :result=\"myAsyncResult\">\n *   <template #default=\"{ value }\">\n *     <UserProfile :user=\"value\" />\n *   </template>\n * </MyLoader>\n */\nexport function makeAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>, name = \"AsyncResultLoader\") {\n    return defineComponent({\n        name,\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        slots: Object as SlotsType<CustomSlots<E> & { default: { value: T } }>,\n        setup(props, context) {\n            let resultRef = useAsyncResultRef(props.result);\n\n            // Watch for prop changes & update listener\n            watch(\n                () => props.result,\n                (newResult, oldResult) => {\n                    if (newResult === oldResult) return;\n                    resultRef = useAsyncResultRef(newResult);\n                },\n                { immediate: true }\n            )\n\n            return () => {\n                const s = resultRef.value.state;\n\n                const renderDefault = context.slots.default ?? (() => h(\"div\", { class: \"success\" }, \"Success\"));\n                const renderError = context.slots.error ?? slots.error ?? (() => h(\"div\", { class: \"error\" }, \"Error\"));\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => h(\"div\", { class: \"loading\" }, \"Loading…\"));\n                const renderIdle = context.slots.idle ?? slots.idle ?? (() => h(\"div\", { class: \"idle\" }, \"Idle\"));\n\n                // Choose what to render based on status\n                switch (s.status) {\n                    case \"loading\":\n                        return renderLoading();\n\n                    case \"error\":\n                        return renderError({ error: s.error });\n\n                    case \"success\":\n                        return renderDefault({ value: s.value });\n\n                    default:\n                        return renderIdle();\n                }\n            }\n        }\n    })\n}"],"mappings":"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","names":["watch","watch"]}
+{"version":3,"sources":["../../src/vue/composables.ts","../../src/vue/components/asyncResultLoader.ts"],"sourcesContent":["import { onUnmounted, ref, triggerRef, watch, type Ref, type WatchSource } from \"vue\";\nimport { AsyncResult, AsyncResultCollection, ErrorBase, type Action, type AsyncResultGenerator, type FlatChainStep, type Result } from \"unwrapped/core\";\n\n\n// === Vue specific types ===\n\ninterface ReactiveProcessOptions {\n    immediate: boolean;\n}\n\n\n\n// === Vue Composables for AsyncResult ===\n\n/**\n * Makes a ref to the given AsyncResult. Whenever the state of the AsyncResult changes,\n * the ref gets retriggered, making those changes visible to Vue's reactivity system.\n * \n * @param asyncResult the result to make reactive\n * @returns the ref to the result\n */\nexport function useAsyncResultRef<T, E extends ErrorBase = ErrorBase>(asyncResult?: AsyncResult<T, E>) {\n    if (!asyncResult) {\n        asyncResult = new AsyncResult<T, E>();\n    }\n    const state = ref<AsyncResult<T, E>>(asyncResult) as Ref<AsyncResult<T, E>>;\n\n    const unsub = asyncResult.listen(() => {\n        triggerRef(state);\n    });\n\n    onUnmounted(() => {\n        unsub();\n    });\n\n    return state;\n}\n\n/**\n * Creates an AsyncResult ref from a promise returning a Result.\n * @param promise the promise returning a Result\n * @returns the ref to the AsyncResult\n */\nexport function useAsyncResultRefFromPromise<T, E extends ErrorBase = ErrorBase>(promise: Promise<Result<T, E>>) {\n    return useAsyncResultRef(AsyncResult.fromResultPromise(promise));\n}\n\n\n\n// === Vue Composables for Chains ===\n\n/**\n * Watches a source, gives it as inputs to the function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param pipe the function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveChain<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, pipe: FlatChainStep<Inputs, T, E>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const result = new AsyncResult<T, E>();\n    const resultRef = useAsyncResultRef(result);\n\n    let unsub: (() => void) | null = null;\n\n    watch(source, (newInputs) => {\n        unsub?.();\n        unsub = result.mirror(pipe(newInputs));\n    }, { immediate: options.immediate });\n\n    onUnmounted(() => {\n        unsub?.();\n    });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for Actions ===\n\n/**\n * The return type of useLazyAction.\n */\nexport interface LazyActionRef<T, E extends ErrorBase = ErrorBase> {\n    resultRef: Ref<AsyncResult<T, E>>;\n    trigger: () => void;\n}\n\n/**\n * Executes an action immediately and returns a ref to the AsyncResult representing the action's state.\n * \n * Same as useAsyncResultRefFromPromise(action()).\n * \n * @param action the action to execute immediately\n * @returns a ref to the AsyncResult representing the action's state\n */\nexport function useAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): Ref<AsyncResult<T, E>> {\n    return useAsyncResultRefFromPromise(action());\n}\n\n/**\n * Creates a lazy action that can be triggered manually.\n * \n * Same as AsyncResult.makeLazyAction(action), but the AsyncResult is wrapped in a ref for Vue reactivity.\n * \n * @param action the action to execute when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): LazyActionRef<T, E> {\n    const lazyAction = AsyncResult.makeLazyAction<T, E>(action);\n    const resultRef = useAsyncResultRef(lazyAction.result);\n\n    return { resultRef, trigger: lazyAction.trigger };\n}\n\n\n// === Vue Composables for Generators ===\n\n/**\n * Runs a generator function immediately and returns a ref to the AsyncResult representing the generator's state.\n * @param generatorFunc the generator function to run immediately\n * @returns a ref to the AsyncResult representing the generator's state\n */\nexport function useGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): Ref<AsyncResult<T, any>> {\n    const resultRef = useAsyncResultRef(AsyncResult.run(generatorFunc));\n    return resultRef;\n}\n\n/**\n * Creates a lazy generator that can be triggered manually.\n * \n * @param generatorFunc the generator function to run when triggered\n * @returns an object containing a ref to the AsyncResult and a trigger function\n */\nexport function useLazyGenerator<T>(generatorFunc: () => AsyncResultGenerator<T>): { resultRef: Ref<AsyncResult<T, any>>, trigger: () => void } {\n    const result = new AsyncResult<T, any>();\n    const resultRef = useAsyncResultRef(result);\n\n    const trigger = () => {\n        result.runInPlace(generatorFunc);\n    }\n\n    return { resultRef, trigger };\n}\n\n/**\n * Watches a source, gives it as inputs to the generator function provided, and updates the result contained in the ref accordingly.\n * \n * @param source the inputs to react to\n * @param generatorFunc the generator function to run when the inputs change\n * @param options optional settings\n * @returns ref to the result\n */\nexport function useReactiveGenerator<Inputs, T, E extends ErrorBase = ErrorBase>(source: WatchSource<Inputs>, generatorFunc: (args: Inputs) => AsyncResultGenerator<T>, options: ReactiveProcessOptions = { immediate: true }): Ref<AsyncResult<T, E>> {\n    const resultRef = useAsyncResultRef(new AsyncResult<T, E>());\n\n    watch(source, (newInputs) => {\n        resultRef.value.runInPlace(() => generatorFunc(newInputs));\n    }, { immediate: options.immediate });\n\n    return resultRef;\n}\n\n\n// === Vue Composables for AsyncResultCollection ===\n\n/**\n * Creates a reactive AsyncResultCollection wrapped in a Vue ref.\n * The AsyncResultCollection notifies Vue's reactivity system whenever its state changes.\n * \n * @template T - The type of the values in the AsyncResultCollection.\n * @template E - The type of the error, extending ErrorBase (default is ErrorBase).\n * @returns a ref to the AsyncResultCollection\n */\nexport function useAsyncResultCollection<T = any, E extends ErrorBase = ErrorBase>() {\n    const list = new AsyncResultCollection<T, E>();\n    const listRef = ref(list);\n\n    list.listen(() => {\n        triggerRef(listRef);\n    });\n\n    return listRef;\n}","import { defineComponent, watch, h, type VNode, type SlotsType } from \"vue\"\nimport { ErrorBase, type AsyncResult } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n    idle?: () => VNode;\n}\n\n/**\n * Factory function to create a component that displays different content based on an AsyncResult's state. Provides slots for loading, error, idle, and success states and passes the relevant data to each slot, and are typed appropriately.\n * @param slots predefined slots for loading, error, and idle states. Useful for not having to repeat the same template for displaying a framework-specific spinner while in loading state, or a custom error message.\n * @param name Optional internal name for the component\n * @returns An instantiable component that accepts an AsyncResult prop and a default slot for the success state.\n * \n * @example\n * // loaders.ts - Create reusable loader with default loading/error UI\n * const MyLoader = makeAsyncResultLoader({\n *   loading: () => h(Spinner),\n *   error: ({ error }) => h(ErrorDisplay, { error }),\n *   idle: () => h('div', 'Ready')\n * });\n * \n * // MyPage.vue - Use the loader with custom success content\n * <MyLoader :result=\"myAsyncResult\">\n *   <template #default=\"{ value }\">\n *     <UserProfile :user=\"value\" />\n *   </template>\n * </MyLoader>\n */\nexport function makeAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>, name = \"AsyncResultLoader\") {\n    return defineComponent({\n        name,\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        slots: Object as SlotsType<CustomSlots<E> & { default: { value: T } }>,\n        setup(props, context) {\n            let resultRef = useAsyncResultRef(props.result);\n\n            // Watch for prop changes & update listener\n            watch(\n                () => props.result,\n                (newResult, oldResult) => {\n                    if (newResult === oldResult) return;\n                    resultRef = useAsyncResultRef(newResult);\n                },\n                { immediate: true }\n            )\n\n            return () => {\n                const s = resultRef.value.state;\n\n                const renderDefault = context.slots.default ?? (() => h(\"div\", { class: \"success\" }, \"Success\"));\n                const renderError = context.slots.error ?? slots.error ?? (() => h(\"div\", { class: \"error\" }, \"Error\"));\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => h(\"div\", { class: \"loading\" }, \"Loading…\"));\n                const renderIdle = context.slots.idle ?? slots.idle ?? (() => h(\"div\", { class: \"idle\" }, \"Idle\"));\n\n                // Choose what to render based on status\n                switch (s.status) {\n                    case \"loading\":\n                        return renderLoading();\n\n                    case \"error\":\n                        return renderError({ error: s.error });\n\n                    case \"success\":\n                        return renderDefault({ value: s.value });\n\n                    default:\n                        return renderIdle();\n                }\n            }\n        }\n    })\n}"],"mappings":"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","names":["watch","watch"]}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "unwrapped",
-    "version": "0.1.7",
+    "version": "0.1.9",
     "publishConfig": {
         "access": "public"
     },