@vueuse/shared 10.4.1 → 10.6.0

package/index.d.cts

@@ -1,5 +1,5 @@
 import * as vue_demi from 'vue-demi';
-import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, WatchOptions, ShallowUnwrapRef as ShallowUnwrapRef$1, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, MaybeRef as MaybeRef$1, WatchCallback, WatchStopHandle } from 'vue-demi';
+import { WatchOptionsBase, Ref, ComputedRef, WritableComputedRef, WatchSource, ComputedGetter, WritableComputedOptions, WatchOptions, InjectionKey, ShallowUnwrapRef as ShallowUnwrapRef$1, inject, provide, UnwrapNestedRefs, UnwrapRef, ToRef, ToRefs, MaybeRef as MaybeRef$1, WatchCallback, WatchStopHandle } from 'vue-demi';
 
 declare function computedEager<T>(fn: () => T, options?: WatchOptionsBase): Readonly<Ref<T>>;
 
@@ -16,11 +16,12 @@ interface WritableComputedRefWithControl<T> extends WritableComputedRef<T>, Comp
 declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: ComputedGetter<T>): ComputedRefWithControl<T>;
 declare function computedWithControl<T, S>(source: WatchSource<S> | WatchSource<S>[], fn: WritableComputedOptions<T>): WritableComputedRefWithControl<T>;
 
-type EventHookOn<T = any> = (fn: (param: T) => void) => {
+type Callback<T> = T extends void ? () => void : (param: T) => void;
+type EventHookOn<T = any> = (fn: Callback<T>) => {
     off: () => void;
 };
-type EventHookOff<T = any> = (fn: (param: T) => void) => void;
-type EventHookTrigger<T = any> = (param: T) => Promise<unknown[]>;
+type EventHookOff<T = any> = (fn: Callback<T>) => void;
+type EventHookTrigger<T = any> = (param?: T) => Promise<unknown[]>;
 interface EventHook<T = any> {
     on: EventHookOn<T>;
     off: EventHookOff<T>;
@@ -34,6 +35,7 @@ interface EventHook<T = any> {
 declare function createEventHook<T = any>(): EventHook<T>;
 
 declare const isClient: boolean;
+declare const isWorker: boolean;
 declare const isDef: <T = any>(val?: T | undefined) => val is T;
 declare const notNullish: <T = any>(val?: T | null | undefined) => val is T;
 declare const assert: (condition: boolean, ...infos: any[]) => void;
@@ -101,7 +103,14 @@ type ElementOf<T> = T extends (infer E)[] ? E : never;
 type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
 type Awaitable<T> = Promise<T> | T;
 type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
-type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promise<ReturnType<T>>;
+/**
+ * Compatible with versions below TypeScript 4.5 Awaited
+ */
+type Awaited<T> = T extends null | undefined ? T : T extends object & {
+    then(onfulfilled: infer F, ...args: infer _): any;
+} ? F extends ((value: infer V, ...args: infer _) => any) ? Awaited<V> : never : T;
+type Promisify<T> = Promise<Awaited<T>>;
+type PromisifyFn<T extends AnyFn> = (...args: ArgumentsType<T>) => Promisify<ReturnType<T>>;
 interface Pausable {
     /**
      * A ref indicate whether a pausable instance is active
@@ -164,7 +173,7 @@ interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
     args: Args;
     thisArg: This;
 }
-type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promise<ReturnType<Invoke>>;
+type EventFilter<Args extends any[] = any[], This = any, Invoke extends AnyFn = AnyFn> = (invoke: Invoke, options: FunctionWrapperOptions<Args, This>) => ReturnType<Invoke> | Promisify<ReturnType<Invoke>>;
 interface ConfigurableEventFilter {
     /**
      * Filter for if events should to be received.
@@ -189,7 +198,7 @@ interface DebounceFilterOptions {
 /**
  * @internal
  */
-declare function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T): (this: any, ...args: ArgumentsType<T>) => Promise<ReturnType<T>>;
+declare function createFilterWrapper<T extends AnyFn>(filter: EventFilter, fn: T): (this: any, ...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
 declare const bypassFilter: EventFilter;
 /**
  * Create an EventFilter that debounce the events
@@ -199,9 +208,9 @@ declare function debounceFilter(ms: MaybeRefOrGetter<number>, options?: Debounce
  * Create an EventFilter that throttle the events
  *
  * @param ms
- * @param [trailing=true]
- * @param [leading=true]
- * @param [rejectOnCancel=false]
+ * @param [trailing]
+ * @param [leading]
+ * @param [rejectOnCancel]
  */
 declare function throttleFilter(ms: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): EventFilter<any[], any, AnyFn>;
 /**
@@ -275,13 +284,19 @@ declare function objectEntries<T extends object>(obj: T): [keyof T, T[keyof T]][
  */
 declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): Fn;
 
+interface CreateInjectionStateOptions<Return> {
+    /**
+     * Custom injectionKey for InjectionState
+     */
+    injectionKey?: string | InjectionKey<Return>;
+}
 /**
  * Create global state that can be injected into components.
  *
  * @see https://vueuse.org/createInjectionState
  *
  */
-declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return): readonly [useProvidingState: (...args: Arguments) => Return, useInjectedState: () => Return | undefined];
+declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): readonly [useProvidingState: (...args: Arguments) => Return, useInjectedState: () => Return | undefined];
 
 /**
  * Make a composable function usable with multiple Vue instances.
@@ -319,12 +334,34 @@ declare function extendRef<R extends Ref<any>, Extend extends object, Options ex
 declare function get<T>(ref: MaybeRef<T>): T;
 declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
 
+/**
+ * On the basis of `inject`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+ *
+ * @example
+ * ```ts
+ * injectLocal('MyInjectionKey', 1)
+ * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+ * ```
+ */
+declare const injectLocal: typeof inject;
+
 declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;
 declare function isDefined<T>(v: ComputedRef<T>): v is ComputedRef<Exclude<T, null | undefined>>;
 declare function isDefined<T>(v: T): v is Exclude<T, null | undefined>;
 
 declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly any[]>(obj: T, arr: A): T & A;
 
+/**
+ * On the basis of `provide`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+ *
+ * @example
+ * ```ts
+ * provideLocal('MyInjectionKey', 1)
+ * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+ * ```
+ */
+declare const provideLocal: typeof provide;
+
 type Reactified<T, Computed extends boolean> = T extends (...args: infer A) => infer R ? (...args: {
     [K in keyof A]: Computed extends true ? MaybeRefOrGetter<A[K]> : MaybeRef<A[K]>;
 }) => ComputedRef<R> : never;
@@ -397,9 +434,6 @@ declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, o
 
 /**
  * Apply default value to a ref.
- *
- * @param source source ref
- * @param targets
  */
 declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
 
@@ -409,8 +443,8 @@ declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue:
  *
  * @param value Ref value to be watched with throttle effect
  * @param  delay  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
- * @param [trailing=true] if true, update the value again after the delay time is up
- * @param [leading=true] if true, update the value on the leading edge of the ms timeout
+ * @param [trailing] if true, update the value again after the delay time is up
+ * @param [leading] if true, update the value on the leading edge of the ms timeout
  */
 declare function refThrottled<T>(value: Ref<T>, delay?: number, trailing?: boolean, leading?: boolean): Ref<T>;
 
@@ -430,9 +464,6 @@ interface ControlledRefOptions<T> {
 }
 /**
  * Explicitly define the deps of computed.
- *
- * @param source
- * @param fn
  */
 declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue_demi.ShallowUnwrapRef<{
     get: (tracking?: boolean) => T;
@@ -450,7 +481,47 @@ declare const controlledRef: typeof refWithControl;
 declare function set<T>(ref: Ref<T>, value: T): void;
 declare function set<O extends object, K extends keyof O>(target: O, key: K, value: O[K]): void;
 
-interface SyncRefOptions<L, R = L> extends ConfigurableFlushSync {
+type Direction = 'ltr' | 'rtl' | 'both';
+type SpecificFieldPartial<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+/**
+ * A = B
+ */
+type Equal<A, B> = A extends B ? (B extends A ? true : false) : false;
+/**
+ * A ∩ B ≠ ∅
+ */
+type IntersectButNotEqual<A, B> = Equal<A, B> extends true ? false : A & B extends never ? false : true;
+/**
+ * A ⊆ B
+ */
+type IncludeButNotEqual<A, B> = Equal<A, B> extends true ? false : A extends B ? true : false;
+/**
+ * A ∩ B = ∅
+ */
+type NotIntersect<A, B> = Equal<A, B> extends true ? false : A & B extends never ? true : false;
+interface EqualType<D extends Direction, L, R, O extends keyof Transform<L, R> = D extends 'both' ? 'ltr' | 'rtl' : D> {
+    transform?: SpecificFieldPartial<Pick<Transform<L, R>, O>, O>;
+}
+type StrictIncludeMap<IncludeType extends 'LR' | 'RL', D extends Exclude<Direction, 'both'>, L, R> = (Equal<[IncludeType, D], ['LR', 'ltr']> & Equal<[IncludeType, D], ['RL', 'rtl']>) extends true ? {
+    transform?: SpecificFieldPartial<Pick<Transform<L, R>, D>, D>;
+} : {
+    transform: Pick<Transform<L, R>, D>;
+};
+type StrictIncludeType<IncludeType extends 'LR' | 'RL', D extends Direction, L, R> = D extends 'both' ? {
+    transform: SpecificFieldPartial<Transform<L, R>, IncludeType extends 'LR' ? 'ltr' : 'rtl'>;
+} : D extends Exclude<Direction, 'both'> ? StrictIncludeMap<IncludeType, D, L, R> : never;
+type IntersectButNotEqualType<D extends Direction, L, R> = D extends 'both' ? {
+    transform: Transform<L, R>;
+} : D extends Exclude<Direction, 'both'> ? {
+    transform: Pick<Transform<L, R>, D>;
+} : never;
+type NotIntersectType<D extends Direction, L, R> = IntersectButNotEqualType<D, L, R>;
+interface Transform<L, R> {
+    ltr: (left: L) => R;
+    rtl: (right: R) => L;
+}
+type TransformType<D extends Direction, L, R> = Equal<L, R> extends true ? EqualType<D, L, R> : IncludeButNotEqual<L, R> extends true ? StrictIncludeType<'LR', D, L, R> : IncludeButNotEqual<R, L> extends true ? StrictIncludeType<'RL', D, L, R> : IntersectButNotEqual<L, R> extends true ? IntersectButNotEqualType<D, L, R> : NotIntersect<L, R> extends true ? NotIntersectType<D, L, R> : never;
+type SyncRefOptions<L, R, D extends Direction> = ConfigurableFlushSync & {
     /**
      * Watch deeply
      *
@@ -468,22 +539,18 @@ interface SyncRefOptions<L, R = L> extends ConfigurableFlushSync {
      *
      * @default 'both'
      */
-    direction?: 'ltr' | 'rtl' | 'both';
-    /**
-     * Custom transform function
-     */
-    transform?: {
-        ltr?: (left: L) => R;
-        rtl?: (right: R) => L;
-    };
-}
+    direction?: D;
+} & TransformType<D, L, R>;
 /**
  * Two-way refs synchronization.
- *
- * @param left
- * @param right
+ * From the set theory perspective to restrict the option's type
+ * Check in the following order:
+ * 1. L = R
+ * 2. L ∩ R ≠ ∅
+ * 3. L ⊆ R
+ * 4. L ∩ R = ∅
  */
-declare function syncRef<L, R = L>(left: Ref<L>, right: Ref<R>, options?: SyncRefOptions<L, R>): () => void;
+declare function syncRef<L, R, D extends Direction>(left: Ref<L>, right: Ref<R>, ...[options]: Equal<L, R> extends true ? [options?: SyncRefOptions<L, R, D>] : [options: SyncRefOptions<L, R, D>]): () => void;
 
 interface SyncRefsOptions extends ConfigurableFlushSync {
     /**
@@ -660,10 +727,10 @@ declare function useArrayDifference<T>(list: MaybeRefOrGetter<T[]>, values: Mayb
  * Reactive `Array.every`
  *
  * @see https://vueuse.org/useArrayEvery
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param fn - a function to test each element.
  *
- * @returns {boolean} **true** if the `fn` function returns a **truthy** value for every element from the array. Otherwise, **false**.
+ * @returns **true** if the `fn` function returns a **truthy** value for every element from the array. Otherwise, **false**.
  */
 declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): ComputedRef<boolean>;
 
@@ -671,10 +738,10 @@ declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
  * Reactive `Array.filter`
  *
  * @see https://vueuse.org/useArrayFilter
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
  *
- * @returns {Array} a shallow copy of a portion of the given array, filtered down to just the elements from the given array that pass the test implemented by the provided function. If no elements pass the test, an empty array will be returned.
+ * @returns a shallow copy of a portion of the given array, filtered down to just the elements from the given array that pass the test implemented by the provided function. If no elements pass the test, an empty array will be returned.
  */
 declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => boolean): ComputedRef<T[]>;
 
@@ -682,7 +749,7 @@ declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>
  * Reactive `Array.find`
  *
  * @see https://vueuse.org/useArrayFind
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param fn - a function to test each element.
  *
  * @returns the first element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
@@ -693,10 +760,10 @@ declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>,
  * Reactive `Array.findIndex`
  *
  * @see https://vueuse.org/useArrayFindIndex
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param fn - a function to test each element.
  *
- * @returns {number} the index of the first element in the array that passes the test. Otherwise, "-1".
+ * @returns the index of the first element in the array that passes the test. Otherwise, "-1".
  */
 declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): ComputedRef<number>;
 
@@ -704,7 +771,7 @@ declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>
  * Reactive `Array.findLast`
  *
  * @see https://vueuse.org/useArrayFindLast
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param fn - a function to test each element.
  *
  * @returns the last element in the array that satisfies the provided testing function. Otherwise, undefined is returned.
@@ -716,6 +783,13 @@ interface UseArrayIncludesOptions<T, V> {
     fromIndex?: number;
     comparator?: UseArrayIncludesComparatorFn<T, V> | keyof T;
 }
+/**
+ * Reactive `Array.includes`
+ *
+ * @see https://vueuse.org/useArrayIncludes
+ *
+ * @returns true if the `value` is found in the array. Otherwise, false.
+ */
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): ComputedRef<boolean>;
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: keyof T): ComputedRef<boolean>;
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, options?: UseArrayIncludesOptions<T, V>): ComputedRef<boolean>;
@@ -724,10 +798,10 @@ declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrG
  * Reactive `Array.join`
  *
  * @see https://vueuse.org/useArrayJoin
- * @param {Array} list - the array was called upon.
- * @param {string} separator - a string to separate each pair of adjacent elements of the array. If omitted, the array elements are separated with a comma (",").
+ * @param list - the array was called upon.
+ * @param separator - a string to separate each pair of adjacent elements of the array. If omitted, the array elements are separated with a comma (",").
  *
- * @returns {string} a string with all array elements joined. If arr.length is 0, the empty string is returned.
+ * @returns a string with all array elements joined. If arr.length is 0, the empty string is returned.
  */
 declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): ComputedRef<string>;
 
@@ -735,10 +809,10 @@ declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, s
  * Reactive `Array.map`
  *
  * @see https://vueuse.org/useArrayMap
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param fn - a function that is called for every element of the given `list`. Each time `fn` executes, the returned value is added to the new array.
  *
- * @returns {Array} a new array with each element being the result of the callback function.
+ * @returns a new array with each element being the result of the callback function.
  */
 declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): ComputedRef<U[]>;
 
@@ -747,7 +821,7 @@ type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentI
  * Reactive `Array.reduce`
  *
  * @see https://vueuse.org/useArrayReduce
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param reducer - a "reducer" function.
  *
  * @returns the value that results from running the "reducer" callback function to completion over the entire array.
@@ -757,7 +831,7 @@ declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>
  * Reactive `Array.reduce`
  *
  * @see https://vueuse.org/useArrayReduce
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param reducer - a "reducer" function.
  * @param initialValue - a value to be initialized the first time when the callback is called.
  *
@@ -769,19 +843,19 @@ declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>
  * Reactive `Array.some`
  *
  * @see https://vueuse.org/useArraySome
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param fn - a function to test each element.
  *
- * @returns {boolean} **true** if the `fn` function returns a **truthy** value for any element from the array. Otherwise, **false**.
+ * @returns **true** if the `fn` function returns a **truthy** value for any element from the array. Otherwise, **false**.
  */
 declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): ComputedRef<boolean>;
 
 /**
  * reactive unique array
  * @see https://vueuse.org/useArrayUnique
- * @param {Array} list - the array was called upon.
+ * @param list - the array was called upon.
  * @param compareFn
- * @returns {Array} A computed ref that returns a unique array of items.
+ * @returns A computed ref that returns a unique array of items.
  */
 declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): ComputedRef<T[]>;
 
@@ -793,8 +867,8 @@ interface UseCounterOptions {
  * Basic counter with utility functions.
  *
  * @see https://vueuse.org/useCounter
- * @param [initialValue=0]
- * @param {Object} options
+ * @param [initialValue]
+ * @param options
  */
 declare function useCounter(initialValue?: MaybeRef$1<number>, options?: UseCounterOptions): {
     count: vue_demi.Ref<number>;
@@ -838,7 +912,7 @@ type UseDateFormatReturn = ReturnType<typeof useDateFormat>;
  * @see https://vueuse.org/useDebounceFn
  * @param  fn          A function to be executed after delay milliseconds debounced.
  * @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
- * @param  opts        options
+ * @param  options     Options
  *
  * @return A new, debounce, function.
  */
@@ -908,8 +982,7 @@ interface UseLastChangedOptions<Immediate extends boolean, InitialValue extends
  * @see https://vueuse.org/useLastChanged
  */
 declare function useLastChanged(source: WatchSource, options?: UseLastChangedOptions<false>): Ref<number | null>;
-declare function useLastChanged(source: WatchSource, options: UseLastChangedOptions<true>): Ref<number>;
-declare function useLastChanged(source: WatchSource, options: UseLastChangedOptions<boolean, number>): Ref<number>;
+declare function useLastChanged(source: WatchSource, options: UseLastChangedOptions<true> | UseLastChangedOptions<boolean, number>): Ref<number>;
 
 /**
  * Throttle execution of a function. Especially useful for rate limiting
@@ -919,11 +992,11 @@ declare function useLastChanged(source: WatchSource, options: UseLastChangedOpti
  *                                    to `callback` when the throttled-function is executed.
  * @param   ms             A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
  *
- * @param [trailing=false] if true, call fn again after the time is up
+ * @param [trailing] if true, call fn again after the time is up
  *
- * @param [leading=true] if true, call fn on the leading edge of the ms timeout
+ * @param [leading] if true, call fn on the leading edge of the ms timeout
  *
- * @param [rejectOnCancel=false] if true, reject the last call if it's been cancel
+ * @param [rejectOnCancel] if true, reject the last call if it's been cancel
  *
  * @return  A new, throttled, function.
  */
@@ -1057,8 +1130,8 @@ declare function watchImmediate<T extends Readonly<MultiWatchSources>>(source: T
 declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
 declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchStopHandle;
 
-declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchOptions<Immediate>): void;
-declare function watchOnce<T, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): void;
+declare function watchOnce<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
+declare function watchOnce<T, Immediate extends Readonly<boolean> = false>(sources: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
 
 interface WatchPausableReturn extends Pausable {
     stop: WatchStopHandle;
@@ -1093,4 +1166,4 @@ declare function watchTriggerable<T extends object, FnReturnT>(source: T, cb: Wa
  */
 declare function whenever<T>(source: WatchSource<T | false | null | undefined>, cb: WatchCallback<T>, options?: WatchOptions): vue_demi.WatchStopHandle;
 
-export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IgnoredUpdater, type MapOldSources, type MapSources, type MaybeRef, type MaybeRefOrGetter, type MultiWatchSources, type Mutable, type Pausable, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, directiveHooks, computedEager as eagerComputed, extendRef, formatDate, get, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, invoke, isClient, isDef, isDefined, isIOS, isObject, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };
+export { type AnyFn, type ArgumentsType, type Arrayable, type Awaitable, type Awaited, type ComputedRefWithControl, type ComputedWithControlRefExtra, type ConfigurableEventFilter, type ConfigurableFlush, type ConfigurableFlushSync, type ControlledRefOptions, type CreateInjectionStateOptions, type DateLike, type DebounceFilterOptions, type DeepMaybeRef, type ElementOf, type EventFilter, type EventHook, type EventHookOff, type EventHookOn, type EventHookTrigger, type ExtendRefOptions, type Fn, type FunctionArgs, type FunctionWrapperOptions, type IgnoredUpdater, type MapOldSources, type MapSources, type MaybeRef, type MaybeRefOrGetter, type MultiWatchSources, type Mutable, type Pausable, type Promisify, type PromisifyFn, type Reactified, type ReactifyNested, type ReactifyObjectOptions, type ReactifyOptions, type ReactiveOmitPredicate, type ReactivePickPredicate, type ReadonlyRefOrGetter, type RemovableRef, type ShallowUnwrapRef, type SingletonPromiseReturn, type Stoppable, type SyncRefOptions, type SyncRefsOptions, type ToRefsOptions, type UntilArrayInstance, type UntilBaseInstance, type UntilToMatchOptions, type UntilValueInstance, type UseArrayIncludesComparatorFn, type UseArrayIncludesOptions, type UseArrayReducer, type UseCounterOptions, type UseDateFormatOptions, type UseDateFormatReturn, type UseIntervalControls, type UseIntervalFnOptions, type UseIntervalOptions, type UseLastChangedOptions, type UseTimeoutFnOptions, type UseTimeoutOptions, type UseToNumberOptions, type UseToggleOptions, type WatchArrayCallback, type WatchAtMostOptions, type WatchAtMostReturn, type WatchDebouncedOptions, type WatchIgnorableReturn, type WatchPausableReturn, type WatchThrottledOptions, type WatchTriggerableCallback, type WatchTriggerableReturn, type WatchWithFilterOptions, type WritableComputedRefWithControl, assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, directiveHooks, computedEager as eagerComputed, extendRef, formatDate, get, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };