feat(utils): hasReactive

src/utils.ts

@@ -1,5 +1,5 @@
 import type { ComputedRef, Ref } from "vue";
-import { readonly, ref, unref } from "vue";
+import { isReactive, readonly, ref, unref } from "vue";
 
 type Reducer<S, A> = (prevState: S, action: A) => S;
 type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any>
@@ -45,3 +45,13 @@ export function unrefs<T extends any[]>(
   }
   return [] as unknown as UnRefArrayItem<T>;
 }
+
+/**
+ * check whether `reactive` value exists
+ */
+export function hasReactive<T>(args: T) {
+  if (args && Array.isArray(args)) {
+    return args.some(isReactive);
+  }
+  return false;
+}

tests/utils.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "vitest";
-import { isRef, ref, unref } from "vue";
+import { isRef, ref, reactive, unref } from "vue";
 
-import { unrefs, useReducer } from "../src/utils";
+import { unrefs, useReducer, hasReactive } from "../src/utils";
 
 describe("unrefs", () => {
   test("should be defined", () => {
@@ -71,3 +71,23 @@ describe("useReducer", () => {
     expect(state.value.num).toBe(2);
   });
 });
+
+describe("hasReactive", () => {
+  test("should be defined", () => {
+    expect(hasReactive).toBeDefined();
+  });
+
+  test("check", () => {
+    expect(hasReactive(null)).toBeFalsy();
+    expect(hasReactive(undefined)).toBeFalsy();
+    expect(hasReactive({})).toBeFalsy();
+    expect(hasReactive({ 0: 1, 1: 2 })).toBeFalsy();
+    expect(hasReactive([])).toBeFalsy();
+    expect(hasReactive([1, 2, 3])).toBeFalsy();
+    expect(hasReactive([ref(1), 2, 3])).toBeFalsy();
+    expect(hasReactive([ref(1), ref(2), 3])).toBeFalsy();
+    expect(hasReactive([ref(1), ref(2), { a: 1 }])).toBeFalsy();
+    expect(hasReactive([reactive({ a: 1 })])).toBeTruthy();
+    expect(hasReactive([1, 2, reactive({ a: 1 })])).toBeTruthy();
+  });
+});