@nex-ui/react/dist/cjs/components/utils/computePosition/computePosition.cjs

🎉 A beautiful, modern, and reliable React component library.

'use strict';

var utils = require('@nex-ui/utils');
var getElementRects = require('./getElementRects.cjs');
var computeCoordinatesByPlacement = require('./computeCoordinatesByPlacement.cjs');
var flip = require('./middleware/flip.cjs');
var shift = require('./middleware/shift.cjs');
var arrow = require('./middleware/arrow.cjs');
var offset = require('./middleware/offset.cjs');

function computePosition(reference, popper, options) {
    const { placement = 'bottom', shift: shiftOption, offset: offsetOption, flip: flipOption, arrow: arrowOption = false } = options ?? {};
    const middlewareOptions = [
        [
            flipOption,
            flip.flip
        ],
        [
            shiftOption,
            shift.shift
        ],
        [
            arrowOption,
            arrow.arrow
        ],
        [
            offsetOption,
            offset.offset
        ]
    ];
    const middlewareList = middlewareOptions.filter(([option])=>option !== false).map(([option, fn])=>fn(option));
    const rects = getElementRects.getElementRects(reference, popper);
    const coordinates = computeCoordinatesByPlacement.computeCoordinatesByPlacement(rects, placement);
    let middlewareData = {};
    let state = {
        rects: {
            popper: {
                ...rects.popper,
                x: coordinates.x,
                y: coordinates.y
            },
            reference: {
                ...rects.reference
            }
        },
        elements: {
            reference,
            popper
        },
        placement,
        middlewareData,
        initialPlacement: placement
    };
    for(let i = 0; i < middlewareList.length; i++){
        const middleware = middlewareList[i];
        let nextX, nextY;
        const { x, y, overrides, data } = middleware.fn(state);
        nextX = x;
        nextY = y;
        if (data) {
            middlewareData = {
                ...middlewareData,
                [middleware.name]: {
                    ...middlewareData[middleware.name],
                    ...data
                }
            };
        }
        let placementOverride;
        if (utils.isPlainObject(overrides)) {
            if (overrides?.placement) {
                placementOverride = overrides?.placement;
                ({ x: nextX, y: nextY } = computeCoordinatesByPlacement.computeCoordinatesByPlacement(rects, placementOverride));
            }
            i--;
        }
        state = {
            ...state,
            rects: {
                ...state.rects,
                popper: {
                    ...state.rects.popper,
                    x: nextX ?? state.rects.popper.x,
                    y: nextY ?? state.rects.popper.y
                }
            },
            middlewareData,
            placement: placementOverride ?? state.placement
        };
    }
    return {
        x: state.rects.popper.x,
        y: state.rects.popper.y,
        placement: state.placement,
        middlewareData: state.middlewareData
    };
}

exports.computePosition = computePosition;