Change race() methods to return PromiseLike instead of Promise

Author: adelrodriguez

src/__tests__/all-settled.test.ts

@@ -73,6 +73,20 @@ describe("allSettled", () => {
     expect(result.b).toEqual({ status: "fulfilled", value: 15 })
   })
 
+  it("passes a non-aborted task signal when no external signal is configured", async () => {
+    let taskSignalAborted: boolean | undefined
+
+    const result = await try$.allSettled({
+      a() {
+        taskSignalAborted = this.$signal.aborted
+        return 1
+      },
+    })
+
+    expect(result.a).toEqual({ status: "fulfilled", value: 1 })
+    expect(taskSignalAborted).toBe(false)
+  })
+
   it("rejects dependent task when referenced task fails", async () => {
     const error = new Error("a failed")
 
@@ -180,6 +194,25 @@ describe("allSettled", () => {
     expect(result.b).toEqual({ status: "fulfilled", value: "b done" })
   })
 
+  it("keeps sibling task signals usable after another task fails", async () => {
+    const signalStates: boolean[] = []
+
+    const result = await try$.allSettled({
+      a() {
+        throw new Error("a failed")
+      },
+      async b() {
+        signalStates.push(this.$signal.aborted)
+        await sleep(10)
+        signalStates.push(this.$signal.aborted)
+        return "b done"
+      },
+    })
+
+    expect(signalStates).toEqual([false, false])
+    expect(result.b).toEqual({ status: "fulfilled", value: "b done" })
+  })
+
   it("applies wrap middleware around allSettled execution", async () => {
     let wrapCalls = 0
 
@@ -256,4 +289,29 @@ describe("allSettled", () => {
 
     expect(cleaned).toBe(true)
   })
+
+  it("runs disposer cleanup for both fulfilled and rejected tasks without external signals", async () => {
+    let cleanedA = false
+    let cleanedB = false
+
+    const result = await try$.allSettled({
+      a() {
+        this.$disposer.defer(() => {
+          cleanedA = true
+        })
+        return 1
+      },
+      b() {
+        this.$disposer.defer(() => {
+          cleanedB = true
+        })
+        throw new Error("boom")
+      },
+    })
+
+    expect(result.a).toEqual({ status: "fulfilled", value: 1 })
+    expect(result.b.status).toBe("rejected")
+    expect(cleanedA).toBe(true)
+    expect(cleanedB).toBe(true)
+  })
 })

src/__tests__/all.test.ts

@@ -44,6 +44,20 @@ describe("all", () => {
     expect(result).toEqual({ a: 10, b: 15 })
   })
 
+  it("passes a non-aborted task signal when no external signal is configured", async () => {
+    let taskSignalAborted: boolean | undefined
+
+    const result = await try$.all({
+      a() {
+        taskSignalAborted = this.$signal.aborted
+        return 1
+      },
+    })
+
+    expect(result).toEqual({ a: 1 })
+    expect(taskSignalAborted).toBe(false)
+  })
+
   it("rejects on first task failure", async () => {
     try {
       await try$.all({
@@ -119,6 +133,32 @@ describe("all", () => {
     expect(signalAborted).toBe(true)
   })
 
+  it("aborts dependency waiters when a sibling task fails", async () => {
+    let signalAbortedWhileWaiting = false
+
+    try {
+      await try$.all({
+        a() {
+          throw new Error("boom")
+        },
+        async b() {
+          try {
+            await this.$result.a
+            return 2
+          } catch (error) {
+            signalAbortedWhileWaiting = this.$signal.aborted
+            throw error
+          }
+        },
+      })
+      expect.unreachable("should have thrown")
+    } catch (error) {
+      expect((error as Error).message).toBe("boom")
+    }
+
+    expect(signalAbortedWhileWaiting).toBe(true)
+  })
+
   it("rejects when a task accesses its own result", async () => {
     try {
       await try$.all({
@@ -249,6 +289,27 @@ describe("all", () => {
     })
   })
 
+  it("keeps catch-context signal usable after failure", async () => {
+    const result = await try$.all(
+      {
+        a() {
+          throw new Error("boom")
+        },
+      },
+      {
+        catch: (_error, ctx) => ({
+          aborted: ctx.signal.aborted,
+          hasSignal: ctx.signal instanceof AbortSignal,
+        }),
+      }
+    )
+
+    expect(result).toEqual({
+      aborted: true,
+      hasSignal: true,
+    })
+  })
+
   it("throws Panic when all catch throws", async () => {
     try {
       await try$.all(
@@ -380,6 +441,22 @@ describe("all", () => {
     expect(cleaned).toBe(true)
   })
 
+  it("allows disposer usage in a successful task without external cancellation", async () => {
+    let cleaned = false
+
+    const result = await try$.all({
+      a() {
+        this.$disposer.defer(() => {
+          cleaned = true
+        })
+        return 1
+      },
+    })
+
+    expect(result).toEqual({ a: 1 })
+    expect(cleaned).toBe(true)
+  })
+
   it("runs disposer cleanup even on failure", async () => {
     let cleaned = false
 

src/__tests__/flow.test.ts

@@ -148,6 +148,20 @@ describe("flow", () => {
     expect(result).toBe("api-value-transformed")
   })
 
+  it("passes a non-aborted task signal when no external signal is configured", async () => {
+    let taskSignalAborted: boolean | undefined
+
+    const result = await try$.flow({
+      a() {
+        taskSignalAborted = this.$signal.aborted
+        return this.$exit("done" as const)
+      },
+    })
+
+    expect(result).toBe("done")
+    expect(taskSignalAborted).toBe(false)
+  })
+
   it("returns early when a dependent task reads a task that already exited", async () => {
     const result = await try$.flow({
       a() {
@@ -174,6 +188,28 @@ describe("flow", () => {
     expect(result).toBe("done")
   })
 
+  it("aborts dependent waiters after early exit", async () => {
+    let dependencySawAbort = false
+
+    const result = await try$.flow({
+      a() {
+        return this.$exit("done" as const)
+      },
+      async b() {
+        try {
+          await this.$result.a
+        } catch {
+          dependencySawAbort = this.$signal.aborted
+        }
+
+        return null
+      },
+    })
+
+    expect(result).toBe("done")
+    expect(dependencySawAbort).toBe(true)
+  })
+
   it("applies wrap middleware in chained flow execution", async () => {
     let wrapCalls = 0
 
@@ -193,6 +229,27 @@ describe("flow", () => {
     expect(wrapCalls).toBe(1)
   })
 
+  it("runs cleanup after early exit even when a task starts through normal dependency flow", async () => {
+    let cleaned = false
+
+    const result = await try$.flow({
+      a() {
+        this.$disposer.defer(() => {
+          cleaned = true
+        })
+
+        return 1
+      },
+      async b() {
+        const value = await this.$result.a
+        return this.$exit(value + 1)
+      },
+    })
+
+    expect(result).toBe(2)
+    expect(cleaned).toBe(true)
+  })
+
   it("retries leaf work inside flow tasks via nested run()", async () => {
     let attempts = 0
 
@@ -253,6 +310,58 @@ describe("flow", () => {
     }
   })
 
+  it("propagates external cancellation while tasks use disposer and dependency results", async () => {
+    const controller = new AbortController()
+    let cleaned = false
+    let dependencySawAbort = false
+
+    const pending = try$.signal(controller.signal).flow({
+      async a() {
+        this.$disposer.defer(() => {
+          cleaned = true
+        })
+
+        if (!this.$signal.aborted) {
+          await new Promise<void>((resolve) => {
+            this.$signal.addEventListener(
+              "abort",
+              () => {
+                resolve()
+              },
+              { once: true }
+            )
+          })
+        }
+
+        throw this.$signal.reason
+      },
+      async b() {
+        try {
+          await this.$result.a
+        } catch {
+          dependencySawAbort = this.$signal.aborted
+          throw this.$signal.reason
+        }
+
+        return this.$exit("late")
+      },
+    })
+
+    setTimeout(() => {
+      controller.abort(new Error("stop"))
+    }, 5)
+
+    try {
+      await pending
+      expect.unreachable("should have thrown")
+    } catch (error) {
+      expect(error).toBeInstanceOf(CancellationError)
+    }
+
+    expect(cleaned).toBe(true)
+    expect(dependencySawAbort).toBe(true)
+  })
+
   it("rejects when a flow task awaits its own result", async () => {
     try {
       await try$.flow({

src/lib/__tests__/coverage-exceptions.test.ts

@@ -135,6 +135,64 @@ describe("coverage exceptions", () => {
 
       expect(result).toBe("aborted")
     })
+
+    it("returns the original promise value when the promise settles before abort", async () => {
+      const controller = new AbortController()
+      let resolvePromise!: (value: string) => void
+      let abortFactoryCalls = 0
+
+      const pending = new Promise<string>((resolve) => {
+        resolvePromise = resolve
+      })
+
+      const resultPromise = resolveWithAbort(controller.signal, pending, () => {
+        abortFactoryCalls += 1
+        return "aborted" as const
+      })
+
+      resolvePromise("done")
+
+      const result = await resultPromise
+      controller.abort(new Error("too late"))
+
+      expect(result).toBe("done")
+      expect(abortFactoryCalls).toBe(0)
+    })
+
+    it("returns the abort result when abort happens after registration and before settlement", async () => {
+      const controller = new AbortController()
+      let resolvePromise!: (value: string) => void
+
+      const pending = new Promise<string>((resolve) => {
+        resolvePromise = resolve
+      })
+
+      const resultPromise = resolveWithAbort(controller.signal, pending, () => "aborted" as const)
+
+      controller.abort(new Error("stop"))
+      resolvePromise("done")
+
+      expect(await resultPromise).toBe("aborted")
+    })
+
+    it("calls createAbortResult exactly once when abort wins", async () => {
+      const controller = new AbortController()
+      let abortFactoryCalls = 0
+
+      const pending = new Promise<string>((resolve) => {
+        void resolve
+      })
+
+      const resultPromise = resolveWithAbort(controller.signal, pending, () => {
+        abortFactoryCalls += 1
+        return "aborted" as const
+      })
+
+      controller.abort(new Error("stop"))
+
+      expect(await resultPromise).toBe("aborted")
+      expect(abortFactoryCalls).toBe(1)
+    })
   })
 
   describe("guard branches", () => {