@vueuse/shared 13.5.0 → 13.7.0

package/index.d.mts

@@ -166,6 +166,8 @@ type EventHookReturn<T> = EventHook<T>;
  * Utility for creating event hooks
  *
  * @see https://vueuse.org/createEventHook
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function createEventHook<T = any>(): EventHookReturn<T>;
 
@@ -226,11 +228,6 @@ interface ThrottleFilterOptions {
 }
 /**
  * Create an EventFilter that throttle the events
- *
- * @param ms
- * @param [trailing]
- * @param [leading]
- * @param [rejectOnCancel]
  */
 declare function throttleFilter(ms: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): EventFilter;
 declare function throttleFilter(options: ThrottleFilterOptions): EventFilter;
@@ -327,6 +324,8 @@ type CreateGlobalStateReturn<Fn extends AnyFn = AnyFn> = Fn;
  *
  * @see https://vueuse.org/createGlobalState
  * @param stateFactory A factory function to create the state
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function createGlobalState<Fn extends AnyFn>(stateFactory: Fn): CreateGlobalStateReturn<Fn>;
 
@@ -345,6 +344,7 @@ interface CreateInjectionStateOptions<Return> {
  *
  * @see https://vueuse.org/createInjectionState
  *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function createInjectionState<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options?: CreateInjectionStateOptions<Return>): readonly [useProvidingState: (...args: Arguments) => Return, useInjectedState: () => Return | undefined];
 
@@ -362,6 +362,8 @@ type ShallowOrDeepRef<T = any, D extends boolean = false> = D extends true ? Ref
  * @param value
  * @param deep
  * @returns the `deepRef` or `shallowRef`
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function createRef<T = any, D extends boolean = false>(value: T, deep?: D): CreateRefReturn<T, D>;
 
@@ -370,6 +372,8 @@ type SharedComposableReturn<T extends AnyFn = AnyFn> = T;
  * Make a composable function usable with multiple Vue instances.
  *
  * @see https://vueuse.org/createSharedComposable
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function createSharedComposable<Fn extends AnyFn>(composable: Fn): SharedComposableReturn<Fn>;
 
@@ -411,6 +415,8 @@ declare function get<T, K extends keyof T>(ref: MaybeRef<T>, key: K): T[K];
  * injectLocal('MyInjectionKey', 1)
  * const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
  * ```
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare const injectLocal: typeof inject;
 
@@ -452,6 +458,8 @@ interface ReactifyOptions<T extends boolean> {
  *
  * @param fn - Source function
  * @param options - Options
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function reactify<T extends AnyFn, K extends boolean = true>(fn: T, options?: ReactifyOptions<K>): ReactifyReturn<T, K>;
 
@@ -469,6 +477,8 @@ interface ReactifyObjectOptions<T extends boolean> extends ReactifyOptions<T> {
 }
 /**
  * Apply `reactify` to an object
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function reactifyObject<T extends object, Keys extends keyof T>(obj: T, keys?: (keyof T)[]): ReactifyObjectReturn<T, Keys, true>;
 declare function reactifyObject<T extends object, S extends boolean = true>(obj: T, options?: ReactifyObjectOptions<S>): ReactifyObjectReturn<T, keyof T, S>;
@@ -511,6 +521,8 @@ declare function refDebounced<T>(value: Ref<T>, ms?: MaybeRefOrGetter<number>, o
 
 /**
  * Apply default value to a ref.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function refDefault<T>(source: Ref<T | undefined | null>, defaultValue: T): Ref<T>;
 
@@ -542,6 +554,8 @@ interface ControlledRefOptions<T> {
 }
 /**
  * Fine-grained controls over ref and its reactivity.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function refWithControl<T>(initial: T, options?: ControlledRefOptions<T>): vue.ShallowUnwrapRef<{
     get: (tracking?: boolean) => T;
@@ -826,6 +840,8 @@ type UseArrayEveryReturn = ComputedRef<boolean>;
  * @param fn - a function to test each element.
  *
  * @returns **true** if the `fn` function returns a **truthy** value for every element from the array. Otherwise, **false**.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayEvery<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayEveryReturn;
 
@@ -838,6 +854,8 @@ type UseArrayFilterReturn<T = any> = ComputedRef<T[]>;
  * @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 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.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayFilter<T, S extends T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => element is S): UseArrayFilterReturn<S>;
 declare function useArrayFilter<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => unknown): UseArrayFilterReturn<T>;
@@ -851,6 +869,8 @@ type UseArrayFindReturn<T = any> = ComputedRef<T | undefined>;
  * @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.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayFind<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindReturn<T>;
 
@@ -863,6 +883,8 @@ type UseArrayFindIndexReturn = ComputedRef<number>;
  * @param fn - a function to test each element.
  *
  * @returns the index of the first element in the array that passes the test. Otherwise, "-1".
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayFindIndex<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArrayFindIndexReturn;
 
@@ -875,6 +897,8 @@ type UseArrayFindLastReturn<T = any> = ComputedRef<T | undefined>;
  * @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.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayFindLast<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => boolean): UseArrayFindLastReturn<T>;
 
@@ -890,6 +914,8 @@ type UseArrayIncludesReturn = ComputedRef<boolean>;
  * @see https://vueuse.org/useArrayIncludes
  *
  * @returns true if the `value` is found in the array. Otherwise, false.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: UseArrayIncludesComparatorFn<T, V>): UseArrayIncludesReturn;
 declare function useArrayIncludes<T, V = any>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, value: MaybeRefOrGetter<V>, comparator?: keyof T): UseArrayIncludesReturn;
@@ -904,6 +930,8 @@ type UseArrayJoinReturn = ComputedRef<string>;
  * @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 a string with all array elements joined. If arr.length is 0, the empty string is returned.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayJoin(list: MaybeRefOrGetter<MaybeRefOrGetter<any>[]>, separator?: MaybeRefOrGetter<string>): UseArrayJoinReturn;
 
@@ -916,6 +944,8 @@ type UseArrayMapReturn<T = any> = ComputedRef<T[]>;
  * @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 a new array with each element being the result of the callback function.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayMap<T, U = T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: T[]) => U): UseArrayMapReturn<U>;
 
@@ -928,6 +958,8 @@ type UseArrayReducer<PV, CV, R> = (previousValue: PV, currentValue: CV, currentI
  * @param reducer - a "reducer" function.
  *
  * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<T, T, T>): ComputedRef<T>;
 /**
@@ -939,6 +971,8 @@ declare function useArrayReduce<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>
  * @param initialValue - a value to be initialized the first time when the callback is called.
  *
  * @returns the value that results from running the "reducer" callback function to completion over the entire array.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayReduce<T, U>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, reducer: UseArrayReducer<U, T, U>, initialValue: MaybeRefOrGetter<U>): ComputedRef<U>;
 
@@ -951,6 +985,8 @@ type UseArraySomeReturn = ComputedRef<boolean>;
  * @param fn - a function to test each element.
  *
  * @returns **true** if the `fn` function returns a **truthy** value for any element from the array. Otherwise, **false**.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArraySome<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, fn: (element: T, index: number, array: MaybeRefOrGetter<T>[]) => unknown): UseArraySomeReturn;
 
@@ -961,6 +997,8 @@ type UseArrayUniqueReturn<T = any> = ComputedRef<T[]>;
  * @param list - the array was called upon.
  * @param compareFn
  * @returns A computed ref that returns a unique array of items.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useArrayUnique<T>(list: MaybeRefOrGetter<MaybeRefOrGetter<T>[]>, compareFn?: (a: T, b: T, array: T[]) => boolean): UseArrayUniqueReturn<T>;
 
@@ -1040,6 +1078,8 @@ type UseDateFormatReturn = ComputedRef<string>;
  * @param date - The date to format, can either be a `Date` object, a timestamp, or a string
  * @param formatStr - The combination of tokens to format the date
  * @param options - UseDateFormatOptions
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useDateFormat(date: MaybeRefOrGetter<DateLike>, formatStr?: MaybeRefOrGetter<string>, options?: UseDateFormatOptions): UseDateFormatReturn;
 
@@ -1053,6 +1093,8 @@ type UseDebounceFnReturn<T extends FunctionArgs> = PromisifyFn<T>;
  * @param  options     Options
  *
  * @return A new, debounce, function.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useDebounceFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, options?: DebounceFilterOptions): UseDebounceFnReturn<T>;
 
@@ -1142,6 +1184,8 @@ declare function useLastChanged(source: WatchSource, options: UseLastChangedOpti
  * @param [rejectOnCancel] if true, reject the last call if it's been cancel (default value: false)
  *
  * @return  A new, throttled, function.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useThrottleFn<T extends FunctionArgs>(fn: T, ms?: MaybeRefOrGetter<number>, trailing?: boolean, leading?: boolean, rejectOnCancel?: boolean): PromisifyFn<T>;
 
@@ -1219,6 +1263,8 @@ interface UseToNumberOptions {
 }
 /**
  * Reactively convert a string ref to number.
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useToNumber(value: MaybeRefOrGetter<number | string>, options?: UseToNumberOptions): ComputedRef<number>;
 
@@ -1226,6 +1272,8 @@ declare function useToNumber(value: MaybeRefOrGetter<number | string>, options?:
  * Reactively convert a ref to string.
  *
  * @see https://vueuse.org/useToString
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 declare function useToString(value: MaybeRefOrGetter<unknown>): ComputedRef<string>;
 

package/index.iife.js

@@ -54,6 +54,7 @@
     return false;
   }
 
+  // @__NO_SIDE_EFFECTS__
   function createEventHook() {
     const fns = /* @__PURE__ */ new Set();
     const off = (fn) => {
@@ -81,6 +82,7 @@
     };
   }
 
+  // @__NO_SIDE_EFFECTS__
   function createGlobalState(stateFactory) {
     let initialized = false;
     let state;
@@ -96,7 +98,7 @@
 
   const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
 
-  const injectLocal = (...args) => {
+  const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
     var _a;
     const key = args[0];
     const instance = (_a = vue.getCurrentInstance()) == null ? void 0 : _a.proxy;
@@ -119,6 +121,7 @@
     return vue.provide(key, value);
   }
 
+  // @__NO_SIDE_EFFECTS__
   function createInjectionState(composable, options) {
     const key = (options == null ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
     const defaultValue = options == null ? void 0 : options.defaultValue;
@@ -131,6 +134,7 @@
     return [useProvidingState, useInjectedState];
   }
 
+  // @__NO_SIDE_EFFECTS__
   function createRef(value, deep) {
     if (deep === true) {
       return vue.ref(value);
@@ -139,6 +143,7 @@
     }
   }
 
+  // @__NO_SIDE_EFFECTS__
   function createSharedComposable(composable) {
     let subscribers = 0;
     let state;
@@ -193,6 +198,7 @@
     return vue.unref(v) != null;
   }
 
+  // @__NO_SIDE_EFFECTS__
   function makeDestructurable(obj, arr) {
     if (typeof Symbol !== "undefined") {
       const clone = { ...obj };
@@ -214,6 +220,7 @@
     }
   }
 
+  // @__NO_SIDE_EFFECTS__
   function reactify(fn, options) {
     const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? vue.unref : vue.toValue;
     return function(...args) {
@@ -221,6 +228,7 @@
     };
   }
 
+  // @__NO_SIDE_EFFECTS__
   function reactifyObject(obj, optionsOrKeys = {}) {
     let keys = [];
     let options;
@@ -565,6 +573,7 @@
     return target || vue.getCurrentInstance();
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useDebounceFn(fn, ms = 200, options = {}) {
     return createFilterWrapper(
       debounceFilter(ms, options),
@@ -581,6 +590,7 @@
     return vue.shallowReadonly(debounced);
   }
 
+  // @__NO_SIDE_EFFECTS__
   function refDefault(source, defaultValue) {
     return vue.computed({
       get() {
@@ -593,6 +603,7 @@
     });
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
     return createFilterWrapper(
       throttleFilter(ms, trailing, leading, rejectOnCancel),
@@ -611,6 +622,7 @@
     return throttled;
   }
 
+  // @__NO_SIDE_EFFECTS__
   function refWithControl(initial, options = {}) {
     let source = initial;
     let track;
@@ -954,6 +966,7 @@
   function defaultComparator(value, othVal) {
     return value === othVal;
   }
+  // @__NO_SIDE_EFFECTS__
   function useArrayDifference(...args) {
     var _a, _b;
     const list = args[0];
@@ -975,20 +988,24 @@
     }
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArrayEvery(list, fn) {
     return vue.computed(() => vue.toValue(list).every((element, index, array) => fn(vue.toValue(element), index, array)));
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArrayFilter(list, fn) {
     return vue.computed(() => vue.toValue(list).map((i) => vue.toValue(i)).filter(fn));
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArrayFind(list, fn) {
     return vue.computed(() => vue.toValue(
       vue.toValue(list).find((element, index, array) => fn(vue.toValue(element), index, array))
     ));
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArrayFindIndex(list, fn) {
     return vue.computed(() => vue.toValue(list).findIndex((element, index, array) => fn(vue.toValue(element), index, array)));
   }
@@ -1001,6 +1018,7 @@
     }
     return void 0;
   }
+  // @__NO_SIDE_EFFECTS__
   function useArrayFindLast(list, fn) {
     return vue.computed(() => vue.toValue(
       !Array.prototype.findLast ? findLast(vue.toValue(list), (element, index, array) => fn(vue.toValue(element), index, array)) : vue.toValue(list).findLast((element, index, array) => fn(vue.toValue(element), index, array))
@@ -1010,6 +1028,7 @@
   function isArrayIncludesOptions(obj) {
     return isObject(obj) && containsProp(obj, "formIndex", "comparator");
   }
+  // @__NO_SIDE_EFFECTS__
   function useArrayIncludes(...args) {
     var _a;
     const list = args[0];
@@ -1033,14 +1052,17 @@
     )));
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArrayJoin(list, separator) {
     return vue.computed(() => vue.toValue(list).map((i) => vue.toValue(i)).join(vue.toValue(separator)));
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArrayMap(list, fn) {
     return vue.computed(() => vue.toValue(list).map((i) => vue.toValue(i)).map(fn));
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArrayReduce(list, reducer, ...args) {
     const reduceCallback = (sum, value, index) => reducer(vue.toValue(sum), vue.toValue(value), index);
     return vue.computed(() => {
@@ -1049,6 +1071,7 @@
     });
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useArraySome(list, fn) {
     return vue.computed(() => vue.toValue(list).some((element, index, array) => fn(vue.toValue(element), index, array)));
   }
@@ -1063,6 +1086,7 @@
       return acc;
     }, []);
   }
+  // @__NO_SIDE_EFFECTS__
   function useArrayUnique(list, compareFn) {
     return vue.computed(() => {
       const resolvedList = vue.toValue(list).map((element) => vue.toValue(element));
@@ -1176,6 +1200,7 @@
     }
     return new Date(date);
   }
+  // @__NO_SIDE_EFFECTS__
   function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
     return vue.computed(() => formatDate(normalizeDate(vue.toValue(date)), vue.toValue(formatStr), options));
   }
@@ -1328,6 +1353,7 @@
     }
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useToNumber(value, options = {}) {
     const {
       method = "parseFloat",
@@ -1346,10 +1372,12 @@
     });
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useToString(value) {
     return vue.computed(() => `${vue.toValue(value)}`);
   }
 
+  // @__NO_SIDE_EFFECTS__
   function useToggle(initialValue = false, options = {}) {
     const {
       truthyValue = true,

package/index.mjs

@@ -53,6 +53,7 @@ function tryOnScopeDispose(fn) {
   return false;
 }
 
+// @__NO_SIDE_EFFECTS__
 function createEventHook() {
   const fns = /* @__PURE__ */ new Set();
   const off = (fn) => {
@@ -80,6 +81,7 @@ function createEventHook() {
   };
 }
 
+// @__NO_SIDE_EFFECTS__
 function createGlobalState(stateFactory) {
   let initialized = false;
   let state;
@@ -95,7 +97,7 @@ function createGlobalState(stateFactory) {
 
 const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
 
-const injectLocal = (...args) => {
+const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
   var _a;
   const key = args[0];
   const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
@@ -118,6 +120,7 @@ function provideLocal(key, value) {
   return provide(key, value);
 }
 
+// @__NO_SIDE_EFFECTS__
 function createInjectionState(composable, options) {
   const key = (options == null ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
   const defaultValue = options == null ? void 0 : options.defaultValue;
@@ -130,6 +133,7 @@ function createInjectionState(composable, options) {
   return [useProvidingState, useInjectedState];
 }
 
+// @__NO_SIDE_EFFECTS__
 function createRef(value, deep) {
   if (deep === true) {
     return ref(value);
@@ -138,6 +142,7 @@ function createRef(value, deep) {
   }
 }
 
+// @__NO_SIDE_EFFECTS__
 function createSharedComposable(composable) {
   let subscribers = 0;
   let state;
@@ -192,6 +197,7 @@ function isDefined(v) {
   return unref(v) != null;
 }
 
+// @__NO_SIDE_EFFECTS__
 function makeDestructurable(obj, arr) {
   if (typeof Symbol !== "undefined") {
     const clone = { ...obj };
@@ -213,6 +219,7 @@ function makeDestructurable(obj, arr) {
   }
 }
 
+// @__NO_SIDE_EFFECTS__
 function reactify(fn, options) {
   const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? unref : toValue$1;
   return function(...args) {
@@ -220,6 +227,7 @@ function reactify(fn, options) {
   };
 }
 
+// @__NO_SIDE_EFFECTS__
 function reactifyObject(obj, optionsOrKeys = {}) {
   let keys = [];
   let options;
@@ -564,6 +572,7 @@ function getLifeCycleTarget(target) {
   return target || getCurrentInstance();
 }
 
+// @__NO_SIDE_EFFECTS__
 function useDebounceFn(fn, ms = 200, options = {}) {
   return createFilterWrapper(
     debounceFilter(ms, options),
@@ -580,6 +589,7 @@ function refDebounced(value, ms = 200, options = {}) {
   return shallowReadonly(debounced);
 }
 
+// @__NO_SIDE_EFFECTS__
 function refDefault(source, defaultValue) {
   return computed({
     get() {
@@ -592,6 +602,7 @@ function refDefault(source, defaultValue) {
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
   return createFilterWrapper(
     throttleFilter(ms, trailing, leading, rejectOnCancel),
@@ -610,6 +621,7 @@ function refThrottled(value, delay = 200, trailing = true, leading = true) {
   return throttled;
 }
 
+// @__NO_SIDE_EFFECTS__
 function refWithControl(initial, options = {}) {
   let source = initial;
   let track;
@@ -953,6 +965,7 @@ function until(r) {
 function defaultComparator(value, othVal) {
   return value === othVal;
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayDifference(...args) {
   var _a, _b;
   const list = args[0];
@@ -974,20 +987,24 @@ function useArrayDifference(...args) {
   }
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayEvery(list, fn) {
   return computed(() => toValue$1(list).every((element, index, array) => fn(toValue$1(element), index, array)));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayFilter(list, fn) {
   return computed(() => toValue$1(list).map((i) => toValue$1(i)).filter(fn));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayFind(list, fn) {
   return computed(() => toValue$1(
     toValue$1(list).find((element, index, array) => fn(toValue$1(element), index, array))
   ));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayFindIndex(list, fn) {
   return computed(() => toValue$1(list).findIndex((element, index, array) => fn(toValue$1(element), index, array)));
 }
@@ -1000,6 +1017,7 @@ function findLast(arr, cb) {
   }
   return void 0;
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayFindLast(list, fn) {
   return computed(() => toValue$1(
     !Array.prototype.findLast ? findLast(toValue$1(list), (element, index, array) => fn(toValue$1(element), index, array)) : toValue$1(list).findLast((element, index, array) => fn(toValue$1(element), index, array))
@@ -1009,6 +1027,7 @@ function useArrayFindLast(list, fn) {
 function isArrayIncludesOptions(obj) {
   return isObject(obj) && containsProp(obj, "formIndex", "comparator");
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayIncludes(...args) {
   var _a;
   const list = args[0];
@@ -1032,14 +1051,17 @@ function useArrayIncludes(...args) {
   )));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayJoin(list, separator) {
   return computed(() => toValue$1(list).map((i) => toValue$1(i)).join(toValue$1(separator)));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayMap(list, fn) {
   return computed(() => toValue$1(list).map((i) => toValue$1(i)).map(fn));
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArrayReduce(list, reducer, ...args) {
   const reduceCallback = (sum, value, index) => reducer(toValue$1(sum), toValue$1(value), index);
   return computed(() => {
@@ -1048,6 +1070,7 @@ function useArrayReduce(list, reducer, ...args) {
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 function useArraySome(list, fn) {
   return computed(() => toValue$1(list).some((element, index, array) => fn(toValue$1(element), index, array)));
 }
@@ -1062,6 +1085,7 @@ function uniqueElementsBy(array, fn) {
     return acc;
   }, []);
 }
+// @__NO_SIDE_EFFECTS__
 function useArrayUnique(list, compareFn) {
   return computed(() => {
     const resolvedList = toValue$1(list).map((element) => toValue$1(element));
@@ -1175,6 +1199,7 @@ function normalizeDate(date) {
   }
   return new Date(date);
 }
+// @__NO_SIDE_EFFECTS__
 function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
   return computed(() => formatDate(normalizeDate(toValue$1(date)), toValue$1(formatStr), options));
 }
@@ -1327,6 +1352,7 @@ function useTimeout(interval = 1e3, options = {}) {
   }
 }
 
+// @__NO_SIDE_EFFECTS__
 function useToNumber(value, options = {}) {
   const {
     method = "parseFloat",
@@ -1345,10 +1371,12 @@ function useToNumber(value, options = {}) {
   });
 }
 
+// @__NO_SIDE_EFFECTS__
 function useToString(value) {
   return computed(() => `${toValue$1(value)}`);
 }
 
+// @__NO_SIDE_EFFECTS__
 function useToggle(initialValue = false, options = {}) {
   const {
     truthyValue = true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vueuse/shared",
   "type": "module",
-  "version": "13.5.0",
+  "version": "13.7.0",
   "author": "Anthony Fu <https://github.com/antfu>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/antfu",