@stratakit/foundations/dist/~hooks.js

Foundational pieces of StrataKit

import { c as _c } from "react-compiler-runtime";
import * as React from "react";
import { isBrowser, supportsPopover } from "./~utils.js";
const useLayoutEffect = isBrowser ? React.useLayoutEffect : React.useEffect;
function useControlledState(initialValue, controlledState, setControlledState) {
  const $ = _c(5);
  const [uncontrolledState, setUncontrolledState] = React.useState(initialValue);
  const state = controlledState !== void 0 ? controlledState : uncontrolledState;
  const setControlledStateRef = useLatestRef(setControlledState);
  let t0;
  if ($[0] !== setControlledStateRef) {
    t0 = (value) => {
      setUncontrolledState(value);
      setControlledStateRef.current?.(value);
    };
    $[0] = setControlledStateRef;
    $[1] = t0;
  } else {
    t0 = $[1];
  }
  const setState = t0;
  let t1;
  if ($[2] !== setState || $[3] !== state) {
    t1 = [state, setState];
    $[2] = setState;
    $[3] = state;
    $[4] = t1;
  } else {
    t1 = $[4];
  }
  return t1;
}
function useLatestRef(value) {
  const $ = _c(2);
  const valueRef = React.useRef(value);
  let t0;
  if ($[0] !== value) {
    t0 = () => {
      valueRef.current = value;
    };
    $[0] = value;
    $[1] = t0;
  } else {
    t0 = $[1];
  }
  React.useInsertionEffect(t0);
  return valueRef;
}
function useMergedRefs(...refs) {
  return React.useCallback((instance) => {
    for (const ref of refs) {
      if (typeof ref === "function") {
        ref(instance);
      } else if (ref) {
        ref.current = instance;
      }
    }
  }, [...refs]);
}
function useUnreactiveCallback(callback) {
  const $ = _c(2);
  const latestCallback = useLatestRef(callback);
  let t0;
  if ($[0] !== latestCallback) {
    t0 = (...t1) => {
      const args = t1;
      return latestCallback.current?.(...args);
    };
    $[0] = latestCallback;
    $[1] = t0;
  } else {
    t0 = $[1];
  }
  return t0;
}
function useEventHandlers(...handlers) {
  const latestHandlers = useLatestRef(handlers);
  return React.useCallback((event) => {
    for (const handler of latestHandlers.current) {
      handler?.(event);
      if (event.defaultPrevented) return;
    }
  }, [latestHandlers]);
}
function useSafeContext(context) {
  const value = React.useContext(context);
  if (value === void 0) {
    throw new Error(`${context.displayName || "Context"} is undefined`);
  }
  return value;
}
function usePopoverApi(t0) {
  const $ = _c(6);
  const {
    element,
    open,
    setOpen
  } = t0;
  let t1;
  let t2;
  if ($[0] !== element || $[1] !== open || $[2] !== setOpen) {
    t1 = function syncPopoverWithOpenState() {
      if (element?.popover && element?.isConnected && open !== void 0) {
        element?.togglePopover?.(open);
        if (open && "CloseWatcher" in window) {
          const closeWatcher = new CloseWatcher();
          closeWatcher.onclose = () => {
            if (open) {
              setOpen(false);
            }
          };
        }
      }
    };
    t2 = [open, element, setOpen];
    $[0] = element;
    $[1] = open;
    $[2] = setOpen;
    $[3] = t1;
    $[4] = t2;
  } else {
    t1 = $[3];
    t2 = $[4];
  }
  React.useEffect(t1, t2);
  let t3;
  if ($[5] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
    t3 = {
      style: {
        zIndex: supportsPopover ? void 0 : 9999
      },
      popover: "manual"
    };
    $[5] = t3;
  } else {
    t3 = $[5];
  }
  return t3;
}
function useIsClient() {
  return React.useSyncExternalStore(_temp2, _temp3, _temp4);
}
function _temp4() {
  return false;
}
function _temp3() {
  return true;
}
function _temp2() {
  return _temp;
}
function _temp() {
}
export {
  useControlledState,
  useEventHandlers,
  useIsClient,
  useLatestRef,
  useLayoutEffect,
  useMergedRefs,
  usePopoverApi,
  useSafeContext,
  useUnreactiveCallback
};