unwrapped 0.1.10 → 0.1.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # unwrapped
 
+## 0.1.12
+
+### Patch Changes
+
+- 4e5f239: Added progress in composables
+
+## 0.1.11
+
+### Patch Changes
+
+- b75c613: Added progress info on AsyncResult
+
 ## 0.1.10
 
 ### Patch Changes

package/dist/core/index.d.mts

@@ -172,24 +172,25 @@ declare class Result<T, E extends ErrorBase = ErrorBase> {
 
 /**
  * Type representing the state of an AsyncResult.
- * It can be 'idle', 'loading' with a promise, or a settled ResultState (success or error).
+ * It can be 'idle', 'loading' with a promise and an optional progress information of type P, or a settled ResultState (success or error).
  */
-type AsyncResultState<T, E extends ErrorBase = ErrorBase> = {
+type AsyncResultState<T, E extends ErrorBase = ErrorBase, P = unknown> = {
     status: 'idle';
 } | {
     status: 'loading';
     promise: Promise<Result<T, E>>;
+    progress?: P;
 } | ResultState<T, E>;
 /**
  * An Action is a function returning a Promise of a Result.
  */
-type Action<T, E extends ErrorBase = ErrorBase> = () => Promise<Result<T, E>>;
+type Action<T, E extends ErrorBase = ErrorBase, P = unknown> = (notifyProgress?: (progress: P) => void) => Promise<Result<T, E>>;
 /**
  * A LazyAction is an object containing a trigger function to start the action, and the AsyncResult representing the action's state.
  */
-type LazyAction<T, E extends ErrorBase = ErrorBase> = {
+type LazyAction<T, E extends ErrorBase = ErrorBase, P = unknown> = {
     trigger: () => void;
-    result: AsyncResult<T, E>;
+    result: AsyncResult<T, E, P>;
 };
 /**
  * A ChainStep is a function that takes an arbitrary input and returns a Result or a Promise of a Result.
@@ -204,7 +205,7 @@ type ChainStep<I, O, E extends ErrorBase = ErrorBase> = (input: I) => Result<O,
  *
  * Used for flat-chaining operations on AsyncResult.
  */
-type FlatChainStep<I, O, E extends ErrorBase = ErrorBase> = (input: I) => AsyncResult<O, E>;
+type FlatChainStep<I, O, E extends ErrorBase = ErrorBase, P = unknown> = (input: I) => AsyncResult<O, E, P>;
 /**
  * Type representing a generator function that yields AsyncResult instances and returns a final value of type T.
  *
@@ -214,22 +215,27 @@ type AsyncResultGenerator<T> = Generator<AsyncResult<any, any>, T, any>;
 /**
  * Type representing a listener function for AsyncResult state changes.
  */
-type AsyncResultListener<T, E extends ErrorBase = ErrorBase> = (result: AsyncResult<T, E>) => any;
+type AsyncResultListener<T, E extends ErrorBase = ErrorBase, P = unknown> = (result: AsyncResult<T, E, P>) => any;
+interface AsyncResultListenerOptions {
+    immediate?: boolean;
+    callOnProgressUpdates?: boolean;
+}
 /**
  * Class representing the asynchronous result of an operation that can be idle, loading, successful, or failed.
  * Provides methods for listening to state changes, updating state, chaining operations, and converting to and from promises.
  * @class AsyncResult
  * @template T - The type of the successful result value.
  * @template E - The type of the error, extending ErrorBase (default is ErrorBase).
+ * @template P - The type of the progress information for loading state (default is unknown).
  */
-declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
+declare class AsyncResult<T, E extends ErrorBase = ErrorBase, P = unknown> {
     private _state;
     private _listeners;
-    constructor(state?: AsyncResultState<T, E>);
+    constructor(state?: AsyncResultState<T, E, P>);
     /**
      * Returns the internal state of the AsyncResult.
      */
-    get state(): AsyncResultState<T, E>;
+    get state(): AsyncResultState<T, E, P>;
     /**
      * Checks if the AsyncResult is successful.
      * @returns whether or not the result is successful
@@ -266,6 +272,11 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @returns the error value or null
      */
     unwrapErrorOrNull(): E | null;
+    /**
+     * Returns the progress information if the AsyncResult is in a loading state, otherwise returns null.
+     * @returns the progress information or null
+     */
+    getProgressOrNull(): P | null;
     private set state(value);
     private setState;
     /**
@@ -301,6 +312,11 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @param error the error
      */
     updateFromError(error: E): this;
+    /**
+     * Updates the progress information of the AsyncResult if it is currently loading.
+     * @param progress progress information to include in the loading state
+     */
+    updateProgress(progress: P): this;
     /**
      * Creates an AsyncResult from a promise that resolves to a value.
      * The AsyncResult is initially in a loading state, and updates to a successful state once the promise resolves.
@@ -326,7 +342,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * Waits for the AsyncResult to settle (either success or error) if it is currently loading.
      * @returns itself once settled
      */
-    waitForSettled(): Promise<AsyncResult<T, E>>;
+    waitForSettled(): Promise<AsyncResult<T, E, P>>;
     /**
      * Waits for the AsyncResult to settle (either success or error) if it is currently loading, and returns a Result representing the settled state.
      * @returns a Result representing the settled state
@@ -368,14 +384,14 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @param immediate whether to call the listener immediately with the current state (default is true)
      * @returns a function to remove the listener
      */
-    listen(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    listen(listener: AsyncResultListener<T, E, P>, options?: AsyncResultListenerOptions): () => void;
     /**
      * Adds a listener that is called whenever the AsyncResult state changes, and automatically unsubscribes once it is settled (success or error).
      * @param listener the listener function to add
      * @param immediate whether to call the listener immediately with the current state (default is true)
      * @returns a function to remove the listener
      */
-    listenUntilSettled(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    listenUntilSettled(listener: AsyncResultListener<T, E, P>, options?: AsyncResultListenerOptions): () => void;
     /**
      * Adds a one-time listener that is called once the AsyncResult settles on a success.
      * @param callback callback called once the AsyncResult settled on a success
@@ -406,20 +422,38 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @param other the AsyncResult to mirror
      * @returns a function to stop mirroring
      */
-    mirror(other: AsyncResult<T, E>): () => void;
+    mirror(other: AsyncResult<T, E, P>, options?: AsyncResultListenerOptions): () => void;
     /**
      * Mirrors the state of another AsyncResult into this one, until the other AsyncResult is settled (success or error).
      * Whenever the other AsyncResult changes state, this AsyncResult is updated to match, until the other AsyncResult is settled.
      * @param other the AsyncResult to mirror
      * @returns a function to stop mirroring
      */
-    mirrorUntilSettled(other: AsyncResult<T, E>): () => void;
+    mirrorUntilSettled(other: AsyncResult<T, E, P>, options?: AsyncResultListenerOptions): () => void;
+    /**
+     * Creates an AsyncResult from an Action.
+     * The AsyncResult is initially in a loading state, and updates to the settled state once the Action's promise resolves.
+     * If the Action's promise rejects, the AsyncResult is updated to an error state with a default ErrorBase.
+     *
+     * Like AsyncResult.fromResultPromise, but for Actions.
+     *
+     * @param action the Action to run to produce the AsyncResult
+     * @return an AsyncResult representing the state of the Action
+     */
+    static fromAction<T, E extends ErrorBase = ErrorBase, P = unknown>(action: Action<T, E, P>): AsyncResult<T, E, P>;
+    /**
+     * Updates the AsyncResult based on the given Action.
+     * Like AsyncResult.fromAction, but in place.
+     * @param action an action that will be called directly
+     * @returns itself
+     */
+    updateFromAction(action: Action<T, E, P>): this;
     /**
      * Creates a LazyAction that can be triggered to run the given Action.
      * @param action the Action to run when triggered
      * @returns an object containing the trigger function and the associated AsyncResult
      */
-    static makeLazyAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): LazyAction<T, E>;
+    static makeLazyAction<T, E extends ErrorBase = ErrorBase, P = unknown>(action: Action<T, E, P>): LazyAction<T, E, P>;
     /**
      * Chains the current AsyncResult with another operation that returns a Result or a Promise of a Result.
      *
@@ -468,7 +502,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      *     return result1 + result2;
      * }
      */
-    [Symbol.iterator](): Generator<AsyncResult<T, E>, T, any>;
+    [Symbol.iterator](): Generator<AsyncResult<T, E, P>, T, any>;
     private static _runGeneratorProcessor;
     /**
      * Runs a generator function that yields AsyncResult instances, propagating errors automatically.
@@ -488,7 +522,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      *     return value1 + value2;
      * }
      */
-    static run<T, E extends ErrorBase = ErrorBase>(generatorFunc: () => AsyncResultGenerator<T>): AsyncResult<T, E>;
+    static run<T, E extends ErrorBase = ErrorBase, P = unknown>(generatorFunc: (notifyProgress?: (progress: P) => void) => AsyncResultGenerator<T>): AsyncResult<T, E, P>;
     /**
      * Runs a generator function that yields AsyncResult instances, propagating errors automatically, and updates this AsyncResult in place.
      * If any yielded AsyncResult is an error, the execution stops and this AsyncResult is updated to that error.
@@ -499,7 +533,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      *
      * @param generatorFunc a generator function that yields AsyncResult instances
      */
-    runInPlace(generatorFunc: () => AsyncResultGenerator<T>): this;
+    runInPlace(generatorFunc: (notifyProgress?: (progress: P) => void) => AsyncResultGenerator<T>): this;
     log(name?: string): void;
     debug(name?: string): () => void;
 }
@@ -754,4 +788,4 @@ declare class KeyedAsyncCache<P, V, E extends ErrorBase = ErrorBase> {
 
 declare function delay(ms: number): AsyncResult<true>;
 
-export { type Action, AsyncResult, AsyncResultCollection, type AsyncResultCollectionItem, type AsyncResultCollectionState, type AsyncResultGenerator, type AsyncResultListener, type AsyncResultState, type ChainStep, ErrorBase, type FlatChainStep, KeyedAsyncCache, type LazyAction, Result, type ResultState, delay };
+export { type Action, AsyncResult, AsyncResultCollection, type AsyncResultCollectionItem, type AsyncResultCollectionState, type AsyncResultGenerator, type AsyncResultListener, type AsyncResultListenerOptions, type AsyncResultState, type ChainStep, ErrorBase, type FlatChainStep, KeyedAsyncCache, type LazyAction, Result, type ResultState, delay };

package/dist/core/index.d.ts

@@ -172,24 +172,25 @@ declare class Result<T, E extends ErrorBase = ErrorBase> {
 
 /**
  * Type representing the state of an AsyncResult.
- * It can be 'idle', 'loading' with a promise, or a settled ResultState (success or error).
+ * It can be 'idle', 'loading' with a promise and an optional progress information of type P, or a settled ResultState (success or error).
  */
-type AsyncResultState<T, E extends ErrorBase = ErrorBase> = {
+type AsyncResultState<T, E extends ErrorBase = ErrorBase, P = unknown> = {
     status: 'idle';
 } | {
     status: 'loading';
     promise: Promise<Result<T, E>>;
+    progress?: P;
 } | ResultState<T, E>;
 /**
  * An Action is a function returning a Promise of a Result.
  */
-type Action<T, E extends ErrorBase = ErrorBase> = () => Promise<Result<T, E>>;
+type Action<T, E extends ErrorBase = ErrorBase, P = unknown> = (notifyProgress?: (progress: P) => void) => Promise<Result<T, E>>;
 /**
  * A LazyAction is an object containing a trigger function to start the action, and the AsyncResult representing the action's state.
  */
-type LazyAction<T, E extends ErrorBase = ErrorBase> = {
+type LazyAction<T, E extends ErrorBase = ErrorBase, P = unknown> = {
     trigger: () => void;
-    result: AsyncResult<T, E>;
+    result: AsyncResult<T, E, P>;
 };
 /**
  * A ChainStep is a function that takes an arbitrary input and returns a Result or a Promise of a Result.
@@ -204,7 +205,7 @@ type ChainStep<I, O, E extends ErrorBase = ErrorBase> = (input: I) => Result<O,
  *
  * Used for flat-chaining operations on AsyncResult.
  */
-type FlatChainStep<I, O, E extends ErrorBase = ErrorBase> = (input: I) => AsyncResult<O, E>;
+type FlatChainStep<I, O, E extends ErrorBase = ErrorBase, P = unknown> = (input: I) => AsyncResult<O, E, P>;
 /**
  * Type representing a generator function that yields AsyncResult instances and returns a final value of type T.
  *
@@ -214,22 +215,27 @@ type AsyncResultGenerator<T> = Generator<AsyncResult<any, any>, T, any>;
 /**
  * Type representing a listener function for AsyncResult state changes.
  */
-type AsyncResultListener<T, E extends ErrorBase = ErrorBase> = (result: AsyncResult<T, E>) => any;
+type AsyncResultListener<T, E extends ErrorBase = ErrorBase, P = unknown> = (result: AsyncResult<T, E, P>) => any;
+interface AsyncResultListenerOptions {
+    immediate?: boolean;
+    callOnProgressUpdates?: boolean;
+}
 /**
  * Class representing the asynchronous result of an operation that can be idle, loading, successful, or failed.
  * Provides methods for listening to state changes, updating state, chaining operations, and converting to and from promises.
  * @class AsyncResult
  * @template T - The type of the successful result value.
  * @template E - The type of the error, extending ErrorBase (default is ErrorBase).
+ * @template P - The type of the progress information for loading state (default is unknown).
  */
-declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
+declare class AsyncResult<T, E extends ErrorBase = ErrorBase, P = unknown> {
     private _state;
     private _listeners;
-    constructor(state?: AsyncResultState<T, E>);
+    constructor(state?: AsyncResultState<T, E, P>);
     /**
      * Returns the internal state of the AsyncResult.
      */
-    get state(): AsyncResultState<T, E>;
+    get state(): AsyncResultState<T, E, P>;
     /**
      * Checks if the AsyncResult is successful.
      * @returns whether or not the result is successful
@@ -266,6 +272,11 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @returns the error value or null
      */
     unwrapErrorOrNull(): E | null;
+    /**
+     * Returns the progress information if the AsyncResult is in a loading state, otherwise returns null.
+     * @returns the progress information or null
+     */
+    getProgressOrNull(): P | null;
     private set state(value);
     private setState;
     /**
@@ -301,6 +312,11 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @param error the error
      */
     updateFromError(error: E): this;
+    /**
+     * Updates the progress information of the AsyncResult if it is currently loading.
+     * @param progress progress information to include in the loading state
+     */
+    updateProgress(progress: P): this;
     /**
      * Creates an AsyncResult from a promise that resolves to a value.
      * The AsyncResult is initially in a loading state, and updates to a successful state once the promise resolves.
@@ -326,7 +342,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * Waits for the AsyncResult to settle (either success or error) if it is currently loading.
      * @returns itself once settled
      */
-    waitForSettled(): Promise<AsyncResult<T, E>>;
+    waitForSettled(): Promise<AsyncResult<T, E, P>>;
     /**
      * Waits for the AsyncResult to settle (either success or error) if it is currently loading, and returns a Result representing the settled state.
      * @returns a Result representing the settled state
@@ -368,14 +384,14 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @param immediate whether to call the listener immediately with the current state (default is true)
      * @returns a function to remove the listener
      */
-    listen(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    listen(listener: AsyncResultListener<T, E, P>, options?: AsyncResultListenerOptions): () => void;
     /**
      * Adds a listener that is called whenever the AsyncResult state changes, and automatically unsubscribes once it is settled (success or error).
      * @param listener the listener function to add
      * @param immediate whether to call the listener immediately with the current state (default is true)
      * @returns a function to remove the listener
      */
-    listenUntilSettled(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    listenUntilSettled(listener: AsyncResultListener<T, E, P>, options?: AsyncResultListenerOptions): () => void;
     /**
      * Adds a one-time listener that is called once the AsyncResult settles on a success.
      * @param callback callback called once the AsyncResult settled on a success
@@ -406,20 +422,38 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      * @param other the AsyncResult to mirror
      * @returns a function to stop mirroring
      */
-    mirror(other: AsyncResult<T, E>): () => void;
+    mirror(other: AsyncResult<T, E, P>, options?: AsyncResultListenerOptions): () => void;
     /**
      * Mirrors the state of another AsyncResult into this one, until the other AsyncResult is settled (success or error).
      * Whenever the other AsyncResult changes state, this AsyncResult is updated to match, until the other AsyncResult is settled.
      * @param other the AsyncResult to mirror
      * @returns a function to stop mirroring
      */
-    mirrorUntilSettled(other: AsyncResult<T, E>): () => void;
+    mirrorUntilSettled(other: AsyncResult<T, E, P>, options?: AsyncResultListenerOptions): () => void;
+    /**
+     * Creates an AsyncResult from an Action.
+     * The AsyncResult is initially in a loading state, and updates to the settled state once the Action's promise resolves.
+     * If the Action's promise rejects, the AsyncResult is updated to an error state with a default ErrorBase.
+     *
+     * Like AsyncResult.fromResultPromise, but for Actions.
+     *
+     * @param action the Action to run to produce the AsyncResult
+     * @return an AsyncResult representing the state of the Action
+     */
+    static fromAction<T, E extends ErrorBase = ErrorBase, P = unknown>(action: Action<T, E, P>): AsyncResult<T, E, P>;
+    /**
+     * Updates the AsyncResult based on the given Action.
+     * Like AsyncResult.fromAction, but in place.
+     * @param action an action that will be called directly
+     * @returns itself
+     */
+    updateFromAction(action: Action<T, E, P>): this;
     /**
      * Creates a LazyAction that can be triggered to run the given Action.
      * @param action the Action to run when triggered
      * @returns an object containing the trigger function and the associated AsyncResult
      */
-    static makeLazyAction<T, E extends ErrorBase = ErrorBase>(action: Action<T, E>): LazyAction<T, E>;
+    static makeLazyAction<T, E extends ErrorBase = ErrorBase, P = unknown>(action: Action<T, E, P>): LazyAction<T, E, P>;
     /**
      * Chains the current AsyncResult with another operation that returns a Result or a Promise of a Result.
      *
@@ -468,7 +502,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      *     return result1 + result2;
      * }
      */
-    [Symbol.iterator](): Generator<AsyncResult<T, E>, T, any>;
+    [Symbol.iterator](): Generator<AsyncResult<T, E, P>, T, any>;
     private static _runGeneratorProcessor;
     /**
      * Runs a generator function that yields AsyncResult instances, propagating errors automatically.
@@ -488,7 +522,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      *     return value1 + value2;
      * }
      */
-    static run<T, E extends ErrorBase = ErrorBase>(generatorFunc: () => AsyncResultGenerator<T>): AsyncResult<T, E>;
+    static run<T, E extends ErrorBase = ErrorBase, P = unknown>(generatorFunc: (notifyProgress?: (progress: P) => void) => AsyncResultGenerator<T>): AsyncResult<T, E, P>;
     /**
      * Runs a generator function that yields AsyncResult instances, propagating errors automatically, and updates this AsyncResult in place.
      * If any yielded AsyncResult is an error, the execution stops and this AsyncResult is updated to that error.
@@ -499,7 +533,7 @@ declare class AsyncResult<T, E extends ErrorBase = ErrorBase> {
      *
      * @param generatorFunc a generator function that yields AsyncResult instances
      */
-    runInPlace(generatorFunc: () => AsyncResultGenerator<T>): this;
+    runInPlace(generatorFunc: (notifyProgress?: (progress: P) => void) => AsyncResultGenerator<T>): this;
     log(name?: string): void;
     debug(name?: string): () => void;
 }
@@ -754,4 +788,4 @@ declare class KeyedAsyncCache<P, V, E extends ErrorBase = ErrorBase> {
 
 declare function delay(ms: number): AsyncResult<true>;
 
-export { type Action, AsyncResult, AsyncResultCollection, type AsyncResultCollectionItem, type AsyncResultCollectionState, type AsyncResultGenerator, type AsyncResultListener, type AsyncResultState, type ChainStep, ErrorBase, type FlatChainStep, KeyedAsyncCache, type LazyAction, Result, type ResultState, delay };
+export { type Action, AsyncResult, AsyncResultCollection, type AsyncResultCollectionItem, type AsyncResultCollectionState, type AsyncResultGenerator, type AsyncResultListener, type AsyncResultListenerOptions, type AsyncResultState, type ChainStep, ErrorBase, type FlatChainStep, KeyedAsyncCache, type LazyAction, Result, type ResultState, delay };

package/dist/core/index.js

@@ -320,10 +320,25 @@ var AsyncResult = class _AsyncResult {
     }
     return null;
   }
+  /**
+   * Returns the progress information if the AsyncResult is in a loading state, otherwise returns null.
+   * @returns the progress information or null
+   */
+  getProgressOrNull() {
+    if (this._state.status === "loading") {
+      return this._state.progress ?? null;
+    }
+    return null;
+  }
   // === Creating/updating from settled values ===
   set state(newState) {
+    const oldState = this._state;
     this._state = newState;
-    this._listeners.forEach((listener) => listener(this));
+    this._listeners.forEach((listenerEntry) => {
+      if (oldState.status !== "loading" || newState.status !== "loading" || listenerEntry.options.callOnProgressUpdates) {
+        listenerEntry.listener(this);
+      }
+    });
   }
   setState(newState) {
     this.state = newState;
@@ -374,6 +389,16 @@ var AsyncResult = class _AsyncResult {
     this.state = { status: "error", error };
     return this;
   }
+  /**
+   * Updates the progress information of the AsyncResult if it is currently loading.
+   * @param progress progress information to include in the loading state
+   */
+  updateProgress(progress) {
+    if (this._state.status === "loading") {
+      this.state = { ...this._state, progress };
+    }
+    return this;
+  }
   // === Creating/updating from promises ===
   /**
    * Creates an AsyncResult from a promise that resolves to a value.
@@ -495,13 +520,14 @@ var AsyncResult = class _AsyncResult {
    * @param immediate whether to call the listener immediately with the current state (default is true)
    * @returns a function to remove the listener
    */
-  listen(listener, immediate = true) {
-    this._listeners.add(listener);
-    if (immediate) {
+  listen(listener, options = { immediate: true, callOnProgressUpdates: true }) {
+    const entry = { listener, options };
+    this._listeners.add(entry);
+    if (options.immediate) {
       listener(this);
     }
     return () => {
-      this._listeners.delete(listener);
+      this._listeners.delete(entry);
     };
   }
   /**
@@ -510,13 +536,13 @@ var AsyncResult = class _AsyncResult {
    * @param immediate whether to call the listener immediately with the current state (default is true)
    * @returns a function to remove the listener
    */
-  listenUntilSettled(listener, immediate = true) {
+  listenUntilSettled(listener, options = { immediate: true, callOnProgressUpdates: true }) {
     const unsub = this.listen((result) => {
       listener(result);
       if (result.state.status === "success" || result.state.status === "error") {
         unsub();
       }
-    }, immediate);
+    }, options);
     return unsub;
   }
   /**
@@ -574,10 +600,10 @@ var AsyncResult = class _AsyncResult {
    * @param other the AsyncResult to mirror
    * @returns a function to stop mirroring
    */
-  mirror(other) {
+  mirror(other, options = { immediate: true, callOnProgressUpdates: true }) {
     return other.listen((newState) => {
       this.setState(newState.state);
-    }, true);
+    }, options);
   }
   /**
    * Mirrors the state of another AsyncResult into this one, until the other AsyncResult is settled (success or error).
@@ -585,12 +611,35 @@ var AsyncResult = class _AsyncResult {
    * @param other the AsyncResult to mirror
    * @returns a function to stop mirroring
    */
-  mirrorUntilSettled(other) {
+  mirrorUntilSettled(other, options = { immediate: true, callOnProgressUpdates: true }) {
     return other.listenUntilSettled((newState) => {
       this.setState(newState.state);
-    }, true);
+    }, options);
   }
   // === Actions ===
+  /**
+   * Creates an AsyncResult from an Action.
+   * The AsyncResult is initially in a loading state, and updates to the settled state once the Action's promise resolves.
+   * If the Action's promise rejects, the AsyncResult is updated to an error state with a default ErrorBase.
+   * 
+   * Like AsyncResult.fromResultPromise, but for Actions.
+   * 
+   * @param action the Action to run to produce the AsyncResult
+   * @return an AsyncResult representing the state of the Action
+   */
+  static fromAction(action) {
+    return new _AsyncResult().updateFromAction(action);
+  }
+  /**
+   * Updates the AsyncResult based on the given Action.
+   * Like AsyncResult.fromAction, but in place.
+   * @param action an action that will be called directly
+   * @returns itself
+   */
+  updateFromAction(action) {
+    const promise = action((progress) => this.updateProgress(progress));
+    return this.updateFromResultPromise(promise);
+  }
   /**
    * Creates a LazyAction that can be triggered to run the given Action.
    * @param action the Action to run when triggered
@@ -599,7 +648,7 @@ var AsyncResult = class _AsyncResult {
   static makeLazyAction(action) {
     const result = new _AsyncResult();
     const trigger = () => {
-      result.updateFromResultPromise(action());
+      result.updateFromAction(action);
     };
     return { trigger, result };
   }
@@ -732,8 +781,10 @@ var AsyncResult = class _AsyncResult {
    * }
    */
   static run(generatorFunc) {
-    const iterator = generatorFunc();
-    return _AsyncResult.fromResultPromise(_AsyncResult._runGeneratorProcessor(iterator)());
+    return _AsyncResult.fromAction(async (notifyProgress) => {
+      const iterator = generatorFunc(notifyProgress);
+      return _AsyncResult._runGeneratorProcessor(iterator)();
+    });
   }
   /**
    * Runs a generator function that yields AsyncResult instances, propagating errors automatically, and updates this AsyncResult in place.
@@ -746,8 +797,10 @@ var AsyncResult = class _AsyncResult {
    * @param generatorFunc a generator function that yields AsyncResult instances
    */
   runInPlace(generatorFunc) {
-    const iterator = generatorFunc();
-    return this.updateFromResultPromise(_AsyncResult._runGeneratorProcessor(iterator)());
+    return this.updateFromAction((notify) => {
+      const iterator = generatorFunc(notify);
+      return _AsyncResult._runGeneratorProcessor(iterator)();
+    });
   }
   // === Debuging ===
   log(name) {
@@ -858,12 +911,12 @@ var AsyncResultCollection = class {
         if (r.isLoading() || r.isIdle()) return;
         this._onTaskFinished();
         this._list.delete(key);
-      }, true);
+      }, { immediate: true, callOnProgressUpdates: true });
     } else {
       unsub = task.listen((r) => {
         if (r.isLoading() || r.isIdle()) return;
         this._onTaskFinished();
-      }, true);
+      }, { immediate: true, callOnProgressUpdates: true });
     }
     this._list.set(key, { key, result: task, unsub });
     this.state = "any-loading";