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

package/dist/{cjs/floating-engine-utils-DDIydT_O.js → esm/floating-engine-utils-BWyJL18G.js}

@@ -1,10 +1,11 @@
-'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;
@@ -61,41 +62,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]);
 }
@@ -191,6 +160,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.
@@ -220,6 +254,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
@@ -237,7 +272,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
@@ -282,71 +320,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.
@@ -429,134 +402,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 {};
     }
   };
 };
@@ -663,7 +677,8 @@ const shift$1 = function (options) {
       const {
         x,
         y,
-        placement
+        placement,
+        platform
       } = state;
       const {
         mainAxis: checkMainAxis = true,
@@ -686,7 +701,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];
@@ -750,7 +765,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';
@@ -1641,6 +1656,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.
@@ -1650,6 +1675,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.
@@ -1657,14 +1690,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
@@ -1673,6 +1698,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.
@@ -1703,111 +1735,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]
                     });
                 }
             });
@@ -1816,15 +1830,28 @@ 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;
-
-exports.updateFloatingBoxPosition = updateFloatingBoxPosition;
-//# sourceMappingURL=floating-engine-utils-DDIydT_O.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-DDIydT_O.js.map
+export { autoUpdate as a, arrow as b, computePosition as c, size as d, detectOverflow as e, autoPlacement as f, floatingBox as g, hide as h, floatingArrow as i, floatingTrigger as j, offset as o, shift as s, toggleContainerDisplay as t, updateFloatingBoxPosition as u };