feat: add Promisify type definition

packages/shared/utils/filters.ts

@@ -1,7 +1,7 @@
 import { readonly, ref } from 'vue-demi'
 import { toValue } from '../toValue'
 import { noop } from './is'
-import type { AnyFn, ArgumentsType, MaybeRefOrGetter, Pausable } from './types'
+import type { AnyFn, ArgumentsType, Awaited, MaybeRefOrGetter, Pausable, Promisify } from './types'
 
 export type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return
 
@@ -14,7 +14,7 @@ export interface FunctionWrapperOptions<Args extends any[] = any[], This = any>
 export type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (
   invoke: Invoke,
   options: FunctionWrapperOptions<Args, This>
-) => ReturnType<Invoke> | Promise<ReturnType<Invoke>>
+) => ReturnType<Invoke> | Promisify<ReturnType<Invoke>>
 
 export interface ConfigurableEventFilter {
   /**
@@ -45,7 +45,7 @@ export interface DebounceFilterOptions {
  */
 export function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T) {
   function wrapper(this: any, ...args: ArgumentsType<T>) {
-    return new Promise<ReturnType<T>>((resolve, reject) => {
+    return new Promise<Awaited<ReturnType<T>>>((resolve, reject) => {
       // make sure it's a promise
       Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args }))
         .then(resolve)

packages/shared/utils/types.ts

@@ -69,7 +69,20 @@ export type Awaitable<T> = Promise<T> | T
 
 export type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never
 
-export type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promise<ReturnType<T>>
+/**
+ * Compatible with versions below TypeScript 4.5 Awaited
+ */
+export type Awaited<T> =
+  T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
+    T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
+      F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
+        Awaited<V> : // recursively unwrap the value
+        never : // the argument to `then` was not callable
+      T // non-object or non-thenable
+
+export type Promisify<T> = Promise<Awaited<T>>
+
+export type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promisify<ReturnType<T>>
 
 export interface Pausable {
   /**