@sit-onyx/headless 1.0.0-beta.0 → 1.0.0-beta.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sit-onyx/headless",
   "description": "Headless composables for Vue",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.1",
   "type": "module",
   "author": "Schwarz IT KG",
   "license": "Apache-2.0",

package/src/composables/comboBox/TestCombobox.ct.tsx

@@ -1,5 +1,5 @@
 import { test } from "@playwright/experimental-ct-vue";
-import { comboboxSelectOnlyTesting, comboboxTesting } from "./createComboBox.ct";
+import { comboboxSelectOnlyTesting, comboboxTesting } from "./createComboBox.testing";
 import SelectOnlyCombobox from "./SelectOnlyCombobox.vue";
 import TestCombobox from "./TestCombobox.vue";
 

package/src/composables/comboBox/createComboBox.ts

@@ -2,13 +2,13 @@ import { computed, unref, type MaybeRef, type Ref } from "vue";
 import { createBuilder } from "../../utils/builder";
 import { createId } from "../../utils/id";
 import { isPrintableCharacter, wasKeyPressed, type PressedKey } from "../../utils/keyboard";
+import { useOutsideClick } from "../helpers/useOutsideClick";
+import { useTypeAhead } from "../helpers/useTypeAhead";
 import {
   createListbox,
   type CreateListboxOptions,
   type ListboxValue,
 } from "../listbox/createListbox";
-import { useOutsideClick } from "../outsideClick";
-import { useTypeAhead } from "../typeAhead";
 
 export type ComboboxAutoComplete = "none" | "list" | "both";
 
@@ -225,7 +225,7 @@ export const createComboBox = createBuilder(
     });
 
     useOutsideClick({
-      queryComponent: () => templateRef.value,
+      element: templateRef,
       onOutsideClick() {
         if (!isExpanded.value) return;
         onToggle?.(true);

package/src/composables/helpers/useGlobalListener.spec.ts

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ref, type Ref } from "vue";
+import { mockVueLifecycle } from "../../utils/vitest";
+import { useGlobalEventListener } from "./useGlobalListener";
+
+let unmount: () => Promise<void> | undefined;
+
+describe("useGlobalEventListener", () => {
+  let target: Ref<HTMLButtonElement>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    unmount = mockVueLifecycle();
+    target = ref(document.createElement("button"));
+    document.body.appendChild(target.value);
+  });
+
+  it("should be defined", () => {
+    expect(useGlobalEventListener).toBeDefined();
+  });
+
+  it("should listen to global events", () => {
+    // ARRANGE
+    const listener = vi.fn();
+    useGlobalEventListener({ type: "click", listener });
+    // ACT
+    const event = new MouseEvent("click", { bubbles: true });
+    target.value.dispatchEvent(event);
+    // ASSERT
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toBeCalledWith(event);
+  });
+
+  it("should stop to listen to global events after unmount", async () => {
+    // ARRANGE
+    const listener = vi.fn();
+    useGlobalEventListener({ type: "click", listener });
+    // ACT
+    await unmount();
+    expect(listener).toHaveBeenCalledTimes(0);
+    target.value.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    // ASSERT
+    expect(listener).toHaveBeenCalledTimes(0);
+  });
+
+  it("should allow for multiple of the same listener types", async () => {
+    // ARRANGE
+    vi.useFakeTimers();
+    const listener = vi.fn();
+    const disabled = ref(false);
+    const listener2 = vi.fn();
+    useGlobalEventListener({ type: "click", listener, disabled });
+    useGlobalEventListener({ type: "click", listener: listener2 });
+    // ACT
+    target.value.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    // ASSERT
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener2).toHaveBeenCalledTimes(1);
+    // ACT
+    disabled.value = true;
+    await vi.runAllTimersAsync();
+    // ACT
+    target.value.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    // ASSERT
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener2).toHaveBeenCalledTimes(2);
+  });
+
+  it("should not listen to events when disabled", async () => {
+    // ARRANGE
+    vi.useFakeTimers();
+    const disabled = ref(false);
+    const listener = vi.fn();
+    useGlobalEventListener({ type: "click", listener, disabled });
+    // ACT
+    await vi.runAllTimersAsync();
+    target.value.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    // ASSERT
+    expect(listener).toHaveBeenCalledTimes(1);
+    // ACT
+    disabled.value = true;
+    await vi.runAllTimersAsync();
+    target.value.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    // ASSERT
+    expect(listener).toHaveBeenCalledTimes(1);
+    // ACT
+    disabled.value = false;
+    await vi.runAllTimersAsync();
+    target.value.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    // ASSERT
+    expect(listener).toHaveBeenCalledTimes(2);
+  });
+});

package/src/composables/helpers/useGlobalListener.ts

@@ -0,0 +1,64 @@
+import { onBeforeMount, onBeforeUnmount, reactive, watchEffect, type Ref } from "vue";
+
+type DocumentEventType = keyof DocumentEventMap;
+type GlobalListener<K extends DocumentEventType = DocumentEventType> = (
+  event: DocumentEventMap[K],
+) => void;
+
+export type UseGlobalEventListenerOptions<K extends DocumentEventType> = {
+  type: K;
+  listener: GlobalListener<K>;
+  disabled?: Ref<boolean>;
+};
+
+const GLOBAL_LISTENERS = reactive(new Map<DocumentEventType, Set<GlobalListener>>());
+
+const updateRemainingListeners = (type: DocumentEventType, remaining?: Set<GlobalListener>) => {
+  if (remaining?.size) {
+    GLOBAL_LISTENERS.set(type, remaining);
+    return;
+  }
+  GLOBAL_LISTENERS.delete(type);
+  document.removeEventListener(type, GLOBAL_HANDLER);
+};
+
+const removeGlobalListener = <K extends DocumentEventType>(
+  type: K,
+  listener: GlobalListener<K>,
+) => {
+  const globalListener = GLOBAL_LISTENERS.get(type);
+  globalListener?.delete(listener as GlobalListener);
+
+  updateRemainingListeners(type, globalListener);
+};
+
+const addGlobalListener = <K extends DocumentEventType>(type: K, listener: GlobalListener<K>) => {
+  const globalListener = GLOBAL_LISTENERS.get(type) ?? new Set();
+  globalListener.add(listener as GlobalListener);
+  GLOBAL_LISTENERS.set(type, globalListener);
+
+  document.addEventListener(type, GLOBAL_HANDLER);
+};
+
+/**
+ * A single and unique function for all event types.
+ * We use the fact that `addEventListener` and `removeEventListener` are idempotent when called with the same function reference.
+ */
+const GLOBAL_HANDLER = (event: Event) => {
+  const type = event.type as DocumentEventType;
+  GLOBAL_LISTENERS.get(type)?.forEach((cb) => cb(event));
+};
+
+export const useGlobalEventListener = <K extends DocumentEventType>({
+  type,
+  listener,
+  disabled,
+}: UseGlobalEventListenerOptions<K>) => {
+  onBeforeMount(() =>
+    watchEffect(() =>
+      disabled?.value ? removeGlobalListener(type, listener) : addGlobalListener(type, listener),
+    ),
+  );
+
+  onBeforeUnmount(() => removeGlobalListener(type, listener));
+};

package/src/composables/helpers/useOutsideClick.ts

@@ -0,0 +1,34 @@
+import { type Ref } from "vue";
+import { useGlobalEventListener } from "./useGlobalListener";
+
+export type UseOutsideClickOptions = {
+  /**
+   * HTML element of the component where clicks should be ignored
+   */
+  element: Ref<HTMLElement | undefined>;
+  /**
+   * Callback when an outside click occurred.
+   */
+  onOutsideClick: () => void;
+  /**
+   * If `true`, event listeners will be removed and no outside clicks will be captured.
+   */
+  disabled?: Ref<boolean>;
+};
+
+/**
+ * Composable for listening to click events that occur outside of a component.
+ * Useful to e.g. close flyouts or tooltips.
+ */
+export const useOutsideClick = ({ element, onOutsideClick, disabled }: UseOutsideClickOptions) => {
+  /**
+   * Document click handle that closes then tooltip when clicked outside.
+   * Should only be called when trigger is "click".
+   */
+  const listener = ({ target }: MouseEvent) => {
+    const isOutsideClick = !element.value?.contains(target as HTMLElement);
+    if (isOutsideClick) onOutsideClick();
+  };
+
+  useGlobalEventListener({ type: "click", listener, disabled });
+};

package/src/composables/{typeAhead.spec.ts → helpers/useTypeAhead.spec.ts}

@@ -1,5 +1,5 @@
 import { beforeAll, expect, test, vi } from "vitest";
-import { useTypeAhead } from "./typeAhead";
+import { useTypeAhead } from "./useTypeAhead";
 
 beforeAll(() => {
   vi.useFakeTimers();

package/src/composables/{typeAhead.ts → helpers/useTypeAhead.ts}

@@ -1,5 +1,5 @@
-import { isPrintableCharacter } from "../utils/keyboard";
-import { debounce } from "../utils/timer";
+import { isPrintableCharacter } from "../../utils/keyboard";
+import { debounce } from "../../utils/timer";
 
 /**
  * Enhances typeAhead to combine multiple inputs in quick succession and filter out non-printable characters.

package/src/composables/listbox/TestListbox.ct.tsx

@@ -1,6 +1,6 @@
 import { test } from "@playwright/experimental-ct-vue";
 import TestListbox from "./TestListbox.vue";
-import { listboxTesting } from "./createListbox.ct";
+import { listboxTesting } from "./createListbox.testing";
 
 test("listbox", async ({ mount, page }) => {
   await mount(<TestListbox />);

package/src/composables/listbox/createListbox.ts

@@ -1,7 +1,7 @@
 import { computed, ref, unref, watchEffect, type MaybeRef, type Ref } from "vue";
 import { createId } from "../..";
 import { createBuilder, type HeadlessElementAttributes } from "../../utils/builder";
-import { useTypeAhead } from "../typeAhead";
+import { useTypeAhead } from "../helpers/useTypeAhead";
 
 export type ListboxValue = string | number | boolean;
 

package/src/composables/menuButton/TestMenuButton.ct.tsx

@@ -1,5 +1,5 @@
 import { test } from "@playwright/experimental-ct-vue";
-import { menuButtonTesting } from "./createMenuButton.ct";
+import { menuButtonTesting } from "./createMenuButton.testing";
 import TestMenuButton from "./TestMenuButton.vue";
 
 test("menuButton", async ({ mount, page }) => {

package/src/composables/menuButton/TestMenuButton.vue

@@ -12,7 +12,7 @@ const activeItem = ref<string>();
 const {
   elements: { button, menu, menuItem, listItem, flyout },
   state: { isExpanded },
-} = createMenuButton({});
+} = createMenuButton();
 </script>
 
 <template>

package/src/composables/menuButton/createMenuButton.ts

@@ -112,7 +112,7 @@ export const createMenuButton = createBuilder(() => {
         "aria-labelledby": buttonId,
         onKeydown: handleKeydown,
       },
-      ...createMenuItem({}).elements,
+      ...createMenuItem().elements,
     },
   };
 });

package/src/composables/tooltip/createTooltip.ts

@@ -1,7 +1,7 @@
 import { computed, onBeforeMount, onBeforeUnmount, ref, unref, type MaybeRef } from "vue";
 import { createId } from "../..";
 import { createBuilder } from "../../utils/builder";
-import { useOutsideClick } from "../outsideClick";
+import { useOutsideClick } from "../helpers/useOutsideClick";
 
 export type CreateTooltipOptions = {
   open: MaybeRef<TooltipOpen>;
@@ -22,6 +22,7 @@ export const TOOLTIP_TRIGGERS = ["hover", "click"] as const;
 export type TooltipTrigger = (typeof TOOLTIP_TRIGGERS)[number];
 
 export const createTooltip = createBuilder((options: CreateTooltipOptions) => {
+  const rootRef = ref<HTMLElement>();
   const tooltipId = createId("tooltip");
   const _isVisible = ref(false);
   let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -87,7 +88,7 @@ export const createTooltip = createBuilder((options: CreateTooltipOptions) => {
 
   // close tooltip on outside click
   useOutsideClick({
-    queryComponent: () => document.getElementById(tooltipId)?.parentElement,
+    element: rootRef,
     onOutsideClick: () => (_isVisible.value = false),
     disabled: computed(() => openType.value !== "click"),
   });
@@ -106,6 +107,9 @@ export const createTooltip = createBuilder((options: CreateTooltipOptions) => {
 
   return {
     elements: {
+      root: {
+        ref: rootRef,
+      },
       trigger: computed(() => ({
         "aria-describedby": tooltipId,
         onClick: openType.value === "click" ? handleClick : undefined,

package/src/index.ts

@@ -4,3 +4,4 @@ export * from "./composables/menuButton/createMenuButton";
 export * from "./composables/tooltip/createTooltip";
 export { createId } from "./utils/id";
 export { isPrintableCharacter, wasKeyPressed } from "./utils/keyboard";
+export { debounce } from "./utils/timer";

package/src/playwright.ts

@@ -1,3 +1,3 @@
-export * from "./composables/comboBox/createComboBox.ct";
-export * from "./composables/listbox/createListbox.ct";
-export * from "./composables/menuButton/createMenuButton.ct";
+export * from "./composables/comboBox/createComboBox.testing";
+export * from "./composables/listbox/createListbox.testing";
+export * from "./composables/menuButton/createMenuButton.testing";

package/src/utils/builder.ts

@@ -1,12 +1,14 @@
-import type { ComputedRef, HtmlHTMLAttributes, Ref } from "vue";
+import type { ComputedRef, HtmlHTMLAttributes, Ref, VNodeRef } from "vue";
 import type { IfDefined } from "./types";
 
+export type ElementAttributes = HtmlHTMLAttributes & { ref?: VNodeRef };
+
 export type IteratedHeadlessElementFunc<T extends Record<string, unknown>> = (
   opts: T,
-) => HtmlHTMLAttributes;
+) => ElementAttributes;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type HeadlessElementAttributes = HtmlHTMLAttributes | IteratedHeadlessElementFunc<any>;
+export type HeadlessElementAttributes = ElementAttributes | IteratedHeadlessElementFunc<any>;
 
 export type HeadlessElements = Record<
   string,
@@ -28,10 +30,10 @@ export type HeadlessComposable<
  * We use this identity function to ensure the correct typings of the headless composables
  */
 export const createBuilder = <
-  P,
-  Elements extends HeadlessElements,
+  Args extends unknown[] = unknown[],
+  Elements extends HeadlessElements = HeadlessElements,
   State extends HeadlessState | undefined = undefined,
   Internals extends object | undefined = undefined,
 >(
-  builder: (props: P) => HeadlessComposable<Elements, State, Internals>,
+  builder: (...args: Args) => HeadlessComposable<Elements, State, Internals>,
 ) => builder;

package/src/utils/math.spec.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "vitest";
+import { MathUtils } from "./math";
+
+describe("MathUtils.clamp", () => {
+  test.each([
+    { number: 1, min: 1, max: 2, result: 1 },
+    { number: 1, min: 2, max: 2, result: 2 },
+    { number: 1, min: 0, max: 0, result: 0 },
+    { number: 1, min: 1, max: 1, result: 1 },
+  ])(
+    "should return $result for key number:$number min:$min max:$max",
+    ({ number, min, max, result }) => expect(MathUtils.clamp(number, min, max)).toBe(result),
+  );
+});

package/src/utils/math.ts

@@ -0,0 +1,6 @@
+export const MathUtils = {
+  /**
+   * Ensures that a given `number` is or is between a given `min` and `max`.
+   */
+  clamp: (number: number, min: number, max: number) => Math.max(Math.min(number, max), min),
+};

package/src/utils/vitest.ts

@@ -0,0 +1,36 @@
+import { vi, type Awaitable } from "vitest";
+
+type Callback = () => Awaitable<void>;
+
+/**
+ * Mocks the following vue lifecycle functions:
+ * - onBeforeMount
+ * - onMounted
+ * - onBeforeUnmount
+ * - onUnmounted
+ *
+ * `onBeforeMount` and `onMounted` callbacks are executed immediately.
+ * `onBeforeUnmount` and `onUnmounted` are executed when the returned callback is run.
+ * @returns a callback to trigger the run of `onBeforeUnmount` and `onUnmounted`
+ */
+export const mockVueLifecycle = () => {
+  const { callbacks } = vi.hoisted(() => ({
+    callbacks: {
+      onBeforeUnmountedCb: null as Callback | null,
+      onUnmountedCb: null as Callback | null,
+    },
+  }));
+
+  vi.mock("vue", async (original) => ({
+    ...((await original()) as typeof import("vue")),
+    onBeforeMount: vi.fn((cb: Callback) => cb()),
+    onMounted: vi.fn((cb: Callback) => cb()),
+    onBeforeUnmount: vi.fn((cb: Callback) => (callbacks.onBeforeUnmountedCb = cb)),
+    onUnmounted: vi.fn((cb: Callback) => (callbacks.onUnmountedCb = cb)),
+  }));
+
+  return async () => {
+    await callbacks.onBeforeUnmountedCb?.();
+    await callbacks.onUnmountedCb?.();
+  };
+};

package/src/composables/outsideClick.ts

@@ -1,52 +0,0 @@
-import { onBeforeMount, onBeforeUnmount, watchEffect, type Ref } from "vue";
-
-export type UseOutsideClickOptions = {
-  /**
-   * Function that returns the HTML element of the component where outside clicks should be listened to.
-   */
-  queryComponent: () => ReturnType<typeof document.querySelector> | undefined;
-  /**
-   * Callback when an outside click occurred.
-   */
-  onOutsideClick: () => void;
-  /**
-   * If `true`, event listeners will be removed and no outside clicks will be captured.
-   */
-  disabled?: Ref<boolean>;
-};
-
-/**
- * Composable for listening to click events that occur outside of a component.
- * Useful to e.g. close flyouts or tooltips.
- */
-export const useOutsideClick = (options: UseOutsideClickOptions) => {
-  /**
-   * Document click handle that closes then tooltip when clicked outside.
-   * Should only be called when trigger is "click".
-   */
-  const handleDocumentClick = (event: MouseEvent) => {
-    const component = options.queryComponent();
-    if (!component || !(event.target instanceof Node)) return;
-
-    const isOutsideClick = !component.contains(event.target);
-    if (isOutsideClick) options.onOutsideClick();
-  };
-
-  // add global document event listeners only on/before mounted to also work in server side rendering
-  onBeforeMount(() => {
-    watchEffect(() => {
-      if (options.disabled?.value) {
-        document.removeEventListener("click", handleDocumentClick);
-      } else {
-        document.addEventListener("click", handleDocumentClick);
-      }
-    });
-  });
-
-  /**
-   * Clean up global event listeners to prevent dangling events.
-   */
-  onBeforeUnmount(() => {
-    document.removeEventListener("click", handleDocumentClick);
-  });
-};