aloha-vue 2.74.0 → 2.75.0

package/src/ui/ASelect/__tests__/SelectedFirstAPI.test.js

@@ -1,101 +1,101 @@
-import {
-  computed,
-  reactive,
-} from "vue";
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import SelectedFirstAPI from "../compositionAPI/SelectedFirstAPI";
-
-import {
-  AKeyId,
-} from "../../../const/AKeys";
-
-const item = (id, label, extra = {}) => ({
-  [AKeyId]: id,
-  _a_label: label,
-  ...extra,
-});
-
-describe("ASelect SelectedFirstAPI", () => {
-  it("keeps source order and removes selected values from all source lists", () => {
-    const props = reactive({
-      modelValue: [3, 1, 3, "exclusive"],
-      showSelectedFirst: true,
-      type: "multiselect",
-    });
-    const data = computed(() => [
-      item(1, "One", { group: "A" }),
-      item(2, "Two", { group: "A" }),
-      item(3, "Three", { __invalidEntry__: true, group: "B" }),
-    ]);
-    const dataExtra = computed(() => [item(1, "Extra one"), item(4, "Four")]);
-    const exclusiveOption = computed(() => item("exclusive", "Exclusive"));
-
-    const result = SelectedFirstAPI(props, {
-      data,
-      dataExtra,
-      exclusiveOption,
-    });
-
-    expect(result.dataSelected.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual(["exclusive", 1, 3]);
-    expect(result.dataSelected.value[2]).toEqual(expect.objectContaining({
-      __invalidEntry__: true,
-      group: "B",
-    }));
-    expect(result.dataWithoutSelected.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual([2]);
-    expect(result.dataExtraWithoutSelected.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual([4]);
-    expect(result.exclusiveOptionWithoutSelected.value).toBeUndefined();
-  });
-
-  it("reuses the sorted data order instead of the model order", () => {
-    const props = reactive({
-      modelValue: [1, 3],
-      showSelectedFirst: true,
-      type: "multiselect",
-    });
-    const data = computed(() => [item(3, "Three"), item(2, "Two"), item(1, "One")]);
-
-    const result = SelectedFirstAPI(props, { data });
-
-    expect(result.dataSelected.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual([3, 1]);
-  });
-
-  it("supports false as a selected value in select mode", () => {
-    const props = reactive({
-      modelValue: false,
-      showSelectedFirst: true,
-      type: "select",
-    });
-    const data = computed(() => [item(false, "No"), item(true, "Yes")]);
-
-    const result = SelectedFirstAPI(props, { data });
-
-    expect(result.dataSelected.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual([false]);
-    expect(result.dataWithoutSelected.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual([true]);
-  });
-
-  it("does not change lists when the prop is disabled", () => {
-    const props = reactive({
-      modelValue: [1],
-      showSelectedFirst: false,
-      type: "multiselect",
-    });
-    const sourceData = [item(1, "One"), item(2, "Two")];
-    const data = computed(() => sourceData);
-
-    const result = SelectedFirstAPI(props, { data });
-
-    expect(result.dataSelected.value).toEqual([]);
-    expect(result.dataWithoutSelected.value).toBe(sourceData);
-  });
-});
+import {
+  computed,
+  reactive,
+} from "vue";
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import SelectedFirstAPI from "../compositionAPI/SelectedFirstAPI";
+
+import {
+  AKeyId,
+} from "../../../const/AKeys";
+
+const item = (id, label, extra = {}) => ({
+  [AKeyId]: id,
+  _a_label: label,
+  ...extra,
+});
+
+describe("ASelect SelectedFirstAPI", () => {
+  it("keeps source order and removes selected values from all source lists", () => {
+    const props = reactive({
+      modelValue: [3, 1, 3, "exclusive"],
+      showSelectedFirst: true,
+      type: "multiselect",
+    });
+    const data = computed(() => [
+      item(1, "One", { group: "A" }),
+      item(2, "Two", { group: "A" }),
+      item(3, "Three", { __invalidEntry__: true, group: "B" }),
+    ]);
+    const dataExtra = computed(() => [item(1, "Extra one"), item(4, "Four")]);
+    const exclusiveOption = computed(() => item("exclusive", "Exclusive"));
+
+    const result = SelectedFirstAPI(props, {
+      data,
+      dataExtra,
+      exclusiveOption,
+    });
+
+    expect(result.dataSelected.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual(["exclusive", 1, 3]);
+    expect(result.dataSelected.value[2]).toEqual(expect.objectContaining({
+      __invalidEntry__: true,
+      group: "B",
+    }));
+    expect(result.dataWithoutSelected.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual([2]);
+    expect(result.dataExtraWithoutSelected.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual([4]);
+    expect(result.exclusiveOptionWithoutSelected.value).toBeUndefined();
+  });
+
+  it("reuses the sorted data order instead of the model order", () => {
+    const props = reactive({
+      modelValue: [1, 3],
+      showSelectedFirst: true,
+      type: "multiselect",
+    });
+    const data = computed(() => [item(3, "Three"), item(2, "Two"), item(1, "One")]);
+
+    const result = SelectedFirstAPI(props, { data });
+
+    expect(result.dataSelected.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual([3, 1]);
+  });
+
+  it("supports false as a selected value in select mode", () => {
+    const props = reactive({
+      modelValue: false,
+      showSelectedFirst: true,
+      type: "select",
+    });
+    const data = computed(() => [item(false, "No"), item(true, "Yes")]);
+
+    const result = SelectedFirstAPI(props, { data });
+
+    expect(result.dataSelected.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual([false]);
+    expect(result.dataWithoutSelected.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual([true]);
+  });
+
+  it("does not change lists when the prop is disabled", () => {
+    const props = reactive({
+      modelValue: [1],
+      showSelectedFirst: false,
+      type: "multiselect",
+    });
+    const sourceData = [item(1, "One"), item(2, "Two")];
+    const data = computed(() => sourceData);
+
+    const result = SelectedFirstAPI(props, { data });
+
+    expect(result.dataSelected.value).toEqual([]);
+    expect(result.dataWithoutSelected.value).toBe(sourceData);
+  });
+});

package/src/ui/ASelect/__tests__/SelectedVisibleAPI.test.js

@@ -1,98 +1,98 @@
-import {
-  ref,
-} from "vue";
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import SelectedVisibleAPI from "../compositionAPI/SelectedVisibleAPI";
-
-import {
-  AKeyId,
-} from "../../../const/AKeys";
-
-const item = (id, label, extra = {}) => ({
-  [AKeyId]: id,
-  _a_label: label,
-  ...extra,
-});
-
-describe("ASelect SelectedVisibleAPI", () => {
-  it("filters selected values using matches from all data sources", () => {
-    const dataSelected = ref([
-      item(1, "Apple"),
-      item(2, "Banana"),
-      item(3, "Carrot"),
-    ]);
-
-    const {
-      dataSelectedVisible,
-    } = SelectedVisibleAPI({
-      dataSelected,
-      searching: ref(true),
-      searchingElements: ref({ 2: true }),
-      searchingElementsExtra: ref({ 3: true }),
-    });
-
-    expect(dataSelectedVisible.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual([2, 3]);
-  });
-
-  it("includes selected values when their nested group matches", () => {
-    const dataSelected = ref([
-      item(1, "Apple", { category: "Food", group: "Fruit" }),
-      item(2, "Carrot", { category: "Food", group: "Vegetables" }),
-    ]);
-
-    const {
-      dataSelectedVisible,
-      searchingGroupsVisible,
-    } = SelectedVisibleAPI({
-      dataSelected,
-      keyGroupArray: ref(["category", "group"]),
-      searching: ref(true),
-      searchingGroupsWithSearchInGroup: ref({ Food_Fruit: true }),
-    });
-
-    expect(dataSelectedVisible.value.map(currentItem => currentItem[AKeyId]))
-      .toEqual([1]);
-    expect(searchingGroupsVisible.value).toEqual({
-      Food: true,
-      Food_Fruit: true,
-    });
-  });
-
-  it("does not expose a group matched only in another section", () => {
-    const dataSelected = ref([
-      item(2, "Banana", { group: "Fruit" }),
-    ]);
-
-    const {
-      dataSelectedVisible,
-      searchingGroupsVisible,
-    } = SelectedVisibleAPI({
-      dataSelected,
-      keyGroupArray: ref(["group"]),
-      searching: ref(true),
-      searchingElements: ref({ 1: true }),
-    });
-
-    expect(dataSelectedVisible.value).toEqual([]);
-    expect(searchingGroupsVisible.value).toEqual({});
-  });
-
-  it("returns all selected values when search is inactive", () => {
-    const dataSelected = ref([item(1, "Apple"), item(2, "Banana")]);
-
-    const {
-      dataSelectedVisible,
-    } = SelectedVisibleAPI({
-      dataSelected,
-      searching: ref(false),
-    });
-
-    expect(dataSelectedVisible.value).toBe(dataSelected.value);
-  });
-});
+import {
+  ref,
+} from "vue";
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import SelectedVisibleAPI from "../compositionAPI/SelectedVisibleAPI";
+
+import {
+  AKeyId,
+} from "../../../const/AKeys";
+
+const item = (id, label, extra = {}) => ({
+  [AKeyId]: id,
+  _a_label: label,
+  ...extra,
+});
+
+describe("ASelect SelectedVisibleAPI", () => {
+  it("filters selected values using matches from all data sources", () => {
+    const dataSelected = ref([
+      item(1, "Apple"),
+      item(2, "Banana"),
+      item(3, "Carrot"),
+    ]);
+
+    const {
+      dataSelectedVisible,
+    } = SelectedVisibleAPI({
+      dataSelected,
+      searching: ref(true),
+      searchingElements: ref({ 2: true }),
+      searchingElementsExtra: ref({ 3: true }),
+    });
+
+    expect(dataSelectedVisible.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual([2, 3]);
+  });
+
+  it("includes selected values when their nested group matches", () => {
+    const dataSelected = ref([
+      item(1, "Apple", { category: "Food", group: "Fruit" }),
+      item(2, "Carrot", { category: "Food", group: "Vegetables" }),
+    ]);
+
+    const {
+      dataSelectedVisible,
+      searchingGroupsVisible,
+    } = SelectedVisibleAPI({
+      dataSelected,
+      keyGroupArray: ref(["category", "group"]),
+      searching: ref(true),
+      searchingGroupsWithSearchInGroup: ref({ Food_Fruit: true }),
+    });
+
+    expect(dataSelectedVisible.value.map(currentItem => currentItem[AKeyId]))
+      .toEqual([1]);
+    expect(searchingGroupsVisible.value).toEqual({
+      Food: true,
+      Food_Fruit: true,
+    });
+  });
+
+  it("does not expose a group matched only in another section", () => {
+    const dataSelected = ref([
+      item(2, "Banana", { group: "Fruit" }),
+    ]);
+
+    const {
+      dataSelectedVisible,
+      searchingGroupsVisible,
+    } = SelectedVisibleAPI({
+      dataSelected,
+      keyGroupArray: ref(["group"]),
+      searching: ref(true),
+      searchingElements: ref({ 1: true }),
+    });
+
+    expect(dataSelectedVisible.value).toEqual([]);
+    expect(searchingGroupsVisible.value).toEqual({});
+  });
+
+  it("returns all selected values when search is inactive", () => {
+    const dataSelected = ref([item(1, "Apple"), item(2, "Banana")]);
+
+    const {
+      dataSelectedVisible,
+    } = SelectedVisibleAPI({
+      dataSelected,
+      searching: ref(false),
+    });
+
+    expect(dataSelectedVisible.value).toBe(dataSelected.value);
+  });
+});

package/src/ui/ASlider/compositionAPI/SliderAPI.js

@@ -220,29 +220,29 @@ export default function SliderAPI(props, {
     const currentIndex = findIndex(dataLocal.value, item => item[AKeyId] === currentValue);
 
     switch (event.key) {
-    case "ArrowLeft":
-    case "ArrowDown":
-      newIndex = currentIndex - 1;
-      break;
-    case "ArrowRight":
-    case "ArrowUp":
-      newIndex = currentIndex + 1;
-      break;
-    case "Home":
-      newIndex = 0;
-      break;
-    case "End":
-      newIndex = lastIndexDataLocal.value;
-      break;
-    case "PageDown":
-      newIndex = currentIndex - 4;
-      break;
-    case "PageUp":
-      newIndex = currentIndex + 4;
-      break;
-    default:
-      isPreventDefault = false;
-      break;
+      case "ArrowLeft":
+      case "ArrowDown":
+        newIndex = currentIndex - 1;
+        break;
+      case "ArrowRight":
+      case "ArrowUp":
+        newIndex = currentIndex + 1;
+        break;
+      case "Home":
+        newIndex = 0;
+        break;
+      case "End":
+        newIndex = lastIndexDataLocal.value;
+        break;
+      case "PageDown":
+        newIndex = currentIndex - 4;
+        break;
+      case "PageUp":
+        newIndex = currentIndex + 4;
+        break;
+      default:
+        isPreventDefault = false;
+        break;
     }
 
     if (isPreventDefault) {

package/src/ui/AValidatedJson/AValidatedJson.js

@@ -25,11 +25,14 @@ import ModelAPI from "./compositionAPI/ModelAPI";
 import SingleModeAPI from "./compositionAPI/SingleModeAPI";
 import TranslateAPI from "./compositionAPI/TranslateAPI";
 
-import Plus from "aloha-svg/dist/js/bootstrap/Plus";
 import {
   uniqueId,
 } from "lodash-es";
 
+const Plus = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-plus" viewBox="0 0 16 16">
+  <path d="M8 4a.5.5 0 0 1 .5.5v3h3a.5.5 0 0 1 0 1h-3v3a.5.5 0 0 1-1 0v-3h-3a.5.5 0 0 1 0-1h3v-3A.5.5 0 0 1 8 4"/>
+</svg>`;
+
 export default {
   name: "AValidatedJson",
   inheritAttrs: false,