@1771technologies/lytenyte-pro/dist/useButton-DWXzFgcr.js

import * as React from "react";
import { u as useForkRef } from "./InternalBackdrop-C4RACVzs.js";
import { d as useEnhancedEffect, j as useEventCallback, m as mergeProps, k as makeEventPreventable } from "./proptypes-BjYr2nFr.js";
let set;
if (process.env.NODE_ENV !== "production") {
  set = /* @__PURE__ */ new Set();
}
function warn(...messages) {
  if (process.env.NODE_ENV !== "production") {
    const messageKey = messages.join(" ");
    if (!set.has(messageKey)) {
      set.add(messageKey);
      console.warn(`Base UI: ${messageKey}`);
    }
  }
}
function useRootElementName(parameters) {
  const {
    rootElementName: rootElementNameProp = ""
  } = parameters;
  const [rootElementName, setRootElementName] = React.useState(rootElementNameProp.toUpperCase());
  if (process.env.NODE_ENV !== "production") {
    useEnhancedEffect(() => {
      if (rootElementNameProp && rootElementName !== rootElementNameProp.toUpperCase()) {
        warn(`useRootElementName expected the '${rootElementNameProp}' element, but a '${rootElementName.toLowerCase()}' was rendered instead`, "This may cause hydration issues in an SSR context, for example in a Next.js app");
      }
    }, [rootElementNameProp, rootElementName]);
  }
  const updateRootElementName = React.useCallback((element) => {
    setRootElementName(element?.tagName ?? "");
  }, []);
  return {
    rootElementName,
    updateRootElementName
  };
}
const CompositeRootContext = /* @__PURE__ */ React.createContext(void 0);
if (process.env.NODE_ENV !== "production") {
  CompositeRootContext.displayName = "CompositeRootContext";
}
function useCompositeRootContext(optional = false) {
  const context = React.useContext(CompositeRootContext);
  if (context === void 0 && !optional) {
    throw new Error("Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>.");
  }
  return context;
}
function useButton(parameters = {}) {
  const {
    buttonRef: externalRef,
    disabled = false,
    focusableWhenDisabled,
    tabIndex,
    type,
    elementName: elementNameProp
  } = parameters;
  const buttonRef = React.useRef(null);
  const {
    rootElementName: elementName,
    updateRootElementName
  } = useRootElementName({
    rootElementName: elementNameProp
  });
  const isCompositeItem = useCompositeRootContext(true) !== void 0;
  const isNativeButton = useEventCallback(() => {
    const element = buttonRef.current;
    return elementName === "BUTTON" || elementName === "INPUT" && ["button", "submit", "reset"].includes(element?.type);
  });
  const isValidLink = useEventCallback(() => {
    const element = buttonRef.current;
    return Boolean(elementName === "A" && element?.href);
  });
  const mergedRef = useForkRef(updateRootElementName, externalRef, buttonRef);
  const buttonProps = React.useMemo(() => {
    const additionalProps = {};
    if (tabIndex !== void 0 && !isCompositeItem) {
      additionalProps.tabIndex = tabIndex;
    }
    if (elementName === "BUTTON" || elementName === "INPUT") {
      if (focusableWhenDisabled || isCompositeItem) {
        additionalProps["aria-disabled"] = disabled;
      } else if (!isCompositeItem) {
        additionalProps.disabled = disabled;
      }
    } else if (elementName !== "") {
      if (elementName !== "A") {
        additionalProps.role = "button";
        if (!isCompositeItem) {
          additionalProps.tabIndex = tabIndex ?? 0;
        }
      } else if (tabIndex && !isCompositeItem) {
        additionalProps.tabIndex = tabIndex;
      }
      if (disabled) {
        additionalProps["aria-disabled"] = disabled;
        if (!isCompositeItem) {
          additionalProps.tabIndex = focusableWhenDisabled ? tabIndex ?? 0 : -1;
        }
      }
    }
    return additionalProps;
  }, [disabled, elementName, focusableWhenDisabled, isCompositeItem, tabIndex]);
  useEnhancedEffect(() => {
    const element = buttonRef.current;
    if (!(element instanceof HTMLButtonElement)) {
      return;
    }
    if (isCompositeItem && disabled && buttonProps.disabled === void 0 && element.disabled) {
      element.disabled = false;
    }
  }, [disabled, buttonProps.disabled, isCompositeItem]);
  const getButtonProps = React.useCallback((externalProps = {}) => {
    const {
      onClick: externalOnClick,
      onMouseDown: externalOnMouseDown,
      onKeyUp: externalOnKeyUp,
      onKeyDown: externalOnKeyDown,
      onPointerDown: externalOnPointerDown,
      ...otherExternalProps
    } = externalProps;
    return mergeProps({
      type,
      onClick(event) {
        if (disabled) {
          event.preventDefault();
          return;
        }
        externalOnClick?.(event);
      },
      onMouseDown(event) {
        if (!disabled) {
          externalOnMouseDown?.(event);
        }
      },
      onKeyDown(event) {
        if (
          // allow Tabbing away from focusableWhenDisabled buttons
          disabled && focusableWhenDisabled && event.key !== "Tab" || event.target === event.currentTarget && !isNativeButton() && event.key === " "
        ) {
          event.preventDefault();
        }
        if (!disabled) {
          makeEventPreventable(event);
          externalOnKeyDown?.(event);
        }
        if (event.baseUIHandlerPrevented) {
          return;
        }
        if (event.target === event.currentTarget && !isNativeButton() && !isValidLink() && event.key === "Enter" && !disabled) {
          externalOnClick?.(event);
          event.preventDefault();
        }
      },
      onKeyUp(event) {
        if (!disabled) {
          makeEventPreventable(event);
          externalOnKeyUp?.(event);
        }
        if (event.baseUIHandlerPrevented) {
          return;
        }
        if (event.target === event.currentTarget && !isNativeButton() && !disabled && event.key === " ") {
          externalOnClick?.(event);
        }
      },
      onPointerDown(event) {
        if (disabled) {
          event.preventDefault();
          return;
        }
        externalOnPointerDown?.(event);
      },
      ref: mergedRef
    }, buttonProps, otherExternalProps);
  }, [buttonProps, disabled, focusableWhenDisabled, isNativeButton, isValidLink, mergedRef, type]);
  return {
    getButtonProps,
    buttonRef: mergedRef
  };
}
export {
  useButton as u,
  warn as w
};