Fallback

function withFallback<T extends AnyFn>(
  fn: T,
  options: FallbackOptions<Settled<ReturnType<T>>>
): T

interface FallbackOptions<T> {
  fallback: T | (() => MaybePromise<T>)
  onFallback?: (error: Error) => void
}

type MaybePromise<T> = T | Promise<T>
type Settled<T> = T extends PromiseLike<infer U> ? U : T

import { withFallback } from 'cruel'

// Static fallback value
const fetchWithFallback = withFallback(
  async (url: string) => {
    const response = await fetch(url)
    return response.json()
  },
  {
    fallback: { data: [], cached: true },
    onFallback: (error) => {
      console.warn('Using fallback data:', error.message)
    }
  }
)

// Dynamic fallback function
const fetchWithCache = withFallback(
  async (id: string) => fetchFromAPI(id),
  {
    fallback: async () => {
      return await getCachedData()
    },
    onFallback: () => {
      console.log('API failed, using cache')
    }
  }
)

const data = await fetchWithFallback('https://api.example.com/data')