unwrapped 0.1.5 → 0.1.6

package/dist/vue/index.d.ts

@@ -1,6 +1,7 @@
+import * as unwrapped_core from 'unwrapped/core';
+import { ErrorBase, AsyncResult, Result, FlatChainStep, Action, AsyncResultGenerator, AsyncResultList } from 'unwrapped/core';
 import * as vue from 'vue';
 import { Ref, WatchSource, VNode } from 'vue';
-import { ErrorBase, AsyncResult, Result, FlatChainStep, Action, AsyncResultGenerator } from 'unwrapped/core';
 
 interface ReactiveProcessOptions {
     immediate: boolean;
@@ -12,7 +13,7 @@ interface ReactiveProcessOptions {
  * @param asyncResult the result to make reactive
  * @returns the ref to the result
  */
-declare function useAsyncResultRef<T, E extends ErrorBase = ErrorBase>(asyncResult: AsyncResult<T, E>): Ref<AsyncResult<T, E>, AsyncResult<T, E>>;
+declare function useAsyncResultRef<T, E extends ErrorBase = ErrorBase>(asyncResult?: AsyncResult<T, E>): Ref<AsyncResult<T, E>, AsyncResult<T, E>>;
 /**
  * Creates an AsyncResult ref from a promise returning a Result.
  * @param promise the promise returning a Result
@@ -78,6 +79,223 @@ declare function useLazyGenerator<T>(generatorFunc: () => AsyncResultGenerator<T
  * @returns ref to the result
  */
 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.
+ *
+ * @template T - The type of the values in the AsyncResultList.
+ * @template E - The type of the error, extending ErrorBase (default is ErrorBase).
+ * @returns a ref to the AsyncResultList
+ */
+declare function useAsyncResultList<T = any, E extends ErrorBase = ErrorBase>(): Ref<{
+    readonly tasks: Map<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;
+        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>;
+    }> & Omit<Map<string, AsyncResult<T, E>>, keyof Map<any, any>>;
+    readonly length: number;
+    readonly items: {
+        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;
+        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.AsyncResultListState;
+    listen: (listener: (taskQueue: AsyncResultList<T, E>) => void) => () => void;
+    add: (key: string, task: AsyncResult<T, E>, removeOnSettle?: boolean) => AsyncResult<T, E>;
+    anyLoading: () => boolean;
+    getAllFiltered: (predicate: (task: AsyncResult<T, E>) => boolean) => AsyncResult<T, E>[];
+    getAllFilteredAndMap: <U>(filterPredicate: (task: AsyncResult<T, E>) => boolean, mapFunc: (task: AsyncResult<T, E>) => U) => U[];
+    getAllSuccess: () => AsyncResult<T, E>[];
+    getAllSuccessValues: () => T[];
+    getAllErrors: () => AsyncResult<T, E>[];
+    getAllErrorValues: () => E[];
+    getAllLoading: () => AsyncResult<T, E>[];
+    getAllLoadingPromises: () => Promise<Result<T, E>>[];
+    log: (name?: string) => void;
+    debug: (name?: string) => () => void;
+}, AsyncResultList<T, E> | {
+    readonly tasks: Map<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;
+        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>;
+    }> & Omit<Map<string, AsyncResult<T, E>>, keyof Map<any, any>>;
+    readonly length: number;
+    readonly items: {
+        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;
+        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.AsyncResultListState;
+    listen: (listener: (taskQueue: AsyncResultList<T, E>) => void) => () => void;
+    add: (key: string, task: AsyncResult<T, E>, removeOnSettle?: boolean) => AsyncResult<T, E>;
+    anyLoading: () => boolean;
+    getAllFiltered: (predicate: (task: AsyncResult<T, E>) => boolean) => AsyncResult<T, E>[];
+    getAllFilteredAndMap: <U>(filterPredicate: (task: AsyncResult<T, E>) => boolean, mapFunc: (task: AsyncResult<T, E>) => U) => U[];
+    getAllSuccess: () => AsyncResult<T, E>[];
+    getAllSuccessValues: () => T[];
+    getAllErrors: () => AsyncResult<T, E>[];
+    getAllErrorValues: () => E[];
+    getAllLoading: () => AsyncResult<T, E>[];
+    getAllLoadingPromises: () => Promise<Result<T, E>>[];
+    log: (name?: string) => void;
+    debug: (name?: string) => () => void;
+}>;
 
 /**
  * A Vue component that displays different content based on the state of an AsyncResult.
@@ -142,4 +360,4 @@ declare function buildCustomAsyncResultLoader<T, E extends ErrorBase = ErrorBase
     };
 }>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-export { AsyncResultLoader, type LazyActionRef, buildCustomAsyncResultLoader, useAction, useAsyncResultRef, useAsyncResultRefFromPromise, useGenerator, useLazyAction, useLazyGenerator, useReactiveChain, useReactiveGenerator };
+export { AsyncResultLoader, type LazyActionRef, buildCustomAsyncResultLoader, useAction, useAsyncResultList, useAsyncResultRef, useAsyncResultRefFromPromise, useGenerator, useLazyAction, useLazyGenerator, useReactiveChain, useReactiveGenerator };

package/dist/vue/index.js

@@ -23,6 +23,7 @@ __export(index_exports, {
   AsyncResultLoader: () => AsyncResultLoader,
   buildCustomAsyncResultLoader: () => buildCustomAsyncResultLoader,
   useAction: () => useAction,
+  useAsyncResultList: () => useAsyncResultList,
   useAsyncResultRef: () => useAsyncResultRef,
   useAsyncResultRefFromPromise: () => useAsyncResultRefFromPromise,
   useGenerator: () => useGenerator,
@@ -37,6 +38,9 @@ module.exports = __toCommonJS(index_exports);
 var import_vue = require("vue");
 var import_core = require("unwrapped/core");
 function useAsyncResultRef(asyncResult) {
+  if (!asyncResult) {
+    asyncResult = new import_core.AsyncResult();
+  }
   const state = (0, import_vue.ref)(asyncResult);
   const unsub = asyncResult.listen(() => {
     (0, import_vue.triggerRef)(state);
@@ -89,6 +93,14 @@ function useReactiveGenerator(source, generatorFunc, options = { immediate: true
   }, { immediate: options.immediate });
   return resultRef;
 }
+function useAsyncResultList() {
+  const list = new import_core.AsyncResultList();
+  const listRef = (0, import_vue.ref)(list);
+  list.listen(() => {
+    (0, import_vue.triggerRef)(listRef);
+  });
+  return listRef;
+}
 
 // src/vue/components/asyncResultLoader.ts
 var import_vue2 = require("vue");

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, 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    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}","import { defineComponent, watch, h, type VNode } from \"vue\"\nimport type { AsyncResult, ErrorBase } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\n/**\n * A Vue component that displays different content based on the state of an AsyncResult.\n * It supports slots for 'loading', 'error', 'success' (default), and 'idle' states.\n * \n * @example\n * <AsyncResultLoader :result=\"myAsyncResult\">\n *   <template #loading>\n *     <div>Loading data...</div>\n *   </template>\n *   <template #error=\"{ error }\">\n *     <div>Error occurred: {{ error.message }}</div>\n *   </template>\n *   <template #default=\"{ value }\">\n *     <div>Data loaded: {{ value }}</div>\n *   </template>\n *   <template #idle>\n *     <div>Waiting to start...</div>\n *   </template>\n * </AsyncResultLoader>\n */\nexport const AsyncResultLoader = defineComponent({\n    name: \"AsyncResultLoader\",\n\n    props: {\n        result: {\n            type: Object as () => AsyncResult<unknown>,\n            required: true\n        }\n    },\n\n    setup(props, { slots }) {\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            // Choose what to render based on status\n            switch (s.status) {\n                case \"loading\":\n                    return slots.loading\n                        ? slots.loading()\n                        : h(\"div\", { class: \"loading\" }, \"Loading…\");\n\n                case \"error\":\n                    return slots.error\n                        ? slots.error({ error: s.error })\n                        : h(\"div\", { class: \"error\" }, `Error: ${s.error}`);\n\n                case \"success\":\n                    return slots.default\n                        ? slots.default({ value: s.value })\n                        : null;\n\n                default:\n                    // \"idle\"\n                    return slots.idle\n                        ? slots.idle()\n                        : h(\"div\", { class: \"idle\" }, \"Idle\");\n            }\n        }\n    }\n})\n\n\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n}\n\n/**\n * Builds a custom AsyncResultLoader component with predefined slots for loading and error states.\n * \n * Useful for creating reusable components with consistent loading and error handling UI (eg. framework-specific spinners, etc...).\n * \n * @param slots the custom slots for loading and error states\n * @returns a Vue component that uses the provided slots\n */\nexport function buildCustomAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>) {\n    const comp = defineComponent({\n        name: \"CustomAsyncResultLoader\",\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        setup(props, context) {\n            return () => {\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => undefined);\n                const renderError = context.slots.error ?? slots.error ?? (() => undefined);\n                return h(\n                    AsyncResultLoader,\n                    { result: props.result },\n                    {\n                        default: context.slots.default ? (propsDefault: { value: T }) => context.slots.default!(propsDefault) : undefined,\n\n                        loading: () => renderLoading(),\n                        error: ((propsError: { error: E }) => renderError(propsError))\n                    }\n                )\n            }\n        }\n    });\n\n    return comp;\n}\n"],"mappings":"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","names":["import_vue"]}
+{"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 } from \"vue\"\nimport type { AsyncResult, ErrorBase } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\n/**\n * A Vue component that displays different content based on the state of an AsyncResult.\n * It supports slots for 'loading', 'error', 'success' (default), and 'idle' states.\n * \n * @example\n * <AsyncResultLoader :result=\"myAsyncResult\">\n *   <template #loading>\n *     <div>Loading data...</div>\n *   </template>\n *   <template #error=\"{ error }\">\n *     <div>Error occurred: {{ error.message }}</div>\n *   </template>\n *   <template #default=\"{ value }\">\n *     <div>Data loaded: {{ value }}</div>\n *   </template>\n *   <template #idle>\n *     <div>Waiting to start...</div>\n *   </template>\n * </AsyncResultLoader>\n */\nexport const AsyncResultLoader = defineComponent({\n    name: \"AsyncResultLoader\",\n\n    props: {\n        result: {\n            type: Object as () => AsyncResult<unknown>,\n            required: true\n        }\n    },\n\n    setup(props, { slots }) {\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            // Choose what to render based on status\n            switch (s.status) {\n                case \"loading\":\n                    return slots.loading\n                        ? slots.loading()\n                        : h(\"div\", { class: \"loading\" }, \"Loading…\");\n\n                case \"error\":\n                    return slots.error\n                        ? slots.error({ error: s.error })\n                        : h(\"div\", { class: \"error\" }, `Error: ${s.error}`);\n\n                case \"success\":\n                    return slots.default\n                        ? slots.default({ value: s.value })\n                        : null;\n\n                default:\n                    // \"idle\"\n                    return slots.idle\n                        ? slots.idle()\n                        : h(\"div\", { class: \"idle\" }, \"Idle\");\n            }\n        }\n    }\n})\n\n\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n}\n\n/**\n * Builds a custom AsyncResultLoader component with predefined slots for loading and error states.\n * \n * Useful for creating reusable components with consistent loading and error handling UI (eg. framework-specific spinners, etc...).\n * \n * @param slots the custom slots for loading and error states\n * @returns a Vue component that uses the provided slots\n */\nexport function buildCustomAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>) {\n    const comp = defineComponent({\n        name: \"CustomAsyncResultLoader\",\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        setup(props, context) {\n            return () => {\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => undefined);\n                const renderError = context.slots.error ?? slots.error ?? (() => undefined);\n                return h(\n                    AsyncResultLoader,\n                    { result: props.result },\n                    {\n                        default: context.slots.default ? (propsDefault: { value: T }) => context.slots.default!(propsDefault) : undefined,\n\n                        loading: () => renderLoading(),\n                        error: ((propsError: { error: E }) => renderError(propsError))\n                    }\n                )\n            }\n        }\n    });\n\n    return comp;\n}\n"],"mappings":"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","names":["import_vue"]}

package/dist/vue/index.mjs

@@ -1,7 +1,10 @@
 // src/vue/composables.ts
 import { onUnmounted, ref, triggerRef, watch } from "vue";
-import { AsyncResult } from "unwrapped/core";
+import { AsyncResult, AsyncResultList } from "unwrapped/core";
 function useAsyncResultRef(asyncResult) {
+  if (!asyncResult) {
+    asyncResult = new AsyncResult();
+  }
   const state = ref(asyncResult);
   const unsub = asyncResult.listen(() => {
     triggerRef(state);
@@ -54,6 +57,14 @@ function useReactiveGenerator(source, generatorFunc, options = { immediate: true
   }, { immediate: options.immediate });
   return resultRef;
 }
+function useAsyncResultList() {
+  const list = new AsyncResultList();
+  const listRef = ref(list);
+  list.listen(() => {
+    triggerRef(listRef);
+  });
+  return listRef;
+}
 
 // src/vue/components/asyncResultLoader.ts
 import { defineComponent, watch as watch2, h } from "vue";
@@ -121,6 +132,7 @@ export {
   AsyncResultLoader,
   buildCustomAsyncResultLoader,
   useAction,
+  useAsyncResultList,
   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, 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    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}","import { defineComponent, watch, h, type VNode } from \"vue\"\nimport type { AsyncResult, ErrorBase } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\n/**\n * A Vue component that displays different content based on the state of an AsyncResult.\n * It supports slots for 'loading', 'error', 'success' (default), and 'idle' states.\n * \n * @example\n * <AsyncResultLoader :result=\"myAsyncResult\">\n *   <template #loading>\n *     <div>Loading data...</div>\n *   </template>\n *   <template #error=\"{ error }\">\n *     <div>Error occurred: {{ error.message }}</div>\n *   </template>\n *   <template #default=\"{ value }\">\n *     <div>Data loaded: {{ value }}</div>\n *   </template>\n *   <template #idle>\n *     <div>Waiting to start...</div>\n *   </template>\n * </AsyncResultLoader>\n */\nexport const AsyncResultLoader = defineComponent({\n    name: \"AsyncResultLoader\",\n\n    props: {\n        result: {\n            type: Object as () => AsyncResult<unknown>,\n            required: true\n        }\n    },\n\n    setup(props, { slots }) {\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            // Choose what to render based on status\n            switch (s.status) {\n                case \"loading\":\n                    return slots.loading\n                        ? slots.loading()\n                        : h(\"div\", { class: \"loading\" }, \"Loading…\");\n\n                case \"error\":\n                    return slots.error\n                        ? slots.error({ error: s.error })\n                        : h(\"div\", { class: \"error\" }, `Error: ${s.error}`);\n\n                case \"success\":\n                    return slots.default\n                        ? slots.default({ value: s.value })\n                        : null;\n\n                default:\n                    // \"idle\"\n                    return slots.idle\n                        ? slots.idle()\n                        : h(\"div\", { class: \"idle\" }, \"Idle\");\n            }\n        }\n    }\n})\n\n\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n}\n\n/**\n * Builds a custom AsyncResultLoader component with predefined slots for loading and error states.\n * \n * Useful for creating reusable components with consistent loading and error handling UI (eg. framework-specific spinners, etc...).\n * \n * @param slots the custom slots for loading and error states\n * @returns a Vue component that uses the provided slots\n */\nexport function buildCustomAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>) {\n    const comp = defineComponent({\n        name: \"CustomAsyncResultLoader\",\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        setup(props, context) {\n            return () => {\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => undefined);\n                const renderError = context.slots.error ?? slots.error ?? (() => undefined);\n                return h(\n                    AsyncResultLoader,\n                    { result: props.result },\n                    {\n                        default: context.slots.default ? (propsDefault: { value: T }) => context.slots.default!(propsDefault) : undefined,\n\n                        loading: () => renderLoading(),\n                        error: ((propsError: { error: E }) => renderError(propsError))\n                    }\n                )\n            }\n        }\n    });\n\n    return comp;\n}\n"],"mappings":";AAAA,SAAS,aAAa,KAAK,YAAY,aAAyC;AAChF,SAAS,mBAAuG;AAoBzG,SAAS,kBAAsD,aAAgC;AAClG,QAAM,QAAQ,IAAuB,WAAW;AAEhD,QAAM,QAAQ,YAAY,OAAO,MAAM;AACnC,eAAW,KAAK;AAAA,EACpB,CAAC;AAED,cAAY,MAAM;AACd,UAAM;AAAA,EACV,CAAC;AAED,SAAO;AACX;AAOO,SAAS,6BAAiE,SAAgC;AAC7G,SAAO,kBAAkB,YAAY,kBAAkB,OAAO,CAAC;AACnE;AAcO,SAAS,iBAA6D,QAA6B,MAAmC,UAAkC,EAAE,WAAW,KAAK,GAA2B;AACxN,QAAM,SAAS,IAAI,YAAkB;AACrC,QAAM,YAAY,kBAAkB,MAAM;AAE1C,MAAI,QAA6B;AAEjC,QAAM,QAAQ,CAAC,cAAc;AACzB,YAAQ;AACR,YAAQ,OAAO,OAAO,KAAK,SAAS,CAAC;AAAA,EACzC,GAAG,EAAE,WAAW,QAAQ,UAAU,CAAC;AAEnC,cAAY,MAAM;AACd,YAAQ;AAAA,EACZ,CAAC;AAED,SAAO;AACX;AAqBO,SAAS,UAA8C,QAA8C;AACxG,SAAO,6BAA6B,OAAO,CAAC;AAChD;AAUO,SAAS,cAAkD,QAA2C;AACzG,QAAM,aAAa,YAAY,eAAqB,MAAM;AAC1D,QAAM,YAAY,kBAAkB,WAAW,MAAM;AAErD,SAAO,EAAE,WAAW,SAAS,WAAW,QAAQ;AACpD;AAUO,SAAS,aAAgB,eAAwE;AACpG,QAAM,YAAY,kBAAkB,YAAY,IAAI,aAAa,CAAC;AAClE,SAAO;AACX;AAQO,SAAS,iBAAoB,eAA4G;AAC5I,QAAM,SAAS,IAAI,YAAoB;AACvC,QAAM,YAAY,kBAAkB,MAAM;AAE1C,QAAM,UAAU,MAAM;AAClB,WAAO,WAAW,aAAa;AAAA,EACnC;AAEA,SAAO,EAAE,WAAW,QAAQ;AAChC;AAUO,SAAS,qBAAiE,QAA6B,eAA0D,UAAkC,EAAE,WAAW,KAAK,GAA2B;AACnP,QAAM,YAAY,kBAAkB,IAAI,YAAkB,CAAC;AAE3D,QAAM,QAAQ,CAAC,cAAc;AACzB,cAAU,MAAM,WAAW,MAAM,cAAc,SAAS,CAAC;AAAA,EAC7D,GAAG,EAAE,WAAW,QAAQ,UAAU,CAAC;AAEnC,SAAO;AACX;;;AC9JA,SAAS,iBAAiB,SAAAA,QAAO,SAAqB;AAwB/C,IAAM,oBAAoB,gBAAgB;AAAA,EAC7C,MAAM;AAAA,EAEN,OAAO;AAAA,IACH,QAAQ;AAAA,MACJ,MAAM;AAAA,MACN,UAAU;AAAA,IACd;AAAA,EACJ;AAAA,EAEA,MAAM,OAAO,EAAE,MAAM,GAAG;AACpB,QAAI,YAAY,kBAAkB,MAAM,MAAM;AAG9C,IAAAC;AAAA,MACI,MAAM,MAAM;AAAA,MACZ,CAAC,WAAW,cAAc;AACtB,YAAI,cAAc,UAAW;AAC7B,oBAAY,kBAAkB,SAAS;AAAA,MAC3C;AAAA,MACA,EAAE,WAAW,KAAK;AAAA,IACtB;AAEA,WAAO,MAAM;AACT,YAAM,IAAI,UAAU,MAAM;AAG1B,cAAQ,EAAE,QAAQ;AAAA,QACd,KAAK;AACD,iBAAO,MAAM,UACP,MAAM,QAAQ,IACd,EAAE,OAAO,EAAE,OAAO,UAAU,GAAG,eAAU;AAAA,QAEnD,KAAK;AACD,iBAAO,MAAM,QACP,MAAM,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,IAC9B,EAAE,OAAO,EAAE,OAAO,QAAQ,GAAG,UAAU,EAAE,KAAK,EAAE;AAAA,QAE1D,KAAK;AACD,iBAAO,MAAM,UACP,MAAM,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,IAChC;AAAA,QAEV;AAEI,iBAAO,MAAM,OACP,MAAM,KAAK,IACX,EAAE,OAAO,EAAE,OAAO,OAAO,GAAG,MAAM;AAAA,MAChD;AAAA,IACJ;AAAA,EACJ;AACJ,CAAC;AAiBM,SAAS,6BAAiE,OAAuB;AACpG,QAAM,OAAO,gBAAgB;AAAA,IACzB,MAAM;AAAA,IACN,OAAO;AAAA,MACH,QAAQ;AAAA,QACJ,MAAM;AAAA,QACN,UAAU;AAAA,MACd;AAAA,IACJ;AAAA,IACA,MAAM,OAAO,SAAS;AAClB,aAAO,MAAM;AACT,cAAM,gBAAgB,QAAQ,MAAM,WAAW,MAAM,YAAY,MAAM;AACvE,cAAM,cAAc,QAAQ,MAAM,SAAS,MAAM,UAAU,MAAM;AACjE,eAAO;AAAA,UACH;AAAA,UACA,EAAE,QAAQ,MAAM,OAAO;AAAA,UACvB;AAAA,YACI,SAAS,QAAQ,MAAM,UAAU,CAAC,iBAA+B,QAAQ,MAAM,QAAS,YAAY,IAAI;AAAA,YAExG,SAAS,MAAM,cAAc;AAAA,YAC7B,QAAQ,CAAC,eAA6B,YAAY,UAAU;AAAA,UAChE;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ,CAAC;AAED,SAAO;AACX;","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, 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 } from \"vue\"\nimport type { AsyncResult, ErrorBase } from \"unwrapped/core\"\nimport { useAsyncResultRef } from \"../composables\"\n\n/**\n * A Vue component that displays different content based on the state of an AsyncResult.\n * It supports slots for 'loading', 'error', 'success' (default), and 'idle' states.\n * \n * @example\n * <AsyncResultLoader :result=\"myAsyncResult\">\n *   <template #loading>\n *     <div>Loading data...</div>\n *   </template>\n *   <template #error=\"{ error }\">\n *     <div>Error occurred: {{ error.message }}</div>\n *   </template>\n *   <template #default=\"{ value }\">\n *     <div>Data loaded: {{ value }}</div>\n *   </template>\n *   <template #idle>\n *     <div>Waiting to start...</div>\n *   </template>\n * </AsyncResultLoader>\n */\nexport const AsyncResultLoader = defineComponent({\n    name: \"AsyncResultLoader\",\n\n    props: {\n        result: {\n            type: Object as () => AsyncResult<unknown>,\n            required: true\n        }\n    },\n\n    setup(props, { slots }) {\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            // Choose what to render based on status\n            switch (s.status) {\n                case \"loading\":\n                    return slots.loading\n                        ? slots.loading()\n                        : h(\"div\", { class: \"loading\" }, \"Loading…\");\n\n                case \"error\":\n                    return slots.error\n                        ? slots.error({ error: s.error })\n                        : h(\"div\", { class: \"error\" }, `Error: ${s.error}`);\n\n                case \"success\":\n                    return slots.default\n                        ? slots.default({ value: s.value })\n                        : null;\n\n                default:\n                    // \"idle\"\n                    return slots.idle\n                        ? slots.idle()\n                        : h(\"div\", { class: \"idle\" }, \"Idle\");\n            }\n        }\n    }\n})\n\n\n\ninterface CustomSlots<E extends ErrorBase = ErrorBase> {\n    loading?: () => VNode;\n    error?: (props: { error: E }) => VNode;\n}\n\n/**\n * Builds a custom AsyncResultLoader component with predefined slots for loading and error states.\n * \n * Useful for creating reusable components with consistent loading and error handling UI (eg. framework-specific spinners, etc...).\n * \n * @param slots the custom slots for loading and error states\n * @returns a Vue component that uses the provided slots\n */\nexport function buildCustomAsyncResultLoader<T, E extends ErrorBase = ErrorBase>(slots: CustomSlots<E>) {\n    const comp = defineComponent({\n        name: \"CustomAsyncResultLoader\",\n        props: {\n            result: {\n                type: Object as () => AsyncResult<T, E>,\n                required: true\n            }\n        },\n        setup(props, context) {\n            return () => {\n                const renderLoading = context.slots.loading ?? slots.loading ?? (() => undefined);\n                const renderError = context.slots.error ?? slots.error ?? (() => undefined);\n                return h(\n                    AsyncResultLoader,\n                    { result: props.result },\n                    {\n                        default: context.slots.default ? (propsDefault: { value: T }) => context.slots.default!(propsDefault) : undefined,\n\n                        loading: () => renderLoading(),\n                        error: ((propsError: { error: E }) => renderError(propsError))\n                    }\n                )\n            }\n        }\n    });\n\n    return comp;\n}\n"],"mappings":"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","names":["watch","watch"]}

package/package.json

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