wabtec-internal-volt-basic-components 1.2.0 → 1.4.0

package/dist/{esm/floating-engine-utils-ClEAm9Wn.js → cjs/floating-engine-utils-BYIoxOr2.js}

@@ -1,8 +1,13 @@
+'use strict';
+
 /**
  * Custom positioning reference element.
  * @see https://floating-ui.com/docs/virtual-elements
  */
 
+const sides = ['top', 'right', 'bottom', 'left'];
+const alignments = ['start', 'end'];
+const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
 const min = Math.min;
 const max = Math.max;
 const round = Math.round;
@@ -59,41 +64,9 @@ function getAlignmentSides(placement, rects, rtl) {
   }
   return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
 }
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
 function getOppositeAlignmentPlacement(placement) {
   return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
 }
-const lrPlacement = ['left', 'right'];
-const rlPlacement = ['right', 'left'];
-const tbPlacement = ['top', 'bottom'];
-const btPlacement = ['bottom', 'top'];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case 'top':
-    case 'bottom':
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case 'left':
-    case 'right':
-      return isStart ? tbPlacement : btPlacement;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === 'start', rtl);
-  if (alignment) {
-    list = list.map(side => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
 function getOppositePlacement(placement) {
   return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
 }
@@ -189,6 +162,71 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
   return coords;
 }
 
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+async function detectOverflow$1(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = 'clippingAncestors',
+    rootBoundary = 'viewport',
+    elementContext = 'floating',
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === 'floating' ? 'reference' : 'floating';
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === 'floating' ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
+  return {
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+  };
+}
+
 /**
  * Computes the `x` and `y` coordinates that will place the floating element
  * next to a given reference element.
@@ -218,6 +256,7 @@ const computePosition$1 = async (reference, floating, config) => {
   let middlewareData = {};
   let resetCount = 0;
   for (let i = 0; i < validMiddleware.length; i++) {
+    var _platform$detectOverf;
     const {
       name,
       fn
@@ -235,7 +274,10 @@ const computePosition$1 = async (reference, floating, config) => {
       strategy,
       middlewareData,
       rects,
-      platform,
+      platform: {
+        ...platform,
+        detectOverflow: (_platform$detectOverf = platform.detectOverflow) != null ? _platform$detectOverf : detectOverflow$1
+      },
       elements: {
         reference,
         floating
@@ -280,71 +322,6 @@ const computePosition$1 = async (reference, floating, config) => {
   };
 };
 
-/**
- * Resolves with an object of overflow side offsets that determine how much the
- * element is overflowing a given clipping boundary on each side.
- * - positive = overflowing the boundary by that number of pixels
- * - negative = how many pixels left before it will overflow
- * - 0 = lies flush with the boundary
- * @see https://floating-ui.com/docs/detectOverflow
- */
-async function detectOverflow(state, options) {
-  var _await$platform$isEle;
-  if (options === void 0) {
-    options = {};
-  }
-  const {
-    x,
-    y,
-    platform,
-    rects,
-    elements,
-    strategy
-  } = state;
-  const {
-    boundary = 'clippingAncestors',
-    rootBoundary = 'viewport',
-    elementContext = 'floating',
-    altBoundary = false,
-    padding = 0
-  } = evaluate(options, state);
-  const paddingObject = getPaddingObject(padding);
-  const altContext = elementContext === 'floating' ? 'reference' : 'floating';
-  const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
-    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
-    boundary,
-    rootBoundary,
-    strategy
-  }));
-  const rect = elementContext === 'floating' ? {
-    x,
-    y,
-    width: rects.floating.width,
-    height: rects.floating.height
-  } : rects.reference;
-  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
-  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  };
-  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements,
-    rect,
-    offsetParent,
-    strategy
-  }) : rect);
-  return {
-    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
-    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
-    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
-    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
-  };
-}
-
 /**
  * Provides data to position an inner element of the floating element so that it
  * appears centered to the reference element.
@@ -427,134 +404,175 @@ const arrow$1 = options => ({
   }
 });
 
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);
+  return allowedPlacementsSortedByAlignment.filter(placement => {
+    if (alignment) {
+      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);
+    }
+    return true;
+  });
+}
 /**
- * Optimizes the visibility of the floating element by flipping the `placement`
- * in order to keep it in view when the preferred placement(s) will overflow the
- * clipping boundary. Alternative to `autoPlacement`.
- * @see https://floating-ui.com/docs/flip
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
  */
-const flip$1 = function (options) {
+const autoPlacement$1 = function (options) {
   if (options === void 0) {
     options = {};
   }
   return {
-    name: 'flip',
+    name: 'autoPlacement',
     options,
     async fn(state) {
-      var _middlewareData$arrow, _middlewareData$flip;
+      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
       const {
-        placement,
-        middlewareData,
         rects,
-        initialPlacement,
+        middlewareData,
+        placement,
         platform,
         elements
       } = state;
       const {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = true,
-        fallbackPlacements: specifiedFallbackPlacements,
-        fallbackStrategy = 'bestFit',
-        fallbackAxisSideDirection = 'none',
-        flipAlignment = true,
+        crossAxis = false,
+        alignment,
+        allowedPlacements = placements,
+        autoAlignment = true,
         ...detectOverflowOptions
       } = evaluate(options, state);
-
-      // If a reset by the arrow was caused due to an alignment offset being
-      // added, we should skip any logic now since `flip()` has already done its
-      // work.
-      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
-      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
+      const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
+      const currentPlacement = placements$1[currentIndex];
+      if (currentPlacement == null) {
         return {};
       }
-      const side = getSide(placement);
-      const initialSideAxis = getSideAxis(initialPlacement);
-      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
-      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
-      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
-      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
-        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
+
+      // Make `computeCoords` start from the right place.
+      if (placement !== currentPlacement) {
+        return {
+          reset: {
+            placement: placements$1[0]
+          }
+        };
       }
-      const placements = [initialPlacement, ...fallbackPlacements];
-      const overflow = await detectOverflow(state, detectOverflowOptions);
-      const overflows = [];
-      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
-      if (checkMainAxis) {
-        overflows.push(overflow[side]);
+      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
+      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {
+        placement: currentPlacement,
+        overflows: currentOverflows
+      }];
+      const nextPlacement = placements$1[currentIndex + 1];
+
+      // There are more placements to check.
+      if (nextPlacement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: nextPlacement
+          }
+        };
       }
-      if (checkCrossAxis) {
-        const sides = getAlignmentSides(placement, rects, rtl);
-        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      const placementsSortedByMostSpace = allOverflows.map(d => {
+        const alignment = getAlignment(d.placement);
+        return [d.placement, alignment && crossAxis ?
+        // Check along the mainAxis and main crossAxis side.
+        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :
+        // Check only the mainAxis.
+        d.overflows[0], d.overflows];
+      }).sort((a, b) => a[1] - b[1]);
+      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,
+      // Aligned placements should not check their opposite crossAxis
+      // side.
+      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));
+      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
+      if (resetPlacement !== placement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: resetPlacement
+          }
+        };
       }
-      overflowsData = [...overflowsData, {
-        placement,
-        overflows
-      }];
+      return {};
+    }
+  };
+};
 
-      // One or more sides is overflowing.
-      if (!overflows.every(side => side <= 0)) {
-        var _middlewareData$flip2, _overflowsData$filter;
-        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
-        const nextPlacement = placements[nextIndex];
-        if (nextPlacement) {
-          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== getSideAxis(nextPlacement) : false;
-          if (!ignoreCrossAxisOverflow ||
-          // We leave the current main axis only if every placement on that axis
-          // overflows the main axis.
-          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
-            // Try next placement and re-run the lifecycle.
+function getSideOffsets(overflow, rect) {
+  return {
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
+  };
+}
+function isAnySideFullyClipped(overflow) {
+  return sides.some(side => overflow[side] >= 0);
+}
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide$1 = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'hide',
+    options,
+    async fn(state) {
+      const {
+        rects,
+        platform
+      } = state;
+      const {
+        strategy = 'referenceHidden',
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      switch (strategy) {
+        case 'referenceHidden':
+          {
+            const overflow = await platform.detectOverflow(state, {
+              ...detectOverflowOptions,
+              elementContext: 'reference'
+            });
+            const offsets = getSideOffsets(overflow, rects.reference);
             return {
               data: {
-                index: nextIndex,
-                overflows: overflowsData
-              },
-              reset: {
-                placement: nextPlacement
+                referenceHiddenOffsets: offsets,
+                referenceHidden: isAnySideFullyClipped(offsets)
               }
             };
           }
-        }
-
-        // First, find the candidates that fit on the mainAxis side of overflow,
-        // then find the placement that fits the best on the main crossAxis side.
-        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
-
-        // Otherwise fallback.
-        if (!resetPlacement) {
-          switch (fallbackStrategy) {
-            case 'bestFit':
-              {
-                var _overflowsData$filter2;
-                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
-                  if (hasFallbackAxisSideDirection) {
-                    const currentSideAxis = getSideAxis(d.placement);
-                    return currentSideAxis === initialSideAxis ||
-                    // Create a bias to the `y` side axis due to horizontal
-                    // reading directions favoring greater width.
-                    currentSideAxis === 'y';
-                  }
-                  return true;
-                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
-                if (placement) {
-                  resetPlacement = placement;
-                }
-                break;
+        case 'escaped':
+          {
+            const overflow = await platform.detectOverflow(state, {
+              ...detectOverflowOptions,
+              altBoundary: true
+            });
+            const offsets = getSideOffsets(overflow, rects.floating);
+            return {
+              data: {
+                escapedOffsets: offsets,
+                escaped: isAnySideFullyClipped(offsets)
               }
-            case 'initialPlacement':
-              resetPlacement = initialPlacement;
-              break;
+            };
+          }
+        default:
+          {
+            return {};
           }
-        }
-        if (placement !== resetPlacement) {
-          return {
-            reset: {
-              placement: resetPlacement
-            }
-          };
-        }
       }
-      return {};
     }
   };
 };
@@ -661,7 +679,8 @@ const shift$1 = function (options) {
       const {
         x,
         y,
-        placement
+        placement,
+        platform
       } = state;
       const {
         mainAxis: checkMainAxis = true,
@@ -684,7 +703,7 @@ const shift$1 = function (options) {
         x,
         y
       };
-      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflow = await platform.detectOverflow(state, detectOverflowOptions);
       const crossAxis = getSideAxis(getSide(placement));
       const mainAxis = getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
@@ -748,7 +767,7 @@ const size$1 = function (options) {
         apply = () => {},
         ...detectOverflowOptions
       } = evaluate(options, state);
-      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflow = await platform.detectOverflow(state, detectOverflowOptions);
       const side = getSide(placement);
       const alignment = getAlignment(placement);
       const isYAxis = getSideAxis(placement) === 'y';
@@ -1639,6 +1658,16 @@ function autoUpdate(reference, floating, update, options) {
   };
 }
 
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+const detectOverflow = detectOverflow$1;
+
 /**
  * Modifies the placement by translating the floating element along the
  * specified axes.
@@ -1648,6 +1677,14 @@ function autoUpdate(reference, floating, update, options) {
  */
 const offset = offset$1;
 
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+const autoPlacement = autoPlacement$1;
+
 /**
  * Optimizes the visibility of the floating element by shifting it in order to
  * keep it in view when it will overflow the clipping boundary.
@@ -1655,14 +1692,6 @@ const offset = offset$1;
  */
 const shift = shift$1;
 
-/**
- * Optimizes the visibility of the floating element by flipping the `placement`
- * in order to keep it in view when the preferred placement(s) will overflow the
- * clipping boundary. Alternative to `autoPlacement`.
- * @see https://floating-ui.com/docs/flip
- */
-const flip = flip$1;
-
 /**
  * Provides data that allows you to change the size of the floating element —
  * for instance, prevent it from overflowing the clipping boundary or match the
@@ -1671,6 +1700,13 @@ const flip = flip$1;
  */
 const size = size$1;
 
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide = hide$1;
+
 /**
  * Provides data to position an inner element of the floating element so that it
  * appears centered to the reference element.
@@ -1701,111 +1737,93 @@ const computePosition = (reference, floating, options) => {
   });
 };
 
-const handleArrowRotation = (side) => {
-    switch (side) {
-        case "top":
-            return "rotate(0deg)";
-        case "right":
-            return "rotate(90deg)";
-        case "bottom":
-            return "rotate(180deg)";
-        case "left":
-            return "rotate(270deg)";
-    }
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const floatingTrigger = (hostEl, selector) => {
+    const floatingBoxTrigger = hostEl.shadowRoot.querySelector(selector);
+    return floatingBoxTrigger;
 };
-const calcPosition = (xAxis, yAxis, side, hasOverflow) => {
-    const x = setNumberInsteadOfNaN(xAxis);
-    const y = setNumberInsteadOfNaN(yAxis);
-    const overflow = hasOverflow ? 7 : 0;
-    switch (side) {
-        case "top":
-            return { top: `${y - 4 + overflow}px`, left: `${x}px` };
-        case "right":
-            return { top: `${y}px`, left: `${x + 4 - overflow}px` };
-        case "bottom":
-            return { top: `${y + 4 - overflow}px`, left: `${x}px` };
-        case "left":
-            return { top: `${y}px`, left: `${x - 4 + overflow}px` };
-    }
+const floatingBox = (hostEl, selector) => {
+    const floatingBoxContainer = hostEl.shadowRoot.querySelector(selector);
+    return floatingBoxContainer;
 };
-const calcArrowMargin = (side) => {
-    const marginHorizontal = "3px";
-    const marginVertical = "5px";
-    switch (side) {
-        case "top":
-            return `0px 0px ${marginVertical} 0px`;
-        case "right":
-            return `0px 0px 0px ${marginHorizontal}`;
-        case "bottom":
-            return `${marginVertical} 0px 0px 0px`;
-        case "left":
-            return `0px ${marginHorizontal} 0px 0px`;
-    }
+const floatingArrow = (hostEl, selector) => {
+    const arrow = hostEl.shadowRoot.querySelector(selector);
+    return arrow;
 };
-const getCurrentPlacement = (data, position) => {
-    if (data && data.offset && data.offset.placement) {
-        return data.offset.placement === position ? position : data.offset.placement;
-    }
-    else {
-        return position;
-    }
+const ARROW_ROTATION = {
+    top: "rotate(0deg)",
+    right: "rotate(90deg)",
+    bottom: "rotate(180deg)",
+    left: "rotate(270deg)"
 };
-const overflowDetected = (data) => {
-    if (data && data.flip && data.flip.overflows && data.flip.overflows.length > 0) {
-        const overflow = data.flip.overflows[0];
-        if (overflow && overflow.placement) {
-            return true;
-        }
-    }
-    return false;
+const ARROW_MARGIN = {
+    top: "0 0 5px 0",
+    right: "0 0 0 3px",
+    bottom: "5px 0 0 0",
+    left: "0 3px 0 0"
+};
+const STATIC_SIDE = {
+    top: "bottom",
+    right: "left",
+    bottom: "top",
+    left: "right"
 };
-const updateFloatingBoxPosition = async (referenceElement, floatingBoxElement, floatingArrow, position, autoPosition) => {
+const AUTO_UPDATE_OPTIONS = {
+    elementResize: true,
+    ancestorScroll: true,
+    ancestorResize: true,
+    layoutShift: true
+};
+const updateFloatingBoxPosition = async (referenceElement, floatingBoxElement, floatingArrow, position, autoPosition, allowedPlacements = null, preserveEndAlignment = false) => {
     if (!floatingBoxElement || !referenceElement) {
         console.warn("[updateFloatingBoxPosition] - Reference element (trigger) and floating element is required");
-        return;
+        return () => { };
     }
-    // Autoupdate options
-    const options = {
-        elementResize: true,
-        ancestorScroll: true,
-        ancestorResize: true,
-        layoutShift: true
-    };
     const updatePositionCallback = () => {
         try {
             computePosition(referenceElement, floatingBoxElement, {
                 placement: position,
                 middleware: [
-                    shift({ boundary: [] }),
-                    offset(),
-                    autoPosition ? flip() : null,
+                    offset(4),
+                    autoPosition ? shift({ padding: 4 }) : null,
+                    autoPosition ? autoPlacement(allowedPlacements ? { allowedPlacements: allowedPlacements } : {}) : null,
+                    autoPosition ? hide() : null,
                     size({
                         apply({ availableWidth, availableHeight, elements }) {
                             Object.assign(elements.floating.style, {
-                                maxWidth: `${setNumberInsteadOfNaN(availableWidth)}px`,
-                                maxHeight: `${setNumberInsteadOfNaN(availableHeight)}px`,
+                                maxWidth: `${Math.max(0, availableWidth || 0)}px`,
+                                maxHeight: `${Math.max(0, availableHeight || 0)}px`
                             });
-                        },
+                        }
                     }),
-                    floatingArrow ? arrow({ element: floatingArrow, padding: 5 }) : null,
-                ],
-            }).then(({ x, y, middlewareData }) => {
-                Object.assign(floatingBoxElement.style, Object.assign({ position: "absolute" }, calcPosition(x, y, position, overflowDetected(middlewareData))));
+                    floatingArrow ? arrow({ element: floatingArrow, padding: 5 }) : null
+                ].filter(Boolean)
+            }).then(({ x, y, placement, middlewareData }) => {
+                if (middlewareData.hide) {
+                    const isHidden = middlewareData.hide.referenceHidden;
+                    Object.assign(floatingBoxElement.style, {
+                        visibility: isHidden ? "hidden" : "visible",
+                        pointerEvents: isHidden ? "none" : "auto"
+                    });
+                    if (isHidden)
+                        return;
+                }
+                Object.assign(floatingBoxElement.style, {
+                    position: "absolute",
+                    top: `${y || 0}px`,
+                    left: preserveEndAlignment && placement.endsWith("-end") ? "" : `${x || 0}px`,
+                    right: preserveEndAlignment && placement.endsWith("-end") ? "0px" : ""
+                });
                 if (middlewareData.arrow && floatingArrow !== null) {
                     const { x, y } = middlewareData.arrow;
-                    const side = getCurrentPlacement(middlewareData, position);
-                    const staticSide = {
-                        top: "bottom",
-                        right: "left",
-                        bottom: "top",
-                        left: "right"
-                    }[side];
+                    const side = placement.split("-")[0];
                     Object.assign(floatingArrow.style, {
-                        left: x != null ? `${setNumberInsteadOfNaN(x)}px` : "",
-                        top: y != null ? `${setNumberInsteadOfNaN(y)}px` : "",
-                        margin: calcArrowMargin(side),
-                        [staticSide]: `${-setNumberInsteadOfNaN(floatingArrow.offsetWidth)}px`,
-                        transform: handleArrowRotation(side)
+                        top: y != null ? `${Math.max(0, y || 0)}px` : "",
+                        left: x != null ? `${Math.max(0, x || 0)}px` : "",
+                        margin: ARROW_MARGIN[side],
+                        [STATIC_SIDE[side]]: `-${floatingArrow.offsetWidth || 0}px`,
+                        transform: ARROW_ROTATION[side]
                     });
                 }
             });
@@ -1814,15 +1832,41 @@ const updateFloatingBoxPosition = async (referenceElement, floatingBoxElement, f
             console.warn("[updatePositionCallback] ", error);
         }
     };
-    const cleanup = autoUpdate(referenceElement, floatingBoxElement, updatePositionCallback, options);
-    if (!autoPosition) {
-        cleanup();
+    if (autoPosition) {
+        return autoUpdate(referenceElement, floatingBoxElement, updatePositionCallback, AUTO_UPDATE_OPTIONS);
+    }
+    else {
+        updatePositionCallback();
+        return () => { };
     }
-    return cleanup;
 };
-const setNumberInsteadOfNaN = (input) => input > 0 ? input : 0;
-
-export { updateFloatingBoxPosition as u };
-//# sourceMappingURL=floating-engine-utils-ClEAm9Wn.js.map
+/**
+ * Toggles the display style of an HTML element.
+ *
+ * @param {HTMLElement} contentBox The HTML element to toggle the display for.
+ * @param {boolean} toggle A boolean value to control the display.
+ *  - True: Sets the display to "block".
+ *  - False: Sets the display to "none".
+ * @returns {void}
+ */
+const toggleContainerDisplay = (contentBox, toggle) => {
+    if (!contentBox) {
+        return;
+    }
+    contentBox.style.display = toggle ? "block" : "none";
+};
 
-//# sourceMappingURL=floating-engine-utils-ClEAm9Wn.js.map
+exports.arrow = arrow;
+exports.autoPlacement = autoPlacement;
+exports.autoUpdate = autoUpdate;
+exports.computePosition = computePosition;
+exports.detectOverflow = detectOverflow;
+exports.floatingArrow = floatingArrow;
+exports.floatingBox = floatingBox;
+exports.floatingTrigger = floatingTrigger;
+exports.hide = hide;
+exports.offset = offset;
+exports.shift = shift;
+exports.size = size;
+exports.toggleContainerDisplay = toggleContainerDisplay;
+exports.updateFloatingBoxPosition = updateFloatingBoxPosition;