@simplybusiness/mobius 8.0.2 → 9.0.1

package/dist/types/src/hooks/useWindowEvent/index.d.ts

@@ -1 +0,0 @@
-export * from "./useWindowEvent";

package/dist/types/src/hooks/useWindowEvent/useWindowEvent.d.ts

@@ -1 +0,0 @@
-export declare function useWindowEvent<EventType extends keyof WindowEventMap>(type: EventType, listener: (this: Window, ev: WindowEventMap[EventType]) => unknown, options?: AddEventListenerOptions): void;

package/dist/types/src/utils/jestHTMLDialogPolyfill.d.ts

@@ -1 +0,0 @@
-export declare const jestHTMLDialogPolyfill: () => void;

package/dist/types/src/utils/jestMockMatchMedia.d.ts

@@ -1 +0,0 @@
-export declare const jestMockMatchMedia: (matches: boolean) => void;

package/src/hooks/useBodyScrollLock/index.ts

@@ -1 +0,0 @@
-export * from "./useBodyScrollLock";

package/src/hooks/useBodyScrollLock/useBodyScrollLock.test.ts

@@ -1,34 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { useBodyScrollLock } from "./useBodyScrollLock";
-
-describe("useBodyScrollLock", () => {
-  it("should be defined", () => {
-    expect(useBodyScrollLock).toBeDefined();
-  });
-
-  it("should not throw", () => {
-    expect(() => renderHook(() => useBodyScrollLock())).not.toThrow();
-  });
-
-  it("should disable scroll by default", () => {
-    renderHook(() => useBodyScrollLock());
-    expect(document.body).toHaveStyle({ overflow: "hidden" });
-  });
-
-  it("should disable scroll when enabled is true", () => {
-    renderHook(() => useBodyScrollLock({ enabled: true }));
-    expect(document.body).toHaveStyle({ overflow: "hidden" });
-  });
-
-  it("should enable scroll when enabled is false", () => {
-    renderHook(() => useBodyScrollLock({ enabled: false }));
-    expect(document.body).toHaveStyle({ overflow: "" });
-  });
-
-  it("should enable scroll on unmount", () => {
-    const { unmount } = renderHook(() => useBodyScrollLock());
-    expect(document.body).toHaveStyle({ overflow: "hidden" });
-    unmount();
-    expect(document.body).toHaveStyle({ overflow: "" });
-  });
-});

package/src/hooks/useBodyScrollLock/useBodyScrollLock.ts

@@ -1,30 +0,0 @@
-import { useEffect } from "react";
-
-export function useBodyScrollLock({
-  enabled = true,
-}: { enabled?: boolean } = {}) {
-  function disableScrollLock() {
-    document.body.style.removeProperty("overflow");
-    document.body.style.removeProperty("scrollbar-gutter");
-    document.documentElement.style.removeProperty("scrollbar-gutter");
-  }
-
-  function enableScrollLock() {
-    document.body.style.overflow = "hidden";
-    // Prevent content jumping due to scrollbar disappearing
-    document.body.style.scrollbarGutter = "stable";
-    document.documentElement.style.scrollbarGutter = "stable";
-  }
-
-  useEffect(() => {
-    if (enabled) {
-      enableScrollLock();
-    } else {
-      disableScrollLock();
-    }
-
-    return () => {
-      disableScrollLock();
-    };
-  }, [enabled]);
-}

package/src/hooks/useDebouncedValue/index.tsx

@@ -1 +0,0 @@
-export * from "./useDebouncedValue";

package/src/hooks/useDebouncedValue/useDebouncedValue.test.tsx

@@ -1,62 +0,0 @@
-import { renderHook, act } from "@testing-library/react";
-import { useDebouncedValue } from "./useDebouncedValue";
-
-describe("useDebouncedValue", () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  it("returns the initial value immediately when delay is 0", () => {
-    const { result } = renderHook(() => useDebouncedValue("initial", 0));
-    expect(result.current).toBe("initial");
-  });
-
-  it("returns the previous value until delay has elapsed", () => {
-    const { result, rerender } = renderHook(
-      ({ value }) => useDebouncedValue(value, 1000),
-      { initialProps: { value: "initial" } },
-    );
-
-    expect(result.current).toBe("initial");
-
-    rerender({ value: "updated" });
-    expect(result.current).toBe("initial");
-
-    act(() => {
-      jest.advanceTimersByTime(999);
-    });
-    expect(result.current).toBe("initial");
-
-    act(() => {
-      jest.advanceTimersByTime(1);
-    });
-    expect(result.current).toBe("updated");
-  });
-
-  it("cancels previous timeout when value changes", () => {
-    const { result, rerender } = renderHook(
-      ({ value }) => useDebouncedValue(value, 1000),
-      { initialProps: { value: "initial" } },
-    );
-
-    rerender({ value: "updated1" });
-    act(() => {
-      jest.advanceTimersByTime(500);
-    });
-
-    rerender({ value: "updated2" });
-    act(() => {
-      jest.advanceTimersByTime(500);
-    });
-    expect(result.current).toBe("initial");
-
-    act(() => {
-      jest.advanceTimersByTime(500);
-    });
-    expect(result.current).toBe("updated2");
-  });
-});

package/src/hooks/useDebouncedValue/useDebouncedValue.tsx

@@ -1,25 +0,0 @@
-import { useEffect, useState } from "react";
-
-export function useDebouncedValue<T>(value: T, delay: number = 0): T {
-  const [debouncedValue, setDebouncedValue] = useState(value);
-
-  useEffect(() => {
-    let timeout: NodeJS.Timeout | null = null;
-    if (delay === 0) {
-      setDebouncedValue(value);
-    } else {
-      timeout = setTimeout(() => {
-        setDebouncedValue(value);
-      }, delay);
-    }
-
-    return () => {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
-      }
-    };
-  }, [value, delay]);
-
-  return debouncedValue;
-}

package/src/hooks/useOnClickOutside/index.tsx

@@ -1 +0,0 @@
-export * from "./useOnClickOutside";

package/src/hooks/useOnClickOutside/useOnClickOutside.test.tsx

@@ -1,189 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { useRef } from "react";
-import { useOnClickOutside } from "./useOnClickOutside";
-
-describe("useOnClickOutside", () => {
-  const addEventListenerSpy = jest.spyOn(document, "addEventListener");
-  const removeEventListenerSpy = jest.spyOn(document, "removeEventListener");
-
-  beforeEach(() => {
-    addEventListenerSpy.mockClear();
-    removeEventListenerSpy.mockClear();
-  });
-
-  afterAll(() => {
-    addEventListenerSpy.mockRestore();
-    removeEventListenerSpy.mockRestore();
-  });
-
-  it("adds event listeners on mount", () => {
-    const handler = jest.fn();
-    const { result } = renderHook(() => {
-      const ref = useRef<HTMLDivElement>(null);
-      useOnClickOutside(ref, handler);
-      return ref;
-    });
-
-    expect(result.current).toBeDefined();
-    expect(addEventListenerSpy).toHaveBeenCalledWith(
-      "mousedown",
-      expect.any(Function),
-    );
-    expect(addEventListenerSpy).toHaveBeenCalledWith(
-      "touchstart",
-      expect.any(Function),
-    );
-    expect(addEventListenerSpy).toHaveBeenCalledWith(
-      "keydown",
-      expect.any(Function),
-    );
-  });
-
-  it("removes event listeners on unmount", () => {
-    const handler = jest.fn();
-    const { unmount } = renderHook(() => {
-      const ref = useRef<HTMLDivElement>(null);
-      useOnClickOutside(ref, handler);
-      return ref;
-    });
-
-    removeEventListenerSpy.mockClear();
-    unmount();
-
-    expect(removeEventListenerSpy).toHaveBeenCalledWith(
-      "mousedown",
-      expect.any(Function),
-    );
-    expect(removeEventListenerSpy).toHaveBeenCalledWith(
-      "touchstart",
-      expect.any(Function),
-    );
-    expect(removeEventListenerSpy).toHaveBeenCalledWith(
-      "keydown",
-      expect.any(Function),
-    );
-  });
-
-  it("calls handler when clicking outside the ref element", () => {
-    const handler = jest.fn();
-    const div = document.createElement("div");
-    document.body.appendChild(div);
-
-    renderHook(() => {
-      const ref = useRef<HTMLDivElement>(div);
-      useOnClickOutside(ref, handler);
-      return ref;
-    });
-
-    // Click outside the element
-    const outsideElement = document.createElement("span");
-    document.body.appendChild(outsideElement);
-
-    const event = new MouseEvent("mousedown", { bubbles: true });
-    outsideElement.dispatchEvent(event);
-
-    expect(handler).toHaveBeenCalledTimes(1);
-
-    document.body.removeChild(div);
-    document.body.removeChild(outsideElement);
-  });
-
-  it("does not call handler when clicking inside the ref element", () => {
-    const handler = jest.fn();
-    const div = document.createElement("div");
-    const child = document.createElement("span");
-    div.appendChild(child);
-    document.body.appendChild(div);
-
-    renderHook(() => {
-      const ref = useRef<HTMLDivElement>(div);
-      useOnClickOutside(ref, handler);
-      return ref;
-    });
-
-    const event = new MouseEvent("mousedown", { bubbles: true });
-    child.dispatchEvent(event);
-
-    expect(handler).not.toHaveBeenCalled();
-
-    document.body.removeChild(div);
-  });
-
-  it("calls handler when Escape key is pressed", () => {
-    const handler = jest.fn();
-    const div = document.createElement("div");
-    document.body.appendChild(div);
-
-    renderHook(() => {
-      const ref = useRef<HTMLDivElement>(div);
-      useOnClickOutside(ref, handler);
-      return ref;
-    });
-
-    const event = new KeyboardEvent("keydown", {
-      key: "Escape",
-      bubbles: true,
-    });
-    document.dispatchEvent(event);
-
-    expect(handler).toHaveBeenCalledTimes(1);
-
-    document.body.removeChild(div);
-  });
-
-  it("does not call handler for non-Escape key presses", () => {
-    const handler = jest.fn();
-    const div = document.createElement("div");
-    document.body.appendChild(div);
-
-    renderHook(() => {
-      const ref = useRef<HTMLDivElement>(div);
-      useOnClickOutside(ref, handler);
-      return ref;
-    });
-
-    const event = new KeyboardEvent("keydown", { key: "Enter", bubbles: true });
-    document.dispatchEvent(event);
-
-    expect(handler).not.toHaveBeenCalled();
-
-    document.body.removeChild(div);
-  });
-
-  it("uses the latest handler without re-subscribing", () => {
-    const handler1 = jest.fn();
-    const handler2 = jest.fn();
-    const div = document.createElement("div");
-    document.body.appendChild(div);
-
-    const { rerender } = renderHook(
-      ({ handler }) => {
-        const ref = useRef<HTMLDivElement>(div);
-        useOnClickOutside(ref, handler);
-        return ref;
-      },
-      { initialProps: { handler: handler1 } },
-    );
-
-    // Clear the spy to only count new subscriptions
-    addEventListenerSpy.mockClear();
-
-    // Rerender with new handler
-    rerender({ handler: handler2 });
-
-    // Should not re-subscribe (useEffectEvent handles this)
-    expect(addEventListenerSpy).not.toHaveBeenCalled();
-
-    // Trigger event - should call the new handler
-    const event = new KeyboardEvent("keydown", {
-      key: "Escape",
-      bubbles: true,
-    });
-    document.dispatchEvent(event);
-
-    expect(handler1).not.toHaveBeenCalled();
-    expect(handler2).toHaveBeenCalledTimes(1);
-
-    document.body.removeChild(div);
-  });
-});

package/src/hooks/useOnClickOutside/useOnClickOutside.tsx

@@ -1,44 +0,0 @@
-"use client";
-
-import type { RefObject } from "react";
-import { useEffect, useEffectEvent } from "react";
-
-export const useOnClickOutside = (
-  ref: RefObject<HTMLElement | null>,
-  handler: (event: MouseEvent | TouchEvent | KeyboardEvent) => void,
-) => {
-  // useEffectEvent creates a stable reference to the handler
-  // that always calls the latest version
-  const stableHandler = useEffectEvent(handler);
-
-  useEffect(() => {
-    const listener = (event: MouseEvent | TouchEvent) => {
-      // Do nothing if clicking ref's element or descendent elements
-      if (!ref.current || ref.current.contains(event.target as HTMLElement)) {
-        return;
-      }
-
-      event.preventDefault();
-      event.stopPropagation();
-      stableHandler(event);
-    };
-
-    const handleEscapeKeyPress = (event: KeyboardEvent) => {
-      if (event.key === "Escape") {
-        event.preventDefault();
-        event.stopPropagation();
-        stableHandler(event);
-      }
-    };
-
-    document.addEventListener("mousedown", listener);
-    document.addEventListener("touchstart", listener);
-    document.addEventListener("keydown", handleEscapeKeyPress);
-
-    return () => {
-      document.removeEventListener("mousedown", listener);
-      document.removeEventListener("touchstart", listener);
-      document.removeEventListener("keydown", handleEscapeKeyPress);
-    };
-  }, [ref]);
-};

package/src/hooks/useOnUnmount/index.tsx

@@ -1 +0,0 @@
-export * from "./useOnUnmount";

package/src/hooks/useOnUnmount/useOnUnmount.test.tsx

@@ -1,37 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { useOnUnmount } from "./useOnUnmount";
-
-describe("useOnUnmount", () => {
-  it("should call the callback on unmount", () => {
-    const callback = jest.fn();
-    const { unmount } = renderHook(() => useOnUnmount(callback));
-
-    expect(callback).not.toHaveBeenCalled();
-
-    unmount();
-
-    expect(callback).toHaveBeenCalled();
-  });
-
-  it("should only use the latest callback", () => {
-    const firstCallback = jest.fn();
-    const secondCallback = jest.fn();
-
-    const { rerender, unmount } = renderHook(
-      ({ callback }) => useOnUnmount(callback),
-      {
-        initialProps: { callback: firstCallback },
-      },
-    );
-
-    // Change the callback
-    rerender({ callback: secondCallback });
-
-    // Unmount the component
-    unmount();
-
-    // Ensure the second callback is called, not the first one
-    expect(firstCallback).not.toHaveBeenCalled();
-    expect(secondCallback).toHaveBeenCalled();
-  });
-});

package/src/hooks/useOnUnmount/useOnUnmount.tsx

@@ -1,8 +0,0 @@
-import { useEffect, useEffectEvent } from "react";
-
-export function useOnUnmount(callback: () => void) {
-  // useEffectEvent creates a stable reference that always calls the latest callback
-  const stableCallback = useEffectEvent(callback);
-
-  useEffect(() => () => stableCallback(), []);
-}

package/src/hooks/usePrefersReducedMotion/index.tsx

@@ -1 +0,0 @@
-export * from "./usePrefersReducedMotion";

package/src/hooks/usePrefersReducedMotion/usePrefersReducedMotion.test.tsx

@@ -1,48 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { usePrefersReducedMotion } from "./usePrefersReducedMotion";
-
-function mockMatchMedia(matches: boolean) {
-  window.matchMedia = jest.fn().mockReturnValue({
-    matches,
-    addEventListener: jest.fn(),
-    removeEventListener: jest.fn(),
-  });
-}
-
-describe("usePrefersReducedMotion", () => {
-  it("should return a boolean", () => {
-    mockMatchMedia(false);
-
-    const { result } = renderHook(() => usePrefersReducedMotion());
-    expect(typeof result.current).toBe("boolean");
-  });
-
-  it("should return false by default", () => {
-    mockMatchMedia(false);
-
-    const { result } = renderHook(() => usePrefersReducedMotion());
-    expect(result.current).toBe(false);
-  });
-
-  it("should return true when the user prefers reduced motion", () => {
-    mockMatchMedia(true);
-
-    const { result } = renderHook(() => usePrefersReducedMotion());
-    expect(result.current).toBe(true);
-  });
-
-  it("should return false when the user does not prefer reduced motion", () => {
-    mockMatchMedia(false);
-
-    const { result } = renderHook(() => usePrefersReducedMotion());
-    expect(result.current).toBe(false);
-  });
-
-  // TODO: These tests need better mocking to work
-  it.todo(
-    "should return true when the user prefers reduced motion after changing",
-  );
-  it.todo(
-    "should return false when the user does not prefer reduced motion after changing",
-  );
-});

package/src/hooks/usePrefersReducedMotion/usePrefersReducedMotion.tsx

@@ -1,22 +0,0 @@
-import { useEffect, useState } from "react";
-
-export function usePrefersReducedMotion(): boolean {
-  const [prefersReducedMotion, setPrefersReducedMotion] = useState(false);
-
-  useEffect(() => {
-    const mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
-    setPrefersReducedMotion(mediaQuery.matches);
-
-    const listener = (event: MediaQueryListEvent) => {
-      setPrefersReducedMotion(event.matches);
-    };
-
-    mediaQuery.addEventListener("change", listener);
-
-    return () => {
-      mediaQuery.removeEventListener("change", listener);
-    };
-  }, []);
-
-  return prefersReducedMotion;
-}

package/src/hooks/useRenderCount/index.ts

@@ -1 +0,0 @@
-export * from "./useRenderCount";

package/src/hooks/useRenderCount/useRenderCount.test.ts

@@ -1,26 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { useRenderCount } from "./useRenderCount";
-
-describe("useRenderCount", () => {
-  it("should return 1 on initial render", () => {
-    const { result } = renderHook(() => useRenderCount());
-    expect(result.current).toBe(1);
-  });
-
-  it("should increment the count on re-render", () => {
-    const { result, rerender } = renderHook(() => useRenderCount());
-    expect(result.current).toBe(1);
-    rerender();
-    expect(result.current).toBe(2);
-    rerender();
-    expect(result.current).toBe(3);
-  });
-
-  it("should maintain the count across multiple renders", () => {
-    const { result, rerender } = renderHook(() => useRenderCount());
-    rerender();
-    rerender();
-    rerender();
-    expect(result.current).toBe(4);
-  });
-});

package/src/hooks/useRenderCount/useRenderCount.ts

@@ -1,9 +0,0 @@
-import { useEffect, useRef } from "react";
-
-export function useRenderCount() {
-  const count = useRef(1);
-  useEffect(() => {
-    count.current += 1;
-  });
-  return count.current;
-}

package/src/hooks/useWindowEvent/index.tsx

@@ -1 +0,0 @@
-export * from "./useWindowEvent";