Encapsulate a timer that can pause startup at any time without worrying about side effects using Vue

import type { ComputedRef, Ref, ShallowRef, WritableComputedRef } from 'vue-demi'
import { getCurrentScope, isRef, onScopeDispose, ref, unref, watch } from 'vue-demi'

/**
  * Void function
  */
export type Fn = () => void

/**
  *Arbitrary function
  */
export type AnyFn = (...args: any[]) => any

/**
  * It may be a ref object, or a normal value
  */
export type MaybeRef<T = any> =
| T
| Ref<T>
| ShallowRef<T>
| WritableComputedRef<T>

/**
  * It may be a ref object, or a normal value, or a getter function
  * @param cb
  * @param interval
  */
export type MaybeRefOrGetter<T = any> = MaybeRef<T> | ComputedRef<T> | (() => T)

/**
  * Get the actual value of a value, ref, or getter
  */
export function toValue<T>(r: MaybeRefOrGetter<T>): T {
  return typeof r === 'function' ? (r as AnyFn)() : unref(r)
}

/***
  * Is it a client or not
  */
export const isClient = typeof window !== 'undefined' && typeof document !== 'undefined'

/**
  * Whether it is within the scope of a Vue 3 responsive effect lifecycle.  If so, it registers a cleanup function (fn parameter) that will be executed at the end of the scope; if it is not in such a scope, it will do nothing.
  * @param fn
  */
export function tryOnScopeDispose(fn: Fn) {
  if (getCurrentScope()) {
    onScopeDispose(fn)
    return true
  }
  return false
}


export interface UseIntervalOptions {
  /**
    * Execute this timer immediately
    */
  immediate?: boolean
  /**
    * After calling resume function, execute the callback function immediately
    */
  immediateCallback?: boolean
}

export interface Pausable {
  /**
    * A ref indicates whether the pausable instance is active
    */
  isActive: Readonly<Ref<boolean>>
  /**
    * Pause timer
    */
  pause: Fn
  /**
    * Recovery timer
    */
  resume: Fn
}

export function useIntervalFn(cb: Fn, interval: MaybeRefOrGetter<number> = 1000, options: UseIntervalOptions = {}): Pausable {
  const {
    immediate = true,
    immediateCallback = true
  } = options

  let timer: ReturnType<typeof setInterval> | null = null
  const isActive = ref(false)

  function clean() {
    if (timer) {
      clearInterval(timer)
      timer = null
    }
  }

  function pause() {
     = false
    clean()
  }

  function resume() {
    const intervalValue = toValue(interval)
    if (intervalValue <= 0) {
      return
    }
     = true

    if (immediateCallback){
      cb()
    }

    clean()

    if () {
      timer = setInterval(cb, intervalValue)
    }
  }

  
  if (immediate && isClient) {
    resume()
  }

  if (isRef(interval) || typeof interval === 'function') {
    const stopWatch = watch(interval, () => {
      if ( && isClient) {
        resume()
      }
    })
    tryOnScopeDispose(stopWatch)
  }

  tryOnScopeDispose(pause)

  return {
    isActive,
    pause,
    resume
  }
}