@vuesax-alpha/nightly/lib/hooks/use-floating/core/middleware/shift.js

A Component Library for Vue 3

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var index = require('../../utils/index.js');
var detectOverflow = require('../detect-overflow.js');

const shift = (options = {}) => ({
  name: "shift",
  options,
  async fn(state) {
    const { x, y, placement } = state;
    const {
      mainAxis: checkMainAxis = true,
      crossAxis: checkCrossAxis = false,
      limiter = { fn: ({ x: x2, y: y2 }) => ({ x: x2, y: y2 }) },
      ...detectOverflowOptions
    } = index.evaluate(options, state);
    const coords = { x, y };
    const overflow = await detectOverflow.detectOverflow(state, detectOverflowOptions);
    const crossAxis = index.getSideAxis(index.getSide(placement));
    const mainAxis = index.getOppositeAxis(crossAxis);
    let mainAxisCoord = coords[mainAxis];
    let crossAxisCoord = coords[crossAxis];
    if (checkMainAxis) {
      const minSide = mainAxis === "y" ? "top" : "left";
      const maxSide = mainAxis === "y" ? "bottom" : "right";
      const min = mainAxisCoord + overflow[minSide];
      const max = mainAxisCoord - overflow[maxSide];
      mainAxisCoord = index.clamp(min, mainAxisCoord, max);
    }
    if (checkCrossAxis) {
      const minSide = crossAxis === "y" ? "top" : "left";
      const maxSide = crossAxis === "y" ? "bottom" : "right";
      const min = crossAxisCoord + overflow[minSide];
      const max = crossAxisCoord - overflow[maxSide];
      crossAxisCoord = index.clamp(min, crossAxisCoord, max);
    }
    const limitedCoords = limiter.fn({
      ...state,
      [mainAxis]: mainAxisCoord,
      [crossAxis]: crossAxisCoord
    });
    return {
      ...limitedCoords,
      data: {
        x: limitedCoords.x - x,
        y: limitedCoords.y - y
      }
    };
  }
});
const limitShift = (options = {}) => ({
  options,
  fn(state) {
    var _a, _b;
    const { x, y, placement, rects, middlewareData } = state;
    const {
      offset = 0,
      mainAxis: checkMainAxis = true,
      crossAxis: checkCrossAxis = true
    } = index.evaluate(options, state);
    const coords = { x, y };
    const crossAxis = index.getSideAxis(placement);
    const mainAxis = index.getOppositeAxis(crossAxis);
    let mainAxisCoord = coords[mainAxis];
    let crossAxisCoord = coords[crossAxis];
    const rawOffset = index.evaluate(offset, state);
    const computedOffset = typeof rawOffset === "number" ? { mainAxis: rawOffset, crossAxis: 0 } : { mainAxis: 0, crossAxis: 0, ...rawOffset };
    if (checkMainAxis) {
      const len = mainAxis === "y" ? "height" : "width";
      const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
      const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
      if (mainAxisCoord < limitMin) {
        mainAxisCoord = limitMin;
      } else if (mainAxisCoord > limitMax) {
        mainAxisCoord = limitMax;
      }
    }
    if (checkCrossAxis) {
      const len = mainAxis === "y" ? "width" : "height";
      const isOriginSide = ["top", "left"].includes(index.getSide(placement));
      const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_a = middlewareData.offset) == null ? void 0 : _a[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
      const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_b = middlewareData.offset) == null ? void 0 : _b[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
      if (crossAxisCoord < limitMin) {
        crossAxisCoord = limitMin;
      } else if (crossAxisCoord > limitMax) {
        crossAxisCoord = limitMax;
      }
    }
    return {
      [mainAxis]: mainAxisCoord,
      [crossAxis]: crossAxisCoord
    };
  }
});

exports.limitShift = limitShift;
exports.shift = shift;
//# sourceMappingURL=shift.js.map