npm - @neynar/ui - Versions diffs - 0.3.1 → 0.5.0 - Mend

@neynar/ui 0.3.1 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1860) hide show

package/dist/node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortal.js ADDED Viewed

@@ -0,0 +1,30 @@
+"use client";
+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
+};
+//# sourceMappingURL=TooltipPortal.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortal.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipPortal.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortal.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useTooltipRootContext } from \"../root/TooltipRootContext.js\";\nimport { TooltipPortalContext } from \"./TooltipPortalContext.js\";\nimport { FloatingPortalLite } from \"../../utils/FloatingPortalLite.js\";\n\n/**\n * A portal element that moves the popup to a different part of the DOM.\n * By default, the portal element is appended to `<body>`.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const TooltipPortal = /*#__PURE__*/React.forwardRef(function TooltipPortal(props, forwardedRef) {\n const {\n keepMounted = false,\n ...portalProps\n } = props;\n const store = useTooltipRootContext();\n const mounted = store.useState('mounted');\n const shouldRender = mounted || keepMounted;\n if (!shouldRender) {\n return null;\n }\n return /*#__PURE__*/_jsx(TooltipPortalContext.Provider, {\n value: keepMounted,\n children: /*#__PURE__*/_jsx(FloatingPortalLite, {\n ref: forwardedRef,\n ...portalProps\n })\n });\n});\nif (process.env.NODE_ENV !== \"production\") TooltipPortal.displayName = \"TooltipPortal\";"],"names":[],"mappings":";;;;;;AAeY;AACV;AAAM;AACU;AACX;AAEL;AACA;AACA;AACA;AACE;AAAO;AAET;AAAwD;AAC/C;AACyC;AACzC;AACF;AACJ;AAEL;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortalContext.js ADDED Viewed

@@ -0,0 +1,16 @@
+import formatErrorMessage from "../../../../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
+};
+//# sourceMappingURL=TooltipPortalContext.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortalContext.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipPortalContext.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/portal/TooltipPortalContext.js"],"sourcesContent":["import _formatErrorMessage from \"@base-ui/utils/formatErrorMessage\";\nimport * as React from 'react';\nexport const TooltipPortalContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== \"production\") TooltipPortalContext.displayName = \"TooltipPortalContext\";\nexport function useTooltipPortalContext() {\n const value = React.useContext(TooltipPortalContext);\n if (value === undefined) {\n throw new Error(process.env.NODE_ENV !== \"production\" ? 'Base UI: <Tooltip.Portal> is missing.' : _formatErrorMessage(70));\n }\n return value;\n}"],"names":["_formatErrorMessage"],"mappings":";;AAEY,MAAC,uBAAoC,sBAAM,cAAc,MAAS;AAC9E,IAAI,QAAQ,IAAI,aAAa,aAAc,sBAAqB,cAAc;AACvE,SAAS,0BAA0B;AACxC,QAAM,QAAQ,MAAM,WAAW,oBAAoB;AACnD,MAAI,UAAU,QAAW;AACvB,UAAM,IAAI,MAAM,QAAQ,IAAI,aAAa,eAAe,0CAA0CA,mBAAoB,EAAE,CAAC;AAAA,EAC3H;AACA,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositioner.js ADDED Viewed

@@ -0,0 +1,100 @@
+"use client";
+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 positioning = useAnchorPositioning({
+    anchor,
+    positionMethod,
+    floatingRootContext,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    arrowPadding,
+    disableAnchorTracking,
+    keepMounted,
+    collisionAvoidance,
+    adaptiveOrigin
+  });
+  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
+};
+//# sourceMappingURL=TooltipPositioner.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositioner.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipPositioner.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositioner.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useTooltipRootContext } from \"../root/TooltipRootContext.js\";\nimport { TooltipPositionerContext } from \"./TooltipPositionerContext.js\";\nimport { useAnchorPositioning } from \"../../utils/useAnchorPositioning.js\";\nimport { popupStateMapping } from \"../../utils/popupStateMapping.js\";\nimport { useTooltipPortalContext } from \"../portal/TooltipPortalContext.js\";\nimport { useRenderElement } from \"../../utils/useRenderElement.js\";\nimport { POPUP_COLLISION_AVOIDANCE } from \"../../utils/constants.js\";\nimport { adaptiveOrigin } from \"../../utils/adaptiveOriginMiddleware.js\";\nimport { getDisabledMountTransitionStyles } from \"../../utils/getDisabledMountTransitionStyles.js\";\n\n/**\n * Positions the tooltip against the trigger.\n * Renders a `<div>` element.\n *\n * Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const TooltipPositioner = /*#__PURE__*/React.forwardRef(function TooltipPositioner(componentProps, forwardedRef) {\n const {\n render,\n className,\n anchor,\n positionMethod = 'absolute',\n side = 'top',\n align = 'center',\n sideOffset = 0,\n alignOffset = 0,\n collisionBoundary = 'clipping-ancestors',\n collisionPadding = 5,\n arrowPadding = 5,\n sticky = false,\n disableAnchorTracking = false,\n collisionAvoidance = POPUP_COLLISION_AVOIDANCE,\n ...elementProps\n } = componentProps;\n const store = useTooltipRootContext();\n const keepMounted = useTooltipPortalContext();\n const open = store.useState('open');\n const mounted = store.useState('mounted');\n const trackCursorAxis = store.useState('trackCursorAxis');\n const disableHoverablePopup = store.useState('disableHoverablePopup');\n const floatingRootContext = store.useState('floatingRootContext');\n const instantType = store.useState('instantType');\n const transitionStatus = store.useState('transitionStatus');\n const positioning = useAnchorPositioning({\n anchor,\n positionMethod,\n floatingRootContext,\n mounted,\n side,\n sideOffset,\n align,\n alignOffset,\n collisionBoundary,\n collisionPadding,\n sticky,\n arrowPadding,\n disableAnchorTracking,\n keepMounted,\n collisionAvoidance,\n adaptiveOrigin\n });\n const defaultProps = React.useMemo(() => {\n const hiddenStyles = {};\n if (!open || trackCursorAxis === 'both' || disableHoverablePopup) {\n hiddenStyles.pointerEvents = 'none';\n }\n return {\n role: 'presentation',\n hidden: !mounted,\n style: {\n ...positioning.positionerStyles,\n ...hiddenStyles\n }\n };\n }, [open, trackCursorAxis, disableHoverablePopup, mounted, positioning.positionerStyles]);\n const state = React.useMemo(() => ({\n open,\n side: positioning.side,\n align: positioning.align,\n anchorHidden: positioning.anchorHidden,\n instant: trackCursorAxis !== 'none' ? 'tracking-cursor' : instantType\n }), [open, positioning.side, positioning.align, positioning.anchorHidden, trackCursorAxis, instantType]);\n const contextValue = React.useMemo(() => ({\n ...state,\n arrowRef: positioning.arrowRef,\n arrowStyles: positioning.arrowStyles,\n arrowUncentered: positioning.arrowUncentered\n }), [state, positioning.arrowRef, positioning.arrowStyles, positioning.arrowUncentered]);\n const element = useRenderElement('div', componentProps, {\n state,\n props: [defaultProps, getDisabledMountTransitionStyles(transitionStatus), elementProps],\n ref: [forwardedRef, store.useStateSetter('positionerElement')],\n stateAttributesMapping: popupStateMapping\n });\n return /*#__PURE__*/_jsx(TooltipPositionerContext.Provider, {\n value: contextValue,\n children: element\n });\n});\nif (process.env.NODE_ENV !== \"production\") TooltipPositioner.displayName = \"TooltipPositioner\";"],"names":[],"mappings":";;;;;;;;;;;;AAoBY;AACV;AAAM;AACJ;AACA;AACA;AACiB;AACV;AACC;AACK;AACC;AACM;AACD;AACJ;AACN;AACe;AACH;AAClB;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAyC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEF;AACE;AACA;AACE;AAA6B;AAE/B;AAAO;AACC;AACG;AACF;AACU;AACZ;AACX;AACA;AAEE;AAAmC;AACjC;AACkB;AACC;AACO;AACgC;AAE5D;AAA0C;AACrC;AACmB;AACG;AACI;AAE/B;AAAwD;AACtD;AACsF;AACzB;AACrC;AAE1B;AAA4D;AACnD;AACG;AAEd;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositionerContext.js ADDED Viewed

@@ -0,0 +1,17 @@
+"use client";
+import formatErrorMessage from "../../../../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
+};
+//# sourceMappingURL=TooltipPositionerContext.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositionerContext.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipPositionerContext.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/positioner/TooltipPositionerContext.js"],"sourcesContent":["'use client';\n\nimport _formatErrorMessage from \"@base-ui/utils/formatErrorMessage\";\nimport * as React from 'react';\nexport const TooltipPositionerContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== \"production\") TooltipPositionerContext.displayName = \"TooltipPositionerContext\";\nexport function useTooltipPositionerContext() {\n const context = React.useContext(TooltipPositionerContext);\n if (context === undefined) {\n throw new Error(process.env.NODE_ENV !== \"production\" ? 'Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>.' : _formatErrorMessage(71));\n }\n return context;\n}"],"names":[],"mappings":";;;AAIY;AACZ;AACO;AACL;AACA;AACE;AAAqM;AAEvM;AACF;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/provider/TooltipProvider.js ADDED Viewed

@@ -0,0 +1,33 @@
+"use client";
+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
+};
+//# sourceMappingURL=TooltipProvider.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/provider/TooltipProvider.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipProvider.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/provider/TooltipProvider.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { FloatingDelayGroup } from \"../../floating-ui-react/index.js\";\nimport { TooltipProviderContext } from \"./TooltipProviderContext.js\";\n\n/**\n * Provides a shared delay for multiple tooltips. The grouping logic ensures that\n * once a tooltip becomes visible, the adjacent tooltips will be shown instantly.\n *\n * Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const TooltipProvider = function TooltipProvider(props) {\n const {\n delay,\n closeDelay,\n timeout = 400\n } = props;\n const contextValue = React.useMemo(() => ({\n delay,\n closeDelay\n }), [delay, closeDelay]);\n const delayValue = React.useMemo(() => ({\n open: delay,\n close: closeDelay\n }), [delay, closeDelay]);\n return /*#__PURE__*/_jsx(TooltipProviderContext.Provider, {\n value: contextValue,\n children: /*#__PURE__*/_jsx(FloatingDelayGroup, {\n delay: delayValue,\n timeoutMs: timeout,\n children: props.children\n })\n });\n};\nif (process.env.NODE_ENV !== \"production\") TooltipProvider.displayName = \"TooltipProvider\";"],"names":[],"mappings":";;;;;AAaY;AACV;AAAM;AACJ;AACA;AACU;AAEZ;AAA0C;AACxC;AACA;AAEF;AAAwC;AAChC;AACC;AAET;AAA0D;AACjD;AACyC;AACvC;AACI;AACK;AACjB;AAEL;AACA;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/provider/TooltipProviderContext.js ADDED Viewed

@@ -0,0 +1,11 @@
+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
+};
+//# sourceMappingURL=TooltipProviderContext.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/provider/TooltipProviderContext.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipProviderContext.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/provider/TooltipProviderContext.js"],"sourcesContent":["import * as React from 'react';\nexport const TooltipProviderContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== \"production\") TooltipProviderContext.displayName = \"TooltipProviderContext\";\nexport function useTooltipProviderContext() {\n return React.useContext(TooltipProviderContext);\n}"],"names":[],"mappings":";AACY,MAAC,yBAAsC,sBAAM,cAAc,MAAS;AAChF,IAAI,QAAQ,IAAI,aAAa,aAAc,wBAAuB,cAAc;AACzE,SAAS,4BAA4B;AAC1C,SAAO,MAAM,WAAW,sBAAsB;AAChD;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/root/TooltipRoot.js ADDED Viewed

@@ -0,0 +1,128 @@
+"use client";
+import * as React from "react";
+import { useIsoLayoutEffect } from "../../../../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 { useImplicitActiveTrigger, useOpenStateTransitions } from "../../utils/popups/popupStoreUtils.js";
+import { useFocus } from "../../floating-ui-react/hooks/useFocus.js";
+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 { none, imperativeAction, disabled } from "../../utils/reason-parts.js";
+function TooltipRoot(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?.store, {
+    open: openProp ?? defaultOpen,
+    activeTriggerId: triggerIdProp !== void 0 ? triggerIdProp : defaultTriggerIdProp
+  });
+  store.useControlledProp("open", openProp, defaultOpen);
+  store.useControlledProp("activeTriggerId", triggerIdProp, defaultTriggerIdProp);
+  store.useContextCallback("onOpenChange", onOpenChange);
+  store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
+  const openState = store.useState("open");
+  const activeTriggerId = store.useState("activeTriggerId");
+  const payload = store.useState("payload");
+  store.useSyncedValues({
+    trackCursorAxis,
+    disableHoverablePopup
+  });
+  const open = !disabled$1 && openState;
+  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 focus = useFocus(floatingRootContext, {
+    enabled: !disabled$1
+  });
+  const dismiss = useDismiss(floatingRootContext, {
+    enabled: !disabled$1,
+    referencePress: true
+  });
+  const clientPoint = useClientPoint(floatingRootContext, {
+    enabled: !disabled$1 && trackCursorAxis !== "none",
+    axis: trackCursorAxis === "none" ? void 0 : trackCursorAxis
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getTriggerProps
+  } = useInteractions([focus, dismiss, clientPoint]);
+  const activeTriggerProps = React.useMemo(() => getReferenceProps(), [getReferenceProps]);
+  const inactiveTriggerProps = React.useMemo(() => getTriggerProps(), [getTriggerProps]);
+  const popupProps = React.useMemo(() => getFloatingProps(), [getFloatingProps]);
+  store.useSyncedValues({
+    floatingRootContext,
+    activeTriggerProps,
+    inactiveTriggerProps,
+    popupProps
+  });
+  return /* @__PURE__ */ jsx(TooltipRootContext.Provider, {
+    value: store,
+    children: typeof children === "function" ? children({
+      payload
+    }) : children
+  });
+}
+function createTooltipEventDetails(store, reason) {
+  const details = createChangeEventDetails(reason);
+  details.preventUnmountOnClose = () => {
+    store.set("preventUnmountingOnClose", true);
+  };
+  return details;
+}
+export {
+  TooltipRoot
+};
+//# sourceMappingURL=TooltipRoot.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/root/TooltipRoot.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipRoot.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/root/TooltipRoot.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { TooltipRootContext } from \"./TooltipRootContext.js\";\nimport { useClientPoint, useDismiss, useFocus, useInteractions } from \"../../floating-ui-react/index.js\";\nimport { createChangeEventDetails } from \"../../utils/createBaseUIEventDetails.js\";\nimport { useImplicitActiveTrigger, useOpenStateTransitions } from \"../../utils/popups/index.js\";\nimport { TooltipStore } from \"../store/TooltipStore.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\n\n/**\n * Groups all parts of the tooltip.\n * Doesn’t render its own HTML element.\n *\n * Documentation: [Base UI Tooltip](https://base-ui.com/react/components/tooltip)\n */\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function TooltipRoot(props) {\n const {\n disabled = false,\n defaultOpen = false,\n open: openProp,\n disableHoverablePopup = false,\n trackCursorAxis = 'none',\n actionsRef,\n onOpenChange,\n onOpenChangeComplete,\n handle,\n triggerId: triggerIdProp,\n defaultTriggerId: defaultTriggerIdProp = null,\n children\n } = props;\n const store = TooltipStore.useStore(handle?.store, {\n open: openProp ?? defaultOpen,\n activeTriggerId: triggerIdProp !== undefined ? triggerIdProp : defaultTriggerIdProp\n });\n store.useControlledProp('open', openProp, defaultOpen);\n store.useControlledProp('activeTriggerId', triggerIdProp, defaultTriggerIdProp);\n store.useContextCallback('onOpenChange', onOpenChange);\n store.useContextCallback('onOpenChangeComplete', onOpenChangeComplete);\n const openState = store.useState('open');\n const activeTriggerId = store.useState('activeTriggerId');\n const payload = store.useState('payload');\n store.useSyncedValues({\n trackCursorAxis,\n disableHoverablePopup\n });\n const open = !disabled && openState;\n useIsoLayoutEffect(() => {\n if (openState && disabled) {\n store.setOpen(false, createChangeEventDetails(REASONS.disabled));\n }\n }, [openState, disabled, store]);\n store.useSyncedValue('disabled', disabled);\n useImplicitActiveTrigger(store);\n const {\n forceUnmount,\n transitionStatus\n } = useOpenStateTransitions(open, store);\n const isInstantPhase = store.useState('isInstantPhase');\n const instantType = store.useState('instantType');\n const lastOpenChangeReason = store.useState('lastOpenChangeReason');\n\n // Animations should be instant in two cases:\n // 1) Opening during the provider's instant phase (adjacent tooltip opens instantly)\n // 2) Closing because another tooltip opened (reason === 'none')\n // Otherwise, allow the animation to play. In particular, do not disable animations\n // during the 'ending' phase unless it's due to a sibling opening.\n const previousInstantTypeRef = React.useRef(null);\n useIsoLayoutEffect(() => {\n if (transitionStatus === 'ending' && lastOpenChangeReason === REASONS.none || transitionStatus !== 'ending' && isInstantPhase) {\n // Capture the current instant type so we can restore it later\n // and set to 'delay' to disable animations while moving from one trigger to another\n // within a delay group.\n if (instantType !== 'delay') {\n previousInstantTypeRef.current = instantType;\n }\n store.set('instantType', 'delay');\n } else if (previousInstantTypeRef.current !== null) {\n store.set('instantType', previousInstantTypeRef.current);\n previousInstantTypeRef.current = null;\n }\n }, [transitionStatus, isInstantPhase, lastOpenChangeReason, instantType, store]);\n useIsoLayoutEffect(() => {\n if (open) {\n if (activeTriggerId == null) {\n store.set('payload', undefined);\n }\n }\n }, [store, activeTriggerId, open]);\n const handleImperativeClose = React.useCallback(() => {\n store.setOpen(false, createTooltipEventDetails(store, REASONS.imperativeAction));\n }, [store]);\n React.useImperativeHandle(actionsRef, () => ({\n unmount: forceUnmount,\n close: handleImperativeClose\n }), [forceUnmount, handleImperativeClose]);\n const floatingRootContext = store.useState('floatingRootContext');\n const focus = useFocus(floatingRootContext, {\n enabled: !disabled\n });\n const dismiss = useDismiss(floatingRootContext, {\n enabled: !disabled,\n referencePress: true\n });\n const clientPoint = useClientPoint(floatingRootContext, {\n enabled: !disabled && trackCursorAxis !== 'none',\n axis: trackCursorAxis === 'none' ? undefined : trackCursorAxis\n });\n const {\n getReferenceProps,\n getFloatingProps,\n getTriggerProps\n } = useInteractions([focus, dismiss, clientPoint]);\n const activeTriggerProps = React.useMemo(() => getReferenceProps(), [getReferenceProps]);\n const inactiveTriggerProps = React.useMemo(() => getTriggerProps(), [getTriggerProps]);\n const popupProps = React.useMemo(() => getFloatingProps(), [getFloatingProps]);\n store.useSyncedValues({\n floatingRootContext,\n activeTriggerProps,\n inactiveTriggerProps,\n popupProps\n });\n return /*#__PURE__*/_jsx(TooltipRootContext.Provider, {\n value: store,\n children: typeof children === 'function' ? children({\n payload\n }) : children\n });\n}\nfunction createTooltipEventDetails(store, reason) {\n const details = createChangeEventDetails(reason);\n details.preventUnmountOnClose = () => {\n store.set('preventUnmountingOnClose', true);\n };\n return details;\n}"],"names":["disabled"],"mappings":";;;;;;;;;;;;;AAkBO;AACL;AAAM;AACO;AACG;AACR;AACkB;AACN;AAClB;AACA;AACA;AACA;AACW;AAC8B;AACzC;AAEF;AAAmD;AAC/B;AAC6C;AAEjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAsB;AACpB;AACA;AAEF;AACA;AACE;AACE;AAA+D;AACjE;AAEF;AACA;AACA;AAAM;AACJ;AACA;AAEF;AACA;AACA;AAOA;AACA;AACE;AAIE;AACE;AAAiC;AAEnC;AAAgC;AAEhC;AACA;AAAiC;AACnC;AAEF;AACE;AACE;AACE;AAA8B;AAChC;AACF;AAEF;AACE;AAA+E;AAEjF;AAA6C;AAClC;AACF;AAET;AACA;AAA4C;AAChCA;AAEZ;AAAgD;AACpCA;AACM;AAElB;AAAwD;AACZ;AACK;AAEjD;AAAM;AACJ;AACA;AACA;AAEF;AACA;AACA;AACA;AAAsB;AACpB;AACA;AACA;AACA;AAEF;AAAsD;AAC7C;AAC6C;AAClD;AACG;AAET;AACA;AACE;AACA;AACE;AAA0C;AAE5C;AACF;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/root/TooltipRootContext.js ADDED Viewed

@@ -0,0 +1,17 @@
+"use client";
+import formatErrorMessage from "../../../../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
+};
+//# sourceMappingURL=TooltipRootContext.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/root/TooltipRootContext.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipRootContext.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/root/TooltipRootContext.js"],"sourcesContent":["'use client';\n\nimport _formatErrorMessage from \"@base-ui/utils/formatErrorMessage\";\nimport * as React from 'react';\nexport const TooltipRootContext = /*#__PURE__*/React.createContext(undefined);\nif (process.env.NODE_ENV !== \"production\") TooltipRootContext.displayName = \"TooltipRootContext\";\nexport function useTooltipRootContext(optional) {\n const context = React.useContext(TooltipRootContext);\n if (context === undefined && !optional) {\n throw new Error(process.env.NODE_ENV !== \"production\" ? 'Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>.' : _formatErrorMessage(72));\n }\n return context;\n}"],"names":[],"mappings":";;;AAIY;AACZ;AACO;AACL;AACA;AACE;AAA+K;AAEjL;AACF;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/store/TooltipStore.js ADDED Viewed

@@ -0,0 +1,96 @@
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { useRefWithInit } from "../../../../utils/esm/useRefWithInit.js";
+import { popupStoreSelectors, createInitialPopupStoreState } from "../../utils/popups/store.js";
+import { useSyncedFloatingRootContext } from "../../floating-ui-react/hooks/useSyncedFloatingRootContext.js";
+import { ReactStore } from "../../../../utils/esm/store/ReactStore.js";
+import { PopupTriggerMap } from "../../utils/popups/popupTriggerMap.js";
+import { createSelector } from "../../../../utils/esm/store/createSelector.js";
+import { triggerHover, triggerFocus, triggerPress, escapeKey } from "../../utils/reason-parts.js";
+const selectors = {
+  ...popupStoreSelectors,
+  disabled: createSelector((state) => state.disabled),
+  instantType: createSelector((state) => state.instantType),
+  isInstantPhase: createSelector((state) => state.isInstantPhase),
+  trackCursorAxis: createSelector((state) => state.trackCursorAxis),
+  disableHoverablePopup: createSelector((state) => state.disableHoverablePopup),
+  lastOpenChangeReason: createSelector((state) => state.openChangeReason),
+  closeDelay: createSelector((state) => state.closeDelay)
+};
+class TooltipStore extends ReactStore {
+  constructor(initialState) {
+    super({
+      ...createInitialState(),
+      ...initialState
+    }, {
+      popupRef: /* @__PURE__ */ React.createRef(),
+      onOpenChange: void 0,
+      onOpenChangeComplete: void 0,
+      triggerElements: new PopupTriggerMap()
+    }, selectors);
+  }
+  setOpen = (nextOpen, eventDetails) => {
+    const reason = eventDetails.reason;
+    const isHover = reason === triggerHover;
+    const isFocusOpen = nextOpen && reason === triggerFocus;
+    const isDismissClose = !nextOpen && (reason === triggerPress || reason === escapeKey);
+    eventDetails.preventUnmountOnClose = () => {
+      this.set("preventUnmountingOnClose", true);
+    };
+    this.context.onOpenChange?.(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    const changeState = () => {
+      const updatedState = {
+        open: nextOpen,
+        openChangeReason: reason
+      };
+      if (isFocusOpen) {
+        updatedState.instantType = "focus";
+      } else if (isDismissClose) {
+        updatedState.instantType = "dismiss";
+      } else if (reason === triggerHover) {
+        updatedState.instantType = void 0;
+      }
+      const newTriggerId = eventDetails.trigger?.id ?? null;
+      if (newTriggerId || nextOpen) {
+        updatedState.activeTriggerId = newTriggerId;
+        updatedState.activeTriggerElement = eventDetails.trigger ?? null;
+      }
+      this.update(updatedState);
+    };
+    if (isHover) {
+      ReactDOM.flushSync(changeState);
+    } else {
+      changeState();
+    }
+  };
+  static useStore(externalStore, initialState) {
+    const store = useRefWithInit(() => {
+      return externalStore ?? new TooltipStore(initialState);
+    }).current;
+    const floatingRootContext = useSyncedFloatingRootContext({
+      popupStore: store,
+      onOpenChange: store.setOpen
+    });
+    store.state.floatingRootContext = floatingRootContext;
+    return store;
+  }
+}
+function createInitialState() {
+  return {
+    ...createInitialPopupStoreState(),
+    disabled: false,
+    instantType: void 0,
+    isInstantPhase: false,
+    trackCursorAxis: "none",
+    disableHoverablePopup: false,
+    openChangeReason: null,
+    closeDelay: 0
+  };
+}
+export {
+  TooltipStore
+};
+//# sourceMappingURL=TooltipStore.js.map

package/dist/node_modules/@base-ui/react/esm/tooltip/store/TooltipStore.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"TooltipStore.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/tooltip/store/TooltipStore.js"],"sourcesContent":["import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { createSelector, ReactStore } from '@base-ui/utils/store';\nimport { useRefWithInit } from '@base-ui/utils/useRefWithInit';\nimport { useSyncedFloatingRootContext } from \"../../floating-ui-react/index.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\nimport { createInitialPopupStoreState, popupStoreSelectors, PopupTriggerMap } from \"../../utils/popups/index.js\";\nconst selectors = {\n ...popupStoreSelectors,\n disabled: createSelector(state => state.disabled),\n instantType: createSelector(state => state.instantType),\n isInstantPhase: createSelector(state => state.isInstantPhase),\n trackCursorAxis: createSelector(state => state.trackCursorAxis),\n disableHoverablePopup: createSelector(state => state.disableHoverablePopup),\n lastOpenChangeReason: createSelector(state => state.openChangeReason),\n closeDelay: createSelector(state => state.closeDelay)\n};\nexport class TooltipStore extends ReactStore {\n constructor(initialState) {\n super({\n ...createInitialState(),\n ...initialState\n }, {\n popupRef: /*#__PURE__*/React.createRef(),\n onOpenChange: undefined,\n onOpenChangeComplete: undefined,\n triggerElements: new PopupTriggerMap()\n }, selectors);\n }\n setOpen = (nextOpen, eventDetails) => {\n const reason = eventDetails.reason;\n const isHover = reason === REASONS.triggerHover;\n const isFocusOpen = nextOpen && reason === REASONS.triggerFocus;\n const isDismissClose = !nextOpen && (reason === REASONS.triggerPress || reason === REASONS.escapeKey);\n eventDetails.preventUnmountOnClose = () => {\n this.set('preventUnmountingOnClose', true);\n };\n this.context.onOpenChange?.(nextOpen, eventDetails);\n if (eventDetails.isCanceled) {\n return;\n }\n const changeState = () => {\n const updatedState = {\n open: nextOpen,\n openChangeReason: reason\n };\n if (isFocusOpen) {\n updatedState.instantType = 'focus';\n } else if (isDismissClose) {\n updatedState.instantType = 'dismiss';\n } else if (reason === REASONS.triggerHover) {\n updatedState.instantType = undefined;\n }\n\n // If a popup is closing, the `trigger` may be null.\n // We want to keep the previous value so that exit animations are played and focus is returned correctly.\n const newTriggerId = eventDetails.trigger?.id ?? null;\n if (newTriggerId || nextOpen) {\n updatedState.activeTriggerId = newTriggerId;\n updatedState.activeTriggerElement = eventDetails.trigger ?? null;\n }\n this.update(updatedState);\n };\n if (isHover) {\n // If a hover reason is provided, we need to flush the state synchronously. This ensures\n // `node.getAnimations()` knows about the new state.\n ReactDOM.flushSync(changeState);\n } else {\n changeState();\n }\n };\n static useStore(externalStore, initialState) {\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const store = useRefWithInit(() => {\n return externalStore ?? new TooltipStore(initialState);\n }).current;\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const floatingRootContext = useSyncedFloatingRootContext({\n popupStore: store,\n onOpenChange: store.setOpen\n });\n\n // It's safe to set this here because when this code runs for the first time,\n // nothing has had a chance to subscribe to the `store` yet.\n // For subsequent renders, the `floatingRootContext` reference remains the same,\n // so it's basically a no-op.\n store.state.floatingRootContext = floatingRootContext;\n return store;\n }\n}\nfunction createInitialState() {\n return {\n ...createInitialPopupStoreState(),\n disabled: false,\n instantType: undefined,\n isInstantPhase: false,\n trackCursorAxis: 'none',\n disableHoverablePopup: false,\n openChangeReason: null,\n closeDelay: 0\n };\n}"],"names":["REASONS.triggerHover","REASONS.triggerFocus","REASONS.triggerPress","REASONS.escapeKey"],"mappings":";;;;;;;;;AAOA,MAAM,YAAY;AAAA,EAChB,GAAG;AAAA,EACH,UAAU,eAAe,WAAS,MAAM,QAAQ;AAAA,EAChD,aAAa,eAAe,WAAS,MAAM,WAAW;AAAA,EACtD,gBAAgB,eAAe,WAAS,MAAM,cAAc;AAAA,EAC5D,iBAAiB,eAAe,WAAS,MAAM,eAAe;AAAA,EAC9D,uBAAuB,eAAe,WAAS,MAAM,qBAAqB;AAAA,EAC1E,sBAAsB,eAAe,WAAS,MAAM,gBAAgB;AAAA,EACpE,YAAY,eAAe,WAAS,MAAM,UAAU;AACtD;AACO,MAAM,qBAAqB,WAAW;AAAA,EAC3C,YAAY,cAAc;AACxB,UAAM;AAAA,MACJ,GAAG,mBAAkB;AAAA,MACrB,GAAG;AAAA,IACT,GAAO;AAAA,MACD,UAAuB,sBAAM,UAAS;AAAA,MACtC,cAAc;AAAA,MACd,sBAAsB;AAAA,MACtB,iBAAiB,IAAI,gBAAe;AAAA,IAC1C,GAAO,SAAS;AAAA,EACd;AAAA,EACA,UAAU,CAAC,UAAU,iBAAiB;AACpC,UAAM,SAAS,aAAa;AAC5B,UAAM,UAAU,WAAWA;AAC3B,UAAM,cAAc,YAAY,WAAWC;AAC3C,UAAM,iBAAiB,CAAC,aAAa,WAAWC,gBAAwB,WAAWC;AACnF,iBAAa,wBAAwB,MAAM;AACzC,WAAK,IAAI,4BAA4B,IAAI;AAAA,IAC3C;AACA,SAAK,QAAQ,eAAe,UAAU,YAAY;AAClD,QAAI,aAAa,YAAY;AAC3B;AAAA,IACF;AACA,UAAM,cAAc,MAAM;AACxB,YAAM,eAAe;AAAA,QACnB,MAAM;AAAA,QACN,kBAAkB;AAAA,MAC1B;AACM,UAAI,aAAa;AACf,qBAAa,cAAc;AAAA,MAC7B,WAAW,gBAAgB;AACzB,qBAAa,cAAc;AAAA,MAC7B,WAAW,WAAWH,cAAsB;AAC1C,qBAAa,cAAc;AAAA,MAC7B;AAIA,YAAM,eAAe,aAAa,SAAS,MAAM;AACjD,UAAI,gBAAgB,UAAU;AAC5B,qBAAa,kBAAkB;AAC/B,qBAAa,uBAAuB,aAAa,WAAW;AAAA,MAC9D;AACA,WAAK,OAAO,YAAY;AAAA,IAC1B;AACA,QAAI,SAAS;AAGX,eAAS,UAAU,WAAW;AAAA,IAChC,OAAO;AACL,kBAAW;AAAA,IACb;AAAA,EACF;AAAA,EACA,OAAO,SAAS,eAAe,cAAc;AAE3C,UAAM,QAAQ,eAAe,MAAM;AACjC,aAAO,iBAAiB,IAAI,aAAa,YAAY;AAAA,IACvD,CAAC,EAAE;AAGH,UAAM,sBAAsB,6BAA6B;AAAA,MACvD,YAAY;AAAA,MACZ,cAAc,MAAM;AAAA,IAC1B,CAAK;AAMD,UAAM,MAAM,sBAAsB;AAClC,WAAO;AAAA,EACT;AACF;AACA,SAAS,qBAAqB;AAC5B,SAAO;AAAA,IACL,GAAG,6BAA4B;AAAA,IAC/B,UAAU;AAAA,IACV,aAAa;AAAA,IACb,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,IACjB,uBAAuB;AAAA,IACvB,kBAAkB;AAAA,IAClB,YAAY;AAAA,EAChB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/tooltip/trigger/TooltipTrigger.js ADDED Viewed

@@ -0,0 +1,107 @@
+"use client";
+import formatErrorMessage from "../../../../utils/esm/formatErrorMessage.js";
+import * as React from "react";
+import { useTooltipRootContext } from "../root/TooltipRootContext.js";
+import { triggerOpenStateMapping } from "../../utils/popupStateMapping.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useTooltipProviderContext } from "../provider/TooltipProviderContext.js";
+import { OPEN_DELAY } from "../utils/constants.js";
+import { useTriggerDataForwarding } from "../../utils/popups/popupStoreUtils.js";
+import { useDelayGroup } from "../../floating-ui-react/components/FloatingDelayGroup.js";
+import { useHoverReferenceInteraction } from "../../floating-ui-react/hooks/useHoverReferenceInteraction.js";
+import { safePolygon } from "../../floating-ui-react/safePolygon.js";
+const TooltipTrigger = /* @__PURE__ */ React.forwardRef(function TooltipTrigger2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    handle,
+    payload,
+    disabled: disabledProp,
+    delay,
+    closeDelay,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const rootContext = useTooltipRootContext(true);
+  const store = handle?.store ?? rootContext;
+  if (!store) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle." : formatErrorMessage(82));
+  }
+  const thisTriggerId = useBaseUiId(idProp);
+  const isTriggerActive = store.useState("isTriggerActive", thisTriggerId);
+  const floatingRootContext = store.useState("floatingRootContext");
+  const isOpenedByThisTrigger = store.useState("isOpenedByTrigger", thisTriggerId);
+  const triggerElementRef = React.useRef(null);
+  const delayWithDefault = delay ?? OPEN_DELAY;
+  const closeDelayWithDefault = closeDelay ?? 0;
+  const {
+    registerTrigger,
+    isMountedByThisTrigger
+  } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+    payload,
+    closeDelay: closeDelayWithDefault
+  });
+  const providerContext = useTooltipProviderContext();
+  const {
+    delayRef,
+    isInstantPhase,
+    hasProvider
+  } = useDelayGroup(floatingRootContext, {
+    open: isOpenedByThisTrigger
+  });
+  store.useSyncedValue("isInstantPhase", isInstantPhase);
+  const rootDisabled = store.useState("disabled");
+  const disabled = disabledProp ?? rootDisabled;
+  const trackCursorAxis = store.useState("trackCursorAxis");
+  const disableHoverablePopup = store.useState("disableHoverablePopup");
+  const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
+    enabled: !disabled,
+    mouseOnly: true,
+    move: false,
+    handleClose: !disableHoverablePopup && trackCursorAxis !== "both" ? safePolygon() : null,
+    restMs() {
+      const providerDelay = providerContext?.delay;
+      const groupOpenValue = typeof delayRef.current === "object" ? delayRef.current.open : void 0;
+      let computedRestMs = delayWithDefault;
+      if (hasProvider) {
+        if (groupOpenValue !== 0) {
+          computedRestMs = delay ?? providerDelay ?? delayWithDefault;
+        } else {
+          computedRestMs = 0;
+        }
+      }
+      return computedRestMs;
+    },
+    delay() {
+      const closeValue = typeof delayRef.current === "object" ? delayRef.current.close : void 0;
+      let computedCloseDelay = closeDelayWithDefault;
+      if (closeDelay == null && hasProvider) {
+        computedCloseDelay = closeValue;
+      }
+      return {
+        close: computedCloseDelay
+      };
+    },
+    triggerElementRef,
+    isActiveTrigger: isTriggerActive
+  });
+  const state = React.useMemo(() => ({
+    open: isOpenedByThisTrigger
+  }), [isOpenedByThisTrigger]);
+  const rootTriggerProps = store.useState("triggerProps", isMountedByThisTrigger);
+  const element = useRenderElement("button", componentProps, {
+    state,
+    ref: [forwardedRef, registerTrigger, triggerElementRef],
+    props: [hoverProps, rootTriggerProps, {
+      id: thisTriggerId
+    }, elementProps],
+    stateAttributesMapping: triggerOpenStateMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") TooltipTrigger.displayName = "TooltipTrigger";
+export {
+  TooltipTrigger
+};
+//# sourceMappingURL=TooltipTrigger.js.map