aloha-vue 2.74.0 → 2.75.0

package/src/ui/compositionApi/__tests__/UiDataWithKeyIdAndLabelAPI.test.js

@@ -1,128 +1,128 @@
-import {
-  createApp,
-  defineComponent,
-} from "vue";
-import {
-  describe,
-  expect,
-  it,
-  jest,
-} from "@jest/globals";
-
-import UiDataWithKeyIdAndLabelAPI from "../UiDataWithKeyIdAndLabelAPI";
-
-import {
-  AKeyId,
-  AKeyLabel,
-} from "../../../const/AKeys";
-
-jest.mock("../../../index", () => ({
-  AKeyId: "_a_id",
-  AKeyLabel: "_a_label",
-  AKeyLabelSearch: "_a_label_search",
-  extractTextFromHtml: value => value,
-  getTranslatedText: ({ placeholder }) => placeholder,
-  isArrayOfArrays: value => Array.isArray(value) && value.every(Array.isArray),
-  isPlaceholderTranslate: () => false,
-}));
-
-const createProps = ({
-  data,
-  isDataSimpleArray = false,
-  mergeData = false,
-}) => ({
-  alwaysTranslate: false,
-  data,
-  dataExtra: [],
-  isDataSimpleArray,
-  keyId: "id",
-  keyLabel: "label",
-  keyLabelCallback: undefined,
-  mergeData,
-  searchTextInHtml: false,
-  translateData: false,
-});
-
-const useDataAPI = props => {
-  let result;
-  const app = createApp(defineComponent({
-    name: "TestUiDataWithKeyIdAndLabelAPI",
-    setup() {
-      result = UiDataWithKeyIdAndLabelAPI(props);
-      return () => null;
-    },
-  }));
-
-  app.mount(document.createElement("div"));
-  return result;
-};
-
-describe("UiDataWithKeyIdAndLabelAPI", () => {
-  it("keeps replacing prop data with internally loaded data by default", () => {
-    const {
-      dataFromServer,
-      dataLocal,
-    } = useDataAPI(createProps({
-      data: [
-        { id: 1, label: "Prop one" },
-        { id: 3, label: "Prop three" },
-      ],
-    }));
-
-    dataFromServer.value = [
-      { id: 1, label: "Internal one" },
-      { id: 2, label: "Internal two" },
-    ];
-
-    expect(dataLocal.value.map(item => item[AKeyLabel])).toEqual([
-      "Internal one",
-      "Internal two",
-    ]);
-  });
-
-  it("merges prop and internally loaded data by ID with internal items taking precedence", () => {
-    const {
-      dataFromServer,
-      dataLocal,
-    } = useDataAPI(createProps({
-      data: [
-        { id: 1, label: "Prop one" },
-        { id: 3, label: "Prop three" },
-      ],
-      mergeData: true,
-    }));
-
-    dataFromServer.value = [
-      { id: 1, label: "Internal one" },
-      { id: 2, label: "Internal two" },
-    ];
-
-    expect(dataLocal.value.map(item => ({
-      id: item[AKeyId],
-      label: item[AKeyLabel],
-    }))).toEqual([
-      { id: 1, label: "Internal one" },
-      { id: 2, label: "Internal two" },
-      { id: 3, label: "Prop three" },
-    ]);
-  });
-
-  it("merges simple arrays by their values", () => {
-    const {
-      dataFromServer,
-      dataLocal,
-    } = useDataAPI(createProps({
-      data: ["one", "three"],
-      isDataSimpleArray: true,
-      mergeData: true,
-    }));
-
-    dataFromServer.value = ["one", "two"];
-
-    expect(dataLocal.value.map(item => item[AKeyId])).toEqual([
-      "one",
-      "two",
-      "three",
-    ]);
-  });
-});
+import {
+  createApp,
+  defineComponent,
+} from "vue";
+import {
+  describe,
+  expect,
+  it,
+  vi,
+} from "vitest";
+
+import UiDataWithKeyIdAndLabelAPI from "../UiDataWithKeyIdAndLabelAPI";
+
+import {
+  AKeyId,
+  AKeyLabel,
+} from "../../../const/AKeys";
+
+vi.mock("../../../index", () => ({
+  AKeyId: "_a_id",
+  AKeyLabel: "_a_label",
+  AKeyLabelSearch: "_a_label_search",
+  extractTextFromHtml: value => value,
+  getTranslatedText: ({ placeholder }) => placeholder,
+  isArrayOfArrays: value => Array.isArray(value) && value.every(Array.isArray),
+  isPlaceholderTranslate: () => false,
+}));
+
+const createProps = ({
+  data,
+  isDataSimpleArray = false,
+  mergeData = false,
+}) => ({
+  alwaysTranslate: false,
+  data,
+  dataExtra: [],
+  isDataSimpleArray,
+  keyId: "id",
+  keyLabel: "label",
+  keyLabelCallback: undefined,
+  mergeData,
+  searchTextInHtml: false,
+  translateData: false,
+});
+
+const useDataAPI = props => {
+  let result;
+  const app = createApp(defineComponent({
+    name: "TestUiDataWithKeyIdAndLabelAPI",
+    setup() {
+      result = UiDataWithKeyIdAndLabelAPI(props);
+      return () => null;
+    },
+  }));
+
+  app.mount(document.createElement("div"));
+  return result;
+};
+
+describe("UiDataWithKeyIdAndLabelAPI", () => {
+  it("keeps replacing prop data with internally loaded data by default", () => {
+    const {
+      dataFromServer,
+      dataLocal,
+    } = useDataAPI(createProps({
+      data: [
+        { id: 1, label: "Prop one" },
+        { id: 3, label: "Prop three" },
+      ],
+    }));
+
+    dataFromServer.value = [
+      { id: 1, label: "Internal one" },
+      { id: 2, label: "Internal two" },
+    ];
+
+    expect(dataLocal.value.map(item => item[AKeyLabel])).toEqual([
+      "Internal one",
+      "Internal two",
+    ]);
+  });
+
+  it("merges prop and internally loaded data by ID with internal items taking precedence", () => {
+    const {
+      dataFromServer,
+      dataLocal,
+    } = useDataAPI(createProps({
+      data: [
+        { id: 1, label: "Prop one" },
+        { id: 3, label: "Prop three" },
+      ],
+      mergeData: true,
+    }));
+
+    dataFromServer.value = [
+      { id: 1, label: "Internal one" },
+      { id: 2, label: "Internal two" },
+    ];
+
+    expect(dataLocal.value.map(item => ({
+      id: item[AKeyId],
+      label: item[AKeyLabel],
+    }))).toEqual([
+      { id: 1, label: "Internal one" },
+      { id: 2, label: "Internal two" },
+      { id: 3, label: "Prop three" },
+    ]);
+  });
+
+  it("merges simple arrays by their values", () => {
+    const {
+      dataFromServer,
+      dataLocal,
+    } = useDataAPI(createProps({
+      data: ["one", "three"],
+      isDataSimpleArray: true,
+      mergeData: true,
+    }));
+
+    dataFromServer.value = ["one", "two"];
+
+    expect(dataLocal.value.map(item => item[AKeyId])).toEqual([
+      "one",
+      "two",
+      "three",
+    ]);
+  });
+});

package/src/ui/compositionApi/__tests__/UiSearchAPI.test.js

@@ -1,71 +1,71 @@
-import {
-  computed,
-} from "vue";
-import {
-  describe,
-  expect,
-  it,
-} from "@jest/globals";
-
-import UIDataGroupAPI from "../UIDataGroupAPI";
-import UiSearchAPI from "../UiSearchAPI";
-
-import {
-  AKeyId,
-  AKeyLabel,
-} from "../../../const/AKeys";
-
-describe("UiSearchAPI", () => {
-  it("includes grouped dataExtra in item and group search", () => {
-    const props = {
-      keyGroup: "group",
-      keyGroupLabelCallback: undefined,
-      searchInGroup: true,
-      searchOutside: false,
-      searchTextInHtml: false,
-      searchTimeout: 0,
-      sortOrderGroup: undefined,
-    };
-    const dataExtra = computed(() => [
-      {
-        [AKeyId]: "extra_1",
-        [AKeyLabel]: "Extra 1",
-        group: "Recommended",
-      },
-      {
-        [AKeyId]: "extra_2",
-        [AKeyLabel]: "Extra 2",
-        group: "Other",
-      },
-    ]);
-    const {
-      groupsForLever: groupsForLeverExtra,
-      hasKeyGroup,
-      keyGroupArray,
-    } = UIDataGroupAPI(props, {
-      data: dataExtra,
-    });
-    const {
-      hasNotElementsWithSearch,
-      searchingElementsExtra,
-      searchingGroups,
-      searchingGroupsWithSearchInGroup,
-      updateModelSearch,
-    } = UiSearchAPI(props, { emit: () => {} }, {
-      dataExtra,
-      groupsForLeverExtra,
-      hasKeyGroup,
-      keyGroupArray,
-    });
-
-    updateModelSearch("Extra 1");
-
-    expect(searchingElementsExtra.value).toEqual({ extra_1: true });
-    expect(searchingGroups.value).toEqual({ Recommended: true });
-
-    updateModelSearch("Recommended");
-
-    expect(searchingGroupsWithSearchInGroup.value).toEqual({ Recommended: true });
-    expect(hasNotElementsWithSearch.value).toBe(false);
-  });
-});
+import {
+  computed,
+} from "vue";
+import {
+  describe,
+  expect,
+  it,
+} from "vitest";
+
+import UIDataGroupAPI from "../UIDataGroupAPI";
+import UiSearchAPI from "../UiSearchAPI";
+
+import {
+  AKeyId,
+  AKeyLabel,
+} from "../../../const/AKeys";
+
+describe("UiSearchAPI", () => {
+  it("includes grouped dataExtra in item and group search", () => {
+    const props = {
+      keyGroup: "group",
+      keyGroupLabelCallback: undefined,
+      searchInGroup: true,
+      searchOutside: false,
+      searchTextInHtml: false,
+      searchTimeout: 0,
+      sortOrderGroup: undefined,
+    };
+    const dataExtra = computed(() => [
+      {
+        [AKeyId]: "extra_1",
+        [AKeyLabel]: "Extra 1",
+        group: "Recommended",
+      },
+      {
+        [AKeyId]: "extra_2",
+        [AKeyLabel]: "Extra 2",
+        group: "Other",
+      },
+    ]);
+    const {
+      groupsForLever: groupsForLeverExtra,
+      hasKeyGroup,
+      keyGroupArray,
+    } = UIDataGroupAPI(props, {
+      data: dataExtra,
+    });
+    const {
+      hasNotElementsWithSearch,
+      searchingElementsExtra,
+      searchingGroups,
+      searchingGroupsWithSearchInGroup,
+      updateModelSearch,
+    } = UiSearchAPI(props, { emit: () => {} }, {
+      dataExtra,
+      groupsForLeverExtra,
+      hasKeyGroup,
+      keyGroupArray,
+    });
+
+    updateModelSearch("Extra 1");
+
+    expect(searchingElementsExtra.value).toEqual({ extra_1: true });
+    expect(searchingGroups.value).toEqual({ Recommended: true });
+
+    updateModelSearch("Recommended");
+
+    expect(searchingGroupsWithSearchInGroup.value).toEqual({ Recommended: true });
+    expect(hasNotElementsWithSearch.value).toBe(false);
+  });
+});

package/src/utils/EventBus.js

@@ -1,8 +1,51 @@
-import emitter from "tiny-emitter/instance";
-
-export default {
-  $on: (...args) => emitter.on(...args),
-  $once: (...args) => emitter.once(...args),
-  $off: (...args) => emitter.off(...args),
-  $emit: (...args) => emitter.emit(...args),
-};
+const listeners = new Map();
+
+const subscribe = (name, callback, context, originalCallback = callback) => {
+  const subscriptions = listeners.get(name) || [];
+  subscriptions.push({ callback, context, originalCallback });
+  listeners.set(name, subscriptions);
+};
+
+const emitter = {
+  on(name, callback, context) {
+    subscribe(name, callback, context);
+    return emitter;
+  },
+  once(name, callback, context) {
+    const onceListener = (...args) => {
+      emitter.off(name, onceListener);
+      callback.apply(context, args);
+    };
+    subscribe(name, onceListener, context, callback);
+    return emitter;
+  },
+  off(name, callback) {
+    if (!callback) {
+      listeners.delete(name);
+      return emitter;
+    }
+    const remaining = (listeners.get(name) || []).filter(subscription => {
+      return subscription.callback !== callback && subscription.originalCallback !== callback;
+    });
+    if (remaining.length) {
+      listeners.set(name, remaining);
+    } else {
+      listeners.delete(name);
+    }
+    return emitter;
+  },
+  emit(name, ...args) {
+    const subscriptions = [...(listeners.get(name) || [])];
+    for (const { callback, context } of subscriptions) {
+      callback.apply(context, args);
+    }
+    return emitter;
+  },
+};
+
+export default {
+  $on: (...args) => emitter.on(...args),
+  $once: (...args) => emitter.once(...args),
+  $off: (...args) => emitter.off(...args),
+  $emit: (...args) => emitter.emit(...args),
+};

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

@@ -0,0 +1,138 @@
+import {
+  afterEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from "vitest";
+
+import EventBus from "../EventBus";
+
+const EVENT = "event-bus-test";
+const OTHER_EVENT = "event-bus-other-test";
+
+afterEach(() => {
+  EventBus.$off(EVENT);
+  EventBus.$off(OTHER_EVENT);
+  EventBus.$off("__proto__");
+});
+
+describe("EventBus", () => {
+  it("passes all arguments and the supplied context in registration order", () => {
+    const calls = [];
+    const context = {};
+    EventBus.$on(EVENT, function(...args) {
+      calls.push({ context: this, args });
+    }, context);
+    EventBus.$on(EVENT, () => calls.push("second"));
+
+    EventBus.$emit(EVENT, 1, { value: 2 });
+
+    expect(calls).toEqual([{ context, args: [1, { value: 2 }] }, "second"]);
+  });
+
+  it("keeps duplicate subscriptions and removes every match for a callback", () => {
+    const callback = vi.fn();
+    const remaining = vi.fn();
+    EventBus.$on(EVENT, callback);
+    EventBus.$on(EVENT, callback);
+    EventBus.$on(EVENT, remaining);
+
+    EventBus.$emit(EVENT);
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    EventBus.$off(EVENT, callback);
+    EventBus.$emit(EVENT);
+    expect(callback).toHaveBeenCalledTimes(2);
+    expect(remaining).toHaveBeenCalledTimes(2);
+  });
+
+  it("removes all listeners for one event without affecting other events", () => {
+    const callback = vi.fn();
+    EventBus.$on(EVENT, callback);
+    EventBus.$on(OTHER_EVENT, callback);
+
+    EventBus.$off(EVENT);
+    EventBus.$emit(EVENT);
+    expect(callback).not.toHaveBeenCalled();
+    EventBus.$emit(OTHER_EVENT);
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("removes a once listener before a recursive emit and preserves its context", () => {
+    const context = {};
+    const callback = vi.fn(function(value) {
+      expect(this).toBe(context);
+      expect(value).toBe(42);
+      EventBus.$emit(EVENT, value);
+    });
+    EventBus.$once(EVENT, callback, context);
+
+    EventBus.$emit(EVENT, 42);
+    EventBus.$emit(EVENT, 42);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  it("can cancel once listeners using the original callback", () => {
+    const callback = vi.fn();
+    EventBus.$once(EVENT, callback);
+    EventBus.$on(EVENT, callback);
+    EventBus.$once(EVENT, callback);
+
+    EventBus.$off(EVENT, callback);
+    EventBus.$emit(EVENT);
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it("uses a snapshot when subscriptions change during an emit", () => {
+    const removed = vi.fn();
+    const added = vi.fn();
+    EventBus.$once(EVENT, () => {
+      EventBus.$off(EVENT, removed);
+      EventBus.$on(EVENT, added);
+    });
+    EventBus.$on(EVENT, removed);
+
+    EventBus.$emit(EVENT);
+    expect(removed).toHaveBeenCalledTimes(1);
+    expect(added).not.toHaveBeenCalled();
+
+    EventBus.$emit(EVENT);
+    expect(removed).toHaveBeenCalledTimes(1);
+    expect(added).toHaveBeenCalledTimes(1);
+  });
+
+  it("propagates listener errors and keeps a throwing once listener removed", () => {
+    const error = new Error("Listener failed");
+    const remaining = vi.fn();
+    EventBus.$once(EVENT, () => {
+      throw error;
+    });
+    EventBus.$on(EVENT, remaining);
+
+    expect(() => EventBus.$emit(EVENT)).toThrow(error);
+    expect(remaining).not.toHaveBeenCalled();
+    EventBus.$emit(EVENT);
+    expect(remaining).toHaveBeenCalledTimes(1);
+  });
+
+  it("supports arbitrary event names and emitting without subscribers", () => {
+    const callback = vi.fn();
+    expect(() => EventBus.$emit(EVENT)).not.toThrow();
+    EventBus.$on("__proto__", callback);
+    EventBus.$emit("__proto__", "value");
+    expect(callback).toHaveBeenCalledWith("value");
+  });
+
+  it("preserves chaining through the emitter returned by the public methods", () => {
+    const callback = vi.fn();
+    const emitter = EventBus.$on(EVENT, callback);
+    expect(emitter.emit(EVENT).off(EVENT, callback).once(EVENT, callback)).toBe(emitter);
+    expect(EventBus.$emit(EVENT)).toBe(emitter);
+    expect(EventBus.$off(EVENT)).toBe(emitter);
+    expect(EventBus.$once(EVENT, callback)).toBe(emitter);
+    expect(callback).toHaveBeenCalledTimes(2);
+  });
+});

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

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

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

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