@navikt/ds-react 6.7.0 → 6.7.1

package/cjs/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/cjs/overlay/dismiss/util/dispatchCustomEvent.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchCustomEvent = exports.CUSTOM_EVENTS = void 0;
+const react_dom_1 = __importDefault(require("react-dom"));
+exports.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.
+ */
+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) {
+        react_dom_1.default.flushSync(() => target.dispatchEvent(event));
+    }
+    else {
+        target.dispatchEvent(event);
+    }
+}
+exports.dispatchCustomEvent = dispatchCustomEvent;
+//# sourceMappingURL=dispatchCustomEvent.js.map

package/cjs/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,0DAAiC;AASpB,QAAA,aAAa,GAAG;IAC3B,aAAa,EAAE,qBAAqB;IACpC,oBAAoB,EAAE,4BAA4B;CACnD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,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,mBAAQ,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;AA5BD,kDA4BC"}

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEscapeKeydown = void 0;
+const react_1 = require("react");
+const hooks_1 = require("../../../util/hooks");
+function useEscapeKeydown(callback, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
+    const onEscapeKeyDown = (0, hooks_1.useCallbackRef)(callback);
+    (0, react_1.useEffect)(() => {
+        const handleKeyDown = (event) => {
+            if (event.key === "Escape") {
+                onEscapeKeyDown(event);
+            }
+        };
+        ownerDocument.addEventListener("keydown", handleKeyDown, true);
+        return () => ownerDocument.removeEventListener("keydown", handleKeyDown, true);
+    }, [onEscapeKeyDown, ownerDocument]);
+}
+exports.useEscapeKeydown = useEscapeKeydown;
+//# sourceMappingURL=useEscapeKeydown.js.map

package/cjs/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,iCAAkC;AAClC,+CAAqD;AAErD,SAAgB,gBAAgB,CAC9B,QAAyC,EACzC,gBAA0B,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,QAAQ;IAE9C,MAAM,eAAe,GAAG,IAAA,sBAAc,EAAC,QAAQ,CAAC,CAAC;IAEjD,IAAA,iBAAS,EAAC,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;AAjBD,4CAiBC"}

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

@@ -0,0 +1,8 @@
+import { CustomFocusEvent } from "./dispatchCustomEvent";
+/**
+ * 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/cjs/overlay/dismiss/util/useFocusOutside.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusOutside = void 0;
+const react_1 = require("react");
+const hooks_1 = require("../../../util/hooks");
+const dispatchCustomEvent_1 = require("./dispatchCustomEvent");
+/**
+ * Tracks focus outside a React subtree. Returns props for the subtree root.
+ */
+function useFocusOutside(callback, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
+    const handleFocusOutside = (0, hooks_1.useCallbackRef)(callback);
+    const isFocusInsideReactTreeRef = (0, react_1.useRef)(false);
+    (0, react_1.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.
+                 */
+                (0, dispatchCustomEvent_1.dispatchCustomEvent)(dispatchCustomEvent_1.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),
+    };
+}
+exports.useFocusOutside = useFocusOutside;
+//# sourceMappingURL=useFocusOutside.js.map

package/cjs/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,iCAA0C;AAC1C,+CAAqD;AACrD,+DAI+B;AAE/B;;GAEG;AACH,SAAgB,eAAe,CAC7B,QAA4C,EAC5C,gBAA0B,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,QAAQ;IAE9C,MAAM,kBAAkB,GAAG,IAAA,sBAAc,EAAC,QAAQ,CAAkB,CAAC;IACrE,MAAM,yBAAyB,GAAG,IAAA,cAAM,EAAC,KAAK,CAAC,CAAC;IAEhD,IAAA,iBAAS,EAAC,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,IAAA,yCAAmB,EACjB,mCAAa,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;AAxCD,0CAwCC"}

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

@@ -0,0 +1,10 @@
+import { CustomPointerDownEvent } from "./dispatchCustomEvent";
+/**
+ * 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/cjs/overlay/dismiss/util/usePointerDownOutside.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePointerDownOutside = void 0;
+const react_1 = require("react");
+const hooks_1 = require("../../../util/hooks");
+const dispatchCustomEvent_1 = require("./dispatchCustomEvent");
+/**
+ * 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.
+ */
+function usePointerDownOutside(callback, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
+    const handlePointerDownOutside = (0, hooks_1.useCallbackRef)(callback);
+    const isPointerInsideReactTreeRef = (0, react_1.useRef)(false);
+    const handleClickRef = (0, react_1.useRef)(() => { });
+    (0, react_1.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() {
+                (0, dispatchCustomEvent_1.dispatchCustomEvent)(dispatchCustomEvent_1.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),
+    };
+}
+exports.usePointerDownOutside = usePointerDownOutside;
+//# sourceMappingURL=usePointerDownOutside.js.map

package/cjs/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,iCAA0C;AAC1C,+CAAqD;AACrD,+DAI+B;AAE/B;;;;;GAKG;AACH,SAAgB,qBAAqB,CACnC,QAAkD,EAClD,gBAA0B,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,QAAQ;IAE9C,MAAM,wBAAwB,GAAG,IAAA,sBAAc,EAAC,QAAQ,CAAkB,CAAC;IAC3E,MAAM,2BAA2B,GAAG,IAAA,cAAM,EAAC,KAAK,CAAC,CAAC;IAClD,MAAM,cAAc,GAAG,IAAA,cAAM,EAAkC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAEzE,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,MAAM,iBAAiB,GAAG,CAAC,KAAmB,EAAE,EAAE;YAChD;;;;;;;;;;eAUG;YACH,SAAS,oBAAoB;gBAC3B,IAAA,yCAAmB,EACjB,mCAAa,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;AAhFD,sDAgFC"}

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

@@ -0,0 +1,53 @@
+import React, { HTMLAttributes } from "react";
+import { AsChildProps } from "../../util/types";
+import { type Align, type Measurable, type Side } from "./Floating.utils";
+/**
+ * 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 };

package/cjs/overlays/floating/Floating.js

@@ -0,0 +1,215 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Floating = exports.useFloatingContext = exports.FloatingProvider = void 0;
+const react_dom_1 = require("@floating-ui/react-dom");
+const react_1 = __importStar(require("react"));
+const Slot_1 = require("../../util/Slot");
+const create_context_1 = require("../../util/create-context");
+const hooks_1 = require("../../util/hooks");
+const Floating_utils_1 = require("./Floating.utils");
+_a = (0, create_context_1.createContext)({
+    name: "FloatingContext",
+    hookName: "useFloating",
+    providerName: "FloatingProvider",
+}), exports.FloatingProvider = _a[0], exports.useFloatingContext = _a[1];
+const Floating = ({ children }) => {
+    const [anchor, setAnchor] = (0, react_1.useState)(null);
+    return (react_1.default.createElement(exports.FloatingProvider, { anchor: anchor, onAnchorChange: setAnchor }, children));
+};
+exports.Floating = Floating;
+/**
+ * `FloatingAnchor` provides an anchor for a Floating instance.
+ * Allows anchoring to non-DOM nodes like a cursor position when used with `virtualRef`.
+ */
+const FloatingAnchor = (0, react_1.forwardRef)((_a, forwardedRef) => {
+    var { virtualRef, asChild } = _a, rest = __rest(_a, ["virtualRef", "asChild"]);
+    const context = (0, exports.useFloatingContext)();
+    const ref = (0, react_1.useRef)(null);
+    const mergedRef = (0, hooks_1.useMergeRefs)(forwardedRef, ref);
+    (0, react_1.useEffect)(() => {
+        // Allows anchoring the floating to non-DOM nodes like a cursor position.
+        // We replace `anchorRef` with a virtual ref in such cases.
+        context.onAnchorChange((virtualRef === null || virtualRef === void 0 ? void 0 : virtualRef.current) || ref.current);
+    });
+    const Comp = asChild ? Slot_1.Slot : "div";
+    return virtualRef ? null : react_1.default.createElement(Comp, Object.assign({ ref: mergedRef }, rest));
+});
+/**
+ * Floating Arrow
+ */
+const OPPOSITE_SIDE = {
+    top: "bottom",
+    right: "left",
+    bottom: "top",
+    left: "right",
+};
+const FloatingArrow = ({ width, height, className }) => {
+    const context = useFloatingContentContext();
+    const side = OPPOSITE_SIDE[context.placedSide];
+    return (react_1.default.createElement("span", { ref: context.onArrowChange, style: {
+            position: "absolute",
+            left: context.arrowX,
+            top: context.arrowY,
+            [side]: 0,
+            transformOrigin: {
+                top: "",
+                right: "0 0",
+                bottom: "center 0",
+                left: "100% 0",
+            }[context.placedSide],
+            transform: {
+                top: "translateY(100%)",
+                right: "translateY(50%) rotate(90deg) translateX(-50%)",
+                bottom: `rotate(180deg)`,
+                left: "translateY(50%) rotate(-90deg) translateX(50%)",
+            }[context.placedSide],
+            visibility: context.hideArrow ? "hidden" : undefined,
+        }, "aria-hidden": true },
+        react_1.default.createElement("svg", { className: className, width: width, height: height, viewBox: "0 0 30 10", preserveAspectRatio: "none", style: { display: "block" } },
+            react_1.default.createElement("polygon", { points: "0,0 30,0 15,10" }))));
+};
+const [FloatingContentProvider, useFloatingContentContext] = (0, create_context_1.createContext)({
+    name: "FloatingContentContext",
+    hookName: "useFloatingContentContext",
+    providerName: "FloatingContentProvider",
+});
+const FloatingContent = (0, react_1.forwardRef)((_a, forwardedRef) => {
+    var _b, _c, _d, _e, _f, _g;
+    var { children, side = "bottom", sideOffset = 0, align = "center", alignOffset = 0, avoidCollisions = true, collisionBoundary = [], collisionPadding: collisionPaddingProp = 0, hideWhenDetached = false, updatePositionStrategy = "optimized", onPlaced, arrow: _arrow } = _a, contentProps = __rest(_a, ["children", "side", "sideOffset", "align", "alignOffset", "avoidCollisions", "collisionBoundary", "collisionPadding", "hideWhenDetached", "updatePositionStrategy", "onPlaced", "arrow"]);
+    const context = (0, exports.useFloatingContext)();
+    const [content, setContent] = (0, react_1.useState)(null);
+    const mergeRefs = (0, hooks_1.useMergeRefs)(forwardedRef, setContent);
+    const arrowDefaults = Object.assign({ padding: 5, width: 0, height: 0 }, _arrow);
+    const [arrow, setArrow] = (0, react_1.useState)(null);
+    const arrowWidth = arrowDefaults.width;
+    const arrowHeight = arrowDefaults.height;
+    const desiredPlacement = (side +
+        (align !== "center" ? "-" + align : ""));
+    const collisionPadding = typeof collisionPaddingProp === "number"
+        ? collisionPaddingProp
+        : Object.assign({ top: 0, right: 0, bottom: 0, left: 0 }, collisionPaddingProp);
+    const boundary = Array.isArray(collisionBoundary)
+        ? collisionBoundary
+        : [collisionBoundary];
+    const hasExplicitBoundaries = boundary.length > 0;
+    /**
+     * .filter(x => x !== null) does not narrow the type of the array enough.
+     */
+    function isNotNull(value) {
+        return value !== null;
+    }
+    const detectOverflowOptions = {
+        padding: collisionPadding,
+        boundary: boundary.filter(isNotNull),
+        // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
+        altBoundary: hasExplicitBoundaries,
+    };
+    const { refs, floatingStyles, placement, isPositioned, middlewareData } = (0, react_dom_1.useFloating)({
+        // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
+        strategy: "fixed",
+        placement: desiredPlacement,
+        whileElementsMounted: (...args) => {
+            const cleanup = (0, react_dom_1.autoUpdate)(...args, {
+                animationFrame: updatePositionStrategy === "always",
+            });
+            return cleanup;
+        },
+        elements: {
+            reference: context.anchor,
+        },
+        middleware: [
+            (0, react_dom_1.offset)({
+                mainAxis: sideOffset + arrowHeight,
+                alignmentAxis: alignOffset,
+            }),
+            avoidCollisions &&
+                (0, react_dom_1.shift)(Object.assign({ mainAxis: true, crossAxis: false, limiter: (0, react_dom_1.limitShift)() }, detectOverflowOptions)),
+            avoidCollisions && (0, react_dom_1.flip)(Object.assign({}, detectOverflowOptions)),
+            (0, react_dom_1.size)(Object.assign(Object.assign({}, detectOverflowOptions), { apply: ({ elements, rects, availableWidth, availableHeight }) => {
+                    const { width: anchorWidth, height: anchorHeight } = rects.reference;
+                    const contentStyle = elements.floating.style;
+                    /**
+                     * Allows styling and animations based on the available space.
+                     */
+                    contentStyle.setProperty("--ac-floating-available-width", `${availableWidth}px`);
+                    contentStyle.setProperty("--ac-floating-available-height", `${availableHeight}px`);
+                    contentStyle.setProperty("--ac-floating-anchor-width", `${anchorWidth}px`);
+                    contentStyle.setProperty("--ac-floating-anchor-height", `${anchorHeight}px`);
+                } })),
+            arrow &&
+                (0, react_dom_1.arrow)({ element: arrow, padding: arrowDefaults.padding }),
+            (0, Floating_utils_1.transformOrigin)({ arrowWidth, arrowHeight }),
+            hideWhenDetached &&
+                (0, react_dom_1.hide)(Object.assign({ strategy: "referenceHidden" }, detectOverflowOptions)),
+        ],
+    });
+    const [placedSide, placedAlign] = (0, Floating_utils_1.getSideAndAlignFromPlacement)(placement);
+    const handlePlaced = (0, hooks_1.useCallbackRef)(onPlaced);
+    (0, hooks_1.useClientLayoutEffect)(() => {
+        isPositioned && (handlePlaced === null || handlePlaced === void 0 ? void 0 : handlePlaced());
+    }, [isPositioned, handlePlaced]);
+    const arrowX = (_b = middlewareData.arrow) === null || _b === void 0 ? void 0 : _b.x;
+    const arrowY = (_c = middlewareData.arrow) === null || _c === void 0 ? void 0 : _c.y;
+    const cannotCenterArrow = ((_d = middlewareData.arrow) === null || _d === void 0 ? void 0 : _d.centerOffset) !== 0;
+    const [contentZIndex, setContentZIndex] = (0, react_1.useState)();
+    (0, hooks_1.useClientLayoutEffect)(() => {
+        if (content)
+            setContentZIndex(window.getComputedStyle(content).zIndex);
+    }, [content]);
+    return (react_1.default.createElement("div", { ref: refs.setFloating, "data-aksel-floating-content-wrapper": "", style: Object.assign(Object.assign({}, floatingStyles), { transform: isPositioned
+                ? floatingStyles.transform
+                : "translate(0, -200%)", minWidth: "max-content", zIndex: contentZIndex, ["--ac-floating-transform-origin"]: [
+                (_e = middlewareData.transformOrigin) === null || _e === void 0 ? void 0 : _e.x,
+                (_f = middlewareData.transformOrigin) === null || _f === void 0 ? void 0 : _f.y,
+            ].join(" ") }), 
+        // Floating UI uses the `dir` attribute on the reference/floating node for logical alignment.
+        // This attribute is necessary for both portalled and inline calculations.
+        dir: "ltr" },
+        react_1.default.createElement(FloatingContentProvider, { placedSide: placedSide, onArrowChange: setArrow, arrowX: arrowX, arrowY: arrowY, hideArrow: cannotCenterArrow },
+            react_1.default.createElement("div", Object.assign({ ref: mergeRefs, "data-side": placedSide, "data-align": placedAlign }, contentProps, { style: Object.assign(Object.assign({}, contentProps.style), { 
+                    // if the FloatingContent hasn't been placed yet (not all measurements done)
+                    // we prevent animations so that users's animation don't kick in too early referring wrong sides
+                    animation: !isPositioned ? "none" : undefined, 
+                    // hide the content if using the hide middleware and should be hidden
+                    opacity: ((_g = middlewareData.hide) === null || _g === void 0 ? void 0 : _g.referenceHidden) ? 0 : undefined }) }),
+                children,
+                (_arrow === null || _arrow === void 0 ? void 0 : _arrow.height) && (_arrow === null || _arrow === void 0 ? void 0 : _arrow.width) && (react_1.default.createElement(FloatingArrow, { width: _arrow.width, height: _arrow.height, className: _arrow.className }))))));
+});
+Floating.Anchor = FloatingAnchor;
+Floating.Content = FloatingContent;
+//# sourceMappingURL=Floating.js.map

package/cjs/overlays/floating/Floating.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Floating.js","sourceRoot":"","sources":["../../../src/overlays/floating/Floating.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sDAWgC;AAChC,+CAMe;AACf,0CAAuC;AACvC,8DAA0D;AAC1D,4CAI0B;AAE1B,qDAM0B;AAUb,KACX,IAAA,8BAAa,EAAuB;IAClC,IAAI,EAAE,iBAAiB;IACvB,QAAQ,EAAE,aAAa;IACvB,YAAY,EAAE,kBAAkB;CACjC,CAAC,EALU,wBAAgB,UAAE,0BAAkB,SAK7C;AAWL,MAAM,QAAQ,GAAsB,CAAC,EAAE,QAAQ,EAAiB,EAAE,EAAE;IAClE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAA,gBAAQ,EAAoB,IAAI,CAAC,CAAC;IAE9D,OAAO,CACL,8BAAC,wBAAgB,IAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,IACxD,QAAQ,CACQ,CACpB,CAAC;AACJ,CAAC,CAAC;AA2UO,4BAAQ;AAjUjB;;;GAGG;AACH,MAAM,cAAc,GAAG,IAAA,kBAAU,EAC/B,CAAC,EAAqD,EAAE,YAAY,EAAE,EAAE;QAAvE,EAAE,UAAU,EAAE,OAAO,OAAgC,EAA3B,IAAI,cAA9B,yBAAgC,CAAF;IAC7B,MAAM,OAAO,GAAG,IAAA,0BAAkB,GAAE,CAAC;IACrC,MAAM,GAAG,GAAG,IAAA,cAAM,EAAiB,IAAI,CAAC,CAAC;IAEzC,MAAM,SAAS,GAAG,IAAA,oBAAY,EAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IAElD,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,yEAAyE;QACzE,2DAA2D;QAC3D,OAAO,CAAC,cAAc,CAAC,CAAA,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,OAAO,KAAI,GAAG,CAAC,OAAO,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEH,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,WAAI,CAAC,CAAC,CAAC,KAAK,CAAC;IAEpC,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,8BAAC,IAAI,kBAAC,GAAG,EAAE,SAAS,IAAM,IAAI,EAAI,CAAC;AAChE,CAAC,CACF,CAAC;AAEF;;GAEG;AACH,MAAM,aAAa,GAAuB;IACxC,GAAG,EAAE,QAAQ;IACb,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,OAAO;CACd,CAAC;AAQF,MAAM,aAAa,GAAG,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAsB,EAAE,EAAE;IACzE,MAAM,OAAO,GAAG,yBAAyB,EAAE,CAAC;IAE5C,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAE/C,OAAO,CACL,wCACE,GAAG,EAAE,OAAO,CAAC,aAAa,EAC1B,KAAK,EAAE;YACL,QAAQ,EAAE,UAAU;YACpB,IAAI,EAAE,OAAO,CAAC,MAAM;YACpB,GAAG,EAAE,OAAO,CAAC,MAAM;YACnB,CAAC,IAAI,CAAC,EAAE,CAAC;YACT,eAAe,EAAE;gBACf,GAAG,EAAE,EAAE;gBACP,KAAK,EAAE,KAAK;gBACZ,MAAM,EAAE,UAAU;gBAClB,IAAI,EAAE,QAAQ;aACf,CAAC,OAAO,CAAC,UAAU,CAAC;YACrB,SAAS,EAAE;gBACT,GAAG,EAAE,kBAAkB;gBACvB,KAAK,EAAE,gDAAgD;gBACvD,MAAM,EAAE,gBAAgB;gBACxB,IAAI,EAAE,gDAAgD;aACvD,CAAC,OAAO,CAAC,UAAU,CAAC;YACrB,UAAU,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS;SACrD;QAGD,uCACE,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAC,WAAW,EACnB,mBAAmB,EAAC,MAAM,EAC1B,KAAK,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;YAE3B,2CAAS,MAAM,EAAC,gBAAgB,GAAG,CAC/B,CACD,CACR,CAAC;AACJ,CAAC,CAAC;AAaF,MAAM,CAAC,uBAAuB,EAAE,yBAAyB,CAAC,GACxD,IAAA,8BAAa,EAA8B;IACzC,IAAI,EAAE,wBAAwB;IAC9B,QAAQ,EAAE,2BAA2B;IACrC,YAAY,EAAE,yBAAyB;CACxC,CAAC,CAAC;AAuBL,MAAM,eAAe,GAAG,IAAA,kBAAU,EAChC,CACE,EAcuB,EACvB,YAAY,EACZ,EAAE;;QAhBF,EACE,QAAQ,EACR,IAAI,GAAG,QAAQ,EACf,UAAU,GAAG,CAAC,EACd,KAAK,GAAG,QAAQ,EAChB,WAAW,GAAG,CAAC,EACf,eAAe,GAAG,IAAI,EACtB,iBAAiB,GAAG,EAAE,EACtB,gBAAgB,EAAE,oBAAoB,GAAG,CAAC,EAC1C,gBAAgB,GAAG,KAAK,EACxB,sBAAsB,GAAG,WAAW,EACpC,QAAQ,EACR,KAAK,EAAE,MAAM,OAEQ,EADlB,YAAY,cAbjB,yLAcC,CADgB;IAIjB,MAAM,OAAO,GAAG,IAAA,0BAAkB,GAAE,CAAC;IAErC,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,IAAA,gBAAQ,EAAwB,IAAI,CAAC,CAAC;IACpE,MAAM,SAAS,GAAG,IAAA,oBAAY,EAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IAEzD,MAAM,aAAa,mBACjB,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,CAAC,IACN,MAAM,CACV,CAAC;IACF,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAA,gBAAQ,EAAyB,IAAI,CAAC,CAAC;IACjE,MAAM,UAAU,GAAG,aAAa,CAAC,KAAK,CAAC;IACvC,MAAM,WAAW,GAAG,aAAa,CAAC,MAAM,CAAC;IAEzC,MAAM,gBAAgB,GAAG,CAAC,IAAI;QAC5B,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAc,CAAC;IAExD,MAAM,gBAAgB,GACpB,OAAO,oBAAoB,KAAK,QAAQ;QACtC,CAAC,CAAC,oBAAoB;QACtB,CAAC,iBAAG,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,IAAK,oBAAoB,CAAE,CAAC;IAExE,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC;QAC/C,CAAC,CAAC,iBAAiB;QACnB,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC;IAExB,MAAM,qBAAqB,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAElD;;OAEG;IACH,SAAS,SAAS,CAAI,KAAe;QACnC,OAAO,KAAK,KAAK,IAAI,CAAC;IACxB,CAAC;IAED,MAAM,qBAAqB,GAAG;QAC5B,OAAO,EAAE,gBAAgB;QACzB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC;QACpC,iFAAiF;QACjF,WAAW,EAAE,qBAAqB;KACnC,CAAC;IAEF,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,GACrE,IAAA,uBAAW,EAAC;QACV,gGAAgG;QAChG,QAAQ,EAAE,OAAO;QACjB,SAAS,EAAE,gBAAgB;QAC3B,oBAAoB,EAAE,CAAC,GAAG,IAAI,EAAE,EAAE;YAChC,MAAM,OAAO,GAAG,IAAA,sBAAU,EAAC,GAAG,IAAI,EAAE;gBAClC,cAAc,EAAE,sBAAsB,KAAK,QAAQ;aACpD,CAAC,CAAC;YACH,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,QAAQ,EAAE;YACR,SAAS,EAAE,OAAO,CAAC,MAAM;SAC1B;QACD,UAAU,EAAE;YACV,IAAA,kBAAM,EAAC;gBACL,QAAQ,EAAE,UAAU,GAAG,WAAW;gBAClC,aAAa,EAAE,WAAW;aAC3B,CAAC;YACF,eAAe;gBACb,IAAA,iBAAK,kBACH,QAAQ,EAAE,IAAI,EACd,SAAS,EAAE,KAAK,EAChB,OAAO,EAAE,IAAA,sBAAU,GAAE,IAClB,qBAAqB,EACxB;YACJ,eAAe,IAAI,IAAA,gBAAI,oBAAM,qBAAqB,EAAG;YACrD,IAAA,gBAAI,kCACC,qBAAqB,KACxB,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,EAAE,EAAE;oBAC9D,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,GAChD,KAAK,CAAC,SAAS,CAAC;oBAClB,MAAM,YAAY,GAAG,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;oBAC7C;;uBAEG;oBACH,YAAY,CAAC,WAAW,CACtB,+BAA+B,EAC/B,GAAG,cAAc,IAAI,CACtB,CAAC;oBACF,YAAY,CAAC,WAAW,CACtB,gCAAgC,EAChC,GAAG,eAAe,IAAI,CACvB,CAAC;oBACF,YAAY,CAAC,WAAW,CACtB,4BAA4B,EAC5B,GAAG,WAAW,IAAI,CACnB,CAAC;oBACF,YAAY,CAAC,WAAW,CACtB,6BAA6B,EAC7B,GAAG,YAAY,IAAI,CACpB,CAAC;gBACJ,CAAC,IACD;YACF,KAAK;gBACH,IAAA,iBAAa,EAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC,OAAO,EAAE,CAAC;YACnE,IAAA,gCAAe,EAAC,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC;YAC5C,gBAAgB;gBACd,IAAA,gBAAI,kBAAG,QAAQ,EAAE,iBAAiB,IAAK,qBAAqB,EAAG;SAClE;KACF,CAAC,CAAC;IAEL,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,GAAG,IAAA,6CAA4B,EAAC,SAAS,CAAC,CAAC;IAE1E,MAAM,YAAY,GAAG,IAAA,sBAAc,EAAC,QAAQ,CAAC,CAAC;IAE9C,IAAA,6BAAqB,EAAC,GAAG,EAAE;QACzB,YAAY,KAAI,YAAY,aAAZ,YAAY,uBAAZ,YAAY,EAAI,CAAA,CAAC;IACnC,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;IAEjC,MAAM,MAAM,GAAG,MAAA,cAAc,CAAC,KAAK,0CAAE,CAAC,CAAC;IACvC,MAAM,MAAM,GAAG,MAAA,cAAc,CAAC,KAAK,0CAAE,CAAC,CAAC;IACvC,MAAM,iBAAiB,GAAG,CAAA,MAAA,cAAc,CAAC,KAAK,0CAAE,YAAY,MAAK,CAAC,CAAC;IAEnE,MAAM,CAAC,aAAa,EAAE,gBAAgB,CAAC,GAAG,IAAA,gBAAQ,GAAU,CAAC;IAC7D,IAAA,6BAAqB,EAAC,GAAG,EAAE;QACzB,IAAI,OAAO;YAAE,gBAAgB,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;IACzE,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAEd,OAAO,CACL,uCACE,GAAG,EAAE,IAAI,CAAC,WAAW,yCACe,EAAE,EACtC,KAAK,kCACA,cAAc,KACjB,SAAS,EAAE,YAAY;gBACrB,CAAC,CAAC,cAAc,CAAC,SAAS;gBAC1B,CAAC,CAAC,qBAAqB,EACzB,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,CAAC,gCAAuC,CAAC,EAAE;gBACzC,MAAA,cAAc,CAAC,eAAe,0CAAE,CAAC;gBACjC,MAAA,cAAc,CAAC,eAAe,0CAAE,CAAC;aAClC,CAAC,IAAI,CAAC,GAAG,CAAC;QAEb,6FAA6F;QAC7F,0EAA0E;QAC1E,GAAG,EAAC,KAAK;QAET,8BAAC,uBAAuB,IACtB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,QAAQ,EACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,iBAAiB;YAE5B,qDACE,GAAG,EAAE,SAAS,eACH,UAAU,gBACT,WAAW,IACnB,YAAY,IAChB,KAAK,kCACA,YAAY,CAAC,KAAK;oBACrB,4EAA4E;oBAC5E,gGAAgG;oBAChG,SAAS,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;oBAC7C,qEAAqE;oBACrE,OAAO,EAAE,CAAA,MAAA,cAAc,CAAC,IAAI,0CAAE,eAAe,EAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;gBAG9D,QAAQ;gBACR,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,MAAM,MAAI,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,KAAK,CAAA,IAAI,CAClC,8BAAC,aAAa,IACZ,KAAK,EAAE,MAAM,CAAC,KAAK,EACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EACrB,SAAS,EAAE,MAAM,CAAC,SAAS,GAC3B,CACH,CACG,CACkB,CACtB,CACP,CAAC;AACJ,CAAC,CACF,CAAC;AAEF,QAAQ,CAAC,MAAM,GAAG,cAAc,CAAC;AACjC,QAAQ,CAAC,OAAO,GAAG,eAAe,CAAC"}

package/cjs/overlays/floating/Floating.utils.d.ts

@@ -0,0 +1,18 @@
+import type { Middleware, Placement } from "@floating-ui/react-dom";
+declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];
+declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];
+type Side = (typeof SIDE_OPTIONS)[number];
+type Align = (typeof ALIGN_OPTIONS)[number];
+type Measurable = {
+    getBoundingClientRect(): DOMRect;
+};
+/**
+ * `transformOrigin` is a custom middleware for floating-ui that calculates the transform origin of the floating-element.
+ */
+declare function transformOrigin(options: {
+    arrowWidth: number;
+    arrowHeight: number;
+}): Middleware;
+declare function getSideAndAlignFromPlacement(placement: Placement): readonly ["left" | "right" | "bottom" | "top", "center" | "start" | "end"];
+export { getSideAndAlignFromPlacement, transformOrigin };
+export type { Side, Align, Measurable };