aloha-vue 2.74.0 → 2.75.1

package/src/utils/__tests__/utils.getTotalNestedCount.test.js

@@ -1,56 +1,56 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import {
-  getTotalNestedCount,
-} from "../utils";
-
-describe("getTotalNestedCount function", () => {
-  it("should correctly count elements in a flat array without nested children", () => {
-    const array = ["hello", "world"];
-
-    expect(getTotalNestedCount({ array, keyChildren: "test" })).toBe(2);
-  });
-
-  it("should accurately count elements in a mixed array with and without specified nested children", () => {
-    const array = [{ children: ["hello", "world"] }, "test"];
-
-    expect(getTotalNestedCount({ array, keyChildren: "children" })).toBe(4);
-    expect(getTotalNestedCount({ array, keyChildren: "" })).toBe(2);
-  });
-
-  it("should handle deeply nested structures and count all elements correctly", () => {
-    const array = [
-      {
-        children: [
-          { children: ["hello", "world"] },
-          { children: ["hello", "world"] },
-        ],
-      },
-      {
-        children: [
-          { children: ["hello", "world"] },
-          { children: ["hello", "world"] },
-          { children: ["hello", "world"] },
-        ],
-      },
-      {
-        children: [
-          { children: ["hello", "world"] },
-        ],
-      },
-    ];
-
-    expect(getTotalNestedCount({ array, keyChildren: "children" })).toBe(21);
-  });
-
-  it("should return zero for an empty array, indicating no elements to count", () => {
-    const array = [];
-
-    expect(getTotalNestedCount({ array, keyChildren: "test" })).toBe(0);
-  });
-});
-
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import {
+  getTotalNestedCount,
+} from "../utils";
+
+describe("getTotalNestedCount function", () => {
+  it("should correctly count elements in a flat array without nested children", () => {
+    const array = ["hello", "world"];
+
+    expect(getTotalNestedCount({ array, keyChildren: "test" })).toBe(2);
+  });
+
+  it("should accurately count elements in a mixed array with and without specified nested children", () => {
+    const array = [{ children: ["hello", "world"] }, "test"];
+
+    expect(getTotalNestedCount({ array, keyChildren: "children" })).toBe(4);
+    expect(getTotalNestedCount({ array, keyChildren: "" })).toBe(2);
+  });
+
+  it("should handle deeply nested structures and count all elements correctly", () => {
+    const array = [
+      {
+        children: [
+          { children: ["hello", "world"] },
+          { children: ["hello", "world"] },
+        ],
+      },
+      {
+        children: [
+          { children: ["hello", "world"] },
+          { children: ["hello", "world"] },
+          { children: ["hello", "world"] },
+        ],
+      },
+      {
+        children: [
+          { children: ["hello", "world"] },
+        ],
+      },
+    ];
+
+    expect(getTotalNestedCount({ array, keyChildren: "children" })).toBe(21);
+  });
+
+  it("should return zero for an empty array, indicating no elements to count", () => {
+    const array = [];
+
+    expect(getTotalNestedCount({ array, keyChildren: "test" })).toBe(0);
+  });
+});
+

package/src/utils/__tests__/utils.isArrayOfArrays.test.js

@@ -1,44 +1,44 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import {
-  isArrayOfArrays,
-} from "../utils";
-
-describe("isArrayOfArrays", () => {
-  it("should return true if provided with an array of arrays", () => {
-    const testData = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
-    const result = isArrayOfArrays(testData);
-
-    expect(result).toBe(true);
-  });
-
-  it("should return false if provided with an array of non-arrays", () => {
-    const testData = [1, 2, 3, 4, 5];
-    const result = isArrayOfArrays(testData);
-
-    expect(result).toBe(false);
-  });
-
-  it("should return false if provided with a non-array", () => {
-    expect(isArrayOfArrays("Aloha")).toBe(false);
-    expect(isArrayOfArrays(123)).toBe(false);
-    expect(isArrayOfArrays(undefined)).toBe(false);
-    expect(isArrayOfArrays(null)).toBe(false);
-    expect(isArrayOfArrays({})).toBe(false);
-  });
-
-  it("should return false if provided with a empty array", () => {
-    expect(isArrayOfArrays([])).toBe(false);
-  });
-
-  it("should return false if provided with an array that contains non-array elements", () => {
-    const testData = [[1, 2, 3], "This is not an array", [7, 8, 9]];
-    const result = isArrayOfArrays(testData);
-
-    expect(result).toBe(false);
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import {
+  isArrayOfArrays,
+} from "../utils";
+
+describe("isArrayOfArrays", () => {
+  it("should return true if provided with an array of arrays", () => {
+    const testData = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+    const result = isArrayOfArrays(testData);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return false if provided with an array of non-arrays", () => {
+    const testData = [1, 2, 3, 4, 5];
+    const result = isArrayOfArrays(testData);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false if provided with a non-array", () => {
+    expect(isArrayOfArrays("Aloha")).toBe(false);
+    expect(isArrayOfArrays(123)).toBe(false);
+    expect(isArrayOfArrays(undefined)).toBe(false);
+    expect(isArrayOfArrays(null)).toBe(false);
+    expect(isArrayOfArrays({})).toBe(false);
+  });
+
+  it("should return false if provided with a empty array", () => {
+    expect(isArrayOfArrays([])).toBe(false);
+  });
+
+  it("should return false if provided with an array that contains non-array elements", () => {
+    const testData = [[1, 2, 3], "This is not an array", [7, 8, 9]];
+    const result = isArrayOfArrays(testData);
+
+    expect(result).toBe(false);
+  });
+});

package/src/utils/__tests__/utils.isArrayOfStrings.test.js

@@ -1,36 +1,36 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import {
-  isArrayOfStrings,
-} from "../utils";
-
-describe("isArrayOfStrings function", () => {
-  it("should return true when input is an array of strings", () => {
-    const array = ["hello", "world"];
-    const result = isArrayOfStrings(array);
-
-    expect(result).toBe(true);
-  });
-
-  it("should return false when input is not an array", () => {
-    const notArray = "hello world";
-    const result = isArrayOfStrings(notArray);
-
-    expect(result).toBe(false);
-  });
-
-  it("should return false if provided with a empty array", () => {
-    expect(isArrayOfStrings([])).toBe(false);
-  });
-
-  it("should return false when input is an array but not all elements are strings", () => {
-    expect(isArrayOfStrings(["hello", 1234])).toBe(false);
-    expect(isArrayOfStrings(["hello", false])).toBe(false);
-    expect(isArrayOfStrings(["hello", undefined])).toBe(false);
-    expect(isArrayOfStrings(["hello", null])).toBe(false);
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import {
+  isArrayOfStrings,
+} from "../utils";
+
+describe("isArrayOfStrings function", () => {
+  it("should return true when input is an array of strings", () => {
+    const array = ["hello", "world"];
+    const result = isArrayOfStrings(array);
+
+    expect(result).toBe(true);
+  });
+
+  it("should return false when input is not an array", () => {
+    const notArray = "hello world";
+    const result = isArrayOfStrings(notArray);
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false if provided with a empty array", () => {
+    expect(isArrayOfStrings([])).toBe(false);
+  });
+
+  it("should return false when input is an array but not all elements are strings", () => {
+    expect(isArrayOfStrings(["hello", 1234])).toBe(false);
+    expect(isArrayOfStrings(["hello", false])).toBe(false);
+    expect(isArrayOfStrings(["hello", undefined])).toBe(false);
+    expect(isArrayOfStrings(["hello", null])).toBe(false);
+  });
+});

package/src/utils/__tests__/utilsArray.aFirst.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   aFirst,

package/src/utils/__tests__/utilsArray.aLast.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   aLast,

package/src/utils/__tests__/utilsLang.isArguments.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isArguments,

package/src/utils/__tests__/utilsLang.isArray.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isArray,

package/src/utils/__tests__/utilsLang.isArrayBuffer.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isArrayBuffer,

package/src/utils/__tests__/utilsLang.isBoolean.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isBoolean,

package/src/utils/__tests__/utilsLang.isBuffer.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isBuffer,

package/src/utils/__tests__/utilsLang.isDate.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isDate,

package/src/utils/__tests__/utilsLang.isElement.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isElement,
@@ -19,9 +19,11 @@ describe("isElement function", () => {
   });
 
   it("should return false for non-elements", () => {
-    const fn = function example() {};
+    const fn = function example() {
+    };
     const arrow = () => {};
-    class Example {}
+    class Example {
+    }
 
     expect(isElement(null)).toBe(false);
     expect(isElement(undefined)).toBe(false);

package/src/utils/__tests__/utilsLang.isError.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isError,

package/src/utils/__tests__/utilsLang.isFinite.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isFinite,

package/src/utils/__tests__/utilsLang.isFunction.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isFunction,

package/src/utils/__tests__/utilsLang.isInteger.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isInteger,

package/src/utils/__tests__/utilsLang.isMap.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isMap,

package/src/utils/__tests__/utilsLang.isNaN.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isNaN,

package/src/utils/__tests__/utilsLang.isNil.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isNil,

package/src/utils/__tests__/utilsLang.isNull.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isNull,

package/src/utils/__tests__/utilsLang.isNumber.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isNumber,

package/src/utils/__tests__/utilsLang.isObject.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isObject,

package/src/utils/__tests__/utilsLang.isObjectLike.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isObjectLike,
@@ -23,9 +23,11 @@ describe("isObjectLike function", () => {
   });
 
   it("should return false for non-object-like values", () => {
-    const fn = function example() {};
+    const fn = function example() {
+    };
     const arrow = () => {};
-    class Example {}
+    class Example {
+    }
 
     expect(isObjectLike(fn)).toBe(false);
     expect(isObjectLike(arrow)).toBe(false);

package/src/utils/__tests__/utilsLang.isPlainObject.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isPlainObject,
@@ -40,7 +40,8 @@ describe("isPlainObject function", () => {
   });
 
   it("should return false for non-object types", () => {
-    const fn = function example() {};
+    const fn = function example() {
+    };
     const arrow = () => {};
 
     expect(isPlainObject(null)).toBe(false);

package/src/utils/__tests__/utilsLang.isPromise.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isPromise,
@@ -14,7 +14,10 @@ describe("isPromise function", () => {
     const resolved = Promise.resolve(123);
     const rejected = Promise.reject(new Error("fail"));
     const chained = Promise.resolve().then(() => 1);
-    const asyncResult = (async() => 1)();
+    const asyncResult = (async() => {
+      const value = await Promise.resolve(1);
+      return value;
+    })();
 
     rejected.catch(() => {});
 

package/src/utils/__tests__/utilsLang.isRegExp.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isRegExp,

package/src/utils/__tests__/utilsLang.isSet.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isSet,

package/src/utils/__tests__/utilsLang.isString.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isString,

package/src/utils/__tests__/utilsLang.isSymbol.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isSymbol,
@@ -19,9 +19,11 @@ describe("isSymbol function", () => {
   });
 
   it("should return false for non-symbol types", () => {
-    const fn = function example() {};
+    const fn = function example() {
+    };
     const arrow = () => {};
-    class Example {}
+    class Example {
+    }
 
     expect(isSymbol("symbol")).toBe(false);
     expect(isSymbol(0)).toBe(false);

package/src/utils/__tests__/utilsLang.isUndefined.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isUndefined,

package/src/utils/__tests__/utilsLang.isWeakMap.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isWeakMap,

package/src/utils/__tests__/utilsLang.isWeakSet.test.js

@@ -2,7 +2,7 @@ import {
   describe,
   expect,
   it,
-} from "@jest/globals";
+} from "vitest";
 
 import {
   isWeakSet,