@elliemae/ds-floating-context 3.70.0-next.6 → 3.70.0-next.61

package/dist/cjs/DSFloatingContext.js

@@ -39,8 +39,19 @@ var import_ds_hooks_headless_tooltip = require("@elliemae/ds-hooks-headless-tool
 var import_react_desc_prop_types = require("./react-desc-prop-types.js");
 var import_useComputedPositionStyles = require("./useComputedPositionStyles.js");
 var import_positionObserver = require("./utils/positionObserver.js");
+var import_useLatestRef = require("./hooks/useLatestRef.js");
+var import_useResolvedReference = require("./hooks/useResolvedReference.js");
+var import_useFloatingClickOutside = require("./hooks/useFloatingClickOutside.js");
+var import_useFloatingResizeObserver = require("./hooks/useFloatingResizeObserver.js");
+var import_useReferenceHiddenByBoundary = require("./hooks/useReferenceHiddenByBoundary.js");
+var import_useSyntheticEventFromControlledState = require("./hooks/useSyntheticEventFromControlledState.js");
+const isKeyboardEvent = (event) => !!event?.key;
 const useFloatingContext = (props = {}) => {
-  const propsWithDefault = (0, import_ds_props_helpers.useMemoMergePropsWithDefault)(props, import_react_desc_prop_types.defaultProps);
+  const { onClickOutside, onEscape, onOpen, onClose, externalReferenceElement, boundaryElement, ...stableProps } = props;
+  const propsWithDefault = (0, import_ds_props_helpers.useMemoMergePropsWithDefault)(
+    stableProps,
+    import_react_desc_prop_types.defaultProps
+  );
   (0, import_ds_props_helpers.useValidateTypescriptPropTypes)(propsWithDefault, import_react_desc_prop_types.DSFloatingContextPropTypes, "FloatingContext");
   const {
     withoutPortal,
@@ -50,68 +61,145 @@ const useFloatingContext = (props = {}) => {
     placement,
     customOffset,
     placementOrderPreference,
-    onOpen,
-    onClose,
-    externallyControlledIsOpen
+    externallyControlledIsOpen,
+    closeOnEscape,
+    returnFocusToReference
   } = propsWithDefault;
+  const isControlled = externallyControlledIsOpen !== void 0;
+  const [floatingWrapperNode, setFloatingWrapperNode] = import_react.default.useState(null);
+  const triggerElementReferenceRef = import_react.default.useRef(null);
+  const onClickOutsideRef = (0, import_useLatestRef.useLatestRef)(onClickOutside);
+  const onEscapeRef = (0, import_useLatestRef.useLatestRef)(onEscape);
+  const onOpenRef = (0, import_useLatestRef.useLatestRef)(onOpen);
+  const onCloseRef = (0, import_useLatestRef.useLatestRef)(onClose);
   const [internalIsOpen, setInternalIsOpen] = import_react.default.useState(false);
   const isOpen = (0, import_react.useMemo)(
     () => externallyControlledIsOpen !== void 0 ? externallyControlledIsOpen : internalIsOpen,
     [externallyControlledIsOpen, internalIsOpen]
   );
-  const handleOpen = import_react.default.useCallback(() => {
-    setInternalIsOpen(true);
-    onOpen?.();
-  }, [onOpen]);
-  const handleClose = import_react.default.useCallback(() => {
-    setInternalIsOpen(false);
-    onClose?.();
-  }, [onClose]);
-  const tooltipHelpers = (0, import_ds_hooks_headless_tooltip.useHeadlessTooltip)({ onOpen: handleOpen, onClose: handleClose });
-  const { setReferenceElement, referenceElement, hideTooltip, showTooltip } = tooltipHelpers;
-  const [floating, setFloating] = import_react.default.useState(null);
+  const isControlledRef = (0, import_useLatestRef.useLatestRef)(isControlled);
+  const closeOnEscapeRef = (0, import_useLatestRef.useLatestRef)(closeOnEscape);
+  const returnFocusToReferenceRef = (0, import_useLatestRef.useLatestRef)(returnFocusToReference);
+  const floatingWrapperNodeRef = (0, import_useLatestRef.useLatestRef)(floatingWrapperNode);
+  const isOpenRef = (0, import_useLatestRef.useLatestRef)(isOpen);
+  const handleOpen = import_react.default.useCallback(
+    (event) => {
+      setInternalIsOpen(true);
+      onOpenRef.current?.({ reason: "interaction", event, isControlled: isControlledRef.current });
+    },
+    [onOpenRef, isControlledRef]
+  );
+  const isFocusWithinFloatingScope = (0, import_react.useCallback)(() => {
+    const active = document.activeElement;
+    if (!active) return false;
+    if (floatingWrapperNodeRef.current?.contains(active)) return true;
+    const reference = triggerElementReferenceRef.current;
+    return reference === active || !!reference?.contains(active);
+  }, [floatingWrapperNodeRef]);
+  const handleClose = import_react.default.useCallback(
+    (event) => {
+      const wasOpen = isOpenRef.current;
+      setInternalIsOpen(false);
+      const isScopedEscapeClose = wasOpen && closeOnEscapeRef.current && isKeyboardEvent(event) && event.key === "Escape" && isFocusWithinFloatingScope();
+      if (isScopedEscapeClose) {
+        onEscapeRef.current?.(event);
+        if (returnFocusToReferenceRef.current && triggerElementReferenceRef.current instanceof HTMLElement) {
+          triggerElementReferenceRef.current.focus();
+        }
+      } else {
+        onCloseRef.current?.({ reason: "interaction", event, isControlled: isControlledRef.current });
+      }
+    },
+    [
+      isOpenRef,
+      closeOnEscapeRef,
+      isFocusWithinFloatingScope,
+      returnFocusToReferenceRef,
+      onCloseRef,
+      onEscapeRef,
+      isControlledRef
+    ]
+  );
+  const shouldFocusReferenceOnEscape = (0, import_react.useCallback)(
+    () => closeOnEscapeRef.current && returnFocusToReferenceRef.current && isFocusWithinFloatingScope(),
+    [closeOnEscapeRef, returnFocusToReferenceRef, isFocusWithinFloatingScope]
+  );
+  const tooltipHelpersConfig = (0, import_react.useMemo)(
+    () => ({ onOpen: handleOpen, onClose: handleClose, focusReferenceOnEscape: shouldFocusReferenceOnEscape }),
+    [handleOpen, handleClose, shouldFocusReferenceOnEscape]
+  );
+  const tooltipHelpers = (0, import_ds_hooks_headless_tooltip.useHeadlessTooltip)(tooltipHelpersConfig);
+  const {
+    setReferenceElement: setInternalReferenceElement,
+    referenceElement: internalReferenceElement,
+    hideTooltip,
+    showTooltip
+  } = tooltipHelpers;
+  const { triggerElementReference, setReferenceElement } = (0, import_useResolvedReference.useResolvedReference)({
+    externalReferenceElement,
+    internalReferenceElement,
+    setInternalReferenceElement
+  });
+  triggerElementReferenceRef.current = triggerElementReference;
   const { arrowStyles, floatingStyles, hasComputedOnce, updateStyles, debouncedUpdateStyles, mutableUpdateStyles } = (0, import_useComputedPositionStyles.useComputedPositionStyles)({
-    reference: referenceElement,
-    floating,
+    triggerElementReference,
+    floatingWrapperNode,
     placement,
     placementOrderPreference,
     customOffset,
     withoutPortal,
-    preventComputing: !isOpen,
+    boundaryElement,
+    isClose: !isOpen,
     debounceMs: 150
   });
-  (0, import_react.useEffect)(() => {
-    if (!isOpen) return;
-    const observers = [];
-    if (floating) {
-      const roFloating = new ResizeObserver(() => {
-        mutableUpdateStyles.current();
-      });
-      roFloating.observe(floating);
-      observers.push(roFloating);
-    }
-    return () => observers.forEach((o) => o.disconnect());
-  }, [isOpen, floating, updateStyles, mutableUpdateStyles]);
+  const floatingResizeOberverConfig = (0, import_react.useMemo)(
+    () => ({ isOpen, floatingWrapperNode, onResize: () => mutableUpdateStyles.current() }),
+    [isOpen, floatingWrapperNode, mutableUpdateStyles]
+  );
+  (0, import_useFloatingResizeObserver.useFloatingResizeObserver)(floatingResizeOberverConfig);
   const onObservedMovement = import_react.default.useCallback(() => {
     if (!isOpen) return;
     debouncedUpdateStyles();
   }, [isOpen, debouncedUpdateStyles]);
-  (0, import_positionObserver.usePositionObserver)(referenceElement, onObservedMovement);
-  const computedFloatingStyles = (0, import_react.useMemo)(
-    () => ({
+  (0, import_positionObserver.usePositionObserver)(triggerElementReference, onObservedMovement);
+  const isReferenceHiddenByBoundary = (0, import_useReferenceHiddenByBoundary.useReferenceHiddenByBoundary)({
+    reference: triggerElementReference,
+    boundaryElement,
+    enabled: isOpen && !!boundaryElement
+  });
+  (0, import_useFloatingClickOutside.useFloatingClickOutside)({
+    isOpen,
+    floatingWrapperNode,
+    triggerElementReference,
+    onClickOutsideRef
+  });
+  const handleControlledOpen = (0, import_react.useCallback)(() => {
+    onOpenRef.current?.({ reason: "controlled-flip", isControlled: true });
+  }, [onOpenRef]);
+  const handleControlledClose = (0, import_react.useCallback)(() => {
+    onCloseRef.current?.({ reason: "controlled-flip", isControlled: true });
+  }, [onCloseRef]);
+  (0, import_useSyntheticEventFromControlledState.useSyntheticEventFromControlledState)({
+    controlledValue: externallyControlledIsOpen,
+    onEnter: handleControlledOpen,
+    onExit: handleControlledClose
+  });
+  const computedFloatingStyles = (0, import_react.useMemo)(() => {
+    const isInteractive = isOpen && hasComputedOnce && !isReferenceHiddenByBoundary;
+    return {
       ...floatingStyles,
-      visibility: isOpen && hasComputedOnce ? "visible" : "hidden"
-    }),
-    [floatingStyles, hasComputedOnce, isOpen]
-  );
+      opacity: isInteractive ? 1 : 0,
+      pointerEvents: isInteractive ? "auto" : "none"
+    };
+  }, [floatingStyles, hasComputedOnce, isOpen, isReferenceHiddenByBoundary]);
   const refs = (0, import_react.useMemo)(
     () => ({
       setReference: setReferenceElement,
-      setFloating,
-      floating,
-      reference: referenceElement
+      setFloating: setFloatingWrapperNode,
+      floating: floatingWrapperNode,
+      reference: triggerElementReference
     }),
-    [setReferenceElement, floating, referenceElement]
+    [setReferenceElement, floatingWrapperNode, triggerElementReference]
   );
   const handlers = (0, import_react.useMemo)(
     () => ({

package/dist/cjs/DSFloatingContext.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/DSFloatingContext.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable max-lines */\n/* eslint-disable consistent-return */\n/* eslint-disable max-statements */\nimport React, { useMemo, useEffect } from 'react';\nimport {\n  useMemoMergePropsWithDefault,\n  useValidateTypescriptPropTypes,\n  describe,\n  type ValidationMap,\n} from '@elliemae/ds-props-helpers';\nimport { useHeadlessTooltip } from '@elliemae/ds-hooks-headless-tooltip';\nimport type { DSHookFloatingContextT } from './react-desc-prop-types.js';\nimport { defaultProps, DSFloatingContextPropTypes } from './react-desc-prop-types.js';\nimport { useComputedPositionStyles } from './useComputedPositionStyles.js';\nimport { usePositionObserver } from './utils/positionObserver.js';\n\nconst useFloatingContext = (props: DSHookFloatingContextT.Props = {}) => {\n  const propsWithDefault = useMemoMergePropsWithDefault<DSHookFloatingContextT.InternalProps>(props, defaultProps);\n  useValidateTypescriptPropTypes(propsWithDefault, DSFloatingContextPropTypes, 'FloatingContext');\n\n  const {\n    withoutPortal,\n    withoutAnimation,\n    portalDOMContainer,\n    animationDuration,\n    placement,\n    customOffset,\n    placementOrderPreference,\n    onOpen,\n    onClose,\n    externallyControlledIsOpen,\n  } = propsWithDefault;\n\n  const [internalIsOpen, setInternalIsOpen] = React.useState<boolean>(false);\n  const isOpen = useMemo(\n    () => (externallyControlledIsOpen !== undefined ? externallyControlledIsOpen : internalIsOpen),\n    [externallyControlledIsOpen, internalIsOpen],\n  );\n\n  const handleOpen = React.useCallback(() => {\n    setInternalIsOpen(true);\n    onOpen?.();\n  }, [onOpen]);\n\n  const handleClose = React.useCallback(() => {\n    setInternalIsOpen(false);\n    onClose?.();\n  }, [onClose]);\n\n  const tooltipHelpers = useHeadlessTooltip({ onOpen: handleOpen, onClose: handleClose });\n  const { setReferenceElement, referenceElement, hideTooltip, showTooltip } = tooltipHelpers;\n\n  // Anchor and floating refs\n  const [floating, setFloating] = React.useState<HTMLElement | null>(null);\n\n  // Compute position (skip when closed)\n  const { arrowStyles, floatingStyles, hasComputedOnce, updateStyles, debouncedUpdateStyles, mutableUpdateStyles } =\n    useComputedPositionStyles({\n      reference: referenceElement,\n      floating,\n      placement,\n      placementOrderPreference,\n      customOffset,\n      withoutPortal,\n      preventComputing: !isOpen,\n      debounceMs: 150,\n    });\n\n  useEffect(() => {\n    if (!isOpen) return;\n\n    const observers: ResizeObserver[] = [];\n\n    if (floating) {\n      const roFloating = new ResizeObserver(() => {\n        mutableUpdateStyles.current();\n      });\n      roFloating.observe(floating);\n      observers.push(roFloating);\n    }\n\n    return () => observers.forEach((o) => o.disconnect());\n  }, [isOpen, floating, updateStyles, mutableUpdateStyles]);\n\n  const onObservedMovement = React.useCallback(() => {\n    if (!isOpen) return;\n    debouncedUpdateStyles();\n  }, [isOpen, debouncedUpdateStyles]);\n  usePositionObserver(referenceElement, onObservedMovement);\n\n  // Expose visibility: only visible if open and already computed at least once\n  const computedFloatingStyles = useMemo<React.CSSProperties>(\n    () => ({\n      ...floatingStyles,\n      visibility: isOpen && hasComputedOnce ? 'visible' : 'hidden',\n    }),\n    [floatingStyles, hasComputedOnce, isOpen],\n  );\n\n  const refs = useMemo(\n    () => ({\n      setReference: setReferenceElement,\n      setFloating,\n      floating,\n      reference: referenceElement,\n    }),\n    [setReferenceElement, floating, referenceElement],\n  );\n\n  const handlers = useMemo(\n    () => ({\n      onMouseEnter: tooltipHelpers.onMouseEnter,\n      onMouseLeave: tooltipHelpers.onMouseLeave,\n      onFocus: tooltipHelpers.onFocus,\n      onBlur: tooltipHelpers.onBlur,\n    }),\n    [tooltipHelpers.onBlur, tooltipHelpers.onFocus, tooltipHelpers.onMouseEnter, tooltipHelpers.onMouseLeave],\n  );\n\n  return useMemo(\n    () => ({\n      refs,\n      floatingStyles: computedFloatingStyles,\n      handlers,\n      isOpen,\n      arrowStyles,\n      hideTooltip,\n      showTooltip,\n      context: {\n        withoutPortal,\n        withoutAnimation,\n        portalDOMContainer,\n        animationDuration,\n      },\n      mutableUpdateStyles,\n      forceUpdatePosition: updateStyles,\n    }),\n    [\n      refs,\n      computedFloatingStyles,\n      handlers,\n      isOpen,\n      arrowStyles,\n      hideTooltip,\n      showTooltip,\n      withoutPortal,\n      withoutAnimation,\n      portalDOMContainer,\n      animationDuration,\n      mutableUpdateStyles,\n      updateStyles,\n    ],\n  );\n};\n\nuseFloatingContext.displayName = 'FloatingContext';\nconst UseFloatingContextWithSchema = describe(useFloatingContext);\nUseFloatingContextWithSchema.propTypes =\n  DSFloatingContextPropTypes as unknown as ValidationMap<DSHookFloatingContextT.Props>;\n\nexport { useFloatingContext, UseFloatingContextWithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": "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",
+  "sourcesContent": ["/* eslint-disable max-lines */\n/* eslint-disable max-statements */\nimport React, { useCallback, useMemo } from 'react';\nimport {\n  useMemoMergePropsWithDefault,\n  useValidateTypescriptPropTypes,\n  describe,\n  type ValidationMap,\n} from '@elliemae/ds-props-helpers';\nimport { useHeadlessTooltip, type UseHeadlessTooltipConfig } from '@elliemae/ds-hooks-headless-tooltip';\nimport type { DSHookFloatingContextT } from './react-desc-prop-types.js';\nimport { defaultProps, DSFloatingContextPropTypes } from './react-desc-prop-types.js';\nimport { useComputedPositionStyles } from './useComputedPositionStyles.js';\nimport { usePositionObserver } from './utils/positionObserver.js';\nimport { useLatestRef } from './hooks/useLatestRef.js';\nimport { useResolvedReference } from './hooks/useResolvedReference.js';\nimport { useFloatingClickOutside } from './hooks/useFloatingClickOutside.js';\nimport { useFloatingResizeObserver } from './hooks/useFloatingResizeObserver.js';\nimport { useReferenceHiddenByBoundary } from './hooks/useReferenceHiddenByBoundary.js';\nimport { useSyntheticEventFromControlledState } from './hooks/useSyntheticEventFromControlledState.js';\n\nconst isKeyboardEvent = (\n  event: React.FocusEvent | React.MouseEvent | KeyboardEvent | undefined,\n): event is KeyboardEvent => !!(event as KeyboardEvent)?.key;\n\n/**\n * useFloatingContext \u2014 headless positioning + open/close lifecycle for a floating surface\n * (popover / tooltip / dialog-like panel). Returns positioning styles + refs, imperative show/hide\n * helpers, interaction handlers to spread on a trigger, and a discriminated open/close notification.\n *\n * COUPLING: this hook is the shared substrate under ds-app-picker, ds-tooltip and others; its\n * open/close/escape/reason contract is relied on across packages. The consumer that leans hardest on\n * the exact semantics below is ds-app-picker\n * (layout/ds-app-picker/src/parts/AppPickerFloatingContext/useAppPickerFloatingContext.ts). Treat\n * changes to these semantics as cross-package.\n *\n * OPEN STATE \u2014 controlled vs uncontrolled\n *  - Uncontrolled: `externallyControlledIsOpen` undefined \u2192 open state lives here (in the underlying\n *    ds-hooks-headless-tooltip) and is driven by the focus/hover handlers + the show/hide helpers.\n *  - Controlled: `externallyControlledIsOpen` is a boolean \u2192 the consumer owns visibility and the\n *    internal open state is inert. `isControlled` is surfaced on every OpenChange payload.\n *\n * NOTIFICATION \u2014 one onOpen/onClose pair, two reasons (see OpenChange in react-desc-prop-types)\n *  - 'interaction': fired synchronously in the event catch phase by this hook's own interaction\n *    handling \u2014 focus/hover/blur/mouseleave, an imperative show/hide, or a NON-scoped Escape falling\n *    through to onClose \u2014 carrying the DOM event when there is one. Fires for controlled contexts too\n *    (the pre-flip signal a controlled consumer may act on).\n *  - 'controlled-flip': fired from a post-commit effect (useSyntheticEventFromControlledState) when\n *    `externallyControlledIsOpen` transitions. No event. NEVER fires on mount \u2014 a surface rendered\n *    already-open gets no onOpen and must seed any initial focus itself.\n *\n * ESCAPE \u2014 one listener, not two\n *  Escape dismissal rides ds-hooks-headless-tooltip's single always-on document keydown listener (it\n *  calls hideTooltip on ANY Escape, even when this context never opened). handleClose is the one place\n *  that interprets it:\n *   - SCOPED Escape (was open + closeOnEscape + key 'Escape' + focus within the panel/reference)\n *       \u2192 routes to `onEscape` (NOT onClose); if returnFocusToReference, focuses the reference.\n *   - anything else, including a non-scoped Escape \u2192 `onClose` with reason 'interaction'.\n *  returnFocusToReference is a SCOPED-ESCAPE-ONLY affordance; no other close path moves focus.\n *\n * FRAGILITY: closeOnEscape is honored independently of who owns open state. A CONTROLLED consumer that\n * leaves closeOnEscape on but does not itself close on Escape will have focus returned to the reference\n * on a scoped Escape while the consumer-owned open state has not changed \u2014 focus can leave a panel that\n * stays open. Controlled consumers should own Escape (ds-app-picker uses `closeOnEscape: !onKeyDown`).\n */\nconst useFloatingContext = (props: DSHookFloatingContextT.Props = {}) => {\n  // Extract unstable callback refs BEFORE useMemoMergePropsWithDefault.\n  // useMemoMergePropsWithDefault compares with fast-deep-equal which compares functions by\n  // reference; an inline callback from the consumer would invalidate propsWithDefault on every\n  // render, which in turn would invalidate the destructured `customOffset` array and re-trigger\n  // the position-computation useLayoutEffect on every render \u2192 infinite loop.\n  const { onClickOutside, onEscape, onOpen, onClose, externalReferenceElement, boundaryElement, ...stableProps } =\n    props;\n\n  const propsWithDefault = useMemoMergePropsWithDefault<DSHookFloatingContextT.InternalProps>(\n    stableProps,\n    defaultProps,\n  );\n  useValidateTypescriptPropTypes(propsWithDefault, DSFloatingContextPropTypes, 'FloatingContext');\n\n  const {\n    withoutPortal,\n    withoutAnimation,\n    portalDOMContainer,\n    animationDuration,\n    placement,\n    customOffset,\n    placementOrderPreference,\n    externallyControlledIsOpen,\n    closeOnEscape,\n    returnFocusToReference,\n  } = propsWithDefault;\n  // Whether the consumer owns the open state. Surfaced on the OpenChange payload so a handler can\n  // branch without re-reading props.\n  const isControlled = externallyControlledIsOpen !== undefined;\n  // Anchor and floating refs\n  const [floatingWrapperNode, setFloatingWrapperNode] = React.useState<HTMLElement | null>(null);\n\n  // Resolved below (after useResolvedReference) into a stable ref rather than referenced directly,\n  // because isFocusWithinFloatingScope / the escape-handling below need to read it from a config\n  // object built BEFORE useResolvedReference (and the useHeadlessTooltip call it depends on) runs.\n  // A ref sidesteps that ordering constraint; the value it holds is always current by the time\n  // anything actually reads it (Escape handling only ever happens after mount, never during this\n  // synchronous render pass).\n  const triggerElementReferenceRef = React.useRef<Element | null>(null);\n\n  // Latest-refs for consumer callbacks (see useLatestRef docs).\n  const onClickOutsideRef = useLatestRef(onClickOutside);\n  const onEscapeRef = useLatestRef(onEscape);\n  const onOpenRef = useLatestRef(onOpen);\n  const onCloseRef = useLatestRef(onClose);\n\n  // Open/close state \u2014 externally controlled when `externallyControlledIsOpen` is provided.\n  const [internalIsOpen, setInternalIsOpen] = React.useState(false);\n  const isOpen = useMemo(\n    () => (externallyControlledIsOpen !== undefined ? externallyControlledIsOpen : internalIsOpen),\n    [externallyControlledIsOpen, internalIsOpen],\n  );\n\n  // Latest-refs for the reactive VALUES that handleOpen/handleClose read. These handlers are wired\n  // into ds-hooks-headless-tooltip's always-on document keydown listener; if a handler's identity\n  // changed whenever one of these values changed (isOpen flips on every open/close,\n  // floatingWrapperNode on every mount/unmount), that listener would detach + re-attach on every\n  // transition. Reading through refs keeps the handlers identity-stable so the listener attaches\n  // once. Handlers only ever run post-commit, so the ref always holds the current value when read \u2014\n  // same rationale as the consumer-callback refs above.\n  const isControlledRef = useLatestRef(isControlled);\n  const closeOnEscapeRef = useLatestRef(closeOnEscape);\n  const returnFocusToReferenceRef = useLatestRef(returnFocusToReference);\n  const floatingWrapperNodeRef = useLatestRef(floatingWrapperNode);\n  const isOpenRef = useLatestRef(isOpen);\n\n  const handleOpen = React.useCallback<Required<UseHeadlessTooltipConfig>['onOpen']>(\n    (event) => {\n      setInternalIsOpen(true);\n      onOpenRef.current?.({ reason: 'interaction', event, isControlled: isControlledRef.current });\n    },\n    [onOpenRef, isControlledRef],\n  );\n\n  // \"In scope\" = the active element is inside the floating (popover) content, or is/inside the\n  // reference (trigger) element. Used to decide whether an Escape is this floating context's concern.\n  const isFocusWithinFloatingScope = useCallback((): boolean => {\n    const active = document.activeElement;\n    if (!active) return false;\n    if (floatingWrapperNodeRef.current?.contains(active)) return true;\n    const reference = triggerElementReferenceRef.current;\n    return reference === active || !!reference?.contains(active);\n  }, [floatingWrapperNodeRef]);\n\n  const handleClose = React.useCallback<Required<UseHeadlessTooltipConfig>['onClose']>(\n    (event) => {\n      // Read before flipping state: a global Escape press can arrive while this context is\n      // already closed (the underlying listener is always-on, see ds-hooks-headless-tooltip), and\n      // onEscape must not fire for that \u2014 only a close that was actually transitioning from open.\n      const wasOpen = isOpenRef.current;\n      setInternalIsOpen(false);\n\n      // Escape routing: when the context was open, `closeOnEscape` is set, the event is a keyboard\n      // Escape, AND focus was within scope, we route to the dedicated `onEscape` callback (instead\n      // of `onClose`) and, if asked, return focus to the reference. Every other close \u2014 including a\n      // non-opted-in Escape \u2014 goes through `onClose` with `reason: 'interaction'`. Whether that\n      // interaction is meaningful to a controlled consumer is THEIR call: they discriminate on the\n      // OpenChange `reason` (interaction vs controlled-flip). We do not decide that for them here.\n      // All reactive values are read through refs (see the latest-ref block above) so this handler's\n      // identity stays stable and the always-on keydown listener is not re-attached per transition.\n      const isScopedEscapeClose =\n        wasOpen &&\n        closeOnEscapeRef.current &&\n        isKeyboardEvent(event) &&\n        event.key === 'Escape' &&\n        isFocusWithinFloatingScope();\n\n      if (isScopedEscapeClose) {\n        onEscapeRef.current?.(event);\n        // Focus the resolved reference directly rather than relying solely on\n        // ds-hooks-headless-tooltip's own focusReferenceOnEscape: that mechanism focuses the\n        // hook's *internal* reference element, which stays null whenever this context is\n        // configured with `externalReferenceElement` (useResolvedReference makes\n        // refs.setReference a no-op in that mode \u2014 see its docstring). triggerElementReferenceRef\n        // is always the correctly-resolved element (internal or external), so focusing it here\n        // works for both.\n        if (returnFocusToReferenceRef.current && triggerElementReferenceRef.current instanceof HTMLElement) {\n          triggerElementReferenceRef.current.focus();\n        }\n      } else {\n        onCloseRef.current?.({ reason: 'interaction', event, isControlled: isControlledRef.current });\n      }\n    },\n    [\n      isOpenRef,\n      closeOnEscapeRef,\n      isFocusWithinFloatingScope,\n      returnFocusToReferenceRef,\n      onCloseRef,\n      onEscapeRef,\n      isControlledRef,\n    ],\n  );\n\n  // Passed as a thunk (not a pre-computed boolean) into useHeadlessTooltip's config: this config\n  // object is built before useResolvedReference runs, so a boolean computed here would be evaluated\n  // one render behind the reference element it depends on. Deferring the check to actual\n  // Escape-handling time (inside ds-hooks-headless-tooltip) avoids that staleness.\n  // Only drives ds-hooks-headless-tooltip's *internal*-reference focus path (see handleClose above\n  // for why the externally-resolved reference is focused directly instead).\n  const shouldFocusReferenceOnEscape = useCallback(\n    () => closeOnEscapeRef.current && returnFocusToReferenceRef.current && isFocusWithinFloatingScope(),\n    [closeOnEscapeRef, returnFocusToReferenceRef, isFocusWithinFloatingScope],\n  );\n  const tooltipHelpersConfig: UseHeadlessTooltipConfig = useMemo(\n    () => ({ onOpen: handleOpen, onClose: handleClose, focusReferenceOnEscape: shouldFocusReferenceOnEscape }),\n    [handleOpen, handleClose, shouldFocusReferenceOnEscape],\n  );\n  // Headless tooltip exposes show/hide helpers + manages its own internal state.\n  const tooltipHelpers = useHeadlessTooltip(tooltipHelpersConfig);\n  const {\n    setReferenceElement: setInternalReferenceElement,\n    referenceElement: internalReferenceElement,\n    hideTooltip,\n    showTooltip,\n  } = tooltipHelpers;\n\n  // Reference element resolution: external takes precedence over internal.\n  const { triggerElementReference, setReferenceElement } = useResolvedReference({\n    externalReferenceElement,\n    internalReferenceElement,\n    setInternalReferenceElement,\n  });\n  // Keep the ref declared above in sync \u2014 see its declaration comment for why this can't just be\n  // read directly from isFocusWithinFloatingScope/handleClose without going through a ref first.\n  triggerElementReferenceRef.current = triggerElementReference;\n\n  // Compute position (skip when closed)\n  const { arrowStyles, floatingStyles, hasComputedOnce, updateStyles, debouncedUpdateStyles, mutableUpdateStyles } =\n    useComputedPositionStyles({\n      triggerElementReference,\n      floatingWrapperNode,\n      placement,\n      placementOrderPreference,\n      customOffset,\n      withoutPortal,\n      boundaryElement,\n      isClose: !isOpen,\n      debounceMs: 150,\n    });\n\n  const floatingResizeOberverConfig = useMemo(\n    () => ({ isOpen, floatingWrapperNode, onResize: () => mutableUpdateStyles.current() }),\n    [isOpen, floatingWrapperNode, mutableUpdateStyles],\n  );\n\n  // Re-compute position when the floating element's size changes (e.g. async content).\n  useFloatingResizeObserver(floatingResizeOberverConfig);\n\n  // Re-compute position when the reference element moves in the viewport.\n  const onObservedMovement = React.useCallback(() => {\n    if (!isOpen) return;\n    debouncedUpdateStyles();\n  }, [isOpen, debouncedUpdateStyles]);\n  usePositionObserver(triggerElementReference, onObservedMovement);\n\n  // Reference fully scrolled out of boundaryElement's visible area (opt-in, paired with\n  // boundaryElement): a clamped position alone would leave the floating element stuck at the\n  // boundary's edge with nothing left to visually anchor it to. This does NOT close the\n  // floating element (isOpen/consumer state is untouched) \u2014 it's purely visual, symmetric with\n  // the reappear case, so scrolling the reference back into view shows the same still-open\n  // floating element again with no re-click needed.\n  const isReferenceHiddenByBoundary = useReferenceHiddenByBoundary({\n    reference: triggerElementReference,\n    boundaryElement,\n    enabled: isOpen && !!boundaryElement,\n  });\n\n  // Click-outside dismissal (opt-in via `onClickOutside`).\n  useFloatingClickOutside({\n    isOpen,\n    floatingWrapperNode,\n    triggerElementReference,\n    onClickOutsideRef,\n  });\n\n  // Route controlled-flip transitions through the SAME onOpen/onClose callbacks, tagged\n  // `reason: 'controlled-flip'`. The interaction handlers above emit `reason: 'interaction'` in the\n  // event catch phase; these cover the transitions driven by the consumer flipping\n  // `externallyControlledIsOpen`, which have no interaction to hang off \u2014 the sanctioned \"sync with\n  // external system\" effect (see the hook). One callback, one contract; `reason` discriminates.\n  const handleControlledOpen = useCallback(() => {\n    onOpenRef.current?.({ reason: 'controlled-flip', isControlled: true });\n  }, [onOpenRef]);\n  const handleControlledClose = useCallback(() => {\n    onCloseRef.current?.({ reason: 'controlled-flip', isControlled: true });\n  }, [onCloseRef]);\n  useSyntheticEventFromControlledState({\n    controlledValue: externallyControlledIsOpen,\n    onEnter: handleControlledOpen,\n    onExit: handleControlledClose,\n  });\n\n  // Expose visibility via opacity (NOT visibility:hidden \u2014 that blocks programmatic focus,\n  // breaking autoFocus on first-open before the position-computation effect can run).\n  // When `externalReferenceElement` is provided, computation runs on the first useLayoutEffect\n  // (reference is known synchronously), so the popper becomes interactive in the same commit.\n  const computedFloatingStyles = useMemo<React.CSSProperties>(() => {\n    const isInteractive = isOpen && hasComputedOnce && !isReferenceHiddenByBoundary;\n    return {\n      ...floatingStyles,\n      opacity: isInteractive ? 1 : 0,\n      pointerEvents: isInteractive ? 'auto' : 'none',\n    };\n  }, [floatingStyles, hasComputedOnce, isOpen, isReferenceHiddenByBoundary]);\n\n  const refs = useMemo(\n    () => ({\n      setReference: setReferenceElement,\n      setFloating: setFloatingWrapperNode,\n      floating: floatingWrapperNode,\n      reference: triggerElementReference,\n    }),\n    [setReferenceElement, floatingWrapperNode, triggerElementReference],\n  );\n\n  const handlers = useMemo(\n    () => ({\n      onMouseEnter: tooltipHelpers.onMouseEnter,\n      onMouseLeave: tooltipHelpers.onMouseLeave,\n      onFocus: tooltipHelpers.onFocus,\n      onBlur: tooltipHelpers.onBlur,\n    }),\n    [tooltipHelpers.onBlur, tooltipHelpers.onFocus, tooltipHelpers.onMouseEnter, tooltipHelpers.onMouseLeave],\n  );\n\n  return useMemo(\n    () => ({\n      refs,\n      floatingStyles: computedFloatingStyles,\n      handlers,\n      isOpen,\n      arrowStyles,\n      hideTooltip,\n      showTooltip,\n      context: {\n        withoutPortal,\n        withoutAnimation,\n        portalDOMContainer,\n        animationDuration,\n      },\n      mutableUpdateStyles,\n      forceUpdatePosition: updateStyles,\n    }),\n    [\n      refs,\n      computedFloatingStyles,\n      handlers,\n      isOpen,\n      arrowStyles,\n      hideTooltip,\n      showTooltip,\n      withoutPortal,\n      withoutAnimation,\n      portalDOMContainer,\n      animationDuration,\n      mutableUpdateStyles,\n      updateStyles,\n    ],\n  );\n};\n\nuseFloatingContext.displayName = 'FloatingContext';\nconst UseFloatingContextWithSchema = describe(useFloatingContext);\nUseFloatingContextWithSchema.propTypes =\n  DSFloatingContextPropTypes as unknown as ValidationMap<DSHookFloatingContextT.Props>;\n\nexport { useFloatingContext, UseFloatingContextWithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
   "names": ["React"]
 }

package/dist/cjs/hooks/useFloatingClickOutside.js

@@ -0,0 +1,60 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useFloatingClickOutside_exports = {};
+__export(useFloatingClickOutside_exports, {
+  useFloatingClickOutside: () => useFloatingClickOutside
+});
+module.exports = __toCommonJS(useFloatingClickOutside_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useFloatingClickOutside = ({
+  isOpen,
+  floatingWrapperNode,
+  triggerElementReference,
+  onClickOutsideRef
+}) => {
+  (0, import_react.useEffect)(() => {
+    if (!isOpen || !floatingWrapperNode || !triggerElementReference) return void 0;
+    const listener = (event) => {
+      const cb = onClickOutsideRef.current;
+      if (!cb) return;
+      const target = event.target;
+      if (!target) return;
+      if (floatingWrapperNode.contains(target) || triggerElementReference.contains(target)) return;
+      cb(event);
+    };
+    document.addEventListener("mousedown", listener, true);
+    document.addEventListener("touchstart", listener, true);
+    return () => {
+      document.removeEventListener("mousedown", listener, true);
+      document.removeEventListener("touchstart", listener, true);
+    };
+  }, [floatingWrapperNode, triggerElementReference, onClickOutsideRef, isOpen]);
+};
+//# sourceMappingURL=useFloatingClickOutside.js.map

package/dist/cjs/hooks/useFloatingClickOutside.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useFloatingClickOutside.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useEffect, type MutableRefObject } from 'react';\n\ninterface UseFloatingClickOutsideParams {\n  isOpen: boolean;\n  floatingWrapperNode: HTMLElement | null;\n  triggerElementReference: Element | null;\n  /**\n   * Latest-ref of the click-outside callback. Passed as a ref (rather than a value)\n   * so consumers can pass inline functions without re-attaching listeners on every render.\n   * Use `useLatestRef(onClickOutside)` to construct it.\n   */\n  onClickOutsideRef: MutableRefObject<((event: MouseEvent | TouchEvent) => void) | undefined>;\n}\n\n/**\n * Attaches mousedown/touchstart listeners on the document that fire when the click target\n * is outside BOTH the floating element and the reference element.\n *\n * Only active when `enabled === true` and both elements exist.\n */\nexport const useFloatingClickOutside = ({\n  isOpen,\n  floatingWrapperNode,\n  triggerElementReference,\n  onClickOutsideRef,\n}: UseFloatingClickOutsideParams) => {\n  useEffect(() => {\n    if (!isOpen || !floatingWrapperNode || !triggerElementReference) return undefined;\n\n    const listener = (event: MouseEvent | TouchEvent) => {\n      const cb = onClickOutsideRef.current;\n      if (!cb) return;\n      const target = event.target as Node | null;\n      if (!target) return;\n      if (floatingWrapperNode.contains(target) || triggerElementReference.contains(target)) return;\n      cb(event);\n    };\n\n    document.addEventListener('mousedown', listener, true);\n    document.addEventListener('touchstart', listener, true);\n    return () => {\n      document.removeEventListener('mousedown', listener, true);\n      document.removeEventListener('touchstart', listener, true);\n    };\n  }, [floatingWrapperNode, triggerElementReference, onClickOutsideRef, isOpen]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAiD;AAoB1C,MAAM,0BAA0B,CAAC;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAqC;AACnC,8BAAU,MAAM;AACd,QAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,wBAAyB,QAAO;AAExE,UAAM,WAAW,CAAC,UAAmC;AACnD,YAAM,KAAK,kBAAkB;AAC7B,UAAI,CAAC,GAAI;AACT,YAAM,SAAS,MAAM;AACrB,UAAI,CAAC,OAAQ;AACb,UAAI,oBAAoB,SAAS,MAAM,KAAK,wBAAwB,SAAS,MAAM,EAAG;AACtF,SAAG,KAAK;AAAA,IACV;AAEA,aAAS,iBAAiB,aAAa,UAAU,IAAI;AACrD,aAAS,iBAAiB,cAAc,UAAU,IAAI;AACtD,WAAO,MAAM;AACX,eAAS,oBAAoB,aAAa,UAAU,IAAI;AACxD,eAAS,oBAAoB,cAAc,UAAU,IAAI;AAAA,IAC3D;AAAA,EACF,GAAG,CAAC,qBAAqB,yBAAyB,mBAAmB,MAAM,CAAC;AAC9E;",
+  "names": []
+}

package/dist/cjs/hooks/useFloatingResizeObserver.js

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useFloatingResizeObserver_exports = {};
+__export(useFloatingResizeObserver_exports, {
+  useFloatingResizeObserver: () => useFloatingResizeObserver
+});
+module.exports = __toCommonJS(useFloatingResizeObserver_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useFloatingResizeObserver = ({
+  isOpen,
+  floatingWrapperNode,
+  onResize
+}) => {
+  const onResizeRef = (0, import_react.useRef)(onResize);
+  onResizeRef.current = onResize;
+  (0, import_react.useEffect)(() => {
+    if (!isOpen || !floatingWrapperNode) return void 0;
+    const observer = new ResizeObserver(() => {
+      onResizeRef.current();
+    });
+    observer.observe(floatingWrapperNode);
+    return () => observer.disconnect();
+  }, [isOpen, floatingWrapperNode]);
+};
+//# sourceMappingURL=useFloatingResizeObserver.js.map

package/dist/cjs/hooks/useFloatingResizeObserver.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useFloatingResizeObserver.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useEffect, useRef } from 'react';\n\ninterface UseFloatingResizeObserverParams {\n  isOpen: boolean;\n  floatingWrapperNode: HTMLElement | null;\n  onResize: () => void;\n}\n\n/**\n * Observes the floating element's size and calls `onResize` when its bounding box changes.\n * Used to re-run position computation when the floating content reflows (e.g. async-loaded data).\n */\nexport const useFloatingResizeObserver = ({\n  isOpen,\n  floatingWrapperNode,\n  onResize,\n}: UseFloatingResizeObserverParams) => {\n  // Latest-ref so an inline `onResize` does not invalidate the effect on every render.\n  // ResizeObserver fires an initial callback on `observe()`, so re-subscribing every render\n  // would call `onResize` \u2192 setState \u2192 re-render \u2192 re-subscribe \u2192 infinite loop.\n  const onResizeRef = useRef(onResize);\n  onResizeRef.current = onResize;\n\n  useEffect(() => {\n    if (!isOpen || !floatingWrapperNode) return undefined;\n\n    const observer = new ResizeObserver(() => {\n      onResizeRef.current();\n    });\n    observer.observe(floatingWrapperNode);\n\n    return () => observer.disconnect();\n  }, [isOpen, floatingWrapperNode]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAkC;AAY3B,MAAM,4BAA4B,CAAC;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AACF,MAAuC;AAIrC,QAAM,kBAAc,qBAAO,QAAQ;AACnC,cAAY,UAAU;AAEtB,8BAAU,MAAM;AACd,QAAI,CAAC,UAAU,CAAC,oBAAqB,QAAO;AAE5C,UAAM,WAAW,IAAI,eAAe,MAAM;AACxC,kBAAY,QAAQ;AAAA,IACtB,CAAC;AACD,aAAS,QAAQ,mBAAmB;AAEpC,WAAO,MAAM,SAAS,WAAW;AAAA,EACnC,GAAG,CAAC,QAAQ,mBAAmB,CAAC;AAClC;",
+  "names": []
+}

package/dist/cjs/hooks/useLatestRef.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useLatestRef_exports = {};
+__export(useLatestRef_exports, {
+  useLatestRef: () => useLatestRef
+});
+module.exports = __toCommonJS(useLatestRef_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useLatestRef = (value) => {
+  const ref = (0, import_react.useRef)(value);
+  ref.current = value;
+  return ref;
+};
+//# sourceMappingURL=useLatestRef.js.map

package/dist/cjs/hooks/useLatestRef.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useLatestRef.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useRef } from 'react';\n\n/**\n * Latest-ref pattern: keeps the value in a ref that's updated on every render.\n * Use this when an effect/listener needs to read the latest value of a prop or callback\n * without including it in the effect's dependency array \u2014 avoids re-attaching listeners\n * (and infinite loops via deep-equal comparators) when consumers pass inline callbacks.\n */\nexport const useLatestRef = <T>(value: T) => {\n  const ref = useRef(value);\n  ref.current = value;\n  return ref;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAuB;AAQhB,MAAM,eAAe,CAAI,UAAa;AAC3C,QAAM,UAAM,qBAAO,KAAK;AACxB,MAAI,UAAU;AACd,SAAO;AACT;",
+  "names": []
+}

package/dist/cjs/hooks/useReferenceHiddenByBoundary.js

@@ -0,0 +1,59 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useReferenceHiddenByBoundary_exports = {};
+__export(useReferenceHiddenByBoundary_exports, {
+  useReferenceHiddenByBoundary: () => useReferenceHiddenByBoundary
+});
+module.exports = __toCommonJS(useReferenceHiddenByBoundary_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useReferenceHiddenByBoundary = ({
+  reference,
+  boundaryElement,
+  enabled
+}) => {
+  const [isHidden, setIsHidden] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    if (!enabled || !reference || !boundaryElement || !window.IntersectionObserver) {
+      setIsHidden(false);
+      return () => {
+      };
+    }
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        setIsHidden(!entry.isIntersecting);
+      },
+      { root: boundaryElement, threshold: 0 }
+    );
+    observer.observe(reference);
+    return () => observer.disconnect();
+  }, [enabled, reference, boundaryElement]);
+  return isHidden;
+};
+//# sourceMappingURL=useReferenceHiddenByBoundary.js.map

package/dist/cjs/hooks/useReferenceHiddenByBoundary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useReferenceHiddenByBoundary.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useEffect, useState } from 'react';\n\n/**\n * Tracks whether `reference` is currently visible at all within `boundaryElement` \u2014 e.g. a\n * scrollable ancestor the reference lives inside. Returns true the moment the reference scrolls\n * fully out of that boundary's visible area (intersection ratio 0), even though it may still be\n * within the browser viewport; flips back to false as soon as it's visible again. This is what\n * boundaryElement/clamping cannot solve on its own: a clamped floating element just sticks at\n * the boundary's edge, orphaned, once its reference is no longer visible to anchor it to \u2014 the\n * consumer still considers it \"open,\" it should just not be shown while its anchor isn't there.\n *\n * Always false (inert) when boundaryElement is not provided \u2014 this is opt-in, paired with\n * useFloatingContext's boundaryElement prop.\n */\nexport const useReferenceHiddenByBoundary = ({\n  reference,\n  boundaryElement,\n  enabled,\n}: {\n  reference: Element | null;\n  boundaryElement?: Element | null;\n  enabled: boolean;\n}): boolean => {\n  const [isHidden, setIsHidden] = useState(false);\n\n  // Justified per antipattern_useeffect_misuse.md: this subscribes to a browser observer API\n  // (IntersectionObserver), the same external-subscription shape as usePositionObserver.ts in\n  // this package \u2014 not derivable via useMemo, since intersection with a scrollable ancestor is\n  // asynchronous, browser-computed layout state, not something React can compute from props.\n  useEffect(() => {\n    if (!enabled || !reference || !boundaryElement || !window.IntersectionObserver) {\n      setIsHidden(false);\n      return () => {};\n    }\n\n    const observer = new IntersectionObserver(\n      ([entry]) => {\n        setIsHidden(!entry.isIntersecting);\n      },\n      { root: boundaryElement, threshold: 0 },\n    );\n    observer.observe(reference);\n\n    return () => observer.disconnect();\n  }, [enabled, reference, boundaryElement]);\n\n  return isHidden;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAoC;AAc7B,MAAM,+BAA+B,CAAC;AAAA,EAC3C;AAAA,EACA;AAAA,EACA;AACF,MAIe;AACb,QAAM,CAAC,UAAU,WAAW,QAAI,uBAAS,KAAK;AAM9C,8BAAU,MAAM;AACd,QAAI,CAAC,WAAW,CAAC,aAAa,CAAC,mBAAmB,CAAC,OAAO,sBAAsB;AAC9E,kBAAY,KAAK;AACjB,aAAO,MAAM;AAAA,MAAC;AAAA,IAChB;AAEA,UAAM,WAAW,IAAI;AAAA,MACnB,CAAC,CAAC,KAAK,MAAM;AACX,oBAAY,CAAC,MAAM,cAAc;AAAA,MACnC;AAAA,MACA,EAAE,MAAM,iBAAiB,WAAW,EAAE;AAAA,IACxC;AACA,aAAS,QAAQ,SAAS;AAE1B,WAAO,MAAM,SAAS,WAAW;AAAA,EACnC,GAAG,CAAC,SAAS,WAAW,eAAe,CAAC;AAExC,SAAO;AACT;",
+  "names": []
+}

package/dist/cjs/hooks/useResolvedReference.js

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useResolvedReference_exports = {};
+__export(useResolvedReference_exports, {
+  useResolvedReference: () => useResolvedReference
+});
+module.exports = __toCommonJS(useResolvedReference_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const useResolvedReference = ({
+  externalReferenceElement,
+  internalReferenceElement,
+  setInternalReferenceElement
+}) => {
+  const hasExternalReference = externalReferenceElement !== void 0;
+  const triggerElementReference = hasExternalReference ? externalReferenceElement : internalReferenceElement;
+  const setReferenceElement = (0, import_react.useCallback)(
+    (el) => {
+      if (hasExternalReference) return;
+      setInternalReferenceElement(el);
+    },
+    [hasExternalReference, setInternalReferenceElement]
+  );
+  return { triggerElementReference, setReferenceElement };
+};
+//# sourceMappingURL=useResolvedReference.js.map

package/dist/cjs/hooks/useResolvedReference.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useResolvedReference.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useCallback } from 'react';\n\ninterface UseResolvedReferenceParams {\n  externalReferenceElement: Element | null | undefined;\n  internalReferenceElement: Element | null;\n  setInternalReferenceElement: (el: Element | null) => void;\n}\n\n/**\n * Resolves the active reference element for the floating context.\n *\n * - When `externalReferenceElement` is provided (anything other than `undefined`, including `null`),\n *   it is used as the source of truth. `setReference` becomes a no-op so consumers that mistakenly\n *   call `refs.setReference()` don't desynchronize the two sources.\n * - Otherwise the internally-managed state is used, populated by the consumer via `refs.setReference()`\n *   (typically as a callback ref: `innerRef={refs.setReference}`).\n */\nexport const useResolvedReference = ({\n  externalReferenceElement,\n  internalReferenceElement,\n  setInternalReferenceElement,\n}: UseResolvedReferenceParams) => {\n  const hasExternalReference = externalReferenceElement !== undefined;\n  const triggerElementReference = hasExternalReference ? externalReferenceElement : internalReferenceElement;\n\n  const setReferenceElement = useCallback(\n    (el: Element | null) => {\n      if (hasExternalReference) return;\n      setInternalReferenceElement(el);\n    },\n    [hasExternalReference, setInternalReferenceElement],\n  );\n\n  return { triggerElementReference, setReferenceElement };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA4B;AAiBrB,MAAM,uBAAuB,CAAC;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AACF,MAAkC;AAChC,QAAM,uBAAuB,6BAA6B;AAC1D,QAAM,0BAA0B,uBAAuB,2BAA2B;AAElF,QAAM,0BAAsB;AAAA,IAC1B,CAAC,OAAuB;AACtB,UAAI,qBAAsB;AAC1B,kCAA4B,EAAE;AAAA,IAChC;AAAA,IACA,CAAC,sBAAsB,2BAA2B;AAAA,EACpD;AAEA,SAAO,EAAE,yBAAyB,oBAAoB;AACxD;",
+  "names": []
+}