@edifice.io/react 2.0.0-develop-rc.3

package/dist/hooks/useDropdown/useDropdown.d.ts

@@ -0,0 +1,32 @@
+import { MutableRefObject, Dispatch, SetStateAction } from 'react';
+import { Placement } from '@floating-ui/react';
+export declare enum KEYS {
+    Enter = "Enter",
+    Space = "Space",
+    ArrowDown = "ArrowDown",
+    ArrowUp = "ArrowUp",
+    Down = "Down",
+    Up = "Up",
+    Tab = "Tab",
+    Esc = "Esc",
+    Escape = "Escape",
+    Home = "Home",
+    End = "End",
+    PageUp = "PageUp",
+    PageDown = "PageDown"
+}
+export interface UseDropdownProps {
+    isFocused: string | null;
+    visible: boolean;
+    itemRefs: MutableRefObject<{
+        [key: string]: HTMLElement | null;
+    }>;
+    triggerRef: MutableRefObject<HTMLButtonElement | null>;
+    menuRef: MutableRefObject<HTMLUListElement | null>;
+    triggerProps: Record<string, any>;
+    menuProps: Record<string, any>;
+    itemProps: Record<string, any>;
+    setVisible: Dispatch<SetStateAction<boolean>>;
+}
+declare const useDropdown: (placement: Placement | undefined, extraTriggerKeyDownHandler?: ((event: React.KeyboardEvent<HTMLButtonElement>) => void) | undefined, isTriggerHovered?: boolean) => UseDropdownProps;
+export default useDropdown;

package/dist/hooks/useDropdown/useDropdown.js

@@ -0,0 +1,158 @@
+import { useId, useState, useRef, useEffect, useCallback } from "react";
+import { useFloating, autoUpdate, offset, size, flip, useHover, safePolygon } from "@floating-ui/react";
+import { mergeRefs } from "../../utils/ref.js";
+const useDropdown = (placement, extraTriggerKeyDownHandler, isTriggerHovered = !1) => {
+  const id = useId(), [visible, setVisible] = useState(!1), [activeIndex, setActiveIndex] = useState(-1), [isFocused, setIsFocused] = useState(null), {
+    refs,
+    floatingStyles,
+    context
+  } = useFloating({
+    placement,
+    open: visible,
+    onOpenChange: setVisible,
+    whileElementsMounted: autoUpdate,
+    middleware: [offset(4), size({
+      apply({
+        rects,
+        elements
+      }) {
+        elements.floating.style.minWidth = `${rects.reference.width}px`;
+      }
+    }), flip({
+      padding: 0
+    })]
+  });
+  useHover(context, {
+    enabled: isTriggerHovered,
+    // Configure the delay for opening and closing separately.
+    delay: {
+      open: 200
+    },
+    handleClose: safePolygon()
+  });
+  const menuRef = useRef(null), triggerRef = useRef(null), itemRefs = useRef({});
+  useEffect(() => {
+    visible ? menuRef.current && (menuRef.current.focus(), setActiveIndex(0)) : (setActiveIndex(-1), itemRefs.current = {});
+  }, [visible]), useEffect(() => {
+    if (activeIndex !== -1) {
+      const currentItem = Object.values(itemRefs.current)[activeIndex];
+      if (currentItem) {
+        const id2 = currentItem.getAttribute("id");
+        setIsFocused(id2), currentItem.focus();
+      }
+    }
+  }, [activeIndex]);
+  const nextItem = () => {
+    const itemCount = Object.values(itemRefs.current).length;
+    setActiveIndex((prevIndex) => (prevIndex + 1) % itemCount);
+  }, previousItem = () => {
+    const itemCount = Object.values(itemRefs.current).length;
+    setActiveIndex((prevIndex) => (prevIndex - 1 + itemCount) % itemCount);
+  }, firstItem = () => {
+    setActiveIndex(0);
+  }, lastItem = () => {
+    const itemCount = Object.values(itemRefs.current).length;
+    setActiveIndex(itemCount - 1);
+  }, openDropdown = useCallback(() => {
+    setVisible(!0);
+  }, []), closeDropdown = useCallback(() => {
+    triggerRef.current && (triggerRef.current.focus({
+      preventScroll: !0
+    }), setVisible(!1));
+  }, []), stopEvents = (flag, event) => {
+    flag && (event.stopPropagation(), event.preventDefault());
+  }, onTriggerKeyDown = useCallback((event) => {
+    let flag = !1;
+    switch (event.code) {
+      case " ":
+      case "Space":
+      case "Enter":
+      case "ArrowDown":
+      case "Down":
+        openDropdown(), flag = !0;
+        break;
+      case "Esc":
+      case "Escape":
+        closeDropdown(), flag = !0;
+        break;
+      case "Up":
+      case "ArrowUp":
+        openDropdown(), flag = !0;
+        break;
+    }
+    extraTriggerKeyDownHandler == null || extraTriggerKeyDownHandler(event), stopEvents(flag, event);
+  }, [closeDropdown, openDropdown]), onMenuItemMouseEnter = (event) => {
+    const index = Object.values(itemRefs.current).findIndex((item) => item.id === event.currentTarget.getAttribute("id"));
+    setActiveIndex(index);
+  }, onMenuItemKeyDown = useCallback((event, onSuccess) => {
+    let flag = !1;
+    if (event.shiftKey)
+      event.key === "Tab" && (closeDropdown(), flag = !0);
+    else {
+      switch (event.code) {
+        case "Escape":
+          closeDropdown();
+          break;
+        case " ":
+        case "Enter":
+          activeIndex !== -1 && (Object.values(itemRefs.current)[activeIndex].getAttribute("role") === "menuitem" && triggerRef.current && (triggerRef.current.focus(), setVisible(!1)), onSuccess == null || onSuccess()), flag = !0;
+          break;
+        case "ArrowDown":
+        case "Down":
+          nextItem(), flag = !0;
+          break;
+        case "ArrowUp":
+        case "Up":
+          previousItem(), flag = !0;
+          break;
+        case "Home":
+          firstItem(), flag = !0;
+          break;
+        case "End":
+          lastItem(), flag = !0;
+          break;
+      }
+      stopEvents(flag, event);
+    }
+  }, [activeIndex, closeDropdown]), onTriggerClick = useCallback((event) => {
+    setVisible(visible !== !0), event.stopPropagation(), event.preventDefault();
+  }, [visible]);
+  return {
+    isFocused,
+    visible,
+    itemRefs,
+    triggerRef,
+    menuRef,
+    /* TriggerProps to spread to any Trigger component */
+    triggerProps: {
+      ref: mergeRefs(triggerRef, refs.setReference),
+      id: `dropdown-toggle-${id}`,
+      "aria-haspopup": "menu",
+      "aria-controls": `dropdown-${id}`,
+      "aria-expanded": !!visible,
+      className: `${visible ? "selected" : ""}`,
+      onClick: onTriggerClick,
+      onKeyDown: onTriggerKeyDown,
+      "aria-activedescendant": isFocused
+    },
+    /* MenuProps to spread to any Menu Component */
+    menuProps: {
+      ref: mergeRefs(menuRef, refs.setFloating),
+      className: "dropdown-menu",
+      "aria-labelledby": `dropdown-toggle-${id}`,
+      style: {
+        ...floatingStyles
+      }
+    },
+    /* ItemProps to spread to any item Component */
+    itemProps: {
+      onMenuItemMouseEnter,
+      onMenuItemClick: closeDropdown,
+      onMenuItemKeyDown
+    },
+    setVisible
+  };
+}, useDropdown$1 = useDropdown;
+export {
+  useDropdown$1 as default
+};

package/dist/hooks/useDropzone/index.d.ts

@@ -0,0 +1 @@
+export { default as useDropzone } from './useDropzone';

package/dist/hooks/useDropzone/useDropzone.d.ts

@@ -0,0 +1,34 @@
+import { ChangeEvent } from 'react';
+declare const useDropzone: (props?: {
+    /**
+     * Truthy when the `accept` attribute of the referenced `input[type=file]`
+     * must be force-checked against any added file.
+     */
+    forceFilters: boolean;
+}) => {
+    /** Reference to an `input[type=file]` HTMLElement, null at first. */
+    inputRef: import('react').MutableRefObject<HTMLInputElement | null>;
+    /** Read-only list of File·s  managed by this hook. */
+    files: File[];
+    /** Truthy when a drag event is triggered. */
+    dragging: boolean;
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragging: <T extends HTMLElement>(event: import('react').DragEvent<T>) => void;
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragLeave: <T_1 extends HTMLElement>(event: import('react').DragEvent<T_1>) => void;
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDrop: <T_2 extends HTMLElement>(event: import('react').DragEvent<T_2>) => void;
+    /** Replace a file in the `files` list. */
+    replaceFileAt: (index: number, file: File) => void;
+    /** Remove a file from the `files` list. */
+    deleteFile: (file: File) => void;
+    /** Add a file to the `files` list. */
+    addFile: (file: File) => void;
+    /** Add many files to the `files` list. */
+    addFiles: (files: File[]) => void;
+    /** Empty the `files` list. */
+    cleanFiles: () => void;
+    /** Callback to attach to your `input[type=file]` HTMLElement. */
+    handleOnChange: (event: ChangeEvent<HTMLInputElement>) => void;
+};
+export default useDropzone;

package/dist/hooks/useDropzone/useDropzone.js

@@ -0,0 +1,76 @@
+import { useState, useRef } from "react";
+const useDropzone = (props) => {
+  const [dragging, setDragging] = useState(!1), [files, setFiles] = useState([]), inputRef = useRef(null), addFile = (file) => {
+    addFiles([file]);
+  }, deleteFile = (file) => {
+    setFiles((prevFiles) => prevFiles.filter((prevFile) => prevFile.name !== file.name));
+  }, replaceFileAt = (index, file) => {
+    setFiles((prevFiles) => {
+      if (0 <= index && index < prevFiles.length) {
+        const firstPart = prevFiles.slice(0, index), lastPart = index === prevFiles.length - 1 ? [] : prevFiles.slice(index + 1);
+        return [...firstPart, file, ...lastPart];
+      }
+      return prevFiles;
+    });
+  }, applyInputFiltersOn = (files2) => {
+    var _a;
+    let filteredFiles = files2;
+    if ((_a = inputRef.current) != null && _a.accept) {
+      const filters = inputRef.current.accept.split(",").map((filter) => filter.trim().toLowerCase()), extensions = filters.filter((filter) => filter.startsWith(".")), mimes = filters.filter((filter) => !filter.startsWith(".")).map((mime) => mime.replace("*", ""));
+      filteredFiles = [], files2.forEach((file) => {
+        const fileName = file.name.toLowerCase();
+        (extensions.some((extension) => fileName.endsWith(extension)) || mimes.some((mime) => file.type.includes(mime))) && filteredFiles.push(file);
+      });
+    }
+    return filteredFiles;
+  }, addFiles = (files2) => {
+    if (props != null && props.forceFilters) {
+      const filesToAdd = applyInputFiltersOn(files2);
+      filesToAdd && filesToAdd.length && setFiles((prevFiles) => [...prevFiles, ...filesToAdd]);
+    } else
+      setFiles((prevFiles) => [...prevFiles, ...files2]);
+  }, cleanFiles = () => {
+    setFiles([]);
+  }, handleOnChange = (event) => {
+    const files2 = event.target.files;
+    files2 && addFiles([...files2]);
+  }, handleDragging = (event) => {
+    event.preventDefault(), event.stopPropagation(), setDragging(!0);
+  }, handleDragLeave = (event) => {
+    event.preventDefault(), event.stopPropagation(), setDragging(!1);
+  };
+  return {
+    /** Reference to an `input[type=file]` HTMLElement, null at first. */
+    inputRef,
+    /** Read-only list of File·s  managed by this hook. */
+    files,
+    /** Truthy when a drag event is triggered. */
+    dragging,
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragging,
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDragLeave,
+    /** Callback to attach to your drop zone (any HTMLElement). */
+    handleDrop: (event) => {
+      var _a;
+      handleDragLeave(event);
+      const files2 = (_a = event.dataTransfer) == null ? void 0 : _a.files;
+      files2 && (addFiles([...files2]), inputRef != null && inputRef.current && (inputRef.current.files = files2));
+    },
+    /** Replace a file in the `files` list. */
+    replaceFileAt,
+    /** Remove a file from the `files` list. */
+    deleteFile,
+    /** Add a file to the `files` list. */
+    addFile,
+    /** Add many files to the `files` list. */
+    addFiles,
+    /** Empty the `files` list. */
+    cleanFiles,
+    /** Callback to attach to your `input[type=file]` HTMLElement. */
+    handleOnChange
+  };
+}, useDropzone$1 = useDropzone;
+export {
+  useDropzone$1 as default
+};

package/dist/hooks/useHover/index.d.ts

@@ -0,0 +1 @@
+export { default as useHover } from './useHover';

package/dist/hooks/useHover/useHover.d.ts

@@ -0,0 +1,2 @@
+import { MutableRefObject } from 'react';
+export default function useHover<T>(): [MutableRefObject<T>, boolean];

package/dist/hooks/useHover/useHover.js

@@ -0,0 +1,22 @@
+import { useState, useRef, useEffect } from "react";
+function useHover() {
+  const [value, setValue] = useState(!1), ref = useRef(null), handleMouseOver = () => {
+    setValue(!0);
+  }, handleMouseOut = () => {
+    setValue(!1);
+  };
+  return useEffect(
+    () => {
+      const node = ref.current;
+      if (node)
+        return node.addEventListener("mouseover", handleMouseOver), node.addEventListener("mouseout", handleMouseOut), () => {
+          node.removeEventListener("mouseover", handleMouseOver), node.removeEventListener("mouseout", handleMouseOut);
+        };
+    },
+    [ref]
+    // Recall only if ref changes
+  ), [ref, value];
+}
+export {
+  useHover as default
+};

package/dist/hooks/useImage/index.d.ts

@@ -0,0 +1 @@
+export { default as useImage } from './useImage';

package/dist/hooks/useImage/useImage.d.ts

@@ -0,0 +1,9 @@
+interface useImageProps {
+    src: string;
+    placeholder: string;
+}
+export default function useImage({ src, placeholder }: useImageProps): {
+    imgSrc: string;
+    onError: () => void;
+};
+export {};

package/dist/hooks/useImage/useImage.js

@@ -0,0 +1,18 @@
+import { useState, useCallback, useEffect } from "react";
+function useImage({
+  src,
+  placeholder
+}) {
+  const [imgSrc, setImgSrc] = useState(src || placeholder), onError = useCallback(() => {
+    setImgSrc(placeholder);
+  }, [placeholder]);
+  return useEffect(() => {
+    setImgSrc(src);
+  }, [src]), {
+    imgSrc,
+    onError
+  };
+}
+export {
+  useImage as default
+};

package/dist/hooks/useImageResizer/index.d.ts

@@ -0,0 +1 @@
+export { default as useImageResizer } from './useImageResizer';

package/dist/hooks/useImageResizer/useImageResizer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @module useImageResizer
+ * @description This module provides a hook to resize and compress image files.
+ * @returns all the action available for the image resizer
+ */
+export default function useImageResizer(): {
+    resizeImageFile: (file: File, maxWidth?: number, maxHeight?: number, quality?: number) => Promise<File>;
+};

package/dist/hooks/useImageResizer/useImageResizer.js

@@ -0,0 +1,42 @@
+function useImageResizer() {
+  const changeHeightWidth = (height, maxHeight, width, maxWidth) => (width > maxWidth && (height = Math.round(height * maxWidth / width), width = maxWidth), height > maxHeight && (width = Math.round(width * maxHeight / height), height = maxHeight), {
+    height,
+    width
+  }), renameFileNameExtension = (filename, newExtension) => {
+    const filenameParts = filename.split(".");
+    return filenameParts.pop(), filenameParts.join(".") + "." + newExtension;
+  }, resizeImage = (image, fileName, maxWidth, maxHeight, compressFormat = "jpeg", quality = 80) => {
+    const qualityDecimal = quality / 100, canvas = document.createElement("canvas"), contentType = `image/${compressFormat}`;
+    let width = image.width, height = image.height;
+    const newHeightWidth = changeHeightWidth(height, maxHeight, width, maxWidth);
+    width = newHeightWidth.width, height = newHeightWidth.height;
+    const ctx = canvas.getContext("2d");
+    return ctx && (canvas.width = width, canvas.height = height, ctx.imageSmoothingEnabled && ctx.imageSmoothingQuality && (ctx.imageSmoothingQuality = "high"), ctx.drawImage(image, 0, 0, width, height)), new Promise((resolve, reject) => {
+      canvas.toBlob((blob) => {
+        blob ? resolve(new File([blob], fileName, {
+          type: contentType,
+          lastModified: (/* @__PURE__ */ new Date()).getTime()
+        })) : reject();
+      }, contentType, qualityDecimal);
+    });
+  };
+  return {
+    resizeImageFile: async (file, maxWidth = 1440, maxHeight = 1440, quality = 80) => {
+      if (!file) throw Error("Image resizer: file not found!");
+      if (!file.type || !file.type.startsWith("image/")) throw Error("Image resizer: the file given is not an image.");
+      const compressFormat = "jpeg";
+      return new Promise((resolve) => {
+        const image = new Image();
+        image.setAttribute("style", "max-width: none;"), image.src = URL.createObjectURL(file), image.onload = async () => {
+          const resizedFile = await resizeImage(image, renameFileNameExtension(file.name, compressFormat), maxWidth, maxHeight, compressFormat, quality);
+          resolve(resizedFile);
+        }, image.onerror = (error) => {
+          throw Error("Image Loading Error: " + error);
+        };
+      });
+    }
+  };
+}
+export {
+  useImageResizer as default
+};

package/dist/hooks/useKeyPress/index.d.ts

@@ -0,0 +1 @@
+export { default as useKeyPress } from './useKeyPress';

package/dist/hooks/useKeyPress/useKeyPress.d.ts

@@ -0,0 +1 @@
+export default function useKeyPress(callback: () => void, keyCodes: string[]): void;

package/dist/hooks/useKeyPress/useKeyPress.js

@@ -0,0 +1,14 @@
+import { useCallback, useEffect } from "react";
+function useKeyPress(callback, keyCodes) {
+  const handler = useCallback(({
+    code
+  }) => {
+    keyCodes.includes(code) && callback();
+  }, [callback, keyCodes]);
+  useEffect(() => (window.addEventListener("keydown", handler), () => {
+    window.removeEventListener("keydown", handler);
+  }), [handler]);
+}
+export {
+  useKeyPress as default
+};

package/dist/hooks/useScrollToTop/index.d.ts

@@ -0,0 +1 @@
+export { default as useScrollToTop } from './useScrollToTop';

package/dist/hooks/useScrollToTop/useScrollToTop.d.ts

@@ -0,0 +1 @@
+export default function useScrollToTop(): () => void;

package/dist/hooks/useScrollToTop/useScrollToTop.js

@@ -0,0 +1,9 @@
+function useScrollToTop() {
+  const refToTop = document.querySelector("html");
+  return () => {
+    refToTop && refToTop.scrollIntoView();
+  };
+}
+export {
+  useScrollToTop as default
+};

package/dist/hooks/useThumbnail/index.d.ts

@@ -0,0 +1 @@
+export { default as useThumbnail } from './useThumbnail';

package/dist/hooks/useThumbnail/useThumbnail.d.ts

@@ -0,0 +1,14 @@
+import { IntersectionOptions } from 'react-intersection-observer';
+type LazyLoadOptions = {
+    ref?: React.RefObject<HTMLElement>;
+    intersectionOptions?: IntersectionOptions;
+};
+/**
+ * Preload a `src` URL and return true if it is available.
+ * @param src the URL to preload
+ * @param options if defined, lazy-load the `src` URL when ref is defined and visible,
+ *        with respect to the [`intersectionOptions`](https://github.com/thebuilder/react-intersection-observer/tree/dceba7f52aebea4d62d539bc55a1db129226bb6c?tab=readme-ov-file#options)
+ * @return `true` if `src` is available, or false otherwise, or `null` while not tested.
+ */
+export default function useThumbnail(src: string, options?: LazyLoadOptions): boolean | null;
+export {};

package/dist/hooks/useThumbnail/useThumbnail.js

@@ -0,0 +1,29 @@
+import { useState, useEffect } from "react";
+import { useInView } from "react-intersection-observer";
+function useThumbnail(src, options) {
+  const [status, setStatus] = useState(null), {
+    ref: inViewRef,
+    inView
+  } = useInView({
+    triggerOnce: !0,
+    ...options == null ? void 0 : options.intersectionOptions
+  });
+  return useEffect(() => {
+    var _a;
+    (_a = options == null ? void 0 : options.ref) != null && _a.current && (inViewRef == null || inViewRef(options.ref.current));
+  }, [options == null ? void 0 : options.ref, inViewRef]), useEffect(() => {
+    if ((options == null ? void 0 : options.ref) === void 0 || inView) {
+      const img = new Image();
+      return img.src = src, img.onload = () => {
+        setStatus(!0);
+      }, img.onerror = () => {
+        setStatus(!1);
+      }, () => {
+        img.onload = null, img.onerror = null, setStatus(null);
+      };
+    }
+  }, [inView]), status;
+}
+export {
+  useThumbnail as default
+};

package/dist/hooks/useTitle/index.d.ts

@@ -0,0 +1 @@
+export { default as useTitle } from './useTitle';

package/dist/hooks/useTitle/useTitle.d.ts

@@ -0,0 +1 @@
+export default function useTitle(): string;

package/dist/hooks/useTitle/useTitle.js

@@ -0,0 +1,10 @@
+import { useState, useEffect } from "react";
+function useTitle() {
+  const documentDefined = typeof document < "u", [title, setTitle] = useState(() => document.title);
+  return useEffect(() => {
+    documentDefined && setTitle(document.title);
+  }, [documentDefined]), title;
+}
+export {
+  useTitle as default
+};

package/dist/hooks/useToast/index.d.ts

@@ -0,0 +1 @@
+export { default as useToast } from './useToast';

package/dist/hooks/useToast/useToast.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { ToastPosition } from 'react-hot-toast';
+export interface CustomToastOptions {
+    id?: string;
+    isDismissible?: boolean;
+    position?: ToastPosition;
+    duration?: number;
+}
+export default function useToast(): {
+    success: (message: string | ReactNode, options?: CustomToastOptions) => string;
+    error: (message: string | ReactNode, options?: CustomToastOptions) => string;
+    info: (message: string | ReactNode, options?: CustomToastOptions) => string;
+    warning: (message: string | ReactNode, options?: CustomToastOptions) => string;
+    loading: (message: import('react-hot-toast').Renderable | import('react-hot-toast').ValueFunction<import('react-hot-toast').Renderable, import('react-hot-toast').Toast>, options?: Partial<Pick<import('react-hot-toast').Toast, "style" | "className" | "id" | "icon" | "position" | "duration" | "ariaProps" | "iconTheme">> | undefined) => string;
+    dismiss: (id: string) => void;
+    remove: (id: string) => void;
+};

package/dist/hooks/useToast/useToast.js

@@ -0,0 +1,34 @@
+import { jsx } from "react/jsx-runtime";
+import toast from "react-hot-toast";
+import Alert from "../../components/Alert/Alert.js";
+const DEFAULT_POSITION = "top-right";
+function useToast() {
+  return {
+    success: (message, options) => toast.custom(/* @__PURE__ */ jsx(Alert, { type: "success", isToast: !0, isDismissible: options == null ? void 0 : options.isDismissible, className: "mb-12", children: message }), {
+      id: options == null ? void 0 : options.id,
+      duration: options == null ? void 0 : options.duration,
+      position: (options == null ? void 0 : options.position) ?? DEFAULT_POSITION
+    }),
+    error: (message, options) => toast.custom(/* @__PURE__ */ jsx(Alert, { type: "danger", isToast: !0, isDismissible: options == null ? void 0 : options.isDismissible, className: "mb-12", children: message }), {
+      id: options == null ? void 0 : options.id,
+      duration: options == null ? void 0 : options.duration,
+      position: (options == null ? void 0 : options.position) ?? DEFAULT_POSITION
+    }),
+    info: (message, options) => toast.custom(/* @__PURE__ */ jsx(Alert, { type: "info", isToast: !0, isDismissible: options == null ? void 0 : options.isDismissible, className: "mb-12", children: message }), {
+      id: options == null ? void 0 : options.id,
+      duration: options == null ? void 0 : options.duration,
+      position: (options == null ? void 0 : options.position) ?? DEFAULT_POSITION
+    }),
+    warning: (message, options) => toast.custom(/* @__PURE__ */ jsx(Alert, { type: "warning", isToast: !0, isDismissible: options == null ? void 0 : options.isDismissible, className: "mb-12", children: message }), {
+      id: options == null ? void 0 : options.id,
+      duration: options == null ? void 0 : options.duration,
+      position: (options == null ? void 0 : options.position) ?? DEFAULT_POSITION
+    }),
+    loading: toast.loading,
+    dismiss: (id) => toast.dismiss(id),
+    remove: (id) => toast.remove(id)
+  };
+}
+export {
+  useToast as default
+};

package/dist/hooks/useToggle/index.d.ts

@@ -0,0 +1 @@
+export { default as useToggle } from './useToggle';

package/dist/hooks/useToggle/useToggle.d.ts

@@ -0,0 +1 @@
+export default function useToggle(initialState?: boolean): [boolean, any];

package/dist/hooks/useToggle/useToggle.js

@@ -0,0 +1,10 @@
+import { useState, useCallback } from "react";
+function useToggle(initialState = !1) {
+  const [state, setState] = useState(initialState), toggle = useCallback(() => {
+    setState((prevState) => !prevState);
+  }, []);
+  return [state, toggle];
+}
+export {
+  useToggle as default
+};

package/dist/hooks/useTrapFocus/index.d.ts

@@ -0,0 +1 @@
+export { default as useTrapFocus } from './useTrapFocus';

package/dist/hooks/useTrapFocus/useTrapFocus.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function useTrapFocus(): import('react').MutableRefObject<HTMLElement | null>;

package/dist/hooks/useTrapFocus/useTrapFocus.js

@@ -0,0 +1,16 @@
+import { useRef, useEffect } from "react";
+function useTrapFocus() {
+  const ref = useRef(null), focusableElements = 'button:not([disabled]), [href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
+  return useEffect(() => {
+    const node = ref.current, firstFocusableElement = node.querySelectorAll(focusableElements)[0], focusableContent = node.querySelectorAll(focusableElements), lastFocusableElement = ref && (focusableContent == null ? void 0 : focusableContent[focusableContent.length - 1]), handleKeydown = (event) => {
+      event.key === "Tab" && (event.shiftKey ? document.activeElement === firstFocusableElement && (lastFocusableElement.focus(), event.preventDefault()) : document.activeElement === lastFocusableElement && (firstFocusableElement.focus(), event.preventDefault()));
+    };
+    if (node)
+      return node.addEventListener("keydown", handleKeydown), () => {
+        node.removeEventListener("keydown", handleKeydown);
+      };
+  }, []), ref;
+}
+export {
+  useTrapFocus as default
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './components';
+export * from './core';
+export * from './hooks';
+export * from './portal';
+export * from './utils';
+export * from './widgets';