Class WithToast

packages/effect-app/src/withToast.ts:44–133

// @effect-diagnostics-next-line missingEffectServiceDependency:off
export class WithToast extends Context.Service<WithToast>()("WithToast", {
  make: Effect.gen(function*() {
    const toast = yield* Toast
    return <A, E, Args extends readonly unknown[], R, WaiR = never, SucR = never, ErrR = never>(
      options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
    ) =>
      Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
        const baseTimeout = options.timeout ?? 3_000

        const stableToastId = typeof options.stableToastId === "function"
          ? options.stableToastId(...args)
          : options.stableToastId

        const requestId: string = yield* Effect.currentSpan.pipe(
          Effect.map((span) => span.traceId),
          Effect.orElseSucceed(() => S.StringId.make())
        )
        const groupId = options.groupId
        const meta = { ...(groupId !== undefined ? { groupId } : {}), requestId }

        const t = yield* wrapEffect(options.onWaiting)(...args)
        const toastId: ToastId | undefined = t === null
          ? stableToastId
          : stableToastId ?? `wait-${Math.random().toString(36).slice(2)}`

        const waitingFiber = t === null ? undefined : yield* Effect.forkChild(
          Effect.sleep("1 seconds").pipe(
            Effect.andThen(toast.info(t, { id: toastId!, timeout: Infinity, ...meta }))
          )
        )
        const interruptWaiting = waitingFiber ? Fiber.interrupt(waitingFiber) : Effect.void

        return yield* self.pipe(
          Effect.tap(Effect.fnUntraced(function*(a) {
            yield* interruptWaiting
            const t = yield* wrapEffect(options.onSuccess)(a, ...args)
            if (t === null) {
              return
            }
            yield* toast.success(
              t,
              toastId !== undefined
                ? { id: toastId, timeout: baseTimeout, ...meta }
                : { timeout: baseTimeout, ...meta }
            )
          })),
          Effect.tapCause(Effect.fnUntraced(function*(cause) {
            yield* interruptWaiting
            yield* Effect.logDebug(
              "WithToast - caught error cause: " + Cause.squash(cause),
              Cause.hasInterruptsOnly(cause),
              cause
            )

            if (Cause.hasInterruptsOnly(cause)) {
              if (toastId) yield* toast.dismiss(toastId)
              return
            }