@burtson-labs/ui 0.13.1 → 0.14.1

package/dist/primitives/vendor/radix/react-popper/popper.js

@@ -0,0 +1,276 @@
+"use client";
+import { createContextScope } from "../react-context/create-context.js";
+import { useComposedRefs } from "../react-compose-refs/compose-refs.js";
+import { useLayoutEffect } from "../react-use-layout-effect/use-layout-effect.js";
+import { Primitive } from "../react-primitive/primitive.js";
+import { useCallbackRef } from "../react-use-callback-ref/use-callback-ref.js";
+import { Root as Root$1 } from "../react-arrow/arrow.js";
+import { useSize } from "../react-use-size/use-size.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+import { arrow, autoUpdate, flip, hide, limitShift, offset, shift, size, useFloating } from "@floating-ui/react-dom";
+//#region src/primitives/vendor/radix/react-popper/popper.tsx
+var POPPER_NAME = "Popper";
+var [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME);
+var [PopperProvider, usePopperContext] = createPopperContext(POPPER_NAME);
+var Popper = (props) => {
+	const { __scopePopper, children } = props;
+	const [anchor, setAnchor] = React.useState(null);
+	const [placementState, setPlacementState] = React.useState(void 0);
+	return /* @__PURE__ */ jsx(PopperProvider, {
+		scope: __scopePopper,
+		anchor,
+		onAnchorChange: setAnchor,
+		placementState,
+		setPlacementState,
+		children
+	});
+};
+var ANCHOR_NAME = "PopperAnchor";
+var PopperAnchor = /* @__PURE__ */ React.forwardRef(function PopperAnchor(props, forwardedRef) {
+	const { __scopePopper, virtualRef, ...anchorProps } = props;
+	const context = usePopperContext(ANCHOR_NAME, __scopePopper);
+	const ref = React.useRef(null);
+	const onAnchorChange = context.onAnchorChange;
+	const callbackRef = React.useCallback((node) => {
+		ref.current = node;
+		if (node) onAnchorChange(node);
+	}, [onAnchorChange]);
+	const composedRefs = useComposedRefs(forwardedRef, callbackRef);
+	const anchorRef = React.useRef(null);
+	React.useEffect(() => {
+		if (!virtualRef) return;
+		const previousAnchor = anchorRef.current;
+		anchorRef.current = virtualRef.current;
+		if (previousAnchor !== anchorRef.current) onAnchorChange(anchorRef.current);
+	});
+	const sideAndAlign = context.placementState && getSideAndAlignFromPlacement(context.placementState);
+	const placedSide = sideAndAlign?.[0];
+	const placedAlign = sideAndAlign?.[1];
+	return virtualRef ? null : /* @__PURE__ */ jsx(Primitive.div, {
+		"data-radix-popper-side": placedSide,
+		"data-radix-popper-align": placedAlign,
+		...anchorProps,
+		ref: composedRefs
+	});
+});
+var CONTENT_NAME = "PopperContent";
+var [PopperContentProvider, useContentContext] = createPopperContext(CONTENT_NAME);
+var PopperContent = /* @__PURE__ */ React.forwardRef(function PopperContent(props, forwardedRef) {
+	const { __scopePopper, side = "bottom", sideOffset = 0, align = "center", alignOffset = 0, arrowPadding = 0, avoidCollisions = true, collisionBoundary = [], collisionPadding: collisionPaddingProp = 0, sticky = "partial", hideWhenDetached = false, updatePositionStrategy = "optimized", onPlaced, ...contentProps } = props;
+	const context = usePopperContext(CONTENT_NAME, __scopePopper);
+	const [content, setContent] = React.useState(null);
+	const composedRefs = useComposedRefs(forwardedRef, setContent);
+	const [arrow$1, setArrow] = React.useState(null);
+	const arrowSize = useSize(arrow$1);
+	const arrowWidth = arrowSize?.width ?? 0;
+	const arrowHeight = arrowSize?.height ?? 0;
+	const desiredPlacement = side + (align !== "center" ? "-" + align : "");
+	const collisionPadding = typeof collisionPaddingProp === "number" ? collisionPaddingProp : {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0,
+		...collisionPaddingProp
+	};
+	const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [collisionBoundary];
+	const hasExplicitBoundaries = boundary.length > 0;
+	const detectOverflowOptions = {
+		padding: collisionPadding,
+		boundary: boundary.filter(isNotNull),
+		altBoundary: hasExplicitBoundaries
+	};
+	const { refs, floatingStyles, placement, isPositioned, middlewareData } = useFloating({
+		strategy: "fixed",
+		placement: desiredPlacement,
+		whileElementsMounted: (...args) => {
+			return autoUpdate(...args, { animationFrame: updatePositionStrategy === "always" });
+		},
+		elements: { reference: context.anchor },
+		middleware: [
+			offset({
+				mainAxis: sideOffset + arrowHeight,
+				alignmentAxis: alignOffset
+			}),
+			avoidCollisions && shift({
+				mainAxis: true,
+				crossAxis: false,
+				limiter: sticky === "partial" ? limitShift() : void 0,
+				...detectOverflowOptions
+			}),
+			avoidCollisions && flip({ ...detectOverflowOptions }),
+			size({
+				...detectOverflowOptions,
+				apply: ({ elements, rects, availableWidth, availableHeight }) => {
+					const { width: anchorWidth, height: anchorHeight } = rects.reference;
+					const contentStyle = elements.floating.style;
+					contentStyle.setProperty("--radix-popper-available-width", `${availableWidth}px`);
+					contentStyle.setProperty("--radix-popper-available-height", `${availableHeight}px`);
+					contentStyle.setProperty("--radix-popper-anchor-width", `${anchorWidth}px`);
+					contentStyle.setProperty("--radix-popper-anchor-height", `${anchorHeight}px`);
+				}
+			}),
+			arrow$1 && arrow({
+				element: arrow$1,
+				padding: arrowPadding
+			}),
+			transformOrigin({
+				arrowWidth,
+				arrowHeight
+			}),
+			hideWhenDetached && hide({
+				strategy: "referenceHidden",
+				...detectOverflowOptions,
+				boundary: hasExplicitBoundaries ? detectOverflowOptions.boundary : void 0
+			})
+		]
+	});
+	const setPlacementState = context.setPlacementState;
+	useLayoutEffect(() => {
+		setPlacementState(placement);
+		return () => {
+			setPlacementState(void 0);
+		};
+	}, [placement, setPlacementState]);
+	const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
+	const handlePlaced = useCallbackRef(onPlaced);
+	useLayoutEffect(() => {
+		if (isPositioned) handlePlaced?.();
+	}, [isPositioned, handlePlaced]);
+	const arrowX = middlewareData.arrow?.x;
+	const arrowY = middlewareData.arrow?.y;
+	const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;
+	const [contentZIndex, setContentZIndex] = React.useState();
+	useLayoutEffect(() => {
+		if (content) setContentZIndex(window.getComputedStyle(content).zIndex);
+	}, [content]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: refs.setFloating,
+		"data-radix-popper-content-wrapper": "",
+		style: {
+			...floatingStyles,
+			transform: isPositioned ? floatingStyles.transform : "translate(0, -200%)",
+			minWidth: "max-content",
+			zIndex: contentZIndex,
+			"--radix-popper-transform-origin": [middlewareData.transformOrigin?.x, middlewareData.transformOrigin?.y].join(" "),
+			...middlewareData.hide?.referenceHidden && {
+				visibility: "hidden",
+				pointerEvents: "none"
+			}
+		},
+		dir: props.dir,
+		children: /* @__PURE__ */ jsx(PopperContentProvider, {
+			scope: __scopePopper,
+			placedSide,
+			placedAlign,
+			onArrowChange: setArrow,
+			arrowX,
+			arrowY,
+			shouldHideArrow: cannotCenterArrow,
+			children: /* @__PURE__ */ jsx(Primitive.div, {
+				"data-side": placedSide,
+				"data-align": placedAlign,
+				...contentProps,
+				ref: composedRefs,
+				style: {
+					...contentProps.style,
+					animation: !isPositioned ? "none" : contentProps.style?.animation
+				}
+			})
+		})
+	});
+});
+var ARROW_NAME = "PopperArrow";
+var OPPOSITE_SIDE = {
+	top: "bottom",
+	right: "left",
+	bottom: "top",
+	left: "right"
+};
+var PopperArrow = /* @__PURE__ */ React.forwardRef(function PopperArrow(props, forwardedRef) {
+	const { __scopePopper, ...arrowProps } = props;
+	const contentContext = useContentContext(ARROW_NAME, __scopePopper);
+	const baseSide = OPPOSITE_SIDE[contentContext.placedSide];
+	return /* @__PURE__ */ jsx("span", {
+		ref: contentContext.onArrowChange,
+		style: {
+			position: "absolute",
+			left: contentContext.arrowX,
+			top: contentContext.arrowY,
+			[baseSide]: 0,
+			transformOrigin: {
+				top: "",
+				right: "0 0",
+				bottom: "center 0",
+				left: "100% 0"
+			}[contentContext.placedSide],
+			transform: {
+				top: "translateY(100%)",
+				right: "translateY(50%) rotate(90deg) translateX(-50%)",
+				bottom: `rotate(180deg)`,
+				left: "translateY(50%) rotate(-90deg) translateX(50%)"
+			}[contentContext.placedSide],
+			visibility: contentContext.shouldHideArrow ? "hidden" : void 0
+		},
+		children: /* @__PURE__ */ jsx(Root$1, {
+			...arrowProps,
+			ref: forwardedRef,
+			style: {
+				...arrowProps.style,
+				display: "block"
+			}
+		})
+	});
+});
+function isNotNull(value) {
+	return value !== null;
+}
+var transformOrigin = (options) => ({
+	name: "transformOrigin",
+	options,
+	fn(data) {
+		const { placement, rects, middlewareData } = data;
+		const isArrowHidden = middlewareData.arrow?.centerOffset !== 0;
+		const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;
+		const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;
+		const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);
+		const noArrowAlign = {
+			start: "0%",
+			center: "50%",
+			end: "100%"
+		}[placedAlign];
+		const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;
+		const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2;
+		let x = "";
+		let y = "";
+		if (placedSide === "bottom") {
+			x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
+			y = `${-arrowHeight}px`;
+		} else if (placedSide === "top") {
+			x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
+			y = `${rects.floating.height + arrowHeight}px`;
+		} else if (placedSide === "right") {
+			x = `${-arrowHeight}px`;
+			y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
+		} else if (placedSide === "left") {
+			x = `${rects.floating.width + arrowHeight}px`;
+			y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
+		}
+		return { data: {
+			x,
+			y
+		} };
+	}
+});
+function getSideAndAlignFromPlacement(placement) {
+	const [side, align = "center"] = placement.split("-");
+	return [side, align];
+}
+var Root = Popper;
+var Anchor = PopperAnchor;
+var Content = PopperContent;
+var Arrow = PopperArrow;
+//#endregion
+export { Anchor, Arrow, Content, Popper, PopperAnchor, PopperArrow, PopperContent, Root, createPopperScope };
+
+//# sourceMappingURL=popper.js.map

package/dist/primitives/vendor/radix/react-popper/popper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"popper.js","names":["arrow","floatingUIarrow","ArrowPrimitive.Root"],"sources":["../../../../../src/primitives/vendor/radix/react-popper/popper.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport {\n  useFloating,\n  autoUpdate,\n  offset,\n  shift,\n  limitShift,\n  hide,\n  arrow as floatingUIarrow,\n  flip,\n  size,\n} from '@floating-ui/react-dom';\nimport * as ArrowPrimitive from '../react-arrow';\nimport { useComposedRefs } from '../react-compose-refs';\nimport { createContextScope } from '../react-context';\nimport { Primitive } from '../react-primitive';\nimport { useCallbackRef } from '../react-use-callback-ref';\nimport { useLayoutEffect } from '../react-use-layout-effect';\nimport { useSize } from '../react-use-size';\n\nimport type { Placement, Middleware } from '@floating-ui/react-dom';\nimport type { Scope } from '../react-context';\nimport type { Measurable } from '../rect';\n\nconst SIDE_OPTIONS = ['top', 'right', 'bottom', 'left'] as const;\nconst ALIGN_OPTIONS = ['start', 'center', 'end'] as const;\n\ntype Side = (typeof SIDE_OPTIONS)[number];\ntype Align = (typeof ALIGN_OPTIONS)[number];\n\n/* -------------------------------------------------------------------------------------------------\n * Popper\n * -----------------------------------------------------------------------------------------------*/\n\nconst POPPER_NAME = 'Popper';\n\ntype ScopedProps<P> = P & { __scopePopper?: Scope };\nconst [createPopperContext, createPopperScope] = createContextScope(POPPER_NAME);\n\ntype PopperContextValue = {\n  anchor: Measurable | null;\n  onAnchorChange(anchor: Measurable | null): void;\n  placementState: Placement | undefined;\n  setPlacementState: React.Dispatch<React.SetStateAction<Placement | undefined>>;\n};\nconst [PopperProvider, usePopperContext] = createPopperContext<PopperContextValue>(POPPER_NAME);\n\ninterface PopperProps {\n  children?: React.ReactNode;\n}\nconst Popper: React.FC<PopperProps> = (props: ScopedProps<PopperProps>) => {\n  const { __scopePopper, children } = props;\n  const [anchor, setAnchor] = React.useState<Measurable | null>(null);\n  const [placementState, setPlacementState] = React.useState<Placement | undefined>(undefined);\n  return (\n    <PopperProvider\n      scope={__scopePopper}\n      anchor={anchor}\n      onAnchorChange={setAnchor}\n      placementState={placementState}\n      setPlacementState={setPlacementState}\n    >\n      {children}\n    </PopperProvider>\n  );\n};\n\n/* -------------------------------------------------------------------------------------------------\n * PopperAnchor\n * -----------------------------------------------------------------------------------------------*/\n\nconst ANCHOR_NAME = 'PopperAnchor';\n\ntype PopperAnchorElement = React.ComponentRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface PopperAnchorProps extends PrimitiveDivProps {\n  virtualRef?: React.RefObject<Measurable | null>;\n}\n\nconst PopperAnchor = /* @__PURE__ */ React.forwardRef<PopperAnchorElement, PopperAnchorProps>(\n  function PopperAnchor(props: ScopedProps<PopperAnchorProps>, forwardedRef) {\n    const { __scopePopper, virtualRef, ...anchorProps } = props;\n    const context = usePopperContext(ANCHOR_NAME, __scopePopper);\n    const ref = React.useRef<PopperAnchorElement>(null);\n    const onAnchorChange = context.onAnchorChange;\n\n    // For DOM anchors, set the anchor from a callback ref rather than an\n    // effect. React invokes callback refs during the commit phase which does\n    // not count toward the nested update depth limit, so mounting many\n    // Popper-based components at once doesn't trigger \"Maximum update depth\n    // exceeded\"\n    // see https://github.com/radix-ui/primitives/issues/3858\n    const callbackRef = React.useCallback(\n      (node: PopperAnchorElement | null) => {\n        ref.current = node;\n        if (node) {\n          onAnchorChange(node);\n        }\n      },\n      [onAnchorChange],\n    );\n    const composedRefs = useComposedRefs(forwardedRef, callbackRef);\n\n    const anchorRef = React.useRef<Measurable | null>(null);\n    React.useEffect(() => {\n      if (!virtualRef) {\n        return;\n      }\n\n      const previousAnchor = anchorRef.current;\n      anchorRef.current = virtualRef.current;\n      if (previousAnchor !== anchorRef.current) {\n        onAnchorChange(anchorRef.current);\n      }\n    });\n\n    const sideAndAlign =\n      context.placementState && getSideAndAlignFromPlacement(context.placementState);\n    const placedSide = sideAndAlign?.[0];\n    const placedAlign = sideAndAlign?.[1];\n\n    return virtualRef ? null : (\n      <Primitive.div\n        data-radix-popper-side={placedSide}\n        data-radix-popper-align={placedAlign}\n        {...anchorProps}\n        ref={composedRefs}\n      />\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * PopperContent\n * -----------------------------------------------------------------------------------------------*/\n\nconst CONTENT_NAME = 'PopperContent';\n\ntype PopperContentContextValue = {\n  placedSide: Side;\n  placedAlign: Align;\n  onArrowChange(arrow: HTMLSpanElement | null): void;\n  arrowX?: number;\n  arrowY?: number;\n  shouldHideArrow: boolean;\n};\n\nconst [PopperContentProvider, useContentContext] =\n  createPopperContext<PopperContentContextValue>(CONTENT_NAME);\n\ntype Boundary = Element | null;\n\ntype PopperContentElement = React.ComponentRef<typeof Primitive.div>;\ninterface PopperContentProps extends PrimitiveDivProps {\n  side?: Side;\n  sideOffset?: number;\n  align?: Align;\n  alignOffset?: number;\n  arrowPadding?: number;\n  avoidCollisions?: boolean;\n  collisionBoundary?: Boundary | Boundary[];\n  collisionPadding?: number | Partial<Record<Side, number>>;\n  sticky?: 'partial' | 'always';\n  hideWhenDetached?: boolean;\n  updatePositionStrategy?: 'optimized' | 'always';\n  onPlaced?: () => void;\n}\n\nconst PopperContent = /* @__PURE__ */ React.forwardRef<PopperContentElement, PopperContentProps>(\n  function PopperContent(props: ScopedProps<PopperContentProps>, forwardedRef) {\n    const {\n      __scopePopper,\n      side = 'bottom',\n      sideOffset = 0,\n      align = 'center',\n      alignOffset = 0,\n      arrowPadding = 0,\n      avoidCollisions = true,\n      collisionBoundary = [],\n      collisionPadding: collisionPaddingProp = 0,\n      sticky = 'partial',\n      hideWhenDetached = false,\n      updatePositionStrategy = 'optimized',\n      onPlaced,\n      ...contentProps\n    } = props;\n\n    const context = usePopperContext(CONTENT_NAME, __scopePopper);\n\n    const [content, setContent] = React.useState<HTMLDivElement | null>(null);\n    const composedRefs = useComposedRefs(forwardedRef, setContent);\n\n    const [arrow, setArrow] = React.useState<HTMLSpanElement | null>(null);\n    const arrowSize = useSize(arrow);\n    const arrowWidth = arrowSize?.width ?? 0;\n    const arrowHeight = arrowSize?.height ?? 0;\n\n    const desiredPlacement = (side + (align !== 'center' ? '-' + align : '')) as Placement;\n\n    const collisionPadding =\n      typeof collisionPaddingProp === 'number'\n        ? collisionPaddingProp\n        : { top: 0, right: 0, bottom: 0, left: 0, ...collisionPaddingProp };\n\n    const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [collisionBoundary];\n    const hasExplicitBoundaries = boundary.length > 0;\n\n    const detectOverflowOptions = {\n      padding: collisionPadding,\n      boundary: boundary.filter(isNotNull),\n      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries\n      altBoundary: hasExplicitBoundaries,\n    };\n\n    const { refs, floatingStyles, placement, isPositioned, middlewareData } = useFloating({\n      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues\n      strategy: 'fixed',\n      placement: desiredPlacement,\n      whileElementsMounted: (...args) => {\n        const cleanup = autoUpdate(...args, {\n          animationFrame: updatePositionStrategy === 'always',\n        });\n        return cleanup;\n      },\n      elements: {\n        reference: context.anchor,\n      },\n      middleware: [\n        offset({ mainAxis: sideOffset + arrowHeight, alignmentAxis: alignOffset }),\n        avoidCollisions &&\n          shift({\n            mainAxis: true,\n            crossAxis: false,\n            limiter: sticky === 'partial' ? limitShift() : undefined,\n            ...detectOverflowOptions,\n          }),\n        avoidCollisions && flip({ ...detectOverflowOptions }),\n        size({\n          ...detectOverflowOptions,\n          apply: ({ elements, rects, availableWidth, availableHeight }) => {\n            const { width: anchorWidth, height: anchorHeight } = rects.reference;\n            const contentStyle = elements.floating.style;\n            contentStyle.setProperty('--radix-popper-available-width', `${availableWidth}px`);\n            contentStyle.setProperty('--radix-popper-available-height', `${availableHeight}px`);\n            contentStyle.setProperty('--radix-popper-anchor-width', `${anchorWidth}px`);\n            contentStyle.setProperty('--radix-popper-anchor-height', `${anchorHeight}px`);\n          },\n        }),\n        arrow && floatingUIarrow({ element: arrow, padding: arrowPadding }),\n        transformOrigin({ arrowWidth, arrowHeight }),\n        hideWhenDetached &&\n          hide({\n            strategy: 'referenceHidden',\n            ...detectOverflowOptions,\n            // `hide` detects whether the anchor (reference) is clipped, so when\n            // no explicit `collisionBoundary` is set we fall back to Floating\n            // UI's default clipping ancestors (e.g. a scrollable menu). This\n            // lets an occluded submenu hide once its anchor scrolls out of view\n            // (#3237). The collision/size middlewares deliberately keep the\n            // viewport-based default to avoid clamping content rendered inside\n            // transformed or overflow-clipping portal containers.\n            boundary: hasExplicitBoundaries ? detectOverflowOptions.boundary : undefined,\n          }),\n      ],\n    });\n\n    const setPlacementState = context.setPlacementState;\n    useLayoutEffect(() => {\n      setPlacementState(placement);\n      return () => {\n        setPlacementState(undefined);\n      };\n    }, [placement, setPlacementState]);\n\n    const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);\n\n    const handlePlaced = useCallbackRef(onPlaced);\n    useLayoutEffect(() => {\n      if (isPositioned) {\n        handlePlaced?.();\n      }\n    }, [isPositioned, handlePlaced]);\n\n    const arrowX = middlewareData.arrow?.x;\n    const arrowY = middlewareData.arrow?.y;\n    const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;\n\n    const [contentZIndex, setContentZIndex] = React.useState<string>();\n    useLayoutEffect(() => {\n      if (content) setContentZIndex(window.getComputedStyle(content).zIndex);\n    }, [content]);\n\n    return (\n      <div\n        ref={refs.setFloating}\n        data-radix-popper-content-wrapper=\"\"\n        style={{\n          ...floatingStyles,\n          transform: isPositioned ? floatingStyles.transform : 'translate(0, -200%)', // keep off the page when measuring\n          minWidth: 'max-content',\n          zIndex: contentZIndex,\n          '--radix-popper-transform-origin': [\n            middlewareData.transformOrigin?.x,\n            middlewareData.transformOrigin?.y,\n          ].join(' '),\n\n          // hide the content if using the hide middleware and should be hidden\n          // set visibility to hidden and disable pointer events so the UI behaves\n          // as if the PopperContent isn't there at all\n          ...(middlewareData.hide?.referenceHidden && {\n            visibility: 'hidden',\n            pointerEvents: 'none',\n          }),\n        }}\n        // Floating UI interally calculates logical alignment based the `dir` attribute on\n        // the reference/floating node, we must add this attribute here to ensure\n        // this is calculated when portalled as well as inline.\n        dir={props.dir}\n      >\n        <PopperContentProvider\n          scope={__scopePopper}\n          placedSide={placedSide}\n          placedAlign={placedAlign}\n          onArrowChange={setArrow}\n          arrowX={arrowX}\n          arrowY={arrowY}\n          shouldHideArrow={cannotCenterArrow}\n        >\n          <Primitive.div\n            data-side={placedSide}\n            data-align={placedAlign}\n            {...contentProps}\n            ref={composedRefs}\n            style={{\n              ...contentProps.style,\n              // if the PopperContent hasn't been placed yet (not all\n              // measurements done) we prevent animations so that users'\n              // animations don't kick in too early from the wrong sides.\n              animation: !isPositioned ? 'none' : contentProps.style?.animation,\n            }}\n          />\n        </PopperContentProvider>\n      </div>\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * PopperArrow\n * -----------------------------------------------------------------------------------------------*/\n\nconst ARROW_NAME = 'PopperArrow';\n\nconst OPPOSITE_SIDE: Record<Side, Side> = {\n  top: 'bottom',\n  right: 'left',\n  bottom: 'top',\n  left: 'right',\n};\n\ntype PopperArrowElement = React.ComponentRef<typeof ArrowPrimitive.Root>;\ntype ArrowProps = React.ComponentPropsWithoutRef<typeof ArrowPrimitive.Root>;\ninterface PopperArrowProps extends ArrowProps {}\n\nconst PopperArrow = /* @__PURE__ */ React.forwardRef<PopperArrowElement, PopperArrowProps>(\n  function PopperArrow(props: ScopedProps<PopperArrowProps>, forwardedRef) {\n    const { __scopePopper, ...arrowProps } = props;\n    const contentContext = useContentContext(ARROW_NAME, __scopePopper);\n    const baseSide = OPPOSITE_SIDE[contentContext.placedSide];\n\n    return (\n      // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)\n      // doesn't report size as we'd expect on SVG elements.\n      // it reports their bounding box which is effectively the largest path inside the SVG.\n      <span\n        ref={contentContext.onArrowChange}\n        style={{\n          position: 'absolute',\n          left: contentContext.arrowX,\n          top: contentContext.arrowY,\n          [baseSide]: 0,\n          transformOrigin: {\n            top: '',\n            right: '0 0',\n            bottom: 'center 0',\n            left: '100% 0',\n          }[contentContext.placedSide],\n          transform: {\n            top: 'translateY(100%)',\n            right: 'translateY(50%) rotate(90deg) translateX(-50%)',\n            bottom: `rotate(180deg)`,\n            left: 'translateY(50%) rotate(-90deg) translateX(50%)',\n          }[contentContext.placedSide],\n          visibility: contentContext.shouldHideArrow ? 'hidden' : undefined,\n        }}\n      >\n        <ArrowPrimitive.Root\n          {...arrowProps}\n          ref={forwardedRef}\n          style={{\n            ...arrowProps.style,\n            // ensures the element can be measured correctly (mostly for if SVG)\n            display: 'block',\n          }}\n        />\n      </span>\n    );\n  },\n);\n\n/* -----------------------------------------------------------------------------------------------*/\n\nfunction isNotNull<T>(value: T | null): value is T {\n  return value !== null;\n}\n\nconst transformOrigin = (options: { arrowWidth: number; arrowHeight: number }): Middleware => ({\n  name: 'transformOrigin',\n  options,\n  fn(data) {\n    const { placement, rects, middlewareData } = data;\n\n    const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0;\n    const isArrowHidden = cannotCenterArrow;\n    const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;\n    const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;\n\n    const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement);\n    const noArrowAlign = { start: '0%', center: '50%', end: '100%' }[placedAlign];\n\n    const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2;\n    const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2;\n\n    let x = '';\n    let y = '';\n\n    if (placedSide === 'bottom') {\n      x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n      y = `${-arrowHeight}px`;\n    } else if (placedSide === 'top') {\n      x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;\n      y = `${rects.floating.height + arrowHeight}px`;\n    } else if (placedSide === 'right') {\n      x = `${-arrowHeight}px`;\n      y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n    } else if (placedSide === 'left') {\n      x = `${rects.floating.width + arrowHeight}px`;\n      y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;\n    }\n    return { data: { x, y } };\n  },\n});\n\nfunction getSideAndAlignFromPlacement(placement: Placement) {\n  const [side, align = 'center'] = placement.split('-');\n  return [side as Side, align as Align] as const;\n}\n\nconst Root = Popper;\nconst Anchor = PopperAnchor;\nconst Content = PopperContent;\nconst Arrow = PopperArrow;\n\nexport {\n  createPopperScope,\n  //\n  Popper,\n  PopperAnchor,\n  PopperContent,\n  PopperArrow,\n  //\n  Root,\n  Anchor,\n  Content,\n  Arrow,\n  //\n  SIDE_OPTIONS,\n  ALIGN_OPTIONS,\n};\nexport type { PopperProps, PopperAnchorProps, PopperContentProps, PopperArrowProps };\n"],"mappings":"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"}

package/dist/primitives/vendor/radix/react-portal/index.d.ts

@@ -0,0 +1,2 @@
+export { Portal, Root, } from './portal';
+export type { PortalProps } from './portal';

package/dist/primitives/vendor/radix/react-portal/portal.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { Primitive } from '../react-primitive';
+type PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface PortalProps extends PrimitiveDivProps {
+    /**
+     * An optional container where the portaled content should be appended.
+     */
+    container?: Element | DocumentFragment | null;
+}
+declare const Portal: React.ForwardRefExoticComponent<PortalProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.ForwardRefExoticComponent<PortalProps & React.RefAttributes<HTMLDivElement>>;
+export { Portal, Root, };
+export type { PortalProps };

package/dist/primitives/vendor/radix/react-portal/portal.js

@@ -0,0 +1,21 @@
+"use client";
+import { useLayoutEffect } from "../react-use-layout-effect/use-layout-effect.js";
+import { Primitive } from "../react-primitive/primitive.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+import * as ReactDOM from "react-dom";
+//#region src/primitives/vendor/radix/react-portal/portal.tsx
+var Portal = /* @__PURE__ */ React.forwardRef(function Portal(props, forwardedRef) {
+	const { container: containerProp, ...portalProps } = props;
+	const [mounted, setMounted] = React.useState(false);
+	useLayoutEffect(() => setMounted(true), []);
+	const container = containerProp || mounted && globalThis?.document?.body;
+	return container ? ReactDOM.createPortal(/* @__PURE__ */ jsx(Primitive.div, {
+		...portalProps,
+		ref: forwardedRef
+	}), container) : null;
+});
+//#endregion
+export { Portal };
+
+//# sourceMappingURL=portal.js.map

package/dist/primitives/vendor/radix/react-portal/portal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-portal/portal.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { Primitive } from '../react-primitive';\nimport { useLayoutEffect } from '../react-use-layout-effect';\n\n/* -------------------------------------------------------------------------------------------------\n * Portal\n * -----------------------------------------------------------------------------------------------*/\n\ntype PortalElement = React.ComponentRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface PortalProps extends PrimitiveDivProps {\n  /**\n   * An optional container where the portaled content should be appended.\n   */\n  container?: Element | DocumentFragment | null;\n}\n\nconst Portal = /* @__PURE__ */ React.forwardRef<PortalElement, PortalProps>(\n  function Portal(props, forwardedRef) {\n    const { container: containerProp, ...portalProps } = props;\n    const [mounted, setMounted] = React.useState(false);\n    useLayoutEffect(() => setMounted(true), []);\n    const container = containerProp || (mounted && globalThis?.document?.body);\n    return container\n      ? ReactDOM.createPortal(<Primitive.div {...portalProps} ref={forwardedRef} />, container)\n      : null;\n  },\n);\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst Root = Portal;\n\nexport {\n  Portal,\n  //\n  Root,\n};\nexport type { PortalProps };\n"],"mappings":";;;;;;;AAoBA,IAAM,SAAyB,sBAAM,WACnC,SAAS,OAAO,OAAO,cAAc;CACnC,MAAM,EAAE,WAAW,eAAe,GAAG,gBAAgB;CACrD,MAAM,CAAC,SAAS,cAAc,MAAM,SAAS,KAAK;CAClD,sBAAsB,WAAW,IAAI,GAAG,CAAC,CAAC;CAC1C,MAAM,YAAY,iBAAkB,WAAW,YAAY,UAAU;CACrE,OAAO,YACH,SAAS,aAAa,oBAAC,UAAU,KAAX;EAAe,GAAI;EAAa,KAAK;CAAe,CAAA,GAAG,SAAS,IACtF;AACN,CACF"}

package/dist/primitives/vendor/radix/react-presence/index.d.ts

@@ -0,0 +1,2 @@
+export { Presence, Root } from './presence';
+export type { PresenceProps } from './presence';

package/dist/primitives/vendor/radix/react-presence/presence.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+interface PresenceProps {
+    children: React.ReactElement | ((props: {
+        present: boolean;
+    }) => React.ReactElement);
+    present: boolean;
+}
+declare const Presence: React.FC<PresenceProps>;
+declare const Root: React.FC<PresenceProps>;
+export { Presence, Root, };
+export type { PresenceProps };

package/dist/primitives/vendor/radix/react-presence/presence.js

@@ -0,0 +1,152 @@
+"use client";
+import { useLayoutEffect } from "../react-use-layout-effect/use-layout-effect.js";
+import { useStateMachine } from "./use-state-machine.js";
+import * as React from "react";
+//#region src/primitives/vendor/radix/react-presence/presence.tsx
+var Presence = (props) => {
+	const { present, children } = props;
+	const presence = usePresence(present);
+	const child = typeof children === "function" ? children({ present: presence.isPresent }) : React.Children.only(children);
+	const ref = useStableComposedRefs(presence.ref, getElementRef(child));
+	return typeof children === "function" || presence.isPresent ? React.cloneElement(child, { ref }) : null;
+};
+function usePresence(present) {
+	const [node, setNode] = React.useState();
+	const stylesRef = React.useRef(null);
+	const prevPresentRef = React.useRef(present);
+	const prevAnimationNameRef = React.useRef("none");
+	const mountAnimationNameRef = React.useRef(void 0);
+	const [state, send] = useStateMachine(present ? "mounted" : "unmounted", {
+		mounted: {
+			UNMOUNT: "unmounted",
+			ANIMATION_OUT: "unmountSuspended"
+		},
+		unmountSuspended: {
+			MOUNT: "mounted",
+			ANIMATION_END: "unmounted"
+		},
+		unmounted: { MOUNT: "mounted" }
+	});
+	React.useEffect(() => {
+		if (state === "mounted") {
+			prevAnimationNameRef.current = mountAnimationNameRef.current ?? getAnimationName(stylesRef.current);
+			mountAnimationNameRef.current = void 0;
+		} else prevAnimationNameRef.current = "none";
+	}, [state]);
+	useLayoutEffect(() => {
+		const styles = stylesRef.current;
+		const wasPresent = prevPresentRef.current;
+		if (wasPresent !== present) {
+			const prevAnimationName = prevAnimationNameRef.current;
+			const currentAnimationName = getAnimationName(styles);
+			if (present) {
+				mountAnimationNameRef.current = currentAnimationName;
+				send("MOUNT");
+			} else if (currentAnimationName === "none" || styles?.display === "none") send("UNMOUNT");
+			else if (wasPresent && prevAnimationName !== currentAnimationName) send("ANIMATION_OUT");
+			else send("UNMOUNT");
+			prevPresentRef.current = present;
+		}
+	}, [present, send]);
+	useLayoutEffect(() => {
+		if (node) {
+			let timeoutId;
+			const ownerWindow = node.ownerDocument.defaultView ?? window;
+			/**
+			* Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`
+			* event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we
+			* make sure we only trigger ANIMATION_END for the currently active animation.
+			*/
+			const handleAnimationEnd = (event) => {
+				const isCurrentAnimation = getAnimationName(stylesRef.current).includes(CSS.escape(event.animationName));
+				if (event.target === node && isCurrentAnimation) {
+					send("ANIMATION_END");
+					if (!prevPresentRef.current) {
+						const currentFillMode = node.style.animationFillMode;
+						node.style.animationFillMode = "forwards";
+						timeoutId = ownerWindow.setTimeout(() => {
+							if (node.style.animationFillMode === "forwards") node.style.animationFillMode = currentFillMode;
+						});
+					}
+				}
+			};
+			const handleAnimationStart = (event) => {
+				if (event.target === node) prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+			};
+			node.addEventListener("animationstart", handleAnimationStart);
+			node.addEventListener("animationcancel", handleAnimationEnd);
+			node.addEventListener("animationend", handleAnimationEnd);
+			return () => {
+				ownerWindow.clearTimeout(timeoutId);
+				node.removeEventListener("animationstart", handleAnimationStart);
+				node.removeEventListener("animationcancel", handleAnimationEnd);
+				node.removeEventListener("animationend", handleAnimationEnd);
+			};
+		} else send("ANIMATION_END");
+	}, [node, send]);
+	return {
+		isPresent: ["mounted", "unmountSuspended"].includes(state),
+		ref: React.useCallback((node) => {
+			if (node) {
+				const styles = getComputedStyle(node);
+				stylesRef.current = styles;
+				mountAnimationNameRef.current = getAnimationName(styles);
+			} else stylesRef.current = null;
+			setNode(node);
+		}, [])
+	};
+}
+function setRef(ref, value) {
+	if (typeof ref === "function") return ref(value);
+	else if (ref !== null && ref !== void 0) ref.current = value;
+}
+/**
+* Unlike `useComposedRefs`, the returned callback never changes identity, even
+* when the composed refs do. This matters in React 19: when a callback ref's
+* identity changes between renders, React detaches the previous ref (calls it
+* with `null`) and attaches the new one on every commit. Because `Presence`
+* calls `setNode` from its own ref, an unstable consumer ref would otherwise
+* cause React to re-run that update on every commit, resulting in a "Maximum
+* update depth exceeded" loop.
+*
+* The latest refs are always read at attach/detach time, so the most recent
+* consumer ref still receives the node when it mounts or unmounts.
+*
+* @see https://github.com/radix-ui/primitives/issues/3664
+*/
+function useStableComposedRefs(...refs) {
+	const refsRef = React.useRef(refs);
+	refsRef.current = refs;
+	return React.useCallback((node) => {
+		const currentRefs = refsRef.current;
+		let hasCleanup = false;
+		const cleanups = currentRefs.map((ref) => {
+			const cleanup = setRef(ref, node);
+			if (!hasCleanup && typeof cleanup === "function") hasCleanup = true;
+			return cleanup;
+		});
+		if (hasCleanup) return () => {
+			for (let i = 0; i < cleanups.length; i++) {
+				const cleanup = cleanups[i];
+				if (typeof cleanup === "function") cleanup();
+				else setRef(currentRefs[i], null);
+			}
+		};
+	}, []);
+}
+function getAnimationName(styles) {
+	return styles?.animationName || "none";
+}
+function getElementRef(element) {
+	let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+	let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.ref;
+	getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+	mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+	if (mayWarn) return element.props.ref;
+	return element.props.ref || element.ref;
+}
+//#endregion
+export { Presence };
+
+//# sourceMappingURL=presence.js.map

package/dist/primitives/vendor/radix/react-presence/presence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-presence/presence.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\nimport { useLayoutEffect } from '../react-use-layout-effect';\nimport { useStateMachine } from './use-state-machine';\n\ninterface PresenceProps {\n  children: React.ReactElement | ((props: { present: boolean }) => React.ReactElement);\n  present: boolean;\n}\n\nconst Presence: React.FC<PresenceProps> = (props) => {\n  const { present, children } = props;\n  const presence = usePresence(present);\n\n  const child = (\n    typeof children === 'function'\n      ? children({ present: presence.isPresent })\n      : React.Children.only(children)\n  ) as React.ReactElement<{ ref?: React.Ref<HTMLElement> }>;\n\n  const ref = useStableComposedRefs(presence.ref, getElementRef(child));\n  const forceMount = typeof children === 'function';\n  return forceMount || presence.isPresent ? React.cloneElement(child, { ref }) : null;\n};\n\n/* -------------------------------------------------------------------------------------------------\n * usePresence\n * -----------------------------------------------------------------------------------------------*/\n\nfunction usePresence(present: boolean) {\n  const [node, setNode] = React.useState<HTMLElement>();\n  const stylesRef = React.useRef<CSSStyleDeclaration | null>(null);\n  const prevPresentRef = React.useRef(present);\n  const prevAnimationNameRef = React.useRef<string>('none');\n  const mountAnimationNameRef = React.useRef<string | undefined>(undefined);\n  const initialState = present ? 'mounted' : 'unmounted';\n  const [state, send] = useStateMachine(initialState, {\n    mounted: {\n      UNMOUNT: 'unmounted',\n      ANIMATION_OUT: 'unmountSuspended',\n    },\n    unmountSuspended: {\n      MOUNT: 'mounted',\n      ANIMATION_END: 'unmounted',\n    },\n    unmounted: {\n      MOUNT: 'mounted',\n    },\n  });\n\n  React.useEffect(() => {\n    if (state === 'mounted') {\n      // Use the animation name captured during the layout phase (or the ref\n      // callback on first mount). By the time this passive effect runs,\n      // sibling effects like react-remove-scroll and DismissableLayer may have\n      // dirtied body styles, so re-reading from the live CSSStyleDeclaration\n      // here would force an expensive synchronous style recalculation.\n      // See: https://github.com/radix-ui/primitives/issues/1634\n      prevAnimationNameRef.current =\n        mountAnimationNameRef.current ?? getAnimationName(stylesRef.current);\n      mountAnimationNameRef.current = undefined;\n    } else {\n      prevAnimationNameRef.current = 'none';\n    }\n  }, [state]);\n\n  useLayoutEffect(() => {\n    const styles = stylesRef.current;\n    const wasPresent = prevPresentRef.current;\n    const hasPresentChanged = wasPresent !== present;\n\n    if (hasPresentChanged) {\n      const prevAnimationName = prevAnimationNameRef.current;\n      const currentAnimationName = getAnimationName(styles);\n\n      if (present) {\n        // Capture the animation name now, while styles are still \"clean\"\n        // (before sibling passive effects dirty the body). The later passive\n        // effect will read from this ref instead of the live\n        // CSSStyleDeclaration, avoiding a forced style recalculation.\n        mountAnimationNameRef.current = currentAnimationName;\n        send('MOUNT');\n      } else if (currentAnimationName === 'none' || styles?.display === 'none') {\n        // If there is no exit animation or the element is hidden, animations won't run\n        // so we unmount instantly\n        send('UNMOUNT');\n      } else {\n        /**\n         * When `present` changes to `false`, we check changes to animation-name to\n         * determine whether an animation has started. We chose this approach (reading\n         * computed styles) because there is no `animationrun` event and `animationstart`\n         * fires after `animation-delay` has expired which would be too late.\n         */\n        const isAnimating = prevAnimationName !== currentAnimationName;\n\n        if (wasPresent && isAnimating) {\n          send('ANIMATION_OUT');\n        } else {\n          send('UNMOUNT');\n        }\n      }\n\n      prevPresentRef.current = present;\n    }\n  }, [present, send]);\n\n  useLayoutEffect(() => {\n    if (node) {\n      let timeoutId: number;\n      const ownerWindow = node.ownerDocument.defaultView ?? window;\n      /**\n       * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`\n       * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we\n       * make sure we only trigger ANIMATION_END for the currently active animation.\n       */\n      const handleAnimationEnd = (event: AnimationEvent) => {\n        const currentAnimationName = getAnimationName(stylesRef.current);\n        // The event.animationName is unescaped for CSS syntax,\n        // so we need to escape it to compare with the animationName computed from the style.\n        const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));\n        if (event.target === node && isCurrentAnimation) {\n          // With React 18 concurrency this update is applied a frame after the\n          // animation ends, creating a flash of visible content. By setting the\n          // animation fill mode to \"forwards\", we force the node to keep the\n          // styles of the last keyframe, removing the flash.\n          //\n          // Previously we flushed the update via ReactDom.flushSync, but with\n          // exit animations this resulted in the node being removed from the\n          // DOM before the synthetic animationEnd event was dispatched, meaning\n          // user-provided event handlers would not be called.\n          // https://github.com/radix-ui/primitives/pull/1849\n          send('ANIMATION_END');\n          if (!prevPresentRef.current) {\n            const currentFillMode = node.style.animationFillMode;\n            node.style.animationFillMode = 'forwards';\n            // Reset the style after the node had time to unmount (for cases\n            // where the component chooses not to unmount). Doing this any\n            // sooner than `setTimeout` (e.g. with `requestAnimationFrame`)\n            // still causes a flash.\n            timeoutId = ownerWindow.setTimeout(() => {\n              if (node.style.animationFillMode === 'forwards') {\n                node.style.animationFillMode = currentFillMode;\n              }\n            });\n          }\n        }\n      };\n      const handleAnimationStart = (event: AnimationEvent) => {\n        if (event.target === node) {\n          // if animation occurred, store its name as the previous animation.\n          prevAnimationNameRef.current = getAnimationName(stylesRef.current);\n        }\n      };\n      node.addEventListener('animationstart', handleAnimationStart);\n      node.addEventListener('animationcancel', handleAnimationEnd);\n      node.addEventListener('animationend', handleAnimationEnd);\n      return () => {\n        ownerWindow.clearTimeout(timeoutId);\n        node.removeEventListener('animationstart', handleAnimationStart);\n        node.removeEventListener('animationcancel', handleAnimationEnd);\n        node.removeEventListener('animationend', handleAnimationEnd);\n      };\n    } else {\n      // Transition to the unmounted state if the node is removed prematurely.\n      // We avoid doing so during cleanup as the node may change but still exist.\n      send('ANIMATION_END');\n    }\n  }, [node, send]);\n\n  return {\n    isPresent: ['mounted', 'unmountSuspended'].includes(state),\n    ref: React.useCallback((node: HTMLElement) => {\n      if (node) {\n        const styles = getComputedStyle(node);\n        stylesRef.current = styles;\n        // Eagerly read the animation name while styles are clean. Ref\n        // callbacks fire during the commit phase, before any passive effects\n        // can dirty body styles. This cached value is consumed by the passive\n        // effect that records prevAnimationNameRef, letting it skip a\n        // redundant (and expensive) live-style read.\n        mountAnimationNameRef.current = getAnimationName(styles);\n      } else {\n        stylesRef.current = null;\n      }\n      setNode(node);\n    }, []),\n  };\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype PossibleRef<T> = React.Ref<T> | undefined;\n\nfunction setRef<T>(ref: PossibleRef<T>, value: T | null) {\n  if (typeof ref === 'function') {\n    return ref(value);\n  } else if (ref !== null && ref !== undefined) {\n    ref.current = value;\n  }\n}\n\n/**\n * Unlike `useComposedRefs`, the returned callback never changes identity, even\n * when the composed refs do. This matters in React 19: when a callback ref's\n * identity changes between renders, React detaches the previous ref (calls it\n * with `null`) and attaches the new one on every commit. Because `Presence`\n * calls `setNode` from its own ref, an unstable consumer ref would otherwise\n * cause React to re-run that update on every commit, resulting in a \"Maximum\n * update depth exceeded\" loop.\n *\n * The latest refs are always read at attach/detach time, so the most recent\n * consumer ref still receives the node when it mounts or unmounts.\n *\n * @see https://github.com/radix-ui/primitives/issues/3664\n */\nfunction useStableComposedRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T> {\n  // Keep the latest refs without changing the callback identity. Assigning during render is\n  // safe here because we only ever read `.current` later (at commit time, in the ref callback).\n  const refsRef = React.useRef(refs);\n  refsRef.current = refs;\n\n  return React.useCallback((node: T | null) => {\n    const currentRefs = refsRef.current;\n    let hasCleanup = false;\n    const cleanups = currentRefs.map((ref) => {\n      const cleanup = setRef(ref, node);\n      if (!hasCleanup && typeof cleanup === 'function') {\n        hasCleanup = true;\n      }\n      return cleanup;\n    });\n\n    if (hasCleanup) {\n      return () => {\n        for (let i = 0; i < cleanups.length; i++) {\n          const cleanup = cleanups[i];\n          if (typeof cleanup === 'function') {\n            cleanup();\n          } else {\n            setRef(currentRefs[i], null);\n          }\n        }\n      };\n    }\n  }, []);\n}\n\nfunction getAnimationName(styles: CSSStyleDeclaration | null) {\n  return styles?.animationName || 'none';\n}\n\n// Before React 19 accessing `element.props.ref` will throw a warning and suggest using `element.ref`\n// After React 19 accessing `element.ref` does the opposite.\n// https://github.com/facebook/react/pull/28348\n//\n// Access the ref using the method that doesn't yield a warning.\nfunction getElementRef(element: React.ReactElement<{ ref?: React.Ref<unknown> }>) {\n  // React <=18 in DEV\n  let getter = Object.getOwnPropertyDescriptor(element.props, 'ref')?.get;\n  let mayWarn = getter && 'isReactWarning' in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return (element as any).ref;\n  }\n\n  // React 19 in DEV\n  getter = Object.getOwnPropertyDescriptor(element, 'ref')?.get;\n  mayWarn = getter && 'isReactWarning' in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.props.ref;\n  }\n\n  // Not DEV\n  return element.props.ref || (element as any).ref;\n}\n\nconst Root = Presence;\n\nexport {\n  Presence,\n  //\n  Root,\n};\nexport type { PresenceProps };\n"],"mappings":"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"}

package/dist/primitives/vendor/radix/react-presence/use-state-machine.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+type Machine<S> = {
+    [k: string]: {
+        [k: string]: S;
+    };
+};
+type MachineState<T> = keyof T;
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+export declare function useStateMachine<M>(initialState: MachineState<M>, machine: M & Machine<MachineState<M>>): [keyof M, React.ActionDispatch<[event: keyof UnionToIntersection<M[keyof M]>]>];
+export {};

package/dist/primitives/vendor/radix/react-presence/use-state-machine.js

@@ -0,0 +1,12 @@
+"use client";
+import * as React from "react";
+//#region src/primitives/vendor/radix/react-presence/use-state-machine.tsx
+function useStateMachine(initialState, machine) {
+	return React.useReducer((state, event) => {
+		return machine[state][event] ?? state;
+	}, initialState);
+}
+//#endregion
+export { useStateMachine };
+
+//# sourceMappingURL=use-state-machine.js.map

package/dist/primitives/vendor/radix/react-presence/use-state-machine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-state-machine.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-presence/use-state-machine.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\n\ntype Machine<S> = { [k: string]: { [k: string]: S } };\ntype MachineState<T> = keyof T;\ntype MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>;\n\n// 🤯 https://fettblog.eu/typescript-union-to-intersection/\ntype UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any\n  ? R\n  : never;\n\nexport function useStateMachine<M>(\n  initialState: MachineState<M>,\n  machine: M & Machine<MachineState<M>>,\n) {\n  return React.useReducer((state: MachineState<M>, event: MachineEvent<M>): MachineState<M> => {\n    const nextState = (machine[state] as any)[event];\n    return nextState ?? state;\n  }, initialState);\n}\n"],"mappings":";;;AAaA,SAAgB,gBACd,cACA,SACA;CACA,OAAO,MAAM,YAAY,OAAwB,UAA4C;EAE3F,OADmB,QAAQ,MAAM,CAAS,UACtB;CACtB,GAAG,YAAY;AACjB"}

package/dist/primitives/vendor/radix/react-primitive/index.d.ts

@@ -0,0 +1,2 @@
+export { Primitive, Root, dispatchDiscreteCustomEvent, } from './primitive';
+export type { PrimitivePropsWithRef } from './primitive';