refactor: add treeshake annotation for @Math category

vueuse · antfu · Jul 28, 2025 · Jul 22, 2025 · Jul 22, 2025 · Jul 23, 2025
commit bde435c552e559d0c79e7a742d947d11248abd9b
diff --git a/packages/math/createGenericProjection/index.ts b/packages/math/createGenericProjection/index.ts
@@ -5,6 +5,7 @@ export type ProjectorFunction<F, T> = (input: F, from: readonly [F, F], to: read
 
 export type UseProjection<F, T> = (input: MaybeRefOrGetter<F>) => ComputedRef<T>
 
+/* @__NO_SIDE_EFFECTS__ */
 export function createGenericProjection<F = number, T = number>(
   fromDomain: MaybeRefOrGetter<readonly [F, F]>,
   toDomain: MaybeRefOrGetter<readonly [T, T]>,

diff --git a/packages/math/createProjection/index.ts b/packages/math/createProjection/index.ts
@@ -6,6 +6,7 @@ function defaultNumericProjector(input: number, from: readonly [number, number],
   return (input - from[0]) / (from[1] - from[0]) * (to[1] - to[0]) + to[0]
 }
 
+/* @__NO_SIDE_EFFECTS__ */
 export function createProjection(
   fromDomain: MaybeRefOrGetter<readonly [number, number]>,
   toDomain: MaybeRefOrGetter<readonly [number, number]>,

diff --git a/packages/math/logicAnd/index.ts b/packages/math/logicAnd/index.ts
@@ -5,6 +5,8 @@ import { computed, toValue } from 'vue'
  * `AND` conditions for refs.
  *
  * @see https://vueuse.org/logicAnd
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function logicAnd(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean> {
   return computed(() => args.every(i => toValue(i)))

diff --git a/packages/math/logicNot/index.ts b/packages/math/logicNot/index.ts
@@ -6,6 +6,8 @@ import { computed, toValue } from 'vue'
  * `NOT` conditions for refs.
  *
  * @see https://vueuse.org/logicNot
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function logicNot(v: MaybeRefOrGetter<any>): ComputedRef<boolean> {
   return computed(() => !toValue(v))

diff --git a/packages/math/logicOr/index.ts b/packages/math/logicOr/index.ts
@@ -5,6 +5,8 @@ import { computed, toValue } from 'vue'
  * `OR` conditions for refs.
  *
  * @see https://vueuse.org/logicOr
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function logicOr(...args: MaybeRefOrGetter<any>[]): ComputedRef<boolean> {
   return computed(() => args.some(i => toValue(i)))

diff --git a/packages/math/useAbs/index.ts b/packages/math/useAbs/index.ts
@@ -5,6 +5,8 @@ import { computed, toValue } from 'vue'
  * Reactive `Math.abs`.
  *
  * @see https://vueuse.org/useAbs
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useAbs(value: MaybeRefOrGetter<number>): ComputedRef<number> {
   return computed(() => Math.abs(toValue(value)))

diff --git a/packages/math/useAverage/index.ts b/packages/math/useAverage/index.ts
@@ -10,6 +10,8 @@ export function useAverage(...args: MaybeRefOrGetter<number>[]): ComputedRef<num
  * Get the average of an array reactively
  *
  * @see https://vueuse.org/useAverage
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useAverage(...args: MaybeComputedRefArgs<number>): ComputedRef<number> {
   return computed(() => {

diff --git a/packages/math/useCeil/index.ts b/packages/math/useCeil/index.ts
@@ -5,6 +5,8 @@ import { computed, toValue } from 'vue'
  * Reactive `Math.ceil`.
  *
  * @see https://vueuse.org/useCeil
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useCeil(value: MaybeRefOrGetter<number>): ComputedRef<number> {
   return computed<number>(() => Math.ceil(toValue(value)))

diff --git a/packages/math/useClamp/index.ts b/packages/math/useClamp/index.ts
@@ -10,6 +10,8 @@ import { computed, ref as deepRef, isReadonly, toValue } from 'vue'
  * @param value number
  * @param min
  * @param max
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useClamp(
   value: ReadonlyRefOrGetter<number>,
@@ -21,6 +23,17 @@ export function useClamp(
   min: MaybeRefOrGetter<number>,
   max: MaybeRefOrGetter<number>,
 ): Ref<number>
+
+/**
+ * Reactively clamp a value between two other values.
+ *
+ * @see https://vueuse.org/useClamp
+ * @param value number
+ * @param min
+ * @param max
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
 export function useClamp(value: MaybeRefOrGetter<number>, min: MaybeRefOrGetter<number>, max: MaybeRefOrGetter<number>) {
   if (typeof value === 'function' || isReadonly(value))
     return computed(() => clamp(toValue(value), toValue(min), toValue(max)))

diff --git a/packages/math/useFloor/index.ts b/packages/math/useFloor/index.ts
@@ -5,6 +5,8 @@ import { computed, toValue } from 'vue'
  * Reactive `Math.floor`
  *
  * @see https://vueuse.org/useFloor
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useFloor(value: MaybeRefOrGetter<number>): ComputedRef<number> {
   return computed<number>(() => Math.floor(toValue(value)))

diff --git a/packages/math/useMath/index.ts b/packages/math/useMath/index.ts
@@ -7,6 +7,8 @@ export type UseMathKeys = keyof { [K in keyof Math as Math[K] extends (...args:
  * Reactive `Math` methods.
  *
  * @see https://vueuse.org/useMath
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useMath<K extends keyof Math>(
   key: K,

diff --git a/packages/math/useMax/index.ts b/packages/math/useMax/index.ts
@@ -10,6 +10,8 @@ export function useMax(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>
  * Reactively get maximum of values.
  *
  * @see https://vueuse.org/useMax
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useMax(...args: MaybeComputedRefArgs<number>) {
   return computed<number>(() => {

diff --git a/packages/math/useMin/index.ts b/packages/math/useMin/index.ts
@@ -10,6 +10,8 @@ export function useMin(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>
  * Reactive `Math.min`.
  *
  * @see https://vueuse.org/useMin
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useMin(...args: MaybeComputedRefArgs<number>) {
   return computed<number>(() => {

diff --git a/packages/math/usePrecision/index.ts b/packages/math/usePrecision/index.ts
@@ -35,6 +35,8 @@ export interface UsePrecisionOptions {
  * Reactively set the precision of a number.
  *
  * @see https://vueuse.org/usePrecision
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function usePrecision(
   value: MaybeRefOrGetter<number>,

diff --git a/packages/math/useProjection/index.ts b/packages/math/useProjection/index.ts
@@ -6,6 +6,8 @@ import { createProjection } from '../createProjection'
  * Reactive numeric projection from one domain to another.
  *
  * @see https://vueuse.org/useProjection
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useProjection(
   input: MaybeRefOrGetter<number>,

diff --git a/packages/math/useRound/index.ts b/packages/math/useRound/index.ts
@@ -5,6 +5,8 @@ import { computed, toValue } from 'vue'
  * Reactive `Math.round`.
  *
  * @see https://vueuse.org/useRound
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useRound(value: MaybeRefOrGetter<number>): ComputedRef<number> {
   return computed<number>(() => Math.round(toValue(value)))

diff --git a/packages/math/useSum/index.ts b/packages/math/useSum/index.ts
@@ -10,6 +10,8 @@ export function useSum(...args: MaybeRefOrGetter<number>[]): ComputedRef<number>
  * Get the sum of a set of numbers.
  *
  * @see https://vueuse.org/useSum
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useSum(...args: MaybeComputedRefArgs<number>): ComputedRef<number> {
   return computed(() => toValueArgsFlat(args).reduce((sum, v) => sum += v, 0))

diff --git a/packages/math/useTrunc/index.ts b/packages/math/useTrunc/index.ts
@@ -5,6 +5,8 @@ import { computed, toValue } from 'vue'
  * Reactive `Math.trunc`.
  *
  * @see https://vueuse.org/useTrunc
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export function useTrunc(value: MaybeRefOrGetter<number>): ComputedRef<number> {
   return computed<number>(() => Math.trunc(toValue(value)))