aloha-vue 2.74.0 → 2.75.1

package/src/compositionAPI/__tests__/AHttpAPI.test.js

@@ -1,42 +1,42 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import {
-  getUrlParams,
-} from "../AHttpAPI";
-
-describe("getUrlParams", () => {
-  it("simple", () => {
-    const URL = "x=false&y=100&z=aloha";
-
-    expect(getUrlParams({ url: URL })).toStrictEqual({ x: "false", y: "100", z: "aloha" });
-  });
-
-  it("Array", () => {
-    const URL = "x=false&x=100&z=aloha&x=aloha";
-
-    expect(getUrlParams({ url: URL })).toStrictEqual({ x: ["false", "100", "aloha"], z: "aloha" });
-  });
-
-  it("value with comma", () => {
-    const URL = "x=a,b,c,d&y=100&z=aloha";
-
-    expect(getUrlParams({ url: URL })).toStrictEqual({ x: "a,b,c,d", y: "100", z: "aloha" });
-  });
-
-  it("allCommasToArray", () => {
-    const URL = "x=aloha,holla&z=aloha";
-
-    expect(getUrlParams({ url: URL, allCommasToArray: true })).toStrictEqual({ x: ["aloha", "holla"], z: "aloha" });
-  });
-
-  it("keysCommaToArray", () => {
-    const URL = "x=aloha,holla&z=aloha";
-
-    expect(getUrlParams({ url: URL, keysCommaToArray: ["x"] })).toStrictEqual({ x: ["aloha", "holla"], z: "aloha" });
-  });
-});
-
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import {
+  getUrlParams,
+} from "../AHttpAPI";
+
+describe("getUrlParams", () => {
+  it("simple", () => {
+    const URL = "x=false&y=100&z=aloha";
+
+    expect(getUrlParams({ url: URL })).toStrictEqual({ x: "false", y: "100", z: "aloha" });
+  });
+
+  it("Array", () => {
+    const URL = "x=false&x=100&z=aloha&x=aloha";
+
+    expect(getUrlParams({ url: URL })).toStrictEqual({ x: ["false", "100", "aloha"], z: "aloha" });
+  });
+
+  it("value with comma", () => {
+    const URL = "x=a,b,c,d&y=100&z=aloha";
+
+    expect(getUrlParams({ url: URL })).toStrictEqual({ x: "a,b,c,d", y: "100", z: "aloha" });
+  });
+
+  it("allCommasToArray", () => {
+    const URL = "x=aloha,holla&z=aloha";
+
+    expect(getUrlParams({ url: URL, allCommasToArray: true })).toStrictEqual({ x: ["aloha", "holla"], z: "aloha" });
+  });
+
+  it("keysCommaToArray", () => {
+    const URL = "x=aloha,holla&z=aloha";
+
+    expect(getUrlParams({ url: URL, keysCommaToArray: ["x"] })).toStrictEqual({ x: ["aloha", "holla"], z: "aloha" });
+  });
+});
+

package/src/filters/__tests__/filterBoolean.test.js

@@ -1,38 +1,38 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import filterBoolean from "../filterBoolean";
-
-describe("filterBoolean", () => {
-  it("value=true", () => {
-    expect(filterBoolean(true)).toBe("_YES_");
-    expect(filterBoolean(123)).toBe("_YES_");
-    expect(filterBoolean("1")).toBe("_YES_");
-    expect(filterBoolean(true, { trueValue: "yes" })).toBe("yes");
-  });
-
-  it("value=false", () => {
-    expect(filterBoolean(false)).toBe("_NO_");
-    expect(filterBoolean(0)).toBe("_NO_");
-    expect(filterBoolean("")).toBe("_NO_");
-    expect(filterBoolean(false, { falseValue: "no" })).toBe("no");
-  });
-
-  it("useNil=true", () => {
-    expect(filterBoolean(undefined, { useNil: true })).toBe("");
-    expect(filterBoolean(null, { useNil: true })).toBe("");
-    expect(filterBoolean(false, { useNil: true })).toBe("_NO_");
-    expect(filterBoolean(true, { useNil: true })).toBe("_YES_");
-  });
-
-  it("useNil=false", () => {
-    expect(filterBoolean(undefined, { useNil: false })).toBe("_NO_");
-    expect(filterBoolean(null, { useNil: false })).toBe("_NO_");
-    expect(filterBoolean(false, { useNil: false })).toBe("_NO_");
-    expect(filterBoolean(true, { useNil: false })).toBe("_YES_");
-  });
-});
-
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import filterBoolean from "../filterBoolean";
+
+describe("filterBoolean", () => {
+  it("value=true", () => {
+    expect(filterBoolean(true)).toBe("_YES_");
+    expect(filterBoolean(123)).toBe("_YES_");
+    expect(filterBoolean("1")).toBe("_YES_");
+    expect(filterBoolean(true, { trueValue: "yes" })).toBe("yes");
+  });
+
+  it("value=false", () => {
+    expect(filterBoolean(false)).toBe("_NO_");
+    expect(filterBoolean(0)).toBe("_NO_");
+    expect(filterBoolean("")).toBe("_NO_");
+    expect(filterBoolean(false, { falseValue: "no" })).toBe("no");
+  });
+
+  it("useNil=true", () => {
+    expect(filterBoolean(undefined, { useNil: true })).toBe("");
+    expect(filterBoolean(null, { useNil: true })).toBe("");
+    expect(filterBoolean(false, { useNil: true })).toBe("_NO_");
+    expect(filterBoolean(true, { useNil: true })).toBe("_YES_");
+  });
+
+  it("useNil=false", () => {
+    expect(filterBoolean(undefined, { useNil: false })).toBe("_NO_");
+    expect(filterBoolean(null, { useNil: false })).toBe("_NO_");
+    expect(filterBoolean(false, { useNil: false })).toBe("_NO_");
+    expect(filterBoolean(true, { useNil: false })).toBe("_YES_");
+  });
+});
+

package/src/filters/__tests__/filterCapitalize.test.js

@@ -1,38 +1,38 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import filterCapitalize from "../filterCapitalize";
-
-describe("filterCapitalize", () => {
-  it("should capitalize a lowercase string", () => {
-    expect(filterCapitalize("foobar")).toBe("Foobar");
-  });
-
-  it("should capitalize an uppercase string", () => {
-    expect(filterCapitalize("FOOBAR")).toBe("Foobar");
-  });
-
-  it("should capitalize a mixed case string", () => {
-    expect(filterCapitalize("fOoBaR")).toBe("Foobar");
-  });
-
-  it("should handle an empty string", () => {
-    expect(filterCapitalize("")).toBe("");
-  });
-
-  it("should handle a string with one character", () => {
-    expect(filterCapitalize("a")).toBe("A");
-    expect(filterCapitalize("A")).toBe("A");
-  });
-
-  it("should handle strings with spaces", () => {
-    expect(filterCapitalize(" foo bar ")).toBe(" foo bar ");
-  });
-
-  it("should not change already capitalized strings", () => {
-    expect(filterCapitalize("Foobar")).toBe("Foobar");
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import filterCapitalize from "../filterCapitalize";
+
+describe("filterCapitalize", () => {
+  it("should capitalize a lowercase string", () => {
+    expect(filterCapitalize("foobar")).toBe("Foobar");
+  });
+
+  it("should capitalize an uppercase string", () => {
+    expect(filterCapitalize("FOOBAR")).toBe("Foobar");
+  });
+
+  it("should capitalize a mixed case string", () => {
+    expect(filterCapitalize("fOoBaR")).toBe("Foobar");
+  });
+
+  it("should handle an empty string", () => {
+    expect(filterCapitalize("")).toBe("");
+  });
+
+  it("should handle a string with one character", () => {
+    expect(filterCapitalize("a")).toBe("A");
+    expect(filterCapitalize("A")).toBe("A");
+  });
+
+  it("should handle strings with spaces", () => {
+    expect(filterCapitalize(" foo bar ")).toBe(" foo bar ");
+  });
+
+  it("should not change already capitalized strings", () => {
+    expect(filterCapitalize("Foobar")).toBe("Foobar");
+  });
+});

package/src/filters/__tests__/filterCurrency.test.js

@@ -1,21 +1,21 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import filterCurrency from "../filterCurrency";
-
-describe("filterCurrency", () => {
-  it("should properly format a given number with default parameters", () => {
-    expect(filterCurrency(1234.5678)).toEqual("1.234,57 €");
-  });
-
-  it("should properly format a given number with custom parameters", () => {
-    expect(filterCurrency(1234.5678, { suffix: "$", digits: 3, digitGrouping: false })).toEqual("1234,568 $");
-  });
-
-  it("should return undefined when a non-number value is passed", () => {
-    expect(filterCurrency(null)).toEqual("");
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import filterCurrency from "../filterCurrency";
+
+describe("filterCurrency", () => {
+  it("should properly format a given number with default parameters", () => {
+    expect(filterCurrency(1234.5678)).toEqual("1.234,57 €");
+  });
+
+  it("should properly format a given number with custom parameters", () => {
+    expect(filterCurrency(1234.5678, { suffix: "$", digits: 3, digitGrouping: false })).toEqual("1234,568 $");
+  });
+
+  it("should return undefined when a non-number value is passed", () => {
+    expect(filterCurrency(null)).toEqual("");
+  });
+});

package/src/filters/__tests__/filterDate.test.js

@@ -1,42 +1,42 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import filterDate from "../filterDate";
-import moment from "moment";
-
-describe("filterDate function", () => {
-  it("returns empty string when input is null, undefined or an empty string", () => {
-    const testCases = [null, undefined, ""];
-    testCases.forEach(tc => {
-      expect(filterDate(tc)).toEqual("");
-    });
-  });
-
-  it("returns the original value when the input is not a valid date", () => {
-    const testCases = ["abc", "a123", "12a3", "123a"];
-    testCases.forEach(tc => {
-      expect(filterDate(tc)).toEqual(tc);
-    });
-  });
-
-  it("returns the formatted date when the input is a valid date", () => {
-    const testCases = [
-      {
-        input: "2023-03-01",
-        format: "YYYY-MM-DD",
-        expected: "2023-03-01",
-      },
-      {
-        input: "2023-03-01",
-        format: "date",
-        expected: moment("2023-03-01").format("DD.MM.YYYY"),
-      },
-    ];
-    testCases.forEach(tc => {
-      expect(filterDate(tc.input, { format: tc.format })).toEqual(tc.expected);
-    });
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import filterDate from "../filterDate";
+import moment from "moment";
+
+describe("filterDate function", () => {
+  it("returns empty string when input is null, undefined or an empty string", () => {
+    const testCases = [null, undefined, ""];
+    testCases.forEach(tc => {
+      expect(filterDate(tc)).toEqual("");
+    });
+  });
+
+  it("returns the original value when the input is not a valid date", () => {
+    const testCases = ["abc", "a123", "12a3", "123a"];
+    testCases.forEach(tc => {
+      expect(filterDate(tc)).toEqual(tc);
+    });
+  });
+
+  it("returns the formatted date when the input is a valid date", () => {
+    const testCases = [
+      {
+        input: "2023-03-01",
+        format: "YYYY-MM-DD",
+        expected: "2023-03-01",
+      },
+      {
+        input: "2023-03-01",
+        format: "date",
+        expected: moment("2023-03-01").format("DD.MM.YYYY"),
+      },
+    ];
+    testCases.forEach(tc => {
+      expect(filterDate(tc.input, { format: tc.format })).toEqual(tc.expected);
+    });
+  });
+});

package/src/filters/__tests__/filterDefaultForEmpty.test.js

@@ -1,24 +1,24 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import filterDefaultForEmpty from "../filterDefaultForEmpty";
-
-describe("filterDefaultForEmpty Function", () => {
-  it("should return 'emptyValue', when the input is null", () => {
-    expect(filterDefaultForEmpty(null)).toBe("-");
-    expect(filterDefaultForEmpty(null, { emptyValue: "default" })).toBe("default");
-  });
-
-  it("should return 'emptyValue', when the input is an empty string", () => {
-    expect(filterDefaultForEmpty("")).toBe("-");
-    expect(filterDefaultForEmpty("", { emptyValue: "default" })).toBe("default");
-  });
-
-  it("should return the inputted value, when it is not null or an empty string", () => {
-    expect(filterDefaultForEmpty("Non-empty value")).toBe("Non-empty value");
-    expect(filterDefaultForEmpty(123)).toBe(123);
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import filterDefaultForEmpty from "../filterDefaultForEmpty";
+
+describe("filterDefaultForEmpty Function", () => {
+  it("should return 'emptyValue', when the input is null", () => {
+    expect(filterDefaultForEmpty(null)).toBe("-");
+    expect(filterDefaultForEmpty(null, { emptyValue: "default" })).toBe("default");
+  });
+
+  it("should return 'emptyValue', when the input is an empty string", () => {
+    expect(filterDefaultForEmpty("")).toBe("-");
+    expect(filterDefaultForEmpty("", { emptyValue: "default" })).toBe("default");
+  });
+
+  it("should return the inputted value, when it is not null or an empty string", () => {
+    expect(filterDefaultForEmpty("Non-empty value")).toBe("Non-empty value");
+    expect(filterDefaultForEmpty(123)).toBe(123);
+  });
+});

package/src/filters/__tests__/filterEmail.test.js

@@ -1,42 +1,42 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import filterEmail from "../filterEmail";
-
-describe("filterEmail", () => {
-  it("basic email", () => {
-    expect(filterEmail("user@aloha.com")).toBe("<a href=\"mailto:user@aloha.com\">user@aloha.com</a>");
-  });
-
-  it("email with CSS class", () => {
-    expect(filterEmail("contact@aloha.com", { linkClass: "email-link" })).toBe("<a href=\"mailto:contact@aloha.com\" class=\"email-link\">contact@aloha.com</a>");
-  });
-
-  it("empty email", () => {
-    expect(filterEmail("")).toBe("");
-  });
-
-  it("null email", () => {
-    expect(filterEmail(null)).toBe("");
-  });
-
-  it("undefined email", () => {
-    expect(filterEmail(undefined)).toBe("");
-  });
-
-  it("numeric value (invalid email)", () => {
-    expect(filterEmail(12345)).toBe("");
-  });
-
-  it("email with special characters", () => {
-    expect(filterEmail("name.surname+filter@company.org")).toBe("<a href=\"mailto:name.surname+filter@company.org\">name.surname+filter@company.org</a>");
-  });
-
-  it("email with combined class attribute", () => {
-    expect(filterEmail("hr@enterprise.net", { linkClass: "external contact" })).toBe("<a href=\"mailto:hr@enterprise.net\" class=\"external contact\">hr@enterprise.net</a>");
-  });
-});
-
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import filterEmail from "../filterEmail";
+
+describe("filterEmail", () => {
+  it("basic email", () => {
+    expect(filterEmail("user@aloha.com")).toBe("<a href=\"mailto:user@aloha.com\">user@aloha.com</a>");
+  });
+
+  it("email with CSS class", () => {
+    expect(filterEmail("contact@aloha.com", { linkClass: "email-link" })).toBe("<a href=\"mailto:contact@aloha.com\" class=\"email-link\">contact@aloha.com</a>");
+  });
+
+  it("empty email", () => {
+    expect(filterEmail("")).toBe("");
+  });
+
+  it("null email", () => {
+    expect(filterEmail(null)).toBe("");
+  });
+
+  it("undefined email", () => {
+    expect(filterEmail(undefined)).toBe("");
+  });
+
+  it("numeric value (invalid email)", () => {
+    expect(filterEmail(12345)).toBe("");
+  });
+
+  it("email with special characters", () => {
+    expect(filterEmail("name.surname+filter@company.org")).toBe("<a href=\"mailto:name.surname+filter@company.org\">name.surname+filter@company.org</a>");
+  });
+
+  it("email with combined class attribute", () => {
+    expect(filterEmail("hr@enterprise.net", { linkClass: "external contact" })).toBe("<a href=\"mailto:hr@enterprise.net\" class=\"external contact\">hr@enterprise.net</a>");
+  });
+});
+

package/src/filters/__tests__/filterEscapeHtml.test.js

@@ -1,45 +1,45 @@
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import filterEscapeHtml from "../filterEscapeHtml";
-
-describe("filterEscapeHtml", () => {
-  it("should escape HTML special characters", () => {
-    const input = "<script>alert(\"XSS Attack\")</script>";
-    const expectedOutput = "&lt;script&gt;alert(\"XSS Attack\")&lt;/script&gt;";
-    expect(filterEscapeHtml(input)).toBe(expectedOutput);
-  });
-
-  it("should return the same string if no special characters", () => {
-    const input = "Hello, World!";
-    const expectedOutput = "Hello, World!";
-    expect(filterEscapeHtml(input)).toBe(expectedOutput);
-  });
-
-  it("should return an empty string if input is empty", () => {
-    const input = "";
-    const expectedOutput = "";
-    expect(filterEscapeHtml(input)).toBe(expectedOutput);
-  });
-
-  it("should escape only special HTML characters and leave the rest", () => {
-    const input = "Hello <strong>world</strong>";
-    const expectedOutput = "Hello &lt;strong&gt;world&lt;/strong&gt;";
-    expect(filterEscapeHtml(input)).toBe(expectedOutput);
-  });
-
-  it("should handle special characters like &, \", '", () => {
-    const input = "Fish & Chips \"Delicious\"";
-    const expectedOutput = "Fish &amp; Chips \"Delicious\"";
-    expect(filterEscapeHtml(input)).toBe(expectedOutput);
-  });
-
-  it("should escape HTML list tags", () => {
-    const input = "<ul><li>test</li></ul>";
-    const expectedOutput = "&lt;ul&gt;&lt;li&gt;test&lt;/li&gt;&lt;/ul&gt;";
-    expect(filterEscapeHtml(input)).toBe(expectedOutput);
-  });
-});
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import filterEscapeHtml from "../filterEscapeHtml";
+
+describe("filterEscapeHtml", () => {
+  it("should escape HTML special characters", () => {
+    const input = "<script>alert(\"XSS Attack\")</script>";
+    const expectedOutput = "&lt;script&gt;alert(\"XSS Attack\")&lt;/script&gt;";
+    expect(filterEscapeHtml(input)).toBe(expectedOutput);
+  });
+
+  it("should return the same string if no special characters", () => {
+    const input = "Hello, World!";
+    const expectedOutput = "Hello, World!";
+    expect(filterEscapeHtml(input)).toBe(expectedOutput);
+  });
+
+  it("should return an empty string if input is empty", () => {
+    const input = "";
+    const expectedOutput = "";
+    expect(filterEscapeHtml(input)).toBe(expectedOutput);
+  });
+
+  it("should escape only special HTML characters and leave the rest", () => {
+    const input = "Hello <strong>world</strong>";
+    const expectedOutput = "Hello &lt;strong&gt;world&lt;/strong&gt;";
+    expect(filterEscapeHtml(input)).toBe(expectedOutput);
+  });
+
+  it("should handle special characters like &, \", '", () => {
+    const input = "Fish & Chips \"Delicious\"";
+    const expectedOutput = "Fish &amp; Chips \"Delicious\"";
+    expect(filterEscapeHtml(input)).toBe(expectedOutput);
+  });
+
+  it("should escape HTML list tags", () => {
+    const input = "<ul><li>test</li></ul>";
+    const expectedOutput = "&lt;ul&gt;&lt;li&gt;test&lt;/li&gt;&lt;/ul&gt;";
+    expect(filterEscapeHtml(input)).toBe(expectedOutput);
+  });
+});