@sikka/hawa 0.26.29 → 0.26.31

package/dist/hooks/index.mjs

@@ -0,0 +1,255 @@
+import {
+  useBreakpoint
+} from "../chunk-D22AALLE.mjs";
+import {
+  reducer,
+  toast,
+  useClipboard,
+  useToast
+} from "../chunk-JNUGOUYJ.mjs";
+import "../chunk-ZFXKCRJC.mjs";
+
+// hooks/useIsomorphicEffect.ts
+import { useEffect, useLayoutEffect } from "react";
+var useIsomorphicEffect = typeof document !== "undefined" ? useLayoutEffect : useEffect;
+
+// hooks/useDiscloser.ts
+import { useState } from "react";
+
+// hooks/useHover.ts
+import { useEffect as useEffect2, useRef, useState as useState2 } from "react";
+
+// hooks/useCarousel.ts
+import { useState as useState3, useRef as useRef2 } from "react";
+
+// hooks/useDialogCarousel.ts
+import { useEffect as useEffect3, useState as useState4 } from "react";
+import AutoHeight from "embla-carousel-auto-height";
+import useEmblaCarousel from "embla-carousel-react";
+var useDialogCarousel = (options) => {
+  const [emblaRef, emblaApi] = useEmblaCarousel(
+    { loop: false, watchDrag: false, startIndex: 0, ...options },
+    [AutoHeight({ destroyHeight: "fit", active: true })]
+  );
+  const [canScrollPrev, setCanScrollPrev] = useState4(false);
+  const checkCanScrollPrev = () => {
+    if (emblaApi) {
+      setCanScrollPrev(emblaApi.canScrollPrev());
+    }
+  };
+  const nextStep = () => {
+    if (emblaApi) {
+      console.log("going to NEXT \u{1F449}");
+      emblaApi.scrollNext();
+    }
+  };
+  const prevStep = () => {
+    if (emblaApi) {
+      console.log("going to BACK \u{1F448}");
+      emblaApi.scrollPrev();
+    }
+  };
+  useEffect3(() => {
+    checkCanScrollPrev();
+    emblaApi && emblaApi.on("select", checkCanScrollPrev);
+    return () => {
+      emblaApi && emblaApi.off("select", checkCanScrollPrev);
+    };
+  }, [emblaApi]);
+  return {
+    emblaRef,
+    emblaApi,
+    nextStep,
+    prevStep,
+    canScrollPrev
+  };
+};
+
+// hooks/useDialogSteps.ts
+import { useState as useState5, useEffect as useEffect4, useRef as useRef3 } from "react";
+var useMultiStepDialog = (initialStep, stepIds, setOpenDialog) => {
+  const [currentStep, setCurrentStep] = useState5(initialStep);
+  const [dialogHeight, setDialogHeight] = useState5(null);
+  const visibleStepRef = useRef3(null);
+  useEffect4(() => {
+    if (visibleStepRef.current) {
+      setDialogHeight(visibleStepRef.current.offsetHeight);
+    }
+  }, [currentStep, setOpenDialog]);
+  const handleNext = () => {
+    const currentIndex = stepIds.indexOf(currentStep);
+    if (currentIndex < stepIds.length - 1) {
+      setTimeout(() => {
+        setCurrentStep(stepIds[currentIndex + 1]);
+      }, 100);
+    }
+  };
+  const handleBack = () => {
+    const currentIndex = stepIds.indexOf(currentStep);
+    if (currentIndex > 0) {
+      setTimeout(() => {
+        setCurrentStep(stepIds[currentIndex - 1]);
+      }, 100);
+    }
+  };
+  return {
+    currentStep,
+    dialogHeight,
+    visibleStepRef,
+    handleNext,
+    handleBack
+  };
+};
+
+// hooks/useWindowSize.ts
+import { useEffect as useEffect5, useState as useState6 } from "react";
+var useWindowSize = () => {
+  const [windowSize, setWindowSize] = useState6({
+    width: void 0,
+    height: void 0
+  });
+  useEffect5(() => {
+    function handleResize() {
+      setWindowSize({
+        width: window.innerWidth,
+        height: window.innerHeight
+      });
+    }
+    window.addEventListener("resize", handleResize);
+    handleResize();
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+  return windowSize;
+};
+
+// hooks/useFocusWithin.ts
+import { useRef as useRef4, useState as useState7, useEffect as useEffect6 } from "react";
+function containsRelatedTarget(event) {
+  if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) {
+    return event.currentTarget.contains(event.relatedTarget);
+  }
+  return false;
+}
+function useFocusWithin({
+  onBlur,
+  onFocus
+} = {}) {
+  const ref = useRef4(null);
+  const [focused, _setFocused] = useState7(false);
+  const focusedRef = useRef4(false);
+  const setFocused = (value) => {
+    _setFocused(value);
+    focusedRef.current = value;
+  };
+  const handleFocusIn = (event) => {
+    if (!focusedRef.current) {
+      setFocused(true);
+      onFocus == null ? void 0 : onFocus(event);
+    }
+  };
+  const handleFocusOut = (event) => {
+    if (focusedRef.current && !containsRelatedTarget(event)) {
+      setFocused(false);
+      onBlur == null ? void 0 : onBlur(event);
+    }
+  };
+  useEffect6(() => {
+    if (ref.current) {
+      ref.current.addEventListener("focusin", handleFocusIn);
+      ref.current.addEventListener("focusout", handleFocusOut);
+      return () => {
+        var _a, _b;
+        (_a = ref.current) == null ? void 0 : _a.removeEventListener("focusin", handleFocusIn);
+        (_b = ref.current) == null ? void 0 : _b.removeEventListener("focusout", handleFocusOut);
+      };
+    }
+    return void 0;
+  }, [handleFocusIn, handleFocusOut]);
+  return { ref, focused };
+}
+
+// hooks/useMediaQuery.ts
+import { useState as useState8, useEffect as useEffect7, useRef as useRef5 } from "react";
+function attachMediaListener(query, callback) {
+  try {
+    query.addEventListener("change", callback);
+    return () => query.removeEventListener("change", callback);
+  } catch (e) {
+    query.addListener(callback);
+    return () => query.removeListener(callback);
+  }
+}
+function getInitialValue(query, initialValue) {
+  if (typeof initialValue === "boolean") {
+    return initialValue;
+  }
+  if (typeof window !== "undefined" && "matchMedia" in window) {
+    return window.matchMedia(query).matches;
+  }
+  return false;
+}
+function useMediaQuery(query, initialValue, { getInitialValueInEffect } = {
+  getInitialValueInEffect: true
+}) {
+  const [matches, setMatches] = useState8(
+    getInitialValueInEffect ? initialValue : getInitialValue(query, initialValue)
+  );
+  const queryRef = useRef5();
+  useEffect7(() => {
+    if ("matchMedia" in window) {
+      queryRef.current = window.matchMedia(query);
+      setMatches(queryRef.current.matches);
+      return attachMediaListener(
+        queryRef.current,
+        (event) => setMatches(event.matches)
+      );
+    }
+    return void 0;
+  }, [query]);
+  return matches;
+}
+
+// hooks/useScrollPosition.ts
+import { useState as useState9, useEffect as useEffect8 } from "react";
+
+// hooks/useTable.ts
+import { useState as useState10, useEffect as useEffect9 } from "react";
+
+// hooks/useTabs.ts
+import { useEffect as useEffect10, useState as useState11 } from "react";
+function useTabs(initialTab = "") {
+  const [activeTab, setActiveTab] = useState11(initialTab);
+  useEffect10(() => {
+    const handleHashChange = () => {
+      const hash = window.location.hash.substring(1);
+      setActiveTab(hash || initialTab);
+    };
+    window.addEventListener("hashchange", handleHashChange);
+    handleHashChange();
+    return () => {
+      window.removeEventListener("hashchange", handleHashChange);
+    };
+  }, [initialTab]);
+  const handleTabChange = (index) => {
+    setActiveTab(index);
+    window.location.hash = index;
+  };
+  return {
+    activeTab,
+    handleTabChange
+  };
+}
+export {
+  reducer,
+  toast,
+  useBreakpoint,
+  useClipboard,
+  useDialogCarousel,
+  useFocusWithin,
+  useIsomorphicEffect,
+  useMediaQuery,
+  useMultiStepDialog,
+  useTabs,
+  useToast,
+  useWindowSize
+};