@navikt/ds-react 6.7.0 → 6.8.0

package/esm/overlay/dismiss/DismissableLayer.js

@@ -0,0 +1,226 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef, useEffect, useMemo, useRef, useState, } from "react";
+import { Slot } from "../../util/Slot.js";
+import { useMergeRefs } from "../../util/hooks/index.js";
+import { createDescendantContext } from "../../util/hooks/descendants/useDescendant.js";
+import { useEscapeKeydown } from "./util/useEscapeKeydown.js";
+import { useFocusOutside } from "./util/useFocusOutside.js";
+import { usePointerDownOutside } from "./util/usePointerDownOutside.js";
+export const [DismissableDescendantsProvider, useDismissableDescendantsContext, useDismissableDescendants, useDismissableDescendant,] = createDescendantContext();
+let originalBodyPointerEvents;
+const DismissableLayer = forwardRef((props, ref) => {
+    const context = useDismissableDescendantsContext(false);
+    /**
+     * To correctly handle nested DismissableLayer,
+     * we only initialize the `Descendants`-API for the root layer to aboid resetting context
+     */
+    return context ? (React.createElement(DismissableLayerNode, Object.assign({ ref: ref }, props))) : (React.createElement(DismissableRoot, null,
+        React.createElement(DismissableLayerNode, Object.assign({ ref: ref }, props))));
+});
+/**
+ * DismissableRoot
+ *
+ * Used to initialize the `Descendants`-API at the root layer.
+ * All subsequent layers will use the same context.
+ */
+const DismissableRoot = ({ children }) => {
+    const descendants = useDismissableDescendants();
+    return (React.createElement(DismissableDescendantsProvider, { value: descendants }, children));
+};
+const DismissableLayerNode = forwardRef((_a, ref) => {
+    var _b;
+    var { children, asChild, onEscapeKeyDown, onPointerDownOutside, onFocusOutside, onInteractOutside, onDismiss, safeZone, disableOutsidePointerEvents = false, enabled = true } = _a, rest = __rest(_a, ["children", "asChild", "onEscapeKeyDown", "onPointerDownOutside", "onFocusOutside", "onInteractOutside", "onDismiss", "safeZone", "disableOutsidePointerEvents", "enabled"]);
+    const { register, index, descendants } = useDismissableDescendant({
+        disableOutsidePointerEvents,
+        disabled: !enabled,
+    });
+    /**
+     * `node` will be set to the ref of the component or nested component
+     * Ex: If
+     * ```
+     * <DismissableLayer asChild>
+     *   <Popover />
+     * </DismissableLayer>
+     * ```
+     * `node` will in this case be the Popover-element.
+     * We use State her and not ref since we want to trigger a rerender when the node changes.
+     */
+    const [node, setNode] = useState(null);
+    const mergedRefs = useMergeRefs(setNode, register, ref);
+    /**
+     * In some cases the `node.ownerDocument` can differ from global document.
+     * This can happend when portaling elements or using web-components
+     */
+    const ownerDocument = (_b = node === null || node === void 0 ? void 0 : node.ownerDocument) !== null && _b !== void 0 ? _b : globalThis === null || globalThis === void 0 ? void 0 : globalThis.document;
+    const hasInteractedOutsideRef = useRef(false);
+    const hasPointerDownOutsideRef = useRef(false);
+    const pointerEnabled = useMemo(() => {
+        let lastIndex = -1;
+        const descendantNodes = descendants.enabledValues();
+        descendantNodes.forEach((obj, _index) => {
+            if (obj.disableOutsidePointerEvents) {
+                lastIndex = _index;
+            }
+        });
+        return {
+            /**
+             * Makes sure we stop events at the highest layer with pointer events disabled.
+             * If not checked, we risk closing every layer when clicking outside the layer.
+             */
+            isPointerEventsEnabled: index >= lastIndex,
+            /**
+             * If we find a node with `disableOutsidePointerEvents` we want to disable pointer events on the body.
+             */
+            isBodyPointerEventsDisabled: lastIndex > -1,
+        };
+    }, [descendants, index]);
+    /**
+     * We want to prevent the Layer from closing when the trigger, anchor element, or its child elements are interacted with.
+     *
+     * To achieve this, we check if the event target is the trigger, anchor or a child. If it is, we prevent default event behavior.
+     *
+     * The `pointerDownOutside` and `focusOutside` handlers already check if the event target is within the DismissableLayer (`node`).
+     * However, since we don't add a `tabIndex` to the Popover/Tooltip, the `focusOutside` handler doesn't correctly handle focus events.
+     * Therefore, we also need to check that neither the trigger (`anchor`) nor the DismissableLayer (`dismissable`) are the event targets.
+     */
+    function handleOutsideEvent(event) {
+        var _a, _b;
+        if ((!(safeZone === null || safeZone === void 0 ? void 0 : safeZone.anchor) && !(safeZone === null || safeZone === void 0 ? void 0 : safeZone.dismissable)) || !enabled) {
+            return;
+        }
+        if (!event.defaultPrevented) {
+            hasInteractedOutsideRef.current = true;
+            if (event.detail.originalEvent.type === "pointerdown") {
+                hasPointerDownOutsideRef.current = true;
+            }
+        }
+        const target = event.target;
+        /**
+         * pointerdown-events works as expected, but focus-events does not.
+         * For focus-event we need to also check `safeZone.dismissable` (the Popover/Tooltip itself) since it does not have a tabIndex.
+         */
+        if (event.detail.originalEvent.type === "pointerdown") {
+            const targetIsTrigger = ((_a = safeZone === null || safeZone === void 0 ? void 0 : safeZone.anchor) === null || _a === void 0 ? void 0 : _a.contains(target)) || target === (safeZone === null || safeZone === void 0 ? void 0 : safeZone.anchor);
+            targetIsTrigger && event.preventDefault();
+        }
+        else {
+            const targetIsNotTrigger = target instanceof HTMLElement &&
+                ![safeZone === null || safeZone === void 0 ? void 0 : safeZone.anchor, safeZone === null || safeZone === void 0 ? void 0 : safeZone.dismissable].some((element) => element === null || element === void 0 ? void 0 : element.contains(target)) &&
+                !target.contains((_b = safeZone === null || safeZone === void 0 ? void 0 : safeZone.dismissable) !== null && _b !== void 0 ? _b : null);
+            !targetIsNotTrigger && event.preventDefault();
+        }
+        /**
+         * In Safari, if the trigger element is inside a container with tabIndex={0}, a click on the trigger
+         * will first fire a 'pointerdownoutside' event on the trigger itself. However, it will then fire a
+         * 'focusoutside' event on the container.
+         *
+         * To handle this, we ignore any 'focusoutside' events if a 'pointerdownoutside' event has already occurred.
+         * 'pointerdownoutside' event is sufficient to indicate interaction outside the DismissableLayer.
+         */
+        if (event.detail.originalEvent.type === "focusin" &&
+            hasPointerDownOutsideRef.current) {
+            event.preventDefault();
+        }
+        hasPointerDownOutsideRef.current = false;
+        hasInteractedOutsideRef.current = false;
+    }
+    const pointerDownOutside = usePointerDownOutside((event) => {
+        if (!pointerEnabled.isPointerEventsEnabled || !enabled) {
+            return;
+        }
+        /**
+         * We call these before letting `handleOutsideEvent` do its checks to give consumer a chance to preventDefault based certain cases.
+         */
+        onPointerDownOutside === null || onPointerDownOutside === void 0 ? void 0 : onPointerDownOutside(event);
+        onInteractOutside === null || onInteractOutside === void 0 ? void 0 : onInteractOutside(event);
+        /**
+         * Add safeZone to prevent closing when interacting with trigger/anchor or its children.
+         */
+        safeZone && handleOutsideEvent(event);
+        /**
+         * Both `onPointerDownOutside` and `onInteractOutside` are able to preventDefault the event, thus stopping call for `onDismiss`.
+         */
+        if (!event.defaultPrevented && onDismiss) {
+            onDismiss();
+        }
+    }, ownerDocument);
+    const focusOutside = useFocusOutside((event) => {
+        if (!enabled) {
+            return;
+        }
+        /**
+         * We call these before letting `handleOutsideEvent` do its checks to give consumer a chance to preventDefault based certain cases.
+         */
+        onFocusOutside === null || onFocusOutside === void 0 ? void 0 : onFocusOutside(event);
+        onInteractOutside === null || onInteractOutside === void 0 ? void 0 : onInteractOutside(event);
+        /**
+         * Add safeZone to prevent closing when interacting with trigger/anchor or its children.
+         */
+        safeZone && handleOutsideEvent(event);
+        /**
+         * Both `onFocusOutside` and `onInteractOutside` are able to preventDefault the event, thus stopping call for `onDismiss`.
+         */
+        if (!event.defaultPrevented && onDismiss) {
+            onDismiss();
+        }
+    }, ownerDocument);
+    useEscapeKeydown((event) => {
+        if (!enabled) {
+            return;
+        }
+        /**
+         * The deepest nested element will always be last in the descendants list.
+         * This allows us to only close the highest layer when pressing escape.
+         *
+         * In some cases a layer might still exist, but be disabled. We want to ignore these layers.
+         */
+        const isHighestLayer = index === descendants.enabledCount() - 1;
+        if (!isHighestLayer) {
+            return;
+        }
+        /**
+         * We call this before letting `handleOutsideEvent` do its checks to give consumer a chance to preventDefault based certain cases.
+         */
+        onEscapeKeyDown === null || onEscapeKeyDown === void 0 ? void 0 : onEscapeKeyDown(event);
+        /**
+         * `onEscapeKeyDown` is able to preventDefault the event, thus stopping call for `onDismiss`.
+         * We want to `preventDefault` the escape-event to avoid sideeffect from other elements on screen
+         */
+        if (!event.defaultPrevented && onDismiss) {
+            event.preventDefault();
+            onDismiss();
+        }
+    }, ownerDocument);
+    /**
+     * If `disableOutsidePointerEvents` is true,
+     * we want to disable pointer events on the body when the first layer is opened.
+     */
+    useEffect(() => {
+        if (!node || !disableOutsidePointerEvents || index !== 0 || !enabled) {
+            return;
+        }
+        originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
+        ownerDocument.body.style.pointerEvents = "none";
+        return () => {
+            ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
+        };
+    }, [node, ownerDocument, disableOutsidePointerEvents, index, enabled]);
+    const Comp = asChild ? Slot : "div";
+    return (React.createElement(Comp, Object.assign({ ref: mergedRefs }, rest, { onFocusCapture: focusOutside.onFocusCapture, onBlurCapture: focusOutside.onBlurCapture, onPointerDownCapture: pointerDownOutside.onPointerDownCapture, style: Object.assign({ pointerEvents: pointerEnabled.isBodyPointerEventsDisabled
+                ? pointerEnabled.isPointerEventsEnabled
+                    ? "auto"
+                    : "none"
+                : undefined }, rest.style) }), children));
+});
+export { DismissableLayer };
+//# sourceMappingURL=DismissableLayer.js.map

package/esm/overlay/dismiss/DismissableLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DismissableLayer.js","sourceRoot":"","sources":["../../../src/overlay/dismiss/DismissableLayer.tsx"],"names":[],"mappings":"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"}

package/esm/overlay/dismiss/util/dispatchCustomEvent.d.ts

@@ -0,0 +1,50 @@
+type CustomFocusEvent = CustomEvent<{
+    originalEvent: FocusEvent;
+}>;
+type CustomPointerDownEvent = CustomEvent<{
+    originalEvent: PointerEvent;
+}>;
+export { CustomFocusEvent, CustomPointerDownEvent };
+export declare const CUSTOM_EVENTS: {
+    FOCUS_OUTSIDE: string;
+    POINTER_DOWN_OUTSIDE: string;
+};
+/**
+ * Use of `discrete` flushes custom event dispatch. This is to mimic the behavior React has for `discrete` events.
+ * https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L318
+ *
+ * React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.
+ *
+ * Internally, React prioritises events in the following order:
+ *  - discrete
+ *  - continuous
+ *  - default
+ *
+ * `discrete` is an  important distinction as updates within these events are applied immediately.
+ * React however, is not able to infer the priority of custom event types due to how they are detected internally.
+ * Because of this, it's possible for updates from custom events to be unexpectedly batched when
+ * dispatched by another `discrete` event.
+ *
+ * In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.
+ * This utility should be used when dispatching a custom event from within another `discrete` event, this utility
+ * is not nessesary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.
+ * For example:
+ *
+ * dispatching a known click 👎
+ * target.dispatchEvent(new Event(‘click’))
+ *
+ * dispatching a custom type within a non-discrete event 👎
+ * onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}
+ *
+ * dispatching a custom type within a `discrete` event 👍
+ * onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}
+ *
+ * Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use
+ * this utility with them. This is because it's possible for those handlers to be called implicitly during render
+ * e.g. when focus is within a component as it is unmounted, or when managing focus on mount.
+ */
+export declare function dispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(name: string, handler: ((event: E) => void) | undefined, detail: {
+    originalEvent: OriginalEvent;
+} & (E extends CustomEvent<infer D> ? D : never), { discrete }?: {
+    discrete: boolean;
+}): void;

package/esm/overlay/dismiss/util/dispatchCustomEvent.js

@@ -0,0 +1,58 @@
+import ReactDOM from "react-dom";
+export const CUSTOM_EVENTS = {
+    FOCUS_OUTSIDE: "AKSEL_FOCUS_OUTSIDE",
+    POINTER_DOWN_OUTSIDE: "AKSEL_POINTER_DOWN_OUTSIDE",
+};
+/**
+ * Use of `discrete` flushes custom event dispatch. This is to mimic the behavior React has for `discrete` events.
+ * https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L318
+ *
+ * React batches *all* event handlers since version 18, this introduces certain considerations when using custom event types.
+ *
+ * Internally, React prioritises events in the following order:
+ *  - discrete
+ *  - continuous
+ *  - default
+ *
+ * `discrete` is an  important distinction as updates within these events are applied immediately.
+ * React however, is not able to infer the priority of custom event types due to how they are detected internally.
+ * Because of this, it's possible for updates from custom events to be unexpectedly batched when
+ * dispatched by another `discrete` event.
+ *
+ * In order to ensure that updates from custom events are applied predictably, we need to manually flush the batch.
+ * This utility should be used when dispatching a custom event from within another `discrete` event, this utility
+ * is not nessesary when dispatching known event types, or if dispatching a custom type inside a non-discrete event.
+ * For example:
+ *
+ * dispatching a known click 👎
+ * target.dispatchEvent(new Event(‘click’))
+ *
+ * dispatching a custom type within a non-discrete event 👎
+ * onScroll={(event) => event.target.dispatchEvent(new CustomEvent(‘customType’))}
+ *
+ * dispatching a custom type within a `discrete` event 👍
+ * onPointerDown={(event) => dispatchDiscreteCustomEvent(event.target, new CustomEvent(‘customType’))}
+ *
+ * Note: though React classifies `focus`, `focusin` and `focusout` events as `discrete`, it's  not recommended to use
+ * this utility with them. This is because it's possible for those handlers to be called implicitly during render
+ * e.g. when focus is within a component as it is unmounted, or when managing focus on mount.
+ */
+export function dispatchCustomEvent(name, handler, detail, { discrete } = { discrete: false }) {
+    if (!handler) {
+        return;
+    }
+    const target = detail.originalEvent.target;
+    const event = new CustomEvent(name, {
+        bubbles: false,
+        cancelable: true,
+        detail,
+    });
+    target.addEventListener(name, handler, { once: true });
+    if (discrete && target) {
+        ReactDOM.flushSync(() => target.dispatchEvent(event));
+    }
+    else {
+        target.dispatchEvent(event);
+    }
+}
+//# sourceMappingURL=dispatchCustomEvent.js.map

package/esm/overlay/dismiss/util/dispatchCustomEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchCustomEvent.js","sourceRoot":"","sources":["../../../../src/overlay/dismiss/util/dispatchCustomEvent.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,WAAW,CAAC;AASjC,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,aAAa,EAAE,qBAAqB;IACpC,oBAAoB,EAAE,4BAA4B;CACnD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,mBAAmB,CAIjC,IAAY,EACZ,OAAyC,EACzC,MAEU,EACV,EAAE,QAAQ,KAA4B,EAAE,QAAQ,EAAE,KAAK,EAAE;IAEzD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO;IACT,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC;IAC3C,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,IAAI,EAAE;QAClC,OAAO,EAAE,KAAK;QACd,UAAU,EAAE,IAAI;QAChB,MAAM;KACP,CAAC,CAAC;IAEH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAwB,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAExE,IAAI,QAAQ,IAAI,MAAM,EAAE,CAAC;QACvB,QAAQ,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;IACxD,CAAC;SAAM,CAAC;QACN,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;AACH,CAAC"}

package/esm/overlay/dismiss/util/useEscapeKeydown.d.ts

@@ -0,0 +1 @@
+export declare function useEscapeKeydown(callback?: (event: KeyboardEvent) => void, ownerDocument?: Document): void;

package/esm/overlay/dismiss/util/useEscapeKeydown.js

@@ -0,0 +1,15 @@
+import { useEffect } from "react";
+import { useCallbackRef } from "../../../util/hooks/index.js";
+export function useEscapeKeydown(callback, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
+    const onEscapeKeyDown = useCallbackRef(callback);
+    useEffect(() => {
+        const handleKeyDown = (event) => {
+            if (event.key === "Escape") {
+                onEscapeKeyDown(event);
+            }
+        };
+        ownerDocument.addEventListener("keydown", handleKeyDown, true);
+        return () => ownerDocument.removeEventListener("keydown", handleKeyDown, true);
+    }, [onEscapeKeyDown, ownerDocument]);
+}
+//# sourceMappingURL=useEscapeKeydown.js.map

package/esm/overlay/dismiss/util/useEscapeKeydown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEscapeKeydown.js","sourceRoot":"","sources":["../../../../src/overlay/dismiss/util/useEscapeKeydown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,UAAU,gBAAgB,CAC9B,QAAyC,EACzC,gBAA0B,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,QAAQ;IAE9C,MAAM,eAAe,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;IAEjD,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,aAAa,GAAG,CAAC,KAAoB,EAAE,EAAE;YAC7C,IAAI,KAAK,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;gBAC3B,eAAe,CAAC,KAAK,CAAC,CAAC;YACzB,CAAC;QACH,CAAC,CAAC;QAEF,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;QAC/D,OAAO,GAAG,EAAE,CACV,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;IACtE,CAAC,EAAE,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,CAAC;AACvC,CAAC"}

package/esm/overlay/dismiss/util/useFocusOutside.d.ts

@@ -0,0 +1,8 @@
+import { CustomFocusEvent } from "./dispatchCustomEvent.js";
+/**
+ * Tracks focus outside a React subtree. Returns props for the subtree root.
+ */
+export declare function useFocusOutside(callback?: (event: CustomFocusEvent) => void, ownerDocument?: Document): {
+    onFocusCapture: () => boolean;
+    onBlurCapture: () => boolean;
+};

package/esm/overlay/dismiss/util/useFocusOutside.js

@@ -0,0 +1,38 @@
+import { useEffect, useRef } from "react";
+import { useCallbackRef } from "../../../util/hooks/index.js";
+import { CUSTOM_EVENTS, dispatchCustomEvent, } from "./dispatchCustomEvent.js";
+/**
+ * Tracks focus outside a React subtree. Returns props for the subtree root.
+ */
+export function useFocusOutside(callback, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
+    const handleFocusOutside = useCallbackRef(callback);
+    const isFocusInsideReactTreeRef = useRef(false);
+    useEffect(() => {
+        const handleFocus = (event) => {
+            if (event.target && !isFocusInsideReactTreeRef.current) {
+                const eventDetail = { originalEvent: event };
+                /**
+                 * The `DismisableLayer`-API is based on the ability to stop events from propagating and in the end calling `onDismiss`
+                 * if `useFocusOutside`-callback runs `event.preventDefault()`.
+                 *
+                 * Because of the `focusin`-event not being cancelable,
+                 * we need to use a custom event to ensure that the event is cancelable.
+                 * https://developer.mozilla.org/en-US/docs/Web/API/Element/focusin_event
+                 * > The focusin event is not cancelable.
+                 */
+                dispatchCustomEvent(CUSTOM_EVENTS.FOCUS_OUTSIDE, handleFocusOutside, eventDetail);
+            }
+        };
+        ownerDocument.addEventListener("focusin", handleFocus);
+        return () => ownerDocument.removeEventListener("focusin", handleFocus);
+    }, [ownerDocument, handleFocusOutside]);
+    /**
+     * By directly setting isFocusInsideReactTreeRef on focus-events at the root of the "dismissable" element,
+     * we can eliminate the need for DOM traversal to verify if the focused element is within the react tree.
+     */
+    return {
+        onFocusCapture: () => (isFocusInsideReactTreeRef.current = true),
+        onBlurCapture: () => (isFocusInsideReactTreeRef.current = false),
+    };
+}
+//# sourceMappingURL=useFocusOutside.js.map

package/esm/overlay/dismiss/util/useFocusOutside.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusOutside.js","sourceRoot":"","sources":["../../../../src/overlay/dismiss/util/useFocusOutside.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EACL,aAAa,EAEb,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAE/B;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,QAA4C,EAC5C,gBAA0B,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,QAAQ;IAE9C,MAAM,kBAAkB,GAAG,cAAc,CAAC,QAAQ,CAAkB,CAAC;IACrE,MAAM,yBAAyB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAEhD,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,WAAW,GAAG,CAAC,KAAiB,EAAE,EAAE;YACxC,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,yBAAyB,CAAC,OAAO,EAAE,CAAC;gBACvD,MAAM,WAAW,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;gBAE7C;;;;;;;;mBAQG;gBACH,mBAAmB,CACjB,aAAa,CAAC,aAAa,EAC3B,kBAAkB,EAClB,WAAW,CACZ,CAAC;YACJ,CAAC;QACH,CAAC,CAAC;QACF,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QACvD,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IACzE,CAAC,EAAE,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAExC;;;OAGG;IACH,OAAO;QACL,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC,yBAAyB,CAAC,OAAO,GAAG,IAAI,CAAC;QAChE,aAAa,EAAE,GAAG,EAAE,CAAC,CAAC,yBAAyB,CAAC,OAAO,GAAG,KAAK,CAAC;KACjE,CAAC;AACJ,CAAC"}

package/esm/overlay/dismiss/util/usePointerDownOutside.d.ts

@@ -0,0 +1,10 @@
+import { CustomPointerDownEvent } from "./dispatchCustomEvent.js";
+/**
+ * Listens for `pointerdown` outside a react subtree. We use `pointerdown` rather than `pointerup`
+ * to mimic layer dismissing behaviour present in OS.
+ * Returns props to pass to the node we want to check for outside events.
+ * By checking `isPointerInsideReactTreeRef` we can determine if the event happened outside the subtree of the node, saving some element-comparisons.
+ */
+export declare function usePointerDownOutside(callback?: (event: CustomPointerDownEvent) => void, ownerDocument?: Document): {
+    onPointerDownCapture: () => boolean;
+};

package/esm/overlay/dismiss/util/usePointerDownOutside.js

@@ -0,0 +1,80 @@
+import { useEffect, useRef } from "react";
+import { useCallbackRef } from "../../../util/hooks/index.js";
+import { CUSTOM_EVENTS, dispatchCustomEvent, } from "./dispatchCustomEvent.js";
+/**
+ * Listens for `pointerdown` outside a react subtree. We use `pointerdown` rather than `pointerup`
+ * to mimic layer dismissing behaviour present in OS.
+ * Returns props to pass to the node we want to check for outside events.
+ * By checking `isPointerInsideReactTreeRef` we can determine if the event happened outside the subtree of the node, saving some element-comparisons.
+ */
+export function usePointerDownOutside(callback, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
+    const handlePointerDownOutside = useCallbackRef(callback);
+    const isPointerInsideReactTreeRef = useRef(false);
+    const handleClickRef = useRef(() => { });
+    useEffect(() => {
+        const handlePointerDown = (event) => {
+            /**
+             * The `DismisableLayer`-API is based on the ability to stop events from propagating and in the end calling `onDismiss`
+             * if `usePointerDownOutside` runs `event.preventDefault()`.
+             *
+             * Altrough `pointerdown` is already a cancelable event,
+             * to to make sure the batching of events works corretly with `focusIn` in `useFocusOutside`,
+             * we still use a custom event like in `useFocusOutside`.
+             *
+             * Since pointer-events are `discrete` events in React: https://github.com/facebook/react/blob/a8a4742f1c54493df00da648a3f9d26e3db9c8b5/packages/react-dom/src/events/ReactDOMEventListener.js#L318
+             * we need to to use flushSync to ensure that the event is dispatched before the next event is raised.
+             */
+            function dispatchPointerEvent() {
+                dispatchCustomEvent(CUSTOM_EVENTS.POINTER_DOWN_OUTSIDE, handlePointerDownOutside, { originalEvent: event }, { discrete: true });
+            }
+            if (event.target && !isPointerInsideReactTreeRef.current) {
+                /**
+                 * On touch devices, we delay reactivating pointer-events to account for the browser's delay in executing events after touch ends.
+                 * This also handles cancellations when no click event is raised due to scrolling or long-pressing.
+                 * We continuously remove the previous listener as we can't be sure it was raised and cleaned up.
+                 */
+                if (event.pointerType === "touch") {
+                    ownerDocument.removeEventListener("click", handleClickRef.current);
+                    handleClickRef.current = dispatchPointerEvent;
+                    ownerDocument.addEventListener("click", handleClickRef.current, {
+                        once: true,
+                    });
+                }
+                else {
+                    dispatchPointerEvent();
+                }
+            }
+            else {
+                // We need to remove the event listener in case the outside click has been canceled.
+                ownerDocument.removeEventListener("click", handleClickRef.current);
+            }
+            isPointerInsideReactTreeRef.current = false;
+        };
+        /**
+         * 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);
+        };
+    }, [ownerDocument, handlePointerDownOutside]);
+    return {
+        // ensures we check React component tree (not just DOM tree)
+        onPointerDownCapture: () => (isPointerInsideReactTreeRef.current = true),
+    };
+}
+//# sourceMappingURL=usePointerDownOutside.js.map

package/esm/overlay/dismiss/util/usePointerDownOutside.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePointerDownOutside.js","sourceRoot":"","sources":["../../../../src/overlay/dismiss/util/usePointerDownOutside.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EACL,aAAa,EAEb,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAE/B;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CACnC,QAAkD,EAClD,gBAA0B,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,QAAQ;IAE9C,MAAM,wBAAwB,GAAG,cAAc,CAAC,QAAQ,CAAkB,CAAC;IAC3E,MAAM,2BAA2B,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAClD,MAAM,cAAc,GAAG,MAAM,CAAkC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAEzE,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,iBAAiB,GAAG,CAAC,KAAmB,EAAE,EAAE;YAChD;;;;;;;;;;eAUG;YACH,SAAS,oBAAoB;gBAC3B,mBAAmB,CACjB,aAAa,CAAC,oBAAoB,EAClC,wBAAwB,EACxB,EAAE,aAAa,EAAE,KAAK,EAAE,EACxB,EAAE,QAAQ,EAAE,IAAI,EAAE,CACnB,CAAC;YACJ,CAAC;YAED,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,EAAE,CAAC;gBACzD;;;;mBAIG;gBACH,IAAI,KAAK,CAAC,WAAW,KAAK,OAAO,EAAE,CAAC;oBAClC,aAAa,CAAC,mBAAmB,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;oBACnE,cAAc,CAAC,OAAO,GAAG,oBAAoB,CAAC;oBAC9C,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,EAAE;wBAC9D,IAAI,EAAE,IAAI;qBACX,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,oBAAoB,EAAE,CAAC;gBACzB,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,oFAAoF;gBACpF,aAAa,CAAC,mBAAmB,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;YACrE,CAAC;YACD,2BAA2B,CAAC,OAAO,GAAG,KAAK,CAAC;QAC9C,CAAC,CAAC;QAEF;;;;;;;;;;;;WAYG;QACH,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE;YACrC,aAAa,CAAC,gBAAgB,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;QACnE,CAAC,EAAE,CAAC,CAAC,CAAC;QAEN,OAAO,GAAG,EAAE;YACV,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YAC7B,aAAa,CAAC,mBAAmB,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;YACpE,aAAa,CAAC,mBAAmB,CAAC,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;QACrE,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,aAAa,EAAE,wBAAwB,CAAC,CAAC,CAAC;IAE9C,OAAO;QACL,4DAA4D;QAC5D,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC,2BAA2B,CAAC,OAAO,GAAG,IAAI,CAAC;KACzE,CAAC;AACJ,CAAC"}

package/esm/overlays/floating/Floating.d.ts

@@ -0,0 +1,53 @@
+import React, { HTMLAttributes } from "react";
+import { AsChildProps } from "../../util/types/index.js";
+import { type Align, type Measurable, type Side } from "./Floating.utils.js";
+/**
+ * Floating Root
+ */
+type FloatingContextValue = {
+    anchor: Measurable | null;
+    onAnchorChange: (anchor: Measurable | null) => void;
+};
+export declare const FloatingProvider: React.ForwardRefExoticComponent<FloatingContextValue & {
+    children: React.ReactNode;
+} & React.RefAttributes<unknown>>, useFloatingContext: <S extends boolean = true>(strict?: S) => S extends true ? FloatingContextValue : FloatingContextValue | undefined;
+interface FloatingProps {
+    children: React.ReactNode;
+}
+interface FloatingComponent extends React.FC<FloatingProps> {
+    Anchor: typeof FloatingAnchor;
+    Content: typeof FloatingContent;
+}
+declare const Floating: FloatingComponent;
+/**
+ * Floating Anchor
+ */
+type FloatingAnchorProps = HTMLAttributes<HTMLDivElement> & AsChildProps & {
+    virtualRef?: React.RefObject<Measurable>;
+};
+/**
+ * `FloatingAnchor` provides an anchor for a Floating instance.
+ * Allows anchoring to non-DOM nodes like a cursor position when used with `virtualRef`.
+ */
+declare const FloatingAnchor: React.ForwardRefExoticComponent<FloatingAnchorProps & React.RefAttributes<HTMLDivElement>>;
+type Boundary = Element | null;
+interface FloatingContentProps extends HTMLAttributes<HTMLDivElement> {
+    side?: Side;
+    sideOffset?: number;
+    align?: Align;
+    alignOffset?: number;
+    avoidCollisions?: boolean;
+    collisionBoundary?: Boundary | Boundary[];
+    collisionPadding?: number | Partial<Record<Side, number>>;
+    hideWhenDetached?: boolean;
+    updatePositionStrategy?: "optimized" | "always";
+    onPlaced?: () => void;
+    arrow?: {
+        className?: string;
+        padding?: number;
+        width: number;
+        height: number;
+    };
+}
+declare const FloatingContent: React.ForwardRefExoticComponent<FloatingContentProps & React.RefAttributes<HTMLDivElement>>;
+export { Floating };