dune-react 0.0.1 → 0.0.3

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/toggle/Toggle.js

@@ -0,0 +1,100 @@
+import * as React from "react";
+import { useStableCallback } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useControlled } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useControlled.js";
+import { useIsoLayoutEffect } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { error } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/error.js";
+import { useBaseUiId } from "../utils/useBaseUiId.js";
+import { useRenderElement } from "../utils/useRenderElement.js";
+import { useToggleGroupContext } from "../toggle-group/ToggleGroupContext.js";
+import { useButton } from "../use-button/useButton.js";
+import { CompositeItem } from "../composite/item/CompositeItem.js";
+import { createChangeEventDetails } from "../utils/createBaseUIEventDetails.js";
+import { jsx } from "react/jsx-runtime";
+import { none } from "../utils/reason-parts.js";
+const Toggle = /* @__PURE__ */ React.forwardRef(function Toggle2(componentProps, forwardedRef) {
+  const {
+    className,
+    defaultPressed: defaultPressedProp = false,
+    disabled: disabledProp = false,
+    form,
+    // never participates in form validation
+    onPressedChange: onPressedChangeProp,
+    pressed: pressedProp,
+    render,
+    type,
+    // cannot change button type
+    value: valueProp,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const value = useBaseUiId(valueProp || void 0);
+  const groupContext = useToggleGroupContext();
+  const groupValue = (groupContext == null ? void 0 : groupContext.value) ?? [];
+  const defaultPressed = groupContext ? void 0 : defaultPressedProp;
+  const disabled = (disabledProp || (groupContext == null ? void 0 : groupContext.disabled)) ?? false;
+  if (process.env.NODE_ENV !== "production") {
+    useIsoLayoutEffect(() => {
+      if (groupContext && valueProp === void 0 && groupContext.isValueInitialized) {
+        error("A `<Toggle>` component rendered in a `<ToggleGroup>` has no explicit `value` prop.", "This will cause issues between the Toggle Group and Toggle values.", "Provide the `<Toggle>` with a `value` prop matching the `<ToggleGroup>` values prop type.");
+      }
+    }, [groupContext, valueProp, groupContext == null ? void 0 : groupContext.isValueInitialized]);
+  }
+  const [pressed, setPressedState] = useControlled({
+    controlled: groupContext ? value !== void 0 && groupValue.indexOf(value) > -1 : pressedProp,
+    default: defaultPressed,
+    name: "Toggle",
+    state: "pressed"
+  });
+  const onPressedChange = useStableCallback((nextPressed, eventDetails) => {
+    var _a;
+    if (value) {
+      (_a = groupContext == null ? void 0 : groupContext.setGroupValue) == null ? void 0 : _a.call(groupContext, value, nextPressed, eventDetails);
+    }
+    onPressedChangeProp == null ? void 0 : onPressedChangeProp(nextPressed, eventDetails);
+  });
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    native: nativeButton
+  });
+  const state = {
+    disabled,
+    pressed
+  };
+  const refs = [buttonRef, forwardedRef];
+  const props = [{
+    "aria-pressed": pressed,
+    onClick(event) {
+      const nextPressed = !pressed;
+      const details = createChangeEventDetails(none, event.nativeEvent);
+      onPressedChange(nextPressed, details);
+      if (details.isCanceled) {
+        return;
+      }
+      setPressedState(nextPressed);
+    }
+  }, elementProps, getButtonProps];
+  const element = useRenderElement("button", componentProps, {
+    enabled: !groupContext,
+    state,
+    ref: refs,
+    props
+  });
+  if (groupContext) {
+    return /* @__PURE__ */ jsx(CompositeItem, {
+      tag: "button",
+      render,
+      className,
+      state,
+      refs,
+      props
+    });
+  }
+  return element;
+});
+if (process.env.NODE_ENV !== "production") Toggle.displayName = "Toggle";
+export {
+  Toggle
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/toggle-group/ToggleGroupContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const ToggleGroupContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ToggleGroupContext.displayName = "ToggleGroupContext";
+function useToggleGroupContext(optional = true) {
+  const context = React.useContext(ToggleGroupContext);
+  if (context === void 0 && !optional) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: ToggleGroupContext is missing. ToggleGroup parts must be placed within <ToggleGroup>." : formatErrorMessage(7));
+  }
+  return context;
+}
+export {
+  ToggleGroupContext,
+  useToggleGroupContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/toolbar/root/ToolbarRootContext.js

@@ -0,0 +1,11 @@
+import * as React from "react";
+const ToolbarRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ToolbarRootContext.displayName = "ToolbarRootContext";
+function useToolbarRootContext(optional) {
+  const context = React.useContext(ToolbarRootContext);
+  return context;
+}
+export {
+  ToolbarRootContext,
+  useToolbarRootContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/arrow/TooltipArrow.js

@@ -0,0 +1,43 @@
+import * as React from "react";
+import { useTooltipPositionerContext } from "../positioner/TooltipPositionerContext.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useTooltipRootContext } from "../root/TooltipRootContext.js";
+const TooltipArrow = /* @__PURE__ */ React.forwardRef(function TooltipArrow2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    ...elementProps
+  } = componentProps;
+  const store = useTooltipRootContext();
+  const instantType = store.useState("instantType");
+  const {
+    open,
+    arrowRef,
+    side,
+    align,
+    arrowUncentered,
+    arrowStyles
+  } = useTooltipPositionerContext();
+  const state = {
+    open,
+    side,
+    align,
+    uncentered: arrowUncentered,
+    instant: instantType
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, arrowRef],
+    props: [{
+      style: arrowStyles,
+      "aria-hidden": true
+    }, elementProps],
+    stateAttributesMapping: popupStateMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") TooltipArrow.displayName = "TooltipArrow";
+export {
+  TooltipArrow
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/popup/TooltipPopup.js

@@ -0,0 +1,64 @@
+import * as React from "react";
+import { useTooltipRootContext } from "../root/TooltipRootContext.js";
+import { useTooltipPositionerContext } from "../positioner/TooltipPositionerContext.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { transitionStatusMapping } from "../../utils/stateAttributesMapping.js";
+import { useOpenChangeComplete } from "../../utils/useOpenChangeComplete.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { getDisabledMountTransitionStyles } from "../../utils/getDisabledMountTransitionStyles.js";
+import { useHoverFloatingInteraction } from "../../floating-ui-react/hooks/useHoverFloatingInteraction.js";
+const stateAttributesMapping = {
+  ...popupStateMapping,
+  ...transitionStatusMapping
+};
+const TooltipPopup = /* @__PURE__ */ React.forwardRef(function TooltipPopup2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    ...elementProps
+  } = componentProps;
+  const store = useTooltipRootContext();
+  const {
+    side,
+    align
+  } = useTooltipPositionerContext();
+  const open = store.useState("open");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const popupProps = store.useState("popupProps");
+  const floatingContext = store.useState("floatingRootContext");
+  useOpenChangeComplete({
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      var _a, _b;
+      if (open) {
+        (_b = (_a = store.context).onOpenChangeComplete) == null ? void 0 : _b.call(_a, true);
+      }
+    }
+  });
+  const disabled = store.useState("disabled");
+  const closeDelay = store.useState("closeDelay");
+  useHoverFloatingInteraction(floatingContext, {
+    enabled: !disabled,
+    closeDelay
+  });
+  const state = {
+    open,
+    side,
+    align,
+    instant: instantType,
+    transitionStatus
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, store.context.popupRef, store.useStateSetter("popupElement")],
+    props: [popupProps, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    stateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") TooltipPopup.displayName = "TooltipPopup";
+export {
+  TooltipPopup
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortal.js

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { useTooltipRootContext } from "../root/TooltipRootContext.js";
+import { TooltipPortalContext } from "./TooltipPortalContext.js";
+import { FloatingPortalLite } from "../../utils/FloatingPortalLite.js";
+import { jsx } from "react/jsx-runtime";
+const TooltipPortal = /* @__PURE__ */ React.forwardRef(function TooltipPortal2(props, forwardedRef) {
+  const {
+    keepMounted = false,
+    ...portalProps
+  } = props;
+  const store = useTooltipRootContext();
+  const mounted = store.useState("mounted");
+  const shouldRender = mounted || keepMounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(TooltipPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ jsx(FloatingPortalLite, {
+      ref: forwardedRef,
+      ...portalProps
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipPortal.displayName = "TooltipPortal";
+export {
+  TooltipPortal
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortalContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const TooltipPortalContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipPortalContext.displayName = "TooltipPortalContext";
+function useTooltipPortalContext() {
+  const value = React.useContext(TooltipPortalContext);
+  if (value === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Portal> is missing." : formatErrorMessage(70));
+  }
+  return value;
+}
+export {
+  TooltipPortalContext,
+  useTooltipPortalContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositioner.js

@@ -0,0 +1,99 @@
+import * as React from "react";
+import { useTooltipRootContext } from "../root/TooltipRootContext.js";
+import { TooltipPositionerContext } from "./TooltipPositionerContext.js";
+import { useAnchorPositioning } from "../../utils/useAnchorPositioning.js";
+import { popupStateMapping } from "../../utils/popupStateMapping.js";
+import { useTooltipPortalContext } from "../portal/TooltipPortalContext.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { POPUP_COLLISION_AVOIDANCE } from "../../utils/constants.js";
+import { adaptiveOrigin } from "../../utils/adaptiveOriginMiddleware.js";
+import { getDisabledMountTransitionStyles } from "../../utils/getDisabledMountTransitionStyles.js";
+import { jsx } from "react/jsx-runtime";
+const TooltipPositioner = /* @__PURE__ */ React.forwardRef(function TooltipPositioner2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    anchor,
+    positionMethod = "absolute",
+    side = "top",
+    align = "center",
+    sideOffset = 0,
+    alignOffset = 0,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding = 5,
+    arrowPadding = 5,
+    sticky = false,
+    disableAnchorTracking = false,
+    collisionAvoidance = POPUP_COLLISION_AVOIDANCE,
+    ...elementProps
+  } = componentProps;
+  const store = useTooltipRootContext();
+  const keepMounted = useTooltipPortalContext();
+  const open = store.useState("open");
+  const mounted = store.useState("mounted");
+  const trackCursorAxis = store.useState("trackCursorAxis");
+  const disableHoverablePopup = store.useState("disableHoverablePopup");
+  const floatingRootContext = store.useState("floatingRootContext");
+  const instantType = store.useState("instantType");
+  const transitionStatus = store.useState("transitionStatus");
+  const hasViewport = store.useState("hasViewport");
+  const positioning = useAnchorPositioning({
+    anchor,
+    positionMethod,
+    floatingRootContext,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    arrowPadding,
+    disableAnchorTracking,
+    keepMounted,
+    collisionAvoidance,
+    adaptiveOrigin: hasViewport ? adaptiveOrigin : void 0
+  });
+  const defaultProps = React.useMemo(() => {
+    const hiddenStyles = {};
+    if (!open || trackCursorAxis === "both" || disableHoverablePopup) {
+      hiddenStyles.pointerEvents = "none";
+    }
+    return {
+      role: "presentation",
+      hidden: !mounted,
+      style: {
+        ...positioning.positionerStyles,
+        ...hiddenStyles
+      }
+    };
+  }, [open, trackCursorAxis, disableHoverablePopup, mounted, positioning.positionerStyles]);
+  const state = React.useMemo(() => ({
+    open,
+    side: positioning.side,
+    align: positioning.align,
+    anchorHidden: positioning.anchorHidden,
+    instant: trackCursorAxis !== "none" ? "tracking-cursor" : instantType
+  }), [open, positioning.side, positioning.align, positioning.anchorHidden, trackCursorAxis, instantType]);
+  const contextValue = React.useMemo(() => ({
+    ...state,
+    arrowRef: positioning.arrowRef,
+    arrowStyles: positioning.arrowStyles,
+    arrowUncentered: positioning.arrowUncentered
+  }), [state, positioning.arrowRef, positioning.arrowStyles, positioning.arrowUncentered]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    props: [defaultProps, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    ref: [forwardedRef, store.useStateSetter("positionerElement")],
+    stateAttributesMapping: popupStateMapping
+  });
+  return /* @__PURE__ */ jsx(TooltipPositionerContext.Provider, {
+    value: contextValue,
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipPositioner.displayName = "TooltipPositioner";
+export {
+  TooltipPositioner
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositionerContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const TooltipPositionerContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipPositionerContext.displayName = "TooltipPositionerContext";
+function useTooltipPositionerContext() {
+  const context = React.useContext(TooltipPositionerContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>." : formatErrorMessage(71));
+  }
+  return context;
+}
+export {
+  TooltipPositionerContext,
+  useTooltipPositionerContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/provider/TooltipProvider.js

@@ -0,0 +1,31 @@
+import * as React from "react";
+import { TooltipProviderContext } from "./TooltipProviderContext.js";
+import { jsx } from "react/jsx-runtime";
+import { FloatingDelayGroup } from "../../floating-ui-react/components/FloatingDelayGroup.js";
+const TooltipProvider = function TooltipProvider2(props) {
+  const {
+    delay,
+    closeDelay,
+    timeout = 400
+  } = props;
+  const contextValue = React.useMemo(() => ({
+    delay,
+    closeDelay
+  }), [delay, closeDelay]);
+  const delayValue = React.useMemo(() => ({
+    open: delay,
+    close: closeDelay
+  }), [delay, closeDelay]);
+  return /* @__PURE__ */ jsx(TooltipProviderContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ jsx(FloatingDelayGroup, {
+      delay: delayValue,
+      timeoutMs: timeout,
+      children: props.children
+    })
+  });
+};
+if (process.env.NODE_ENV !== "production") TooltipProvider.displayName = "TooltipProvider";
+export {
+  TooltipProvider
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/provider/TooltipProviderContext.js

@@ -0,0 +1,10 @@
+import * as React from "react";
+const TooltipProviderContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipProviderContext.displayName = "TooltipProviderContext";
+function useTooltipProviderContext() {
+  return React.useContext(TooltipProviderContext);
+}
+export {
+  TooltipProviderContext,
+  useTooltipProviderContext
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/root/TooltipRoot.js

@@ -0,0 +1,134 @@
+import * as React from "react";
+import { fastComponent } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/fastHooks.js";
+import { useOnFirstRender } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useOnFirstRender.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { TooltipRootContext } from "./TooltipRootContext.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { TooltipStore } from "../store/TooltipStore.js";
+import { jsx } from "react/jsx-runtime";
+import { useDismiss } from "../../floating-ui-react/hooks/useDismiss.js";
+import { useClientPoint } from "../../floating-ui-react/hooks/useClientPoint.js";
+import { useInteractions } from "../../floating-ui-react/hooks/useInteractions.js";
+import { disabled, none, imperativeAction } from "../../utils/reason-parts.js";
+import { useImplicitActiveTrigger, useOpenStateTransitions } from "../../utils/popups/popupStoreUtils.js";
+const TooltipRoot = fastComponent(function TooltipRoot2(props) {
+  const {
+    disabled: disabled$1 = false,
+    defaultOpen = false,
+    open: openProp,
+    disableHoverablePopup = false,
+    trackCursorAxis = "none",
+    actionsRef,
+    onOpenChange,
+    onOpenChangeComplete,
+    handle,
+    triggerId: triggerIdProp,
+    defaultTriggerId: defaultTriggerIdProp = null,
+    children
+  } = props;
+  const store = TooltipStore.useStore(handle == null ? void 0 : handle.store, {
+    open: defaultOpen,
+    openProp,
+    activeTriggerId: defaultTriggerIdProp,
+    triggerIdProp
+  });
+  useOnFirstRender(() => {
+    if (openProp === void 0 && store.state.open === false && defaultOpen === true) {
+      store.update({
+        open: true,
+        activeTriggerId: defaultTriggerIdProp
+      });
+    }
+  });
+  store.useControlledProp("openProp", openProp);
+  store.useControlledProp("triggerIdProp", triggerIdProp);
+  store.useContextCallback("onOpenChange", onOpenChange);
+  store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
+  const openState = store.useState("open");
+  const open = !disabled$1 && openState;
+  const activeTriggerId = store.useState("activeTriggerId");
+  const payload = store.useState("payload");
+  store.useSyncedValues({
+    trackCursorAxis,
+    disableHoverablePopup
+  });
+  useIsoLayoutEffect(() => {
+    if (openState && disabled$1) {
+      store.setOpen(false, createChangeEventDetails(disabled));
+    }
+  }, [openState, disabled$1, store]);
+  store.useSyncedValue("disabled", disabled$1);
+  useImplicitActiveTrigger(store);
+  const {
+    forceUnmount,
+    transitionStatus
+  } = useOpenStateTransitions(open, store);
+  const isInstantPhase = store.useState("isInstantPhase");
+  const instantType = store.useState("instantType");
+  const lastOpenChangeReason = store.useState("lastOpenChangeReason");
+  const previousInstantTypeRef = React.useRef(null);
+  useIsoLayoutEffect(() => {
+    if (transitionStatus === "ending" && lastOpenChangeReason === none || transitionStatus !== "ending" && isInstantPhase) {
+      if (instantType !== "delay") {
+        previousInstantTypeRef.current = instantType;
+      }
+      store.set("instantType", "delay");
+    } else if (previousInstantTypeRef.current !== null) {
+      store.set("instantType", previousInstantTypeRef.current);
+      previousInstantTypeRef.current = null;
+    }
+  }, [transitionStatus, isInstantPhase, lastOpenChangeReason, instantType, store]);
+  useIsoLayoutEffect(() => {
+    if (open) {
+      if (activeTriggerId == null) {
+        store.set("payload", void 0);
+      }
+    }
+  }, [store, activeTriggerId, open]);
+  const handleImperativeClose = React.useCallback(() => {
+    store.setOpen(false, createTooltipEventDetails(store, imperativeAction));
+  }, [store]);
+  React.useImperativeHandle(actionsRef, () => ({
+    unmount: forceUnmount,
+    close: handleImperativeClose
+  }), [forceUnmount, handleImperativeClose]);
+  const floatingRootContext = store.useState("floatingRootContext");
+  const dismiss = useDismiss(floatingRootContext, {
+    enabled: !disabled$1,
+    referencePress: () => store.select("closeOnClick")
+  });
+  const clientPoint = useClientPoint(floatingRootContext, {
+    enabled: !disabled$1 && trackCursorAxis !== "none",
+    axis: trackCursorAxis === "none" ? void 0 : trackCursorAxis
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getTriggerProps
+  } = useInteractions([dismiss, clientPoint]);
+  const activeTriggerProps = React.useMemo(() => getReferenceProps(), [getReferenceProps]);
+  const inactiveTriggerProps = React.useMemo(() => getTriggerProps(), [getTriggerProps]);
+  const popupProps = React.useMemo(() => getFloatingProps(), [getFloatingProps]);
+  store.useSyncedValues({
+    activeTriggerProps,
+    inactiveTriggerProps,
+    popupProps
+  });
+  return /* @__PURE__ */ jsx(TooltipRootContext.Provider, {
+    value: store,
+    children: typeof children === "function" ? children({
+      payload
+    }) : children
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipRoot.displayName = "TooltipRoot";
+function createTooltipEventDetails(store, reason) {
+  const details = createChangeEventDetails(reason);
+  details.preventUnmountOnClose = () => {
+    store.set("preventUnmountingOnClose", true);
+  };
+  return details;
+}
+export {
+  TooltipRoot
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/root/TooltipRootContext.js

@@ -0,0 +1,15 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+const TooltipRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipRootContext.displayName = "TooltipRootContext";
+function useTooltipRootContext(optional) {
+  const context = React.useContext(TooltipRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>." : formatErrorMessage(72));
+  }
+  return context;
+}
+export {
+  TooltipRootContext,
+  useTooltipRootContext
+};