@sikka/hawa 0.26.29 → 0.26.30

package/dist/hooks/index.d.ts

@@ -0,0 +1,108 @@
+import * as React$1 from 'react';
+import React__default, { useLayoutEffect } from 'react';
+import { T as ToastProps, a as ToastActionElement } from '../Toast-pOd4uGZz.js';
+import 'class-variance-authority/types';
+import '@radix-ui/react-toast';
+import 'class-variance-authority';
+import '../commonTypes-CKtkuNFH.js';
+
+declare const useIsomorphicEffect: typeof useLayoutEffect;
+
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    severity?: "info" | "warning" | "error" | "success" | "none";
+    action?: ToastActionElement;
+    size?: "default" | "sm";
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType["ADD_TOAST"];
+    toast: ToasterToast;
+} | {
+    type: ActionType["UPDATE_TOAST"];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType["DISMISS_TOAST"];
+    toastId?: ToasterToast["id"];
+} | {
+    type: ActionType["REMOVE_TOAST"];
+    toastId?: ToasterToast["id"];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, "id">;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+
+type DialogCarouselType = {
+    canScrollPrev?: any;
+    emblaRef?: any;
+    emblaApi?: any;
+    nextStep?: any;
+    prevStep?: any;
+};
+declare const useDialogCarousel: (options?: any) => DialogCarouselType;
+
+declare const useMultiStepDialog: (initialStep: any, stepIds: any[], setOpenDialog: any) => {
+    currentStep: any;
+    dialogHeight: null;
+    visibleStepRef: React__default.MutableRefObject<any>;
+    handleNext: () => void;
+    handleBack: () => void;
+};
+
+declare function useClipboard({ timeout }?: {
+    timeout?: number | undefined;
+}): {
+    copy: (value: any) => void;
+    reset: () => void;
+    error: Error | null;
+    copied: boolean;
+};
+
+declare const useBreakpoint: () => any;
+
+interface WindowSize {
+    width: number | undefined;
+    height: number | undefined;
+}
+declare const useWindowSize: () => WindowSize;
+
+interface UseFocusWithinOptions {
+    onFocus?(event: FocusEvent): void;
+    onBlur?(event: FocusEvent): void;
+}
+declare function useFocusWithin<T extends HTMLElement = any>({ onBlur, onFocus }?: UseFocusWithinOptions): {
+    ref: React.MutableRefObject<T>;
+    focused: boolean;
+};
+
+interface UseMediaQueryOptions {
+    getInitialValueInEffect: boolean;
+}
+declare function useMediaQuery(query: string, initialValue?: boolean, { getInitialValueInEffect }?: UseMediaQueryOptions): boolean | undefined;
+
+declare function useTabs(initialTab?: string): {
+    activeTab: string;
+    handleTabChange: (index: any) => void;
+};
+
+export { type UseFocusWithinOptions, type UseMediaQueryOptions, reducer, toast, useBreakpoint, useClipboard, useDialogCarousel, useFocusWithin, useIsomorphicEffect, useMediaQuery, useMultiStepDialog, useTabs, useToast, useWindowSize };

package/dist/hooks/index.js

@@ -0,0 +1,459 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  reducer: () => reducer,
+  toast: () => toast,
+  useBreakpoint: () => useBreakpoint,
+  useClipboard: () => useClipboard,
+  useDialogCarousel: () => useDialogCarousel,
+  useFocusWithin: () => useFocusWithin,
+  useIsomorphicEffect: () => useIsomorphicEffect,
+  useMediaQuery: () => useMediaQuery,
+  useMultiStepDialog: () => useMultiStepDialog,
+  useTabs: () => useTabs,
+  useToast: () => useToast,
+  useWindowSize: () => useWindowSize
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// hooks/useIsomorphicEffect.ts
+var import_react = require("react");
+var useIsomorphicEffect = typeof document !== "undefined" ? import_react.useLayoutEffect : import_react.useEffect;
+
+// hooks/useDiscloser.ts
+var import_react2 = require("react");
+
+// hooks/useHover.ts
+var import_react3 = require("react");
+
+// hooks/useToast.ts
+var React3 = __toESM(require("react"));
+var TOAST_LIMIT = 5;
+var TOAST_REMOVE_DELAY = 1e5;
+var count = 0;
+function genId() {
+  count = (count + 1) % Number.MAX_VALUE;
+  return count.toString();
+}
+var toastTimeouts = /* @__PURE__ */ new Map();
+var addToRemoveQueue = (toastId) => {
+  if (toastTimeouts.has(toastId)) {
+    return;
+  }
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId);
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId
+    });
+  }, TOAST_REMOVE_DELAY);
+  toastTimeouts.set(toastId, timeout);
+};
+var reducer = (state, action) => {
+  switch (action.type) {
+    case "ADD_TOAST":
+      console.log("adding toast case");
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT)
+      };
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map(
+          (t) => t.id === action.toast.id ? { ...t, ...action.toast } : t
+        )
+      };
+    case "DISMISS_TOAST": {
+      const { toastId } = action;
+      if (toastId) {
+        addToRemoveQueue(toastId);
+      } else {
+        state.toasts.forEach((toast2) => {
+          addToRemoveQueue(toast2.id);
+        });
+      }
+      return {
+        ...state,
+        toasts: state.toasts.map(
+          (t) => t.id === toastId || toastId === void 0 ? { ...t, open: false } : t
+        )
+      };
+    }
+    case "REMOVE_TOAST":
+      if (action.toastId === void 0) {
+        return { ...state, toasts: [] };
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId)
+      };
+  }
+};
+var listeners = [];
+var memoryState = { toasts: [] };
+function dispatch(action) {
+  console.log("dispatching toast");
+  memoryState = reducer(memoryState, action);
+  listeners.forEach((listener) => {
+    console.log("mapping through listerners in dispathc");
+    listener(memoryState);
+  });
+}
+function toast({ ...props }) {
+  const id = genId();
+  const update = (props2) => dispatch({
+    type: "UPDATE_TOAST",
+    toast: { ...props2, id }
+  });
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open)
+          dismiss();
+      }
+    }
+  });
+  return {
+    id,
+    dismiss,
+    update
+  };
+}
+function useToast() {
+  const [state, setState] = React3.useState(memoryState);
+  React3.useEffect(() => {
+    console.log("useToast triggered in useEffect");
+    console.log("toast state", state);
+    console.log("listerners BEFORE", listeners);
+    console.log("TOAST: setState is ", setState);
+    listeners.push(setState);
+    return () => {
+      const index = listeners.indexOf(setState);
+      console.log("listerners AFTER", listeners);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }, [state]);
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId) => dispatch({ type: "DISMISS_TOAST", toastId })
+  };
+}
+
+// hooks/useCarousel.ts
+var import_react4 = require("react");
+
+// hooks/useDialogCarousel.ts
+var import_react5 = require("react");
+var import_embla_carousel_auto_height = __toESM(require("embla-carousel-auto-height"));
+var import_embla_carousel_react = __toESM(require("embla-carousel-react"));
+var useDialogCarousel = (options) => {
+  const [emblaRef, emblaApi] = (0, import_embla_carousel_react.default)(
+    { loop: false, watchDrag: false, startIndex: 0, ...options },
+    [(0, import_embla_carousel_auto_height.default)({ destroyHeight: "fit", active: true })]
+  );
+  const [canScrollPrev, setCanScrollPrev] = (0, import_react5.useState)(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();
+    }
+  };
+  (0, import_react5.useEffect)(() => {
+    checkCanScrollPrev();
+    emblaApi && emblaApi.on("select", checkCanScrollPrev);
+    return () => {
+      emblaApi && emblaApi.off("select", checkCanScrollPrev);
+    };
+  }, [emblaApi]);
+  return {
+    emblaRef,
+    emblaApi,
+    nextStep,
+    prevStep,
+    canScrollPrev
+  };
+};
+
+// hooks/useDialogSteps.ts
+var import_react6 = require("react");
+var useMultiStepDialog = (initialStep, stepIds, setOpenDialog) => {
+  const [currentStep, setCurrentStep] = (0, import_react6.useState)(initialStep);
+  const [dialogHeight, setDialogHeight] = (0, import_react6.useState)(null);
+  const visibleStepRef = (0, import_react6.useRef)(null);
+  (0, import_react6.useEffect)(() => {
+    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/useClipboard.ts
+var import_react7 = require("react");
+function useClipboard({ timeout = 2e3 } = {}) {
+  const [error, setError] = (0, import_react7.useState)(null);
+  const [copied, setCopied] = (0, import_react7.useState)(false);
+  const [copyTimeout, setCopyTimeout] = (0, import_react7.useState)(null);
+  const handleCopyResult = (value) => {
+    clearTimeout(copyTimeout);
+    setCopyTimeout(setTimeout(() => setCopied(false), timeout));
+    setCopied(value);
+  };
+  const copy = (valueToCopy) => {
+    if ("clipboard" in navigator) {
+      navigator.clipboard.writeText(valueToCopy).then(() => handleCopyResult(true)).catch((err) => setError(err));
+    } else {
+      setError(new Error("useClipboard: navigator.clipboard is not supported"));
+    }
+  };
+  const reset = () => {
+    setCopied(false);
+    setError(null);
+    clearTimeout(copyTimeout);
+  };
+  return { copy, reset, error, copied };
+}
+
+// hooks/useBreakpoint.ts
+var import_react8 = require("react");
+var useBreakpoint = () => {
+  const [breakpoint, setBreakpoint] = (0, import_react8.useState)(null);
+  (0, import_react8.useEffect)(() => {
+    if (typeof window !== "undefined") {
+      const resize = () => {
+        setBreakpoint(window.innerWidth);
+      };
+      resize();
+      window.addEventListener("resize", resize);
+      return () => {
+        window.removeEventListener("resize", resize);
+      };
+    }
+  }, []);
+  return breakpoint;
+};
+
+// hooks/useWindowSize.ts
+var import_react9 = require("react");
+var useWindowSize = () => {
+  const [windowSize, setWindowSize] = (0, import_react9.useState)({
+    width: void 0,
+    height: void 0
+  });
+  (0, import_react9.useEffect)(() => {
+    function handleResize() {
+      setWindowSize({
+        width: window.innerWidth,
+        height: window.innerHeight
+      });
+    }
+    window.addEventListener("resize", handleResize);
+    handleResize();
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+  return windowSize;
+};
+
+// hooks/useFocusWithin.ts
+var import_react10 = require("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 = (0, import_react10.useRef)(null);
+  const [focused, _setFocused] = (0, import_react10.useState)(false);
+  const focusedRef = (0, import_react10.useRef)(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);
+    }
+  };
+  (0, import_react10.useEffect)(() => {
+    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
+var import_react11 = require("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] = (0, import_react11.useState)(
+    getInitialValueInEffect ? initialValue : getInitialValue(query, initialValue)
+  );
+  const queryRef = (0, import_react11.useRef)();
+  (0, import_react11.useEffect)(() => {
+    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
+var import_react12 = require("react");
+
+// hooks/useTable.ts
+var import_react13 = require("react");
+
+// hooks/useTabs.ts
+var import_react14 = require("react");
+function useTabs(initialTab = "") {
+  const [activeTab, setActiveTab] = (0, import_react14.useState)(initialTab);
+  (0, import_react14.useEffect)(() => {
+    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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reducer,
+  toast,
+  useBreakpoint,
+  useClipboard,
+  useDialogCarousel,
+  useFocusWithin,
+  useIsomorphicEffect,
+  useMediaQuery,
+  useMultiStepDialog,
+  useTabs,
+  useToast,
+  useWindowSize
+});