@burtson-labs/ui 0.13.1 → 0.14.1

package/dist/primitives/vendor/radix/react-dismissable-layer/dismissable-layer.js

@@ -0,0 +1,336 @@
+"use client";
+import { useComposedRefs } from "../react-compose-refs/compose-refs.js";
+import { composeEventHandlers } from "../primitive/primitive.js";
+import { Primitive, dispatchDiscreteCustomEvent } from "../react-primitive/primitive.js";
+import { useCallbackRef } from "../react-use-callback-ref/use-callback-ref.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/primitives/vendor/radix/react-dismissable-layer/dismissable-layer.tsx
+var CONTEXT_UPDATE = "dismissableLayer.update";
+var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
+var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
+var originalBodyPointerEvents;
+var DismissableLayerContext = React.createContext({
+	layers: /* @__PURE__ */ new Set(),
+	layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+	branches: /* @__PURE__ */ new Set(),
+	dismissableSurfaces: /* @__PURE__ */ new Set()
+});
+var DismissableLayer = /* @__PURE__ */ React.forwardRef(function DismissableLayer(props, forwardedRef) {
+	const { disableOutsidePointerEvents = false, deferPointerDownOutside = false, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, onDismiss, ...layerProps } = props;
+	const context = React.useContext(DismissableLayerContext);
+	const [node, setNode] = React.useState(null);
+	const ownerDocument = node?.ownerDocument ?? globalThis?.document;
+	const [, force] = React.useState({});
+	const composedRefs = useComposedRefs(forwardedRef, setNode);
+	const layers = Array.from(context.layers);
+	const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
+	const highestLayerWithOutsidePointerEventsDisabledIndex = highestLayerWithOutsidePointerEventsDisabled ? layers.indexOf(highestLayerWithOutsidePointerEventsDisabled) : -1;
+	const index = node ? layers.indexOf(node) : -1;
+	const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
+	const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;
+	const isDeferredPointerDownOutsideRef = React.useRef(false);
+	const pointerDownOutside = usePointerDownOutside((event) => {
+		onPointerDownOutside?.(event);
+		onInteractOutside?.(event);
+		if (!event.defaultPrevented) onDismiss?.();
+	}, {
+		ownerDocument,
+		deferPointerDownOutside,
+		isDeferredPointerDownOutsideRef,
+		dismissableSurfaces: context.dismissableSurfaces,
+		shouldHandlePointerDownOutside: React.useCallback((target) => {
+			if (!(target instanceof Node)) return false;
+			const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));
+			return isPointerEventsEnabled && !isPointerDownOnBranch;
+		}, [context.branches, isPointerEventsEnabled])
+	});
+	const focusOutside = useFocusOutside((event) => {
+		if (deferPointerDownOutside && isDeferredPointerDownOutsideRef.current) return;
+		const target = event.target;
+		if ([...context.branches].some((branch) => branch.contains(target))) return;
+		onFocusOutside?.(event);
+		onInteractOutside?.(event);
+		if (!event.defaultPrevented) onDismiss?.();
+	}, ownerDocument);
+	const isHighestLayer = node ? index === layers.length - 1 : false;
+	const handleKeyDown = useCallbackRef((event) => {
+		if (event.key !== "Escape") return;
+		onEscapeKeyDown?.(event);
+		if (!event.defaultPrevented && onDismiss) {
+			event.preventDefault();
+			onDismiss();
+		}
+	});
+	React.useEffect(() => {
+		if (!isHighestLayer) return;
+		ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
+		return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
+	}, [
+		ownerDocument,
+		isHighestLayer,
+		handleKeyDown
+	]);
+	React.useEffect(() => {
+		if (!node) return;
+		if (disableOutsidePointerEvents) {
+			if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+				originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
+				ownerDocument.body.style.pointerEvents = "none";
+			}
+			context.layersWithOutsidePointerEventsDisabled.add(node);
+		}
+		context.layers.add(node);
+		dispatchUpdate();
+		return () => {
+			if (disableOutsidePointerEvents) {
+				context.layersWithOutsidePointerEventsDisabled.delete(node);
+				if (context.layersWithOutsidePointerEventsDisabled.size === 0) ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
+			}
+		};
+	}, [
+		node,
+		ownerDocument,
+		disableOutsidePointerEvents,
+		context
+	]);
+	/**
+	* We purposefully prevent combining this effect with the `disableOutsidePointerEvents` effect
+	* because a change to `disableOutsidePointerEvents` would remove this layer from the stack
+	* and add it to the end again so the layering order wouldn't be _creation order_.
+	* We only want them to be removed from context stacks when unmounted.
+	*/
+	React.useEffect(() => {
+		return () => {
+			if (!node) return;
+			context.layers.delete(node);
+			context.layersWithOutsidePointerEventsDisabled.delete(node);
+			dispatchUpdate();
+		};
+	}, [node, context]);
+	React.useEffect(() => {
+		const handleUpdate = () => force({});
+		document.addEventListener(CONTEXT_UPDATE, handleUpdate);
+		return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
+	}, []);
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		...layerProps,
+		ref: composedRefs,
+		style: {
+			pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
+			...props.style
+		},
+		onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),
+		onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),
+		onPointerDownCapture: composeEventHandlers(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture)
+	});
+});
+var DismissableLayerBranch = /* @__PURE__ */ React.forwardRef(function DismissableLayerBranch(props, forwardedRef) {
+	const context = React.useContext(DismissableLayerContext);
+	const ref = React.useRef(null);
+	const composedRefs = useComposedRefs(forwardedRef, ref);
+	React.useEffect(() => {
+		const node = ref.current;
+		if (node) {
+			context.branches.add(node);
+			return () => {
+				context.branches.delete(node);
+			};
+		}
+	}, [context.branches]);
+	return /* @__PURE__ */ jsx(Primitive.div, {
+		...props,
+		ref: composedRefs
+	});
+});
+/**
+* Registers a node as a "dismiss surface" for the enclosing DismissableLayer
+*/
+function useDismissableLayerSurface() {
+	const context = React.useContext(DismissableLayerContext);
+	const [node, setNode] = React.useState(null);
+	React.useEffect(() => {
+		if (!node) return;
+		context.dismissableSurfaces.add(node);
+		return () => {
+			context.dismissableSurfaces.delete(node);
+		};
+	}, [node, context.dismissableSurfaces]);
+	return setNode;
+}
+var IS_TRUE = () => true;
+/**
+* Listens for `pointerdown` outside a react subtree. We detect the start of the interaction on
+* `pointerdown`, then wait for `click` so external code can intercept later mouse events.
+* Returns props to pass to the node we want to check for outside events.
+*/
+function usePointerDownOutside(onPointerDownOutside, args) {
+	const { ownerDocument = globalThis?.document, deferPointerDownOutside = false, isDeferredPointerDownOutsideRef, dismissableSurfaces, shouldHandlePointerDownOutside = IS_TRUE } = args;
+	const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);
+	const isPointerInsideReactTreeRef = React.useRef(false);
+	const isPointerDownOutsideRef = React.useRef(false);
+	const interceptedOutsideInteractionEventsRef = React.useRef(/* @__PURE__ */ new Map());
+	const handleClickRef = React.useRef(() => {});
+	React.useEffect(() => {
+		function resetOutsideInteraction() {
+			isPointerDownOutsideRef.current = false;
+			isDeferredPointerDownOutsideRef.current = false;
+			interceptedOutsideInteractionEventsRef.current.clear();
+		}
+		function isOutsideInteractionIntercepted() {
+			return Array.from(interceptedOutsideInteractionEventsRef.current.values()).some(Boolean);
+		}
+		function handleInteractionCapture(event) {
+			if (!isPointerDownOutsideRef.current) return;
+			const target = event.target;
+			if (!(target instanceof Node && [...dismissableSurfaces].some((surface) => surface.contains(target)))) interceptedOutsideInteractionEventsRef.current.set(event.type, true);
+			if (event.type === "click") window.setTimeout(() => {
+				if (isPointerDownOutsideRef.current) handleClickRef.current();
+			}, 0);
+		}
+		function handleInteractionBubble(event) {
+			if (isPointerDownOutsideRef.current) interceptedOutsideInteractionEventsRef.current.set(event.type, false);
+		}
+		const handlePointerDown = (event) => {
+			if (event.target && !isPointerInsideReactTreeRef.current) {
+				if (!shouldHandlePointerDownOutside(event.target)) {
+					ownerDocument.removeEventListener("click", handleClickRef.current);
+					resetOutsideInteraction();
+					isPointerInsideReactTreeRef.current = false;
+					return;
+				}
+				const eventDetail = { originalEvent: event };
+				isPointerDownOutsideRef.current = true;
+				isDeferredPointerDownOutsideRef.current = deferPointerDownOutside && event.button === 0;
+				interceptedOutsideInteractionEventsRef.current.clear();
+				function handleAndDispatchPointerDownOutsideEvent() {
+					ownerDocument.removeEventListener("click", handleClickRef.current);
+					const wasOutsideInteractionIntercepted = isOutsideInteractionIntercepted();
+					resetOutsideInteraction();
+					if (!wasOutsideInteractionIntercepted) handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, handlePointerDownOutside, eventDetail, { discrete: true });
+				}
+				/**
+				* When deferring, we need to wait for a click event because:
+				*
+				* 1. On touch devices, browsers implement a ~350ms delay between the
+				*    time the user stops touching the display and when the browser
+				*    executes events. We need to ensure we don't reactivate
+				*    pointer-events within this timeframe otherwise the browser may
+				*    execute events that should have been prevented.
+				*
+				* 2. Browser extensions and other third-party code may call
+				*    `stopPropagation` on later mouse events like `mousedown`,
+				*    `mouseup`, or `click`. Waiting lets those intercepted events
+				*    cancel the outside interaction before we dismiss the layer. See
+				*    https://github.com/radix-ui/primitives/issues/2055
+				*
+				* Additionally, this also lets us deal automatically with cancellations
+				* when a click event isn't raised because the page was considered
+				* scrolled/drag-scrolled, long-pressed, etc.
+				*
+				* This is why we also continuously remove the previous listener,
+				* because we cannot be certain that it was raised, and therefore
+				* cleaned-up.
+				*
+				* For non-primary buttons, we dispatch the event immediately because we
+				* cannot be certain that the event was canceled.
+				*/
+				if (!deferPointerDownOutside || event.button !== 0) handleAndDispatchPointerDownOutsideEvent();
+				else {
+					ownerDocument.removeEventListener("click", handleClickRef.current);
+					handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;
+					ownerDocument.addEventListener("click", handleClickRef.current, { once: true });
+				}
+			} else {
+				ownerDocument.removeEventListener("click", handleClickRef.current);
+				resetOutsideInteraction();
+			}
+			isPointerInsideReactTreeRef.current = false;
+		};
+		const outsideInteractionEvents = [
+			"pointerup",
+			"mousedown",
+			"mouseup",
+			"touchstart",
+			"touchend",
+			"click"
+		];
+		for (const eventName of outsideInteractionEvents) {
+			ownerDocument.addEventListener(eventName, handleInteractionCapture, true);
+			ownerDocument.addEventListener(eventName, handleInteractionBubble);
+		}
+		/**
+		* if this hook executes in a component that mounts via a `pointerdown` event, the event
+		* would bubble up to the document and trigger a `pointerDownOutside` event. We avoid
+		* this by delaying the event listener registration on the document.
+		* This is not React specific, but rather how the DOM works, ie:
+		* ```
+		* button.addEventListener('pointerdown', () => {
+		*   console.log('I will log');
+		*   document.addEventListener('pointerdown', () => {
+		*     console.log('I will also log');
+		*   })
+		* });
+		*/
+		const timerId = window.setTimeout(() => {
+			ownerDocument.addEventListener("pointerdown", handlePointerDown);
+		}, 0);
+		return () => {
+			window.clearTimeout(timerId);
+			ownerDocument.removeEventListener("pointerdown", handlePointerDown);
+			ownerDocument.removeEventListener("click", handleClickRef.current);
+			for (const eventName of outsideInteractionEvents) {
+				ownerDocument.removeEventListener(eventName, handleInteractionCapture, true);
+				ownerDocument.removeEventListener(eventName, handleInteractionBubble);
+			}
+		};
+	}, [
+		ownerDocument,
+		handlePointerDownOutside,
+		deferPointerDownOutside,
+		isDeferredPointerDownOutsideRef,
+		dismissableSurfaces,
+		shouldHandlePointerDownOutside
+	]);
+	return { onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true };
+}
+/**
+* Listens for when focus happens outside a react subtree.
+* Returns props to pass to the root (node) of the subtree we want to check.
+*/
+function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
+	const handleFocusOutside = useCallbackRef(onFocusOutside);
+	const isFocusInsideReactTreeRef = React.useRef(false);
+	React.useEffect(() => {
+		const handleFocus = (event) => {
+			if (event.target && !isFocusInsideReactTreeRef.current) handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, { originalEvent: event }, { discrete: false });
+		};
+		ownerDocument.addEventListener("focusin", handleFocus);
+		return () => ownerDocument.removeEventListener("focusin", handleFocus);
+	}, [ownerDocument, handleFocusOutside]);
+	return {
+		onFocusCapture: () => isFocusInsideReactTreeRef.current = true,
+		onBlurCapture: () => isFocusInsideReactTreeRef.current = false
+	};
+}
+function dispatchUpdate() {
+	const event = new CustomEvent(CONTEXT_UPDATE);
+	document.dispatchEvent(event);
+}
+function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
+	const target = detail.originalEvent.target;
+	const event = new CustomEvent(name, {
+		bubbles: false,
+		cancelable: true,
+		detail
+	});
+	if (handler) target.addEventListener(name, handler, { once: true });
+	if (discrete) dispatchDiscreteCustomEvent(target, event);
+	else target.dispatchEvent(event);
+}
+var Root = DismissableLayer;
+var Branch = DismissableLayerBranch;
+//#endregion
+export { Branch, DismissableLayer, DismissableLayerBranch, Root, useDismissableLayerSurface };
+
+//# sourceMappingURL=dismissable-layer.js.map

package/dist/primitives/vendor/radix/react-dismissable-layer/dismissable-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dismissable-layer.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-dismissable-layer/dismissable-layer.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 { composeEventHandlers } from '../primitive';\nimport { Primitive, dispatchDiscreteCustomEvent } from '../react-primitive';\nimport { useComposedRefs } from '../react-compose-refs';\nimport { useCallbackRef } from '../react-use-callback-ref';\n\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayer\n * -----------------------------------------------------------------------------------------------*/\nconst CONTEXT_UPDATE = 'dismissableLayer.update';\nconst POINTER_DOWN_OUTSIDE = 'dismissableLayer.pointerDownOutside';\nconst FOCUS_OUTSIDE = 'dismissableLayer.focusOutside';\n\nlet originalBodyPointerEvents: string;\n\nconst DismissableLayerContext = React.createContext({\n  layers: new Set<DismissableLayerElement>(),\n  layersWithOutsidePointerEventsDisabled: new Set<DismissableLayerElement>(),\n  branches: new Set<DismissableLayerBranchElement>(),\n\n  // Outside elements that belong to a layer's own dismiss affordance (eg, a\n  // dialog overlay). Pressing them should dismiss the layer regardless of\n  // whether or not they stop propagation.\n  //\n  // See https://github.com/radix-ui/primitives/issues/3346\n  dismissableSurfaces: new Set<DismissableLayerBranchElement>(),\n});\n\ntype DismissableLayerElement = React.ComponentRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface DismissableLayerProps extends PrimitiveDivProps {\n  /**\n   * When `true`, hover/focus/click interactions will be disabled on elements outside\n   * the `DismissableLayer`. Users will need to click twice on outside elements to\n   * interact with them: once to close the `DismissableLayer`, and again to trigger the element.\n   */\n  disableOutsidePointerEvents?: boolean;\n  /**\n   * When `true`, a `'pointerdown'` event outside of the layered element will\n   * wait for the interaction's click event before dispatching, allowing\n   * third-party code to stop propagation of later events and cancel dismissal.\n   */\n  deferPointerDownOutside?: boolean;\n  /**\n   * Event handler called when the escape key is down.\n   * Can be prevented.\n   */\n  onEscapeKeyDown?: (event: KeyboardEvent) => void;\n  /**\n   * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;\n  /**\n   * Event handler called when the focus moves outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  onFocusOutside?: (event: FocusOutsideEvent) => void;\n  /**\n   * Event handler called when an interaction happens outside the `DismissableLayer`.\n   * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.\n   * Can be prevented.\n   */\n  onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;\n  /**\n   * Handler called when the `DismissableLayer` should be dismissed\n   */\n  onDismiss?: () => void;\n}\n\nconst DismissableLayer = /* @__PURE__ */ React.forwardRef<\n  DismissableLayerElement,\n  DismissableLayerProps\n>(\n  // blank line to reduce diff noise\n  function DismissableLayer(props, forwardedRef) {\n    const {\n      disableOutsidePointerEvents = false,\n      deferPointerDownOutside = false,\n      onEscapeKeyDown,\n      onPointerDownOutside,\n      onFocusOutside,\n      onInteractOutside,\n      onDismiss,\n      ...layerProps\n    } = props;\n    const context = React.useContext(DismissableLayerContext);\n    const [node, setNode] = React.useState<DismissableLayerElement | null>(null);\n    const ownerDocument = node?.ownerDocument ?? globalThis?.document;\n    const [, force] = React.useState({});\n    const composedRefs = useComposedRefs(forwardedRef, setNode);\n    const layers = Array.from(context.layers);\n    const [highestLayerWithOutsidePointerEventsDisabled] = [\n      ...context.layersWithOutsidePointerEventsDisabled,\n    ].slice(-1);\n    const highestLayerWithOutsidePointerEventsDisabledIndex =\n      highestLayerWithOutsidePointerEventsDisabled\n        ? layers.indexOf(highestLayerWithOutsidePointerEventsDisabled)\n        : -1;\n    const index = node ? layers.indexOf(node) : -1;\n    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;\n    const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;\n    const isDeferredPointerDownOutsideRef = React.useRef(false);\n\n    const pointerDownOutside = usePointerDownOutside(\n      (event) => {\n        onPointerDownOutside?.(event);\n        onInteractOutside?.(event);\n        if (!event.defaultPrevented) onDismiss?.();\n      },\n      {\n        ownerDocument,\n        deferPointerDownOutside,\n        isDeferredPointerDownOutsideRef,\n        dismissableSurfaces: context.dismissableSurfaces,\n        shouldHandlePointerDownOutside: React.useCallback(\n          (target: EventTarget | null) => {\n            if (!(target instanceof Node)) {\n              return false;\n            }\n\n            const isPointerDownOnBranch = [...context.branches].some((branch) =>\n              branch.contains(target),\n            );\n            return isPointerEventsEnabled && !isPointerDownOnBranch;\n          },\n          [context.branches, isPointerEventsEnabled],\n        ),\n      },\n    );\n\n    const focusOutside = useFocusOutside((event) => {\n      if (deferPointerDownOutside && isDeferredPointerDownOutsideRef.current) {\n        return;\n      }\n\n      const target = event.target as HTMLElement;\n      const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (isFocusInBranch) return;\n      onFocusOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n\n    const isHighestLayer = node ? index === layers.length - 1 : false;\n\n    // Stabilize via `useCallbackRef` rather than `useEffectEvent`: React's\n    // native `useEffectEvent` returns a stale closure inside `forwardRef`\n    // components on React 19.2.x, which caused escape handlers to observe\n    // mount-time props/state instead of the latest values.\n    //\n    // We should revert this to use useEffectEvent when the fix lands in React.\n    //\n    // - https://github.com/radix-ui/primitives/issues/4014\n    // - https://github.com/react/react/pull/34831\n    const handleKeyDown = useCallbackRef((event: KeyboardEvent) => {\n      if (event.key !== 'Escape') {\n        return;\n      }\n\n      onEscapeKeyDown?.(event);\n      if (!event.defaultPrevented && onDismiss) {\n        event.preventDefault();\n        onDismiss();\n      }\n    });\n\n    React.useEffect(() => {\n      if (!isHighestLayer) {\n        return;\n      }\n\n      ownerDocument.addEventListener('keydown', handleKeyDown, { capture: true });\n      return () => ownerDocument.removeEventListener('keydown', handleKeyDown, { capture: true });\n    }, [ownerDocument, isHighestLayer, handleKeyDown]);\n\n    React.useEffect(() => {\n      if (!node) return;\n      if (disableOutsidePointerEvents) {\n        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n          originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;\n          ownerDocument.body.style.pointerEvents = 'none';\n        }\n        context.layersWithOutsidePointerEventsDisabled.add(node);\n      }\n      context.layers.add(node);\n      dispatchUpdate();\n      return () => {\n        // We must remove this layer from the disabled set whenever\n        // `disableOutsidePointerEvents` becomes `false` (eg, when a modal\n        // closes but stays mounted during an exit animation) and not only on\n        // unmount. Otherwise the `body` `pointer-events` could be left as\n        // `none` when multiple layers overlap.\n        // See: https://github.com/radix-ui/primitives/issues/3645\n        if (disableOutsidePointerEvents) {\n          context.layersWithOutsidePointerEventsDisabled.delete(node);\n          if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n            ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;\n          }\n        }\n      };\n    }, [node, ownerDocument, disableOutsidePointerEvents, context]);\n\n    /**\n     * We purposefully prevent combining this effect with the `disableOutsidePointerEvents` effect\n     * because a change to `disableOutsidePointerEvents` would remove this layer from the stack\n     * and add it to the end again so the layering order wouldn't be _creation order_.\n     * We only want them to be removed from context stacks when unmounted.\n     */\n    React.useEffect(() => {\n      return () => {\n        if (!node) return;\n        context.layers.delete(node);\n        context.layersWithOutsidePointerEventsDisabled.delete(node);\n        dispatchUpdate();\n      };\n    }, [node, context]);\n\n    React.useEffect(() => {\n      const handleUpdate = () => force({});\n      document.addEventListener(CONTEXT_UPDATE, handleUpdate);\n      return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);\n    }, []);\n\n    return (\n      <Primitive.div\n        {...layerProps}\n        ref={composedRefs}\n        style={{\n          pointerEvents: isBodyPointerEventsDisabled\n            ? isPointerEventsEnabled\n              ? 'auto'\n              : 'none'\n            : undefined,\n          ...props.style,\n        }}\n        onFocusCapture={composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture)}\n        onBlurCapture={composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture)}\n        onPointerDownCapture={composeEventHandlers(\n          props.onPointerDownCapture,\n          pointerDownOutside.onPointerDownCapture,\n        )}\n      />\n    );\n  },\n);\n\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayerBranch\n * -----------------------------------------------------------------------------------------------*/\n\ntype DismissableLayerBranchElement = React.ComponentRef<typeof Primitive.div>;\ninterface DismissableLayerBranchProps extends PrimitiveDivProps {}\n\nconst DismissableLayerBranch = /* @__PURE__ */ React.forwardRef<\n  DismissableLayerBranchElement,\n  DismissableLayerBranchProps\n>(function DismissableLayerBranch(props, forwardedRef) {\n  const context = React.useContext(DismissableLayerContext);\n  const ref = React.useRef<DismissableLayerBranchElement>(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n\n  React.useEffect(() => {\n    const node = ref.current;\n    if (node) {\n      context.branches.add(node);\n      return () => {\n        context.branches.delete(node);\n      };\n    }\n  }, [context.branches]);\n\n  return <Primitive.div {...props} ref={composedRefs} />;\n});\n\n/* -----------------------------------------------------------------------------------------------*/\n\n/**\n * Registers a node as a \"dismiss surface\" for the enclosing DismissableLayer\n */\nfunction useDismissableLayerSurface(): React.RefCallback<DismissableLayerBranchElement> {\n  const context = React.useContext(DismissableLayerContext);\n  const [node, setNode] = React.useState<DismissableLayerBranchElement | null>(null);\n\n  React.useEffect(() => {\n    if (!node) {\n      return;\n    }\n    context.dismissableSurfaces.add(node);\n    return () => {\n      context.dismissableSurfaces.delete(node);\n    };\n  }, [node, context.dismissableSurfaces]);\n\n  return setNode;\n}\n\ntype PointerDownOutsideEvent = CustomEvent<{ originalEvent: PointerEvent }>;\ntype FocusOutsideEvent = CustomEvent<{ originalEvent: FocusEvent }>;\n\nconst IS_TRUE = () => true;\n\n/**\n * Listens for `pointerdown` outside a react subtree. We detect the start of the interaction on\n * `pointerdown`, then wait for `click` so external code can intercept later mouse events.\n * Returns props to pass to the node we want to check for outside events.\n */\nfunction usePointerDownOutside(\n  onPointerDownOutside: ((event: PointerDownOutsideEvent) => void) | undefined,\n  args: {\n    ownerDocument: Document | undefined;\n    deferPointerDownOutside: boolean;\n    isDeferredPointerDownOutsideRef: React.RefObject<boolean>;\n    dismissableSurfaces: Set<DismissableLayerBranchElement>;\n    shouldHandlePointerDownOutside?: (target: EventTarget | null) => boolean;\n  },\n) {\n  const {\n    ownerDocument = globalThis?.document,\n    deferPointerDownOutside = false,\n    isDeferredPointerDownOutsideRef,\n    dismissableSurfaces,\n    shouldHandlePointerDownOutside = IS_TRUE,\n  } = args;\n  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside) as EventListener;\n  const isPointerInsideReactTreeRef = React.useRef(false);\n  const isPointerDownOutsideRef = React.useRef(false);\n  const interceptedOutsideInteractionEventsRef = React.useRef<Map<string, boolean>>(new Map());\n  const handleClickRef = React.useRef(() => {});\n\n  React.useEffect(() => {\n    function resetOutsideInteraction() {\n      isPointerDownOutsideRef.current = false;\n      isDeferredPointerDownOutsideRef.current = false;\n      interceptedOutsideInteractionEventsRef.current.clear();\n    }\n\n    function isOutsideInteractionIntercepted() {\n      return Array.from(interceptedOutsideInteractionEventsRef.current.values()).some(Boolean);\n    }\n\n    function handleInteractionCapture(event: Event) {\n      if (!isPointerDownOutsideRef.current) {\n        return;\n      }\n\n      const target = event.target;\n      const isDismissableSurface =\n        target instanceof Node &&\n        [...dismissableSurfaces].some((surface) => surface.contains(target as Node));\n\n      if (!isDismissableSurface) {\n        interceptedOutsideInteractionEventsRef.current.set(event.type, true);\n      }\n\n      if (event.type === 'click') {\n        window.setTimeout(() => {\n          if (isPointerDownOutsideRef.current) {\n            handleClickRef.current();\n          }\n        }, 0);\n      }\n    }\n\n    function handleInteractionBubble(event: Event) {\n      if (isPointerDownOutsideRef.current) {\n        interceptedOutsideInteractionEventsRef.current.set(event.type, false);\n      }\n    }\n\n    const handlePointerDown = (event: PointerEvent) => {\n      if (event.target && !isPointerInsideReactTreeRef.current) {\n        if (!shouldHandlePointerDownOutside(event.target)) {\n          ownerDocument.removeEventListener('click', handleClickRef.current);\n          resetOutsideInteraction();\n          isPointerInsideReactTreeRef.current = false;\n          return;\n        }\n\n        const eventDetail = { originalEvent: event };\n        isPointerDownOutsideRef.current = true;\n        isDeferredPointerDownOutsideRef.current = deferPointerDownOutside && event.button === 0;\n        interceptedOutsideInteractionEventsRef.current.clear();\n\n        function handleAndDispatchPointerDownOutsideEvent() {\n          ownerDocument.removeEventListener('click', handleClickRef.current);\n          const wasOutsideInteractionIntercepted = isOutsideInteractionIntercepted();\n          resetOutsideInteraction();\n\n          if (!wasOutsideInteractionIntercepted) {\n            handleAndDispatchCustomEvent(\n              POINTER_DOWN_OUTSIDE,\n              handlePointerDownOutside,\n              eventDetail,\n              { discrete: true },\n            );\n          }\n        }\n\n        /**\n         * When deferring, we need to wait for a click event because:\n         *\n         * 1. On touch devices, browsers implement a ~350ms delay between the\n         *    time the user stops touching the display and when the browser\n         *    executes events. We need to ensure we don't reactivate\n         *    pointer-events within this timeframe otherwise the browser may\n         *    execute events that should have been prevented.\n         *\n         * 2. Browser extensions and other third-party code may call\n         *    `stopPropagation` on later mouse events like `mousedown`,\n         *    `mouseup`, or `click`. Waiting lets those intercepted events\n         *    cancel the outside interaction before we dismiss the layer. See\n         *    https://github.com/radix-ui/primitives/issues/2055\n         *\n         * Additionally, this also lets us deal automatically with cancellations\n         * when a click event isn't raised because the page was considered\n         * scrolled/drag-scrolled, long-pressed, etc.\n         *\n         * This is why we also continuously remove the previous listener,\n         * because we cannot be certain that it was raised, and therefore\n         * cleaned-up.\n         *\n         * For non-primary buttons, we dispatch the event immediately because we\n         * cannot be certain that the event was canceled.\n         */\n        if (!deferPointerDownOutside || event.button !== 0) {\n          handleAndDispatchPointerDownOutsideEvent();\n        } else {\n          ownerDocument.removeEventListener('click', handleClickRef.current);\n          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;\n          ownerDocument.addEventListener('click', handleClickRef.current, { once: true });\n        }\n      } else {\n        // We need to remove the event listener in case the outside click has been canceled.\n        // See: https://github.com/radix-ui/primitives/issues/2171\n        ownerDocument.removeEventListener('click', handleClickRef.current);\n        resetOutsideInteraction();\n      }\n      isPointerInsideReactTreeRef.current = false;\n    };\n\n    const outsideInteractionEvents = [\n      'pointerup',\n      'mousedown',\n      'mouseup',\n      'touchstart',\n      'touchend',\n      'click',\n    ];\n\n    for (const eventName of outsideInteractionEvents) {\n      ownerDocument.addEventListener(eventName, handleInteractionCapture, true);\n      ownerDocument.addEventListener(eventName, handleInteractionBubble);\n    }\n\n    /**\n     * if this hook executes in a component that mounts via a `pointerdown` event, the event\n     * would bubble up to the document and trigger a `pointerDownOutside` event. We avoid\n     * this by delaying the event listener registration on the document.\n     * This is not React specific, but rather how the DOM works, ie:\n     * ```\n     * button.addEventListener('pointerdown', () => {\n     *   console.log('I will log');\n     *   document.addEventListener('pointerdown', () => {\n     *     console.log('I will also log');\n     *   })\n     * });\n     */\n    const timerId = window.setTimeout(() => {\n      ownerDocument.addEventListener('pointerdown', handlePointerDown);\n    }, 0);\n    return () => {\n      window.clearTimeout(timerId);\n      ownerDocument.removeEventListener('pointerdown', handlePointerDown);\n      ownerDocument.removeEventListener('click', handleClickRef.current);\n      for (const eventName of outsideInteractionEvents) {\n        ownerDocument.removeEventListener(eventName, handleInteractionCapture, true);\n        ownerDocument.removeEventListener(eventName, handleInteractionBubble);\n      }\n    };\n  }, [\n    ownerDocument,\n    handlePointerDownOutside,\n    deferPointerDownOutside,\n    isDeferredPointerDownOutsideRef,\n    dismissableSurfaces,\n    shouldHandlePointerDownOutside,\n  ]);\n\n  return {\n    // ensures we check React component tree (not just DOM tree)\n    onPointerDownCapture: () => (isPointerInsideReactTreeRef.current = true),\n  };\n}\n\n/**\n * Listens for when focus happens outside a react subtree.\n * Returns props to pass to the root (node) of the subtree we want to check.\n */\nfunction useFocusOutside(\n  onFocusOutside?: (event: FocusOutsideEvent) => void,\n  ownerDocument: Document = globalThis?.document,\n) {\n  const handleFocusOutside = useCallbackRef(onFocusOutside) as EventListener;\n  const isFocusInsideReactTreeRef = React.useRef(false);\n\n  React.useEffect(() => {\n    const handleFocus = (event: FocusEvent) => {\n      if (event.target && !isFocusInsideReactTreeRef.current) {\n        const eventDetail = { originalEvent: event };\n        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {\n          discrete: false,\n        });\n      }\n    };\n    ownerDocument.addEventListener('focusin', handleFocus);\n    return () => ownerDocument.removeEventListener('focusin', handleFocus);\n  }, [ownerDocument, handleFocusOutside]);\n\n  return {\n    onFocusCapture: () => (isFocusInsideReactTreeRef.current = true),\n    onBlurCapture: () => (isFocusInsideReactTreeRef.current = false),\n  };\n}\n\nfunction dispatchUpdate() {\n  const event = new CustomEvent(CONTEXT_UPDATE);\n  document.dispatchEvent(event);\n}\n\nfunction handleAndDispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(\n  name: string,\n  handler: ((event: E) => void) | undefined,\n  detail: { originalEvent: OriginalEvent } & (E extends CustomEvent<infer D> ? D : never),\n  { discrete }: { discrete: boolean },\n) {\n  const target = detail.originalEvent.target;\n  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });\n  if (handler) target.addEventListener(name, handler as EventListener, { once: true });\n\n  if (discrete) {\n    dispatchDiscreteCustomEvent(target, event);\n  } else {\n    target.dispatchEvent(event);\n  }\n}\n\nconst Root = DismissableLayer;\nconst Branch = DismissableLayerBranch;\n\nexport {\n  DismissableLayer,\n  DismissableLayerBranch,\n  useDismissableLayerSurface,\n  //\n  Root,\n  Branch,\n};\nexport type { DismissableLayerProps };\n"],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+export { DismissableLayer, DismissableLayerBranch, Root, Branch, 
+/** @internal */
+useDismissableLayerSurface, } from './dismissable-layer';
+export type { DismissableLayerProps } from './dismissable-layer';

package/dist/primitives/vendor/radix/react-dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,95 @@
+import * as React from 'react';
+import { Primitive } from '../react-primitive';
+import * as MenuPrimitive from '../react-menu';
+type Direction = 'ltr' | 'rtl';
+declare const createDropdownMenuScope: import("../react-context").CreateScope;
+interface DropdownMenuProps {
+    children?: React.ReactNode;
+    dir?: Direction;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+    modal?: boolean;
+}
+declare const DropdownMenu: React.FC<DropdownMenuProps>;
+type PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface DropdownMenuTriggerProps extends PrimitiveButtonProps {
+}
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type MenuPortalProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Portal>;
+interface DropdownMenuPortalProps extends MenuPortalProps {
+}
+declare const DropdownMenuPortal: React.FC<DropdownMenuPortalProps>;
+type MenuContentProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Content>;
+interface DropdownMenuContentProps extends Omit<MenuContentProps, 'onEntryFocus'> {
+}
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+type MenuGroupProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Group>;
+interface DropdownMenuGroupProps extends MenuGroupProps {
+}
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+type MenuLabelProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Label>;
+interface DropdownMenuLabelProps extends MenuLabelProps {
+}
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+type MenuItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Item>;
+interface DropdownMenuItemProps extends MenuItemProps {
+}
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuCheckboxItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.CheckboxItem>;
+interface DropdownMenuCheckboxItemProps extends MenuCheckboxItemProps {
+}
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuRadioGroupProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.RadioGroup>;
+interface DropdownMenuRadioGroupProps extends MenuRadioGroupProps {
+}
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+type MenuRadioItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.RadioItem>;
+interface DropdownMenuRadioItemProps extends MenuRadioItemProps {
+}
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuItemIndicatorProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.ItemIndicator>;
+interface DropdownMenuItemIndicatorProps extends MenuItemIndicatorProps {
+}
+declare const DropdownMenuItemIndicator: React.ForwardRefExoticComponent<DropdownMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+type MenuSeparatorProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Separator>;
+interface DropdownMenuSeparatorProps extends MenuSeparatorProps {
+}
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+type MenuArrowProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Arrow>;
+interface DropdownMenuArrowProps extends MenuArrowProps {
+}
+declare const DropdownMenuArrow: React.ForwardRefExoticComponent<DropdownMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
+interface DropdownMenuSubProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+}
+declare const DropdownMenuSub: React.FC<DropdownMenuSubProps>;
+type MenuSubTriggerProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.SubTrigger>;
+interface DropdownMenuSubTriggerProps extends MenuSubTriggerProps {
+}
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+type MenuSubContentProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.SubContent>;
+interface DropdownMenuSubContentProps extends MenuSubContentProps {
+}
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.FC<DropdownMenuProps>;
+declare const Trigger: React.ForwardRefExoticComponent<DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Portal: React.FC<DropdownMenuPortalProps>;
+declare const Content: React.ForwardRefExoticComponent<DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group: React.ForwardRefExoticComponent<DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label: React.ForwardRefExoticComponent<DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem: React.ForwardRefExoticComponent<DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup: React.ForwardRefExoticComponent<DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem: React.ForwardRefExoticComponent<DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator: React.ForwardRefExoticComponent<DropdownMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Separator: React.ForwardRefExoticComponent<DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Arrow: React.ForwardRefExoticComponent<DropdownMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const Sub: React.FC<DropdownMenuSubProps>;
+declare const SubTrigger: React.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent: React.ForwardRefExoticComponent<DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+export { createDropdownMenuScope, DropdownMenu, DropdownMenuTrigger, DropdownMenuPortal, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuItemIndicator, DropdownMenuSeparator, DropdownMenuArrow, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, Root, Trigger, Portal, Content, Group, Label, Item, CheckboxItem, RadioGroup, RadioItem, ItemIndicator, Separator, Arrow, Sub, SubTrigger, SubContent, };
+export type { DropdownMenuProps, DropdownMenuTriggerProps, DropdownMenuPortalProps, DropdownMenuContentProps, DropdownMenuGroupProps, DropdownMenuLabelProps, DropdownMenuItemProps, DropdownMenuCheckboxItemProps, DropdownMenuRadioGroupProps, DropdownMenuRadioItemProps, DropdownMenuItemIndicatorProps, DropdownMenuSeparatorProps, DropdownMenuArrowProps, DropdownMenuSubProps, DropdownMenuSubTriggerProps, DropdownMenuSubContentProps, };