aloha-vue 2.62.0 → 2.63.0

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

@@ -1,237 +1,237 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import {
-  aOrderBy,
-} from "../utils";
-
-describe("aOrderBy", () => {
-  it("sorts by a string property ignoring case by default", () => {
-    const users = [
-      { name: "beta" },
-      { name: "Alpha" },
-      { name: "gamma" },
-      { name: "delta" },
-      { name: "alpha" },
-    ];
-
-    const result = aOrderBy(users, "name");
-
-    expect(result.map(user => user.name)).toEqual([
-      "Alpha",
-      "alpha",
-      "beta",
-      "delta",
-      "gamma",
-    ]);
-  });
-
-  it("orders results descending when order argument provided", () => {
-    const users = [
-      { name: "beta" },
-      { name: "Alpha" },
-      { name: "gamma" },
-      { name: "delta" },
-      { name: "alpha" },
-    ];
-
-    const result = aOrderBy(users, "name", "desc");
-
-    expect(result.map(user => user.name)).toEqual([
-      "gamma",
-      "delta",
-      "beta",
-      "Alpha",
-      "alpha",
-    ]);
-  });
-
-  it("supports iteratee functions returning strings", () => {
-    const users = [
-      { firstName: "carol" },
-      { firstName: "Bob" },
-      { firstName: "alice" },
-    ];
-
-    const result = aOrderBy(users, user => user.firstName);
-
-    expect(result.map(user => user.firstName)).toEqual([
-      "alice",
-      "Bob",
-      "carol",
-    ]);
-  });
-
-  it("uses secondary iteratees to break ties", () => {
-    const users = [
-      { name: "alex", score: 5 },
-      { name: "Alex", score: 3 },
-      { name: "alex", score: 2 },
-      { name: "alex", score: 7 },
-    ];
-
-    const result = aOrderBy(users, ["name", user => user.score], ["asc", "asc"]);
-
-    expect(result.map(user => ({ name: user.name, score: user.score }))).toEqual([
-      { name: "alex", score: 2 },
-      { name: "Alex", score: 3 },
-      { name: "alex", score: 5 },
-      { name: "alex", score: 7 },
-    ]);
-  });
-
-  it("accepts iteratees and orders passed as arrays", () => {
-    const users = [
-      { profile: { lastName: "davis" }, age: 40 },
-      { profile: { lastName: "Davis" }, age: 35 },
-      { profile: { lastName: "anders" }, age: 50 },
-      { profile: { lastName: "Anders" }, age: 20 },
-    ];
-
-    const result = aOrderBy(
-      users,
-      ["profile.lastName", user => user.age],
-      ["asc", "desc"],
-    );
-
-    expect(result.map(user => ({
-      lastName: user.profile.lastName,
-      age: user.age,
-    }))).toEqual([
-      { lastName: "anders", age: 50 },
-      { lastName: "Anders", age: 20 },
-      { lastName: "davis", age: 40 },
-      { lastName: "Davis", age: 35 },
-    ]);
-  });
-
-  it("sorts by nested path with descending order ignoring case", () => {
-    const users = [
-      { profile: { lastName: "smith" } },
-      { profile: { lastName: "Johnson" } },
-      { profile: { lastName: "adams" } },
-      { profile: { lastName: "brown" } },
-    ];
-
-    const result = aOrderBy(users, "profile.lastName", "desc");
-
-    expect(result.map(user => user.profile.lastName)).toEqual([
-      "smith",
-      "Johnson",
-      "brown",
-      "adams",
-    ]);
-  });
-
-  it("behaves like lodash orderBy when caseSensitive true", () => {
-    const users = [
-      { user: "fred", age: 48 },
-      { user: "barney", age: 36 },
-      { user: "Fred", age: 40 },
-      { user: "Barney", age: 34 },
-    ];
-
-    const result = aOrderBy(
-      users,
-      ["user", "age"],
-      ["asc", "desc"],
-      { caseSensitive: true },
-    );
-
-    expect(result.map(user => ({ user: user.user, age: user.age }))).toEqual([
-      { user: "Barney", age: 34 },
-      { user: "Fred", age: 40 },
-      { user: "barney", age: 36 },
-      { user: "fred", age: 48 },
-    ]);
-  });
-
-  it("defaults to identity iteratee when none provided", () => {
-    const values = ["Banana", "apple", "Apricot"];
-
-    const caseInsensitive = aOrderBy(values);
-    const caseSensitive = aOrderBy(values, undefined, undefined, { caseSensitive: true });
-
-    expect(caseInsensitive).toEqual(["apple", "Apricot", "Banana"]);
-    expect(caseSensitive).toEqual(["Apricot", "Banana", "apple"]);
-  });
-
-  it("defaults missing orders to asc when array shorter than iteratees", () => {
-    const users = [
-      { name: "Alpha", score: 4 },
-      { name: "alpha", score: 3 },
-      { name: "beta", score: 1 },
-      { name: "Beta", score: 2 },
-    ];
-
-    const result = aOrderBy(
-      users,
-      ["name", user => user.score],
-      ["asc"],
-    );
-
-    expect(result.map(user => ({ name: user.name, score: user.score }))).toEqual([
-      { name: "alpha", score: 3 },
-      { name: "Alpha", score: 4 },
-      { name: "beta", score: 1 },
-      { name: "Beta", score: 2 },
-    ]);
-  });
-
-  it("handles object iteratee shorthand combined with additional iteratees", () => {
-    const users = [
-      { name: "Alice", role: "editor" },
-      { name: "Bob", role: "admin" },
-      { name: "carol", role: "admin" },
-      { name: "dave", role: "viewer" },
-    ];
-
-    const result = aOrderBy(
-      users,
-      [{ role: "admin" }, user => user.name],
-      ["desc", "asc"],
-    );
-
-    expect(result.map(user => user.name)).toEqual([
-      "Bob",
-      "carol",
-      "Alice",
-      "dave",
-    ]);
-  });
-
-  it("uses default iteratee when iteratee is null but order provided", () => {
-    const numbers = [3, 1, 2];
-
-    const result = aOrderBy(numbers, null, "desc");
-
-    expect(result).toEqual([3, 2, 1]);
-  });
-
-  it("applies options together with iteratees and order arguments", () => {
-    const codes = [
-      { code: "abC", rank: 3 },
-      { code: "Abd", rank: 1 },
-      { code: "abc", rank: 2 },
-    ];
-
-    const caseInsensitive = aOrderBy(
-      codes,
-      "code",
-      "asc",
-      { caseSensitive: false },
-    );
-    const caseSensitive = aOrderBy(
-      codes,
-      "code",
-      "asc",
-      { caseSensitive: true },
-    );
-
-    expect(caseInsensitive.map(item => item.code)).toEqual(["abC", "abc", "Abd"]);
-    expect(caseSensitive.map(item => item.code)).toEqual(["Abd", "abC", "abc"]);
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "@jest/globals";
+
+import {
+  aOrderBy,
+} from "../utils";
+
+describe("aOrderBy", () => {
+  it("sorts by a string property ignoring case by default", () => {
+    const users = [
+      { name: "beta" },
+      { name: "Alpha" },
+      { name: "gamma" },
+      { name: "delta" },
+      { name: "alpha" },
+    ];
+
+    const result = aOrderBy(users, "name");
+
+    expect(result.map(user => user.name)).toEqual([
+      "Alpha",
+      "alpha",
+      "beta",
+      "delta",
+      "gamma",
+    ]);
+  });
+
+  it("orders results descending when order argument provided", () => {
+    const users = [
+      { name: "beta" },
+      { name: "Alpha" },
+      { name: "gamma" },
+      { name: "delta" },
+      { name: "alpha" },
+    ];
+
+    const result = aOrderBy(users, "name", "desc");
+
+    expect(result.map(user => user.name)).toEqual([
+      "gamma",
+      "delta",
+      "beta",
+      "Alpha",
+      "alpha",
+    ]);
+  });
+
+  it("supports iteratee functions returning strings", () => {
+    const users = [
+      { firstName: "carol" },
+      { firstName: "Bob" },
+      { firstName: "alice" },
+    ];
+
+    const result = aOrderBy(users, user => user.firstName);
+
+    expect(result.map(user => user.firstName)).toEqual([
+      "alice",
+      "Bob",
+      "carol",
+    ]);
+  });
+
+  it("uses secondary iteratees to break ties", () => {
+    const users = [
+      { name: "alex", score: 5 },
+      { name: "Alex", score: 3 },
+      { name: "alex", score: 2 },
+      { name: "alex", score: 7 },
+    ];
+
+    const result = aOrderBy(users, ["name", user => user.score], ["asc", "asc"]);
+
+    expect(result.map(user => ({ name: user.name, score: user.score }))).toEqual([
+      { name: "alex", score: 2 },
+      { name: "Alex", score: 3 },
+      { name: "alex", score: 5 },
+      { name: "alex", score: 7 },
+    ]);
+  });
+
+  it("accepts iteratees and orders passed as arrays", () => {
+    const users = [
+      { profile: { lastName: "davis" }, age: 40 },
+      { profile: { lastName: "Davis" }, age: 35 },
+      { profile: { lastName: "anders" }, age: 50 },
+      { profile: { lastName: "Anders" }, age: 20 },
+    ];
+
+    const result = aOrderBy(
+      users,
+      ["profile.lastName", user => user.age],
+      ["asc", "desc"],
+    );
+
+    expect(result.map(user => ({
+      lastName: user.profile.lastName,
+      age: user.age,
+    }))).toEqual([
+      { lastName: "anders", age: 50 },
+      { lastName: "Anders", age: 20 },
+      { lastName: "davis", age: 40 },
+      { lastName: "Davis", age: 35 },
+    ]);
+  });
+
+  it("sorts by nested path with descending order ignoring case", () => {
+    const users = [
+      { profile: { lastName: "smith" } },
+      { profile: { lastName: "Johnson" } },
+      { profile: { lastName: "adams" } },
+      { profile: { lastName: "brown" } },
+    ];
+
+    const result = aOrderBy(users, "profile.lastName", "desc");
+
+    expect(result.map(user => user.profile.lastName)).toEqual([
+      "smith",
+      "Johnson",
+      "brown",
+      "adams",
+    ]);
+  });
+
+  it("behaves like lodash orderBy when caseSensitive true", () => {
+    const users = [
+      { user: "fred", age: 48 },
+      { user: "barney", age: 36 },
+      { user: "Fred", age: 40 },
+      { user: "Barney", age: 34 },
+    ];
+
+    const result = aOrderBy(
+      users,
+      ["user", "age"],
+      ["asc", "desc"],
+      { caseSensitive: true },
+    );
+
+    expect(result.map(user => ({ user: user.user, age: user.age }))).toEqual([
+      { user: "Barney", age: 34 },
+      { user: "Fred", age: 40 },
+      { user: "barney", age: 36 },
+      { user: "fred", age: 48 },
+    ]);
+  });
+
+  it("defaults to identity iteratee when none provided", () => {
+    const values = ["Banana", "apple", "Apricot"];
+
+    const caseInsensitive = aOrderBy(values);
+    const caseSensitive = aOrderBy(values, undefined, undefined, { caseSensitive: true });
+
+    expect(caseInsensitive).toEqual(["apple", "Apricot", "Banana"]);
+    expect(caseSensitive).toEqual(["Apricot", "Banana", "apple"]);
+  });
+
+  it("defaults missing orders to asc when array shorter than iteratees", () => {
+    const users = [
+      { name: "Alpha", score: 4 },
+      { name: "alpha", score: 3 },
+      { name: "beta", score: 1 },
+      { name: "Beta", score: 2 },
+    ];
+
+    const result = aOrderBy(
+      users,
+      ["name", user => user.score],
+      ["asc"],
+    );
+
+    expect(result.map(user => ({ name: user.name, score: user.score }))).toEqual([
+      { name: "alpha", score: 3 },
+      { name: "Alpha", score: 4 },
+      { name: "beta", score: 1 },
+      { name: "Beta", score: 2 },
+    ]);
+  });
+
+  it("handles object iteratee shorthand combined with additional iteratees", () => {
+    const users = [
+      { name: "Alice", role: "editor" },
+      { name: "Bob", role: "admin" },
+      { name: "carol", role: "admin" },
+      { name: "dave", role: "viewer" },
+    ];
+
+    const result = aOrderBy(
+      users,
+      [{ role: "admin" }, user => user.name],
+      ["desc", "asc"],
+    );
+
+    expect(result.map(user => user.name)).toEqual([
+      "Bob",
+      "carol",
+      "Alice",
+      "dave",
+    ]);
+  });
+
+  it("uses default iteratee when iteratee is null but order provided", () => {
+    const numbers = [3, 1, 2];
+
+    const result = aOrderBy(numbers, null, "desc");
+
+    expect(result).toEqual([3, 2, 1]);
+  });
+
+  it("applies options together with iteratees and order arguments", () => {
+    const codes = [
+      { code: "abC", rank: 3 },
+      { code: "Abd", rank: 1 },
+      { code: "abc", rank: 2 },
+    ];
+
+    const caseInsensitive = aOrderBy(
+      codes,
+      "code",
+      "asc",
+      { caseSensitive: false },
+    );
+    const caseSensitive = aOrderBy(
+      codes,
+      "code",
+      "asc",
+      { caseSensitive: true },
+    );
+
+    expect(caseInsensitive.map(item => item.code)).toEqual(["abC", "abc", "Abd"]);
+    expect(caseSensitive.map(item => item.code)).toEqual(["Abd", "abC", "abc"]);
+  });
+});