Added a way to stop the operation

src/App.tsx

@@ -1,5 +1,5 @@
 import "./App.css";
-import { sleep, Operation } from "effection";
+import { sleep, Operation, run } from "effection";
 import { Player } from "./components/Player";
 import { useState } from "react";
 
@@ -174,6 +174,21 @@ export const App = () => {
             {...options}
           />
         </li>
+        <li key="7" className="p-5">
+          <Player
+            title="Can be stopped when encountering a specific problem"
+            description="Show a loading spinner after 1 minute then show a message that connect because of VPN connection"
+            load={async function ({ stop }) {
+              await run(function* () {
+                yield* sleep(4000);
+                yield* stop("Not connected to the VPN.");
+              });
+
+              return "Will never happen"
+            }}
+            {...options}
+          />
+        </li>
       </ul>
     </>
   );

src/components/LoadingSpinner.tsx

@@ -39,6 +39,12 @@ export function LoadingSpinner({ loader }: { loader: LoaderState<unknown> }): JS
           Failed after 3 attempts. Please contact support.
         </p>
       )
+    case "stopped":
+      return (
+        <p className="text-sky-400">
+          {loader.reason}
+        </p>
+      )
   }
 
   return <></>

src/hooks/useLoader.ts

@@ -1,7 +1,7 @@
 import { useMemo, useEffect, useState, useCallback } from "react";
-import { run, type Callable } from "effection";
+import { createChannel, run, spawn, type Callable, each, race, Operation } from "effection";
 import { CreateLoaderOptions, createLoader } from "../operations/createLoader";
-import { setUpdateContext, update } from "../operations/UpdateContext";
+import { setUpdateContext } from "../operations/UpdateContext";
 
 export type LoaderState<T> =
   | {
@@ -33,11 +33,16 @@ export type LoaderState<T> =
   | {
       type: "failed";
       error: Error;
-    };
+    }
+  | {
+    type: "stopped";
+    reason: string;
+  };
 
 export type LoaderFn<T> = (params: {
   attempt: number;
   signal: AbortSignal;
+  stop: (reason: string) => Operation<void>;
 }) => Callable<T>;
 
 export type UseLoaderOptions<T> = Partial<Omit<CreateLoaderOptions<T>, "load">>;
@@ -86,9 +91,24 @@ export function useLoader<T>(
 
   useEffect(() => {
     const task = run(function* () {
-      yield* setUpdateContext(setState);
-      yield* update({ type: "initial" })
-      yield* loader();
+      const channel = createChannel<LoaderState<unknown>>();
+
+      yield* setUpdateContext(channel.send);
+
+      const updates = yield* spawn(function*() {
+        for (const value of yield* each(channel)) {
+          setState(value);
+          if (value.type === "stopped") {
+            throw new Error("Forced interrupt")
+          }
+          yield* each.next();
+        }
+      });
+
+      const driver = yield* spawn(loader);
+
+      yield* race([updates, driver]);
+
     });
 
     return () => {

src/operations/UpdateContext.ts

@@ -1,13 +1,16 @@
-import { Operation, createContext, lift } from "effection";
+import { Operation, createContext, suspend } from "effection";
 import { LoaderState } from "../hooks/useLoader";
 
-export const UpdateContext = createContext<typeof update>("update");
+export const UpdateContext = createContext<<T>(value: LoaderState<T>) => Operation<void>>("update");
 
 export const update = function* update<T>(value: LoaderState<T>): Operation<void> {
-  const setState = yield* UpdateContext;
-  yield* setState(value);
+  const send = yield* UpdateContext;
+  yield* send(value);
+  if (value.type === "stopped") {
+    yield* suspend();
+  }
 }
 
-export function* setUpdateContext(setState: (value: LoaderState<unknown>) => void): Operation<void> {
-  yield* UpdateContext.set(lift(setState));
+export function* setUpdateContext(send: (value: LoaderState<unknown>) => Operation<void>): Operation<void> {
+  yield* UpdateContext.set(send);
 }

src/operations/createLoader.ts

@@ -1,5 +1,12 @@
 /* eslint-disable react-hooks/rules-of-hooks */
-import { Operation, sleep, spawn, call, useAbortSignal } from "effection";
+import {
+  Operation,
+  sleep,
+  spawn,
+  call,
+  useAbortSignal,
+  useScope,
+} from "effection";
 import { CreateSpinnerOptions, createSpinner } from "./createSpinner";
 import { update } from "./UpdateContext";
 import { LoaderFn } from "../hooks/useLoader";
@@ -26,6 +33,8 @@ export function createLoader<T>({
       type: "started",
     });
 
+    const scope = yield* useScope();
+
     for (let attempt = 0; attempt <= retryAttempts; attempt++) {
       const spinner = yield* spawn(function* () {
         if (attempt === 0) {
@@ -40,7 +49,14 @@ export function createLoader<T>({
       const signal = yield* useAbortSignal();
 
       try {
-        const result = yield* call(() => load({ attempt, signal }));
+        const result = yield* call(() =>
+          load({
+            attempt,
+            signal,
+            stop: (reason: string) =>
+              scope.run(() => update({ type: "stopped", reason })),
+          })
+        );
 
         yield* update({
           type: "success",