@windstream/react-shared-components 0.1.92 → 0.1.94

package/src/hooks/use-carousel-swipe.ts

@@ -1,264 +1,264 @@
-import React, {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
-
-/**
- * Configuration options for the carousel swipe behavior
- */
-export interface CarouselSwipeConfig {
-  /** Total number of items in the carousel */
-  itemCount: number;
-  /** Percentage of card width to offset each slide (default: 105) */
-  cardOffsetPercentage?: number;
-  /** Percentage of container width needed to trigger slide change (default: 0.15) */
-  swipeThreshold?: number;
-  /** Mobile breakpoint in pixels (default: 768) */
-  mobileBreakpoint?: number;
-  /** Auto-scroll interval in milliseconds (default: 8000). Set to 0 to disable. */
-  autoScrollInterval?: number;
-  /** Enable auto-scroll (default: true) */
-  enableAutoScroll?: boolean;
-}
-
-/**
- * Return value from the useCarouselSwipe hook
- */
-export interface CarouselSwipeReturn {
-  /** Current active slide index */
-  currentIndex: number;
-  /** Current swipe offset in pixels */
-  swipeOffset: number;
-  /** Whether user is currently swiping */
-  isSwiping: boolean;
-  /** Whether viewport is mobile size */
-  isMobile: boolean;
-  /** Memoized container width */
-  containerWidth: number;
-  /** Ref to attach to the carousel container element */
-  containerRef: React.RefObject<HTMLDivElement>;
-  /** Navigate to next slide */
-  nextSlide: () => void;
-  /** Navigate to previous slide */
-  prevSlide: () => void;
-  /** Navigate to specific slide index */
-  goToSlide: (index: number) => void;
-  /** Touch start handler */
-  handleTouchStart: (e: React.TouchEvent) => void;
-  /** Touch move handler */
-  handleTouchMove: (e: React.TouchEvent) => void;
-  /** Touch end handler */
-  handleTouchEnd: () => void;
-  /** Constants used for calculations */
-  constants: {
-    CARD_OFFSET_PERCENTAGE: number;
-    SWIPE_THRESHOLD: number;
-    MOBILE_BREAKPOINT: number;
-    AUTO_SCROLL_INTERVAL: number;
-  };
-}
-
-/**
- * Custom hook for implementing swipe/touch gestures in carousels
- *
- * Features:
- * - Touch/swipe support with smooth finger-following
- * - Auto-scroll with pause on interaction
- * - Responsive mobile detection with resize listener
- * - Performance optimized with memoization
- * - Configurable thresholds and behavior
- *
- * @example
- * ```tsx
- * const carousel = useCarouselSwipe({
- *   itemCount: items.length,
- *   autoScrollInterval: 5000,
- * });
- *
- * return (
- *   <div
- *     ref={carousel.containerRef}
- *     onTouchStart={carousel.handleTouchStart}
- *     onTouchMove={carousel.handleTouchMove}
- *     onTouchEnd={carousel.handleTouchEnd}
- *   >
- *     {items.map((item, index) => (
- *       <div
- *         key={index}
- *         style={{
- *           transform: `translateX(${calculateTransform(index, carousel)})`,
- *         }}
- *       >
- *         {item}
- *       </div>
- *     ))}
- *   </div>
- * );
- * ```
- */
-export function useCarouselSwipe(
-  config: CarouselSwipeConfig
-): CarouselSwipeReturn {
-  const {
-    itemCount,
-    cardOffsetPercentage = 105,
-    swipeThreshold = 0.15,
-    mobileBreakpoint = 768,
-    autoScrollInterval = 8000,
-    enableAutoScroll = true,
-  } = config;
-
-  // State
-  const [currentIndex, setCurrentIndex] = useState(0);
-  const [swipeOffset, setSwipeOffset] = useState(0);
-  const [isSwiping, setIsSwiping] = useState(false);
-  const [containerWidth, setContainerWidth] = useState(window.innerWidth);
-  // Performance: Store mobile state to avoid repeated window.innerWidth checks on every render
-  // This prevents expensive DOM queries during swipe operations
-  const [isMobile, setIsMobile] = useState(false);
-
-  // Refs
-  const timeoutRef = useRef<ReturnType<typeof setInterval> | null>(null);
-  const touchStartX = useRef<number>(0);
-  const containerRef = useRef<HTMLDivElement>(null);
-
-  // Constants
-  const constants = {
-    CARD_OFFSET_PERCENTAGE: cardOffsetPercentage,
-    SWIPE_THRESHOLD: swipeThreshold,
-    MOBILE_BREAKPOINT: mobileBreakpoint,
-    AUTO_SCROLL_INTERVAL: autoScrollInterval,
-  };
-
-  // Performance: Memoize container width to prevent recalculation on every render
-  // This is especially important during swipe operations where the component re-renders
-  // frequently. Without memoization, it'd query the DOM on every frame while swiping.
-  useEffect(() => {
-    const updateWidth = () => {
-      setContainerWidth(containerRef.current?.offsetWidth || window.innerWidth);
-    };
-    updateWidth(); // Initial
-    window.addEventListener("resize", updateWidth);
-    return () => window.removeEventListener("resize", updateWidth);
-  }, []);
-
-  // Navigation functions
-  const nextSlide = useCallback(() => {
-    if (itemCount === 0) return;
-    setCurrentIndex(prev => (prev + 1) % itemCount);
-  }, [itemCount]);
-
-  const prevSlide = useCallback(() => {
-    if (itemCount === 0) return;
-    setCurrentIndex(prev => (prev === 0 ? itemCount - 1 : prev - 1));
-  }, [itemCount]);
-
-  const goToSlide = useCallback(
-    (index: number) => {
-      if (index < 0 || index >= itemCount) return;
-      setCurrentIndex(index);
-    },
-    [itemCount]
-  );
-
-  // Touch handlers for mobile swipe
-  const handleTouchStart = useCallback((e: React.TouchEvent) => {
-    touchStartX.current = e.touches[0].clientX;
-    setIsSwiping(true);
-    // Pause auto-scroll during user interaction
-    if (timeoutRef.current) {
-      clearInterval(timeoutRef.current);
-    }
-  }, []);
-
-  const handleTouchMove = useCallback(
-    (e: React.TouchEvent) => {
-      if (!isSwiping) return;
-      const currentX = e.touches[0].clientX;
-      const diff = currentX - touchStartX.current;
-      setSwipeOffset(diff);
-    },
-    [isSwiping]
-  );
-
-  const handleTouchEnd = useCallback(() => {
-    setIsSwiping(false);
-    // Use memoized containerWidth and constant threshold for performance
-    const threshold = containerWidth * swipeThreshold;
-
-    // Determine if swipe was strong enough to change slides
-    if (swipeOffset > threshold) {
-      prevSlide();
-    } else if (swipeOffset < -threshold) {
-      nextSlide();
-    }
-
-    // Reset swipe offset to return card to snapped position
-    setSwipeOffset(0);
-
-    // Restart auto-scroll after user interaction completes
-    if (enableAutoScroll && autoScrollInterval > 0) {
-      timeoutRef.current = setInterval(() => {
-        nextSlide();
-      }, autoScrollInterval);
-    }
-  }, [
-    swipeOffset,
-    containerWidth,
-    swipeThreshold,
-    prevSlide,
-    nextSlide,
-    enableAutoScroll,
-    autoScrollInterval,
-  ]);
-
-  // Performance: Detect mobile viewport and update on resize
-  // This replaces inline window.innerWidth checks that were running on every render.
-  // By using state and a resize listener, we only check when the viewport actually changes.
-  useEffect(() => {
-    const checkMobile = () => {
-      setIsMobile(window.innerWidth < mobileBreakpoint);
-    };
-
-    // Check immediately on mount
-    checkMobile();
-
-    // Update when window is resized (e.g., device rotation, browser resize)
-    window.addEventListener("resize", checkMobile);
-    return () => window.removeEventListener("resize", checkMobile);
-  }, [mobileBreakpoint]);
-
-  // Auto-scroll logic
-  useEffect(() => {
-    if (!enableAutoScroll || itemCount === 0 || autoScrollInterval === 0) {
-      return;
-    }
-
-    timeoutRef.current = setInterval(() => {
-      nextSlide();
-    }, autoScrollInterval);
-
-    return () => {
-      if (timeoutRef.current) clearInterval(timeoutRef.current);
-    };
-  }, [nextSlide, itemCount, enableAutoScroll, autoScrollInterval]);
-
-  return {
-    currentIndex,
-    swipeOffset,
-    isSwiping,
-    isMobile,
-    containerWidth,
-    containerRef,
-    nextSlide,
-    prevSlide,
-    goToSlide,
-    handleTouchStart,
-    handleTouchMove,
-    handleTouchEnd,
-    constants,
-  };
-}
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+
+/**
+ * Configuration options for the carousel swipe behavior
+ */
+export interface CarouselSwipeConfig {
+  /** Total number of items in the carousel */
+  itemCount: number;
+  /** Percentage of card width to offset each slide (default: 105) */
+  cardOffsetPercentage?: number;
+  /** Percentage of container width needed to trigger slide change (default: 0.15) */
+  swipeThreshold?: number;
+  /** Mobile breakpoint in pixels (default: 768) */
+  mobileBreakpoint?: number;
+  /** Auto-scroll interval in milliseconds (default: 8000). Set to 0 to disable. */
+  autoScrollInterval?: number;
+  /** Enable auto-scroll (default: true) */
+  enableAutoScroll?: boolean;
+}
+
+/**
+ * Return value from the useCarouselSwipe hook
+ */
+export interface CarouselSwipeReturn {
+  /** Current active slide index */
+  currentIndex: number;
+  /** Current swipe offset in pixels */
+  swipeOffset: number;
+  /** Whether user is currently swiping */
+  isSwiping: boolean;
+  /** Whether viewport is mobile size */
+  isMobile: boolean;
+  /** Memoized container width */
+  containerWidth: number;
+  /** Ref to attach to the carousel container element */
+  containerRef: React.RefObject<HTMLDivElement>;
+  /** Navigate to next slide */
+  nextSlide: () => void;
+  /** Navigate to previous slide */
+  prevSlide: () => void;
+  /** Navigate to specific slide index */
+  goToSlide: (index: number) => void;
+  /** Touch start handler */
+  handleTouchStart: (e: React.TouchEvent) => void;
+  /** Touch move handler */
+  handleTouchMove: (e: React.TouchEvent) => void;
+  /** Touch end handler */
+  handleTouchEnd: () => void;
+  /** Constants used for calculations */
+  constants: {
+    CARD_OFFSET_PERCENTAGE: number;
+    SWIPE_THRESHOLD: number;
+    MOBILE_BREAKPOINT: number;
+    AUTO_SCROLL_INTERVAL: number;
+  };
+}
+
+/**
+ * Custom hook for implementing swipe/touch gestures in carousels
+ *
+ * Features:
+ * - Touch/swipe support with smooth finger-following
+ * - Auto-scroll with pause on interaction
+ * - Responsive mobile detection with resize listener
+ * - Performance optimized with memoization
+ * - Configurable thresholds and behavior
+ *
+ * @example
+ * ```tsx
+ * const carousel = useCarouselSwipe({
+ *   itemCount: items.length,
+ *   autoScrollInterval: 5000,
+ * });
+ *
+ * return (
+ *   <div
+ *     ref={carousel.containerRef}
+ *     onTouchStart={carousel.handleTouchStart}
+ *     onTouchMove={carousel.handleTouchMove}
+ *     onTouchEnd={carousel.handleTouchEnd}
+ *   >
+ *     {items.map((item, index) => (
+ *       <div
+ *         key={index}
+ *         style={{
+ *           transform: `translateX(${calculateTransform(index, carousel)})`,
+ *         }}
+ *       >
+ *         {item}
+ *       </div>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+export function useCarouselSwipe(
+  config: CarouselSwipeConfig
+): CarouselSwipeReturn {
+  const {
+    itemCount,
+    cardOffsetPercentage = 105,
+    swipeThreshold = 0.15,
+    mobileBreakpoint = 768,
+    autoScrollInterval = 8000,
+    enableAutoScroll = true,
+  } = config;
+
+  // State
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const [swipeOffset, setSwipeOffset] = useState(0);
+  const [isSwiping, setIsSwiping] = useState(false);
+  const [containerWidth, setContainerWidth] = useState(window.innerWidth);
+  // Performance: Store mobile state to avoid repeated window.innerWidth checks on every render
+  // This prevents expensive DOM queries during swipe operations
+  const [isMobile, setIsMobile] = useState(false);
+
+  // Refs
+  const timeoutRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const touchStartX = useRef<number>(0);
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  // Constants
+  const constants = {
+    CARD_OFFSET_PERCENTAGE: cardOffsetPercentage,
+    SWIPE_THRESHOLD: swipeThreshold,
+    MOBILE_BREAKPOINT: mobileBreakpoint,
+    AUTO_SCROLL_INTERVAL: autoScrollInterval,
+  };
+
+  // Performance: Memoize container width to prevent recalculation on every render
+  // This is especially important during swipe operations where the component re-renders
+  // frequently. Without memoization, it'd query the DOM on every frame while swiping.
+  useEffect(() => {
+    const updateWidth = () => {
+      setContainerWidth(containerRef.current?.offsetWidth || window.innerWidth);
+    };
+    updateWidth(); // Initial
+    window.addEventListener("resize", updateWidth);
+    return () => window.removeEventListener("resize", updateWidth);
+  }, []);
+
+  // Navigation functions
+  const nextSlide = useCallback(() => {
+    if (itemCount === 0) return;
+    setCurrentIndex(prev => (prev + 1) % itemCount);
+  }, [itemCount]);
+
+  const prevSlide = useCallback(() => {
+    if (itemCount === 0) return;
+    setCurrentIndex(prev => (prev === 0 ? itemCount - 1 : prev - 1));
+  }, [itemCount]);
+
+  const goToSlide = useCallback(
+    (index: number) => {
+      if (index < 0 || index >= itemCount) return;
+      setCurrentIndex(index);
+    },
+    [itemCount]
+  );
+
+  // Touch handlers for mobile swipe
+  const handleTouchStart = useCallback((e: React.TouchEvent) => {
+    touchStartX.current = e.touches[0].clientX;
+    setIsSwiping(true);
+    // Pause auto-scroll during user interaction
+    if (timeoutRef.current) {
+      clearInterval(timeoutRef.current);
+    }
+  }, []);
+
+  const handleTouchMove = useCallback(
+    (e: React.TouchEvent) => {
+      if (!isSwiping) return;
+      const currentX = e.touches[0].clientX;
+      const diff = currentX - touchStartX.current;
+      setSwipeOffset(diff);
+    },
+    [isSwiping]
+  );
+
+  const handleTouchEnd = useCallback(() => {
+    setIsSwiping(false);
+    // Use memoized containerWidth and constant threshold for performance
+    const threshold = containerWidth * swipeThreshold;
+
+    // Determine if swipe was strong enough to change slides
+    if (swipeOffset > threshold) {
+      prevSlide();
+    } else if (swipeOffset < -threshold) {
+      nextSlide();
+    }
+
+    // Reset swipe offset to return card to snapped position
+    setSwipeOffset(0);
+
+    // Restart auto-scroll after user interaction completes
+    if (enableAutoScroll && autoScrollInterval > 0) {
+      timeoutRef.current = setInterval(() => {
+        nextSlide();
+      }, autoScrollInterval);
+    }
+  }, [
+    swipeOffset,
+    containerWidth,
+    swipeThreshold,
+    prevSlide,
+    nextSlide,
+    enableAutoScroll,
+    autoScrollInterval,
+  ]);
+
+  // Performance: Detect mobile viewport and update on resize
+  // This replaces inline window.innerWidth checks that were running on every render.
+  // By using state and a resize listener, we only check when the viewport actually changes.
+  useEffect(() => {
+    const checkMobile = () => {
+      setIsMobile(window.innerWidth < mobileBreakpoint);
+    };
+
+    // Check immediately on mount
+    checkMobile();
+
+    // Update when window is resized (e.g., device rotation, browser resize)
+    window.addEventListener("resize", checkMobile);
+    return () => window.removeEventListener("resize", checkMobile);
+  }, [mobileBreakpoint]);
+
+  // Auto-scroll logic
+  useEffect(() => {
+    if (!enableAutoScroll || itemCount === 0 || autoScrollInterval === 0) {
+      return;
+    }
+
+    timeoutRef.current = setInterval(() => {
+      nextSlide();
+    }, autoScrollInterval);
+
+    return () => {
+      if (timeoutRef.current) clearInterval(timeoutRef.current);
+    };
+  }, [nextSlide, itemCount, enableAutoScroll, autoScrollInterval]);
+
+  return {
+    currentIndex,
+    swipeOffset,
+    isSwiping,
+    isMobile,
+    containerWidth,
+    containerRef,
+    nextSlide,
+    prevSlide,
+    goToSlide,
+    handleTouchStart,
+    handleTouchMove,
+    handleTouchEnd,
+    constants,
+  };
+}

package/src/hooks/use-outside-click.test.ts

@@ -0,0 +1,142 @@
+import React from "react";
+import { useOutsideClick } from "./use-outside-click";
+
+import { renderHook } from "@testing-library/react";
+
+describe("useOutsideClick", () => {
+  let callback: jest.Mock;
+
+  beforeEach(() => {
+    callback = jest.fn();
+  });
+
+  describe("Event listener lifecycle", () => {
+    it("adds click event listener on mount", () => {
+      const addSpy = jest.spyOn(document, "addEventListener");
+      const ref = { current: document.createElement("div") };
+      renderHook(() => useOutsideClick(ref, callback));
+      const clickCalls = addSpy.mock.calls.filter(c => c[0] === "click");
+      expect(clickCalls.length).toBeGreaterThanOrEqual(1);
+      addSpy.mockRestore();
+    });
+
+    it("removes click event listener on unmount", () => {
+      const removeSpy = jest.spyOn(document, "removeEventListener");
+      const ref = { current: document.createElement("div") };
+      const { unmount } = renderHook(() => useOutsideClick(ref, callback));
+      unmount();
+      const clickCalls = removeSpy.mock.calls.filter(c => c[0] === "click");
+      expect(clickCalls.length).toBeGreaterThanOrEqual(1);
+      removeSpy.mockRestore();
+    });
+  });
+
+  describe("Click detection", () => {
+    it("calls callback when clicking outside the ref element", () => {
+      const inside = document.createElement("div");
+      const outside = document.createElement("button");
+      document.body.appendChild(inside);
+      document.body.appendChild(outside);
+
+      const ref = { current: inside };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      outside.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      document.body.removeChild(inside);
+      document.body.removeChild(outside);
+    });
+
+    it("does not call callback when clicking inside the ref element", () => {
+      const container = document.createElement("div");
+      const child = document.createElement("span");
+      container.appendChild(child);
+      document.body.appendChild(container);
+
+      const ref = { current: container };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      child.click();
+      expect(callback).not.toHaveBeenCalled();
+
+      document.body.removeChild(container);
+    });
+
+    it("does not call callback when clicking on the ref element itself", () => {
+      const el = document.createElement("div");
+      document.body.appendChild(el);
+
+      const ref = { current: el };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      el.click();
+      expect(callback).not.toHaveBeenCalled();
+
+      document.body.removeChild(el);
+    });
+
+    it("calls callback when ref.current is null", () => {
+      const ref = { current: null } as React.RefObject<any>;
+      renderHook(() => useOutsideClick(ref, callback));
+
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("calls callback when ref is undefined-like", () => {
+      const ref = {} as React.RefObject<any>;
+      renderHook(() => useOutsideClick(ref, callback));
+
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("calls callback when ref is null", () => {
+      renderHook(() => useOutsideClick(null as any, callback));
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("Multiple clicks", () => {
+    it("calls callback for each outside click", () => {
+      const inside = document.createElement("div");
+      document.body.appendChild(inside);
+
+      const ref = { current: inside };
+      renderHook(() => useOutsideClick(ref, callback));
+
+      document.body.click();
+      document.body.click();
+      document.body.click();
+      expect(callback).toHaveBeenCalledTimes(3);
+
+      document.body.removeChild(inside);
+    });
+  });
+
+  describe("Re-render behavior", () => {
+    it("updates listener on re-render with new callback", () => {
+      const el = document.createElement("div");
+      document.body.appendChild(el);
+
+      const callback1 = jest.fn();
+      const callback2 = jest.fn();
+      const ref = { current: el };
+
+      const { rerender } = renderHook(({ cb }) => useOutsideClick(ref, cb), {
+        initialProps: { cb: callback1 },
+      });
+
+      document.body.click();
+      expect(callback1).toHaveBeenCalledTimes(1);
+
+      rerender({ cb: callback2 });
+      document.body.click();
+      expect(callback2).toHaveBeenCalledTimes(1);
+
+      document.body.removeChild(el);
+    });
+  });
+});