cbvirtua 1.0.6 → 1.0.8

package/v2/floating-ui/core/middleware/autoPlacement.js

@@ -1,84 +0,0 @@
-import { detectOverflow, } from '../detectOverflow';
-import { getBasePlacement } from '../utils/getBasePlacement';
-import { getAlignment } from '../utils/getAlignment';
-import { getAlignmentSides } from '../utils/getAlignmentSides';
-import { getOppositeAlignmentPlacement } from '../utils/getOppositeAlignmentPlacement';
-import { allPlacements } from '../enums';
-export function getPlacementList(alignment, autoAlignment, allowedPlacements) {
-    const allowedPlacementsSortedByAlignment = alignment
-        ? [
-            ...allowedPlacements.filter((placement) => getAlignment(placement) === alignment),
-            ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment),
-        ]
-        : allowedPlacements.filter((placement) => getBasePlacement(placement) === placement);
-    return allowedPlacementsSortedByAlignment.filter((placement) => {
-        if (alignment) {
-            return (getAlignment(placement) === alignment ||
-                (autoAlignment
-                    ? getOppositeAlignmentPlacement(placement) !== placement
-                    : false));
-        }
-        return true;
-    });
-}
-export const autoPlacement = (options = {}) => ({
-    name: 'autoPlacement',
-    options,
-    async fn(middlewareArguments) {
-        var _a, _b, _c, _d, _e, _f;
-        const { x, y, rects, middlewareData, placement } = middlewareArguments;
-        const { alignment = null, allowedPlacements = allPlacements, autoAlignment = true, ...detectOverflowOptions } = options;
-        if ((_a = middlewareData.autoPlacement) === null || _a === void 0 ? void 0 : _a.skip) {
-            return {};
-        }
-        const placements = getPlacementList(alignment, autoAlignment, allowedPlacements);
-        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-        const currentIndex = (_c = (_b = middlewareData.autoPlacement) === null || _b === void 0 ? void 0 : _b.index) !== null && _c !== void 0 ? _c : 0;
-        const currentPlacement = placements[currentIndex];
-        const { main, cross } = getAlignmentSides(currentPlacement, rects);
-        // Make `computeCoords` start from the right place
-        if (placement !== currentPlacement) {
-            return {
-                x,
-                y,
-                reset: {
-                    placement: placements[0],
-                },
-            };
-        }
-        const currentOverflows = [
-            overflow[getBasePlacement(currentPlacement)],
-            overflow[main],
-            overflow[cross],
-        ];
-        const allOverflows = [
-            ...((_e = (_d = middlewareData.autoPlacement) === null || _d === void 0 ? void 0 : _d.overflows) !== null && _e !== void 0 ? _e : []),
-            { placement: currentPlacement, overflows: currentOverflows },
-        ];
-        const nextPlacement = placements[currentIndex + 1];
-        // There are more placements to check
-        if (nextPlacement) {
-            return {
-                data: {
-                    index: currentIndex + 1,
-                    overflows: allOverflows,
-                },
-                reset: {
-                    placement: nextPlacement,
-                },
-            };
-        }
-        const placementsSortedByLeastOverflow = allOverflows
-            .slice()
-            .sort((a, b) => a.overflows[0] - b.overflows[0]);
-        const placementThatFitsOnAllSides = (_f = placementsSortedByLeastOverflow.find(({ overflows }) => overflows.every((overflow) => overflow <= 0))) === null || _f === void 0 ? void 0 : _f.placement;
-        return {
-            data: {
-                skip: true,
-            },
-            reset: {
-                placement: placementThatFitsOnAllSides !== null && placementThatFitsOnAllSides !== void 0 ? placementThatFitsOnAllSides : placementsSortedByLeastOverflow[0].placement,
-            },
-        };
-    },
-});

package/v2/floating-ui/core/middleware/flip.js

@@ -1,82 +0,0 @@
-import { getOppositePlacement } from '../utils/getOppositePlacement';
-import { getBasePlacement } from '../utils/getBasePlacement';
-import { detectOverflow, } from '../detectOverflow';
-import { getAlignmentSides } from '../utils/getAlignmentSides';
-import { getExpandedPlacements } from '../utils/getExpandedPlacements';
-export const flip = (options = {}) => ({
-    name: 'flip',
-    options,
-    async fn(middlewareArguments) {
-        var _a, _b, _c, _d, _e;
-        const { placement, middlewareData, rects, initialPlacement } = middlewareArguments;
-        if ((_a = middlewareData.flip) === null || _a === void 0 ? void 0 : _a.skip) {
-            return {};
-        }
-        const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = 'bestFit', flipAlignment = true, ...detectOverflowOptions } = options;
-        const basePlacement = getBasePlacement(placement);
-        const isBasePlacement = basePlacement === initialPlacement;
-        const fallbackPlacements = specifiedFallbackPlacements ||
-            (isBasePlacement || !flipAlignment
-                ? [getOppositePlacement(initialPlacement)]
-                : getExpandedPlacements(initialPlacement));
-        const placements = [initialPlacement, ...fallbackPlacements];
-        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-        const overflows = [];
-        let overflowsData = ((_b = middlewareData.flip) === null || _b === void 0 ? void 0 : _b.overflows) || [];
-        if (checkMainAxis) {
-            overflows.push(overflow[basePlacement]);
-        }
-        if (checkCrossAxis) {
-            const { main, cross } = getAlignmentSides(placement, rects);
-            overflows.push(overflow[main], overflow[cross]);
-        }
-        overflowsData = [...overflowsData, { placement, overflows }];
-        // One or more sides is overflowing
-        if (!overflows.every((side) => side <= 0)) {
-            const nextIndex = ((_d = (_c = middlewareData.flip) === null || _c === void 0 ? void 0 : _c.index) !== null && _d !== void 0 ? _d : 0) + 1;
-            const nextPlacement = placements[nextIndex];
-            if (nextPlacement) {
-                // Try next placement and re-run the lifecycle
-                return {
-                    data: {
-                        index: nextIndex,
-                        overflows: overflowsData,
-                    },
-                    reset: {
-                        placement: nextPlacement,
-                    },
-                };
-            }
-            let resetPlacement = 'bottom';
-            switch (fallbackStrategy) {
-                case 'bestFit': {
-                    const placement = (_e = overflowsData
-                        .slice()
-                        .sort((a, b) => a.overflows
-                        .filter((overflow) => overflow > 0)
-                        .reduce((acc, overflow) => acc + overflow, 0) -
-                        b.overflows
-                            .filter((overflow) => overflow > 0)
-                            .reduce((acc, overflow) => acc + overflow, 0))[0]) === null || _e === void 0 ? void 0 : _e.placement;
-                    if (placement) {
-                        resetPlacement = placement;
-                    }
-                    break;
-                }
-                case 'initialPlacement':
-                    resetPlacement = initialPlacement;
-                    break;
-                default:
-            }
-            return {
-                data: {
-                    skip: true,
-                },
-                reset: {
-                    placement: resetPlacement,
-                },
-            };
-        }
-        return {};
-    },
-});

package/v2/floating-ui/core/middleware/hide.js

@@ -1,36 +0,0 @@
-import { basePlacements } from '../enums';
-import { detectOverflow } from '../detectOverflow';
-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 basePlacements.some((side) => overflow[side] >= 0);
-}
-export const hide = () => ({
-    name: 'hide',
-    async fn(modifierArguments) {
-        const referenceOverflow = await detectOverflow(modifierArguments, {
-            elementContext: 'reference',
-        });
-        const floatingAltOverflow = await detectOverflow(modifierArguments, {
-            altBoundary: true,
-        });
-        const referenceHiddenOffsets = getSideOffsets(referenceOverflow, modifierArguments.rects.reference);
-        const escapedOffsets = getSideOffsets(floatingAltOverflow, modifierArguments.rects.floating);
-        const referenceHidden = isAnySideFullyClipped(referenceHiddenOffsets);
-        const escaped = isAnySideFullyClipped(escapedOffsets);
-        return {
-            data: {
-                referenceHidden,
-                referenceHiddenOffsets,
-                escaped,
-                escapedOffsets,
-            },
-        };
-    },
-});

package/v2/floating-ui/core/middleware/inline.js

@@ -1,100 +0,0 @@
-import { getBasePlacement } from '../utils/getBasePlacement';
-import { getMainAxisFromPlacement } from '../utils/getMainAxisFromPlacement';
-import { getSideObjectFromPadding } from '../utils/getPaddingObject';
-import { max, min } from '../utils/math';
-import { rectToClientRect } from '../utils/rectToClientRect';
-export const inline = (options = {}) => ({
-    name: 'inline',
-    options,
-    async fn(middlewareArguments) {
-        var _a, _b, _c;
-        const { placement, elements, rects, platform, strategy, middlewareData } = middlewareArguments;
-        // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
-        // ClientRect's bounds, despite the event listener being triggered. A
-        // padding of 2 seems to handle this issue.
-        const { padding = 2, x, y } = options;
-        if ((_a = middlewareData.inline) === null || _a === void 0 ? void 0 : _a.skip) {
-            return {};
-        }
-        const fallback = rectToClientRect(await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-            rect: rects.reference,
-            offsetParent: await platform.getOffsetParent({
-                element: elements.floating,
-            }),
-            strategy,
-        }));
-        const clientRects = Array.from((_c = (await ((_b = platform.getClientRects) === null || _b === void 0 ? void 0 : _b.call(platform, { element: elements.reference })))) !== null && _c !== void 0 ? _c : []);
-        const paddingObject = getSideObjectFromPadding(padding);
-        function getBoundingClientRect() {
-            var _a;
-            // There are two rects and they are disjoined
-            if (clientRects.length === 2 &&
-                clientRects[0].left > clientRects[1].right &&
-                x != null &&
-                y != null) {
-                // Find the first rect in which the point is fully inside
-                return ((_a = clientRects.find((rect) => x > rect.left - paddingObject.left &&
-                    x < rect.right + paddingObject.right &&
-                    y > rect.top - paddingObject.top &&
-                    y < rect.bottom + paddingObject.bottom)) !== null && _a !== void 0 ? _a : fallback);
-            }
-            // There are 2 or more connected rects
-            if (clientRects.length >= 2) {
-                if (getMainAxisFromPlacement(placement) === 'x') {
-                    const firstRect = clientRects[0];
-                    const lastRect = clientRects[clientRects.length - 1];
-                    const isTop = getBasePlacement(placement) === 'top';
-                    const top = firstRect.top;
-                    const bottom = lastRect.bottom;
-                    const left = isTop ? firstRect.left : lastRect.left;
-                    const right = isTop ? firstRect.right : lastRect.right;
-                    const width = right - left;
-                    const height = bottom - top;
-                    return {
-                        top,
-                        bottom,
-                        left,
-                        right,
-                        width,
-                        height,
-                        x: left,
-                        y: top,
-                    };
-                }
-                const isLeftPlacement = getBasePlacement(placement) === 'left';
-                const maxRight = max(...clientRects.map((rect) => rect.right));
-                const minLeft = min(...clientRects.map((rect) => rect.left));
-                const measureRects = clientRects.filter((rect) => isLeftPlacement ? rect.left === minLeft : rect.right === maxRight);
-                const top = measureRects[0].top;
-                const bottom = measureRects[measureRects.length - 1].bottom;
-                const left = minLeft;
-                const right = maxRight;
-                const width = right - left;
-                const height = bottom - top;
-                return {
-                    top,
-                    bottom,
-                    left,
-                    right,
-                    width,
-                    height,
-                    x: left,
-                    y: top,
-                };
-            }
-            return fallback;
-        }
-        return {
-            data: {
-                skip: true,
-            },
-            reset: {
-                rects: await platform.getElementRects({
-                    reference: { getBoundingClientRect },
-                    floating: elements.floating,
-                    strategy,
-                }),
-            },
-        };
-    },
-});

package/v2/floating-ui/core/middleware/offset.js

@@ -1,26 +0,0 @@
-import { getBasePlacement } from '../utils/getBasePlacement';
-import { getMainAxisFromPlacement } from '../utils/getMainAxisFromPlacement';
-export function convertValueToCoords({ placement, rects, value, }) {
-    const basePlacement = getBasePlacement(placement);
-    const multiplier = ['left', 'top'].includes(basePlacement) ? -1 : 1;
-    const rawValue = typeof value === 'function' ? value({ ...rects, placement }) : value;
-    const { mainAxis, crossAxis } = typeof rawValue === 'number'
-        ? { mainAxis: rawValue, crossAxis: 0 }
-        : { mainAxis: 0, crossAxis: 0, ...rawValue };
-    return getMainAxisFromPlacement(basePlacement) === 'x'
-        ? { x: crossAxis, y: mainAxis * multiplier }
-        : { x: mainAxis * multiplier, y: crossAxis };
-}
-export const offset = (value = 0) => ({
-    name: 'offset',
-    options: value,
-    fn(middlewareArguments) {
-        const { x, y, placement, rects } = middlewareArguments;
-        const diffCoords = convertValueToCoords({ placement, rects, value });
-        return {
-            x: x + diffCoords.x,
-            y: y + diffCoords.y,
-            data: diffCoords,
-        };
-    },
-});

package/v2/floating-ui/core/middleware/shift.js

@@ -1,99 +0,0 @@
-import { getBasePlacement } from '../utils/getBasePlacement';
-import { getMainAxisFromPlacement } from '../utils/getMainAxisFromPlacement';
-import { getCrossAxis } from '../utils/getCrossAxis';
-import { within } from '../utils/within';
-import { detectOverflow, } from '../detectOverflow';
-export const shift = (options = {}) => ({
-    name: 'shift',
-    options,
-    async fn(middlewareArguments) {
-        const { x, y, placement } = middlewareArguments;
-        const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: ({ x, y }) => ({ x, y }) }, ...detectOverflowOptions } = options;
-        const coords = { x, y };
-        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-        const mainAxis = getMainAxisFromPlacement(getBasePlacement(placement));
-        const crossAxis = getCrossAxis(mainAxis);
-        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 = within(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 = within(min, crossAxisCoord, max);
-        }
-        const limitedCoords = limiter.fn({
-            ...middlewareArguments,
-            [mainAxis]: mainAxisCoord,
-            [crossAxis]: crossAxisCoord,
-        });
-        return {
-            ...limitedCoords,
-            data: {
-                x: limitedCoords.x - x,
-                y: limitedCoords.y - y,
-            },
-        };
-    },
-});
-export const limitShift = (options = {}) => ({
-    options,
-    fn(middlewareArguments) {
-        var _a, _b, _c, _d;
-        const { x, y, placement, rects, middlewareData } = middlewareArguments;
-        const { offset = 0, mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, } = options;
-        const coords = { x, y };
-        const mainAxis = getMainAxisFromPlacement(placement);
-        const crossAxis = getCrossAxis(mainAxis);
-        let mainAxisCoord = coords[mainAxis];
-        let crossAxisCoord = coords[crossAxis];
-        const rawOffset = typeof offset === 'function' ? offset({ ...rects, placement }) : offset;
-        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(getBasePlacement(placement));
-            const limitMin = rects.reference[crossAxis] -
-                rects.floating[len] -
-                ((_b = (_a = middlewareData.offset) === null || _a === void 0 ? void 0 : _a[mainAxis]) !== null && _b !== void 0 ? _b : 0) +
-                (isOriginSide ? 0 : computedOffset.crossAxis);
-            const limitMax = rects.reference[crossAxis] +
-                rects.reference[len] +
-                ((_d = (_c = middlewareData.offset) === null || _c === void 0 ? void 0 : _c[mainAxis]) !== null && _d !== void 0 ? _d : 0) -
-                (isOriginSide ? computedOffset.crossAxis : 0);
-            if (crossAxisCoord < limitMin) {
-                crossAxisCoord = limitMin;
-            }
-            else if (crossAxisCoord > limitMax) {
-                crossAxisCoord = limitMax;
-            }
-        }
-        return {
-            [mainAxis]: mainAxisCoord,
-            [crossAxis]: crossAxisCoord,
-        };
-    },
-});

package/v2/floating-ui/core/middleware/size.js

@@ -1,58 +0,0 @@
-import { detectOverflow, } from '../detectOverflow';
-import { getBasePlacement } from '../utils/getBasePlacement';
-import { getAlignment } from '../utils/getAlignment';
-import { max } from '../utils/math';
-export const size = (options = {}) => ({
-    name: 'size',
-    options,
-    async fn(middlewareArguments) {
-        var _a;
-        const { placement, rects, middlewareData } = middlewareArguments;
-        const { apply, ...detectOverflowOptions } = options;
-        if ((_a = middlewareData.size) === null || _a === void 0 ? void 0 : _a.skip) {
-            return {};
-        }
-        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-        const basePlacement = getBasePlacement(placement);
-        const isEnd = getAlignment(placement) === 'end';
-        let heightSide;
-        let widthSide;
-        if (basePlacement === 'top' || basePlacement === 'bottom') {
-            heightSide = basePlacement;
-            widthSide = isEnd ? 'left' : 'right';
-        }
-        else {
-            widthSide = basePlacement;
-            heightSide = isEnd ? 'top' : 'bottom';
-        }
-        const xMin = max(overflow.left, 0);
-        const xMax = max(overflow.right, 0);
-        const yMin = max(overflow.top, 0);
-        const yMax = max(overflow.bottom, 0);
-        const dimensions = {
-            height: rects.floating.height -
-                (['left', 'right'].includes(placement)
-                    ? 2 *
-                        (yMin !== 0 || yMax !== 0
-                            ? yMin + yMax
-                            : max(overflow.top, overflow.bottom))
-                    : overflow[heightSide]),
-            width: rects.floating.width -
-                (['top', 'bottom'].includes(placement)
-                    ? 2 *
-                        (xMin !== 0 || xMax !== 0
-                            ? xMin + xMax
-                            : max(overflow.left, overflow.right))
-                    : overflow[widthSide]),
-        };
-        apply === null || apply === void 0 ? void 0 : apply({ ...dimensions, ...rects });
-        return {
-            data: {
-                skip: true,
-            },
-            reset: {
-                rects: true,
-            },
-        };
-    },
-});

package/v2/floating-ui/core/types.js

@@ -1,11 +0,0 @@
-export { computePosition } from './computePosition';
-export { rectToClientRect } from './utils/rectToClientRect';
-export { detectOverflow } from './detectOverflow';
-export { arrow } from './middleware/arrow';
-export { autoPlacement } from './middleware/autoPlacement';
-export { flip } from './middleware/flip';
-export { hide } from './middleware/hide';
-export { offset } from './middleware/offset';
-export { shift, limitShift } from './middleware/shift';
-export { size } from './middleware/size';
-export { inline } from './middleware/inline';

package/v2/floating-ui/core/utils/expandPaddingObject.js

@@ -1,3 +0,0 @@
-export function expandPaddingObject(padding) {
-    return { top: 0, right: 0, bottom: 0, left: 0, ...padding };
-}

package/v2/floating-ui/core/utils/getAlignment.js

@@ -1,3 +0,0 @@
-export function getAlignment(placement) {
-    return placement.split('-')[1];
-}

package/v2/floating-ui/core/utils/getAlignmentSides.js

@@ -1,23 +0,0 @@
-import { getLengthFromAxis } from './getLengthFromAxis';
-import { getMainAxisFromPlacement } from './getMainAxisFromPlacement';
-import { getOppositePlacement } from './getOppositePlacement';
-import { getAlignment } from './getAlignment';
-export function getAlignmentSides(placement, rects) {
-    const isStart = getAlignment(placement) === 'start';
-    const mainAxis = getMainAxisFromPlacement(placement);
-    const length = getLengthFromAxis(mainAxis);
-    let mainAlignmentSide = mainAxis === 'x'
-        ? isStart
-            ? 'right'
-            : 'left'
-        : isStart
-            ? 'bottom'
-            : 'top';
-    if (rects.reference[length] > rects.floating[length]) {
-        mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-    }
-    return {
-        main: mainAlignmentSide,
-        cross: getOppositePlacement(mainAlignmentSide),
-    };
-}

package/v2/floating-ui/core/utils/getBasePlacement.js

@@ -1,3 +0,0 @@
-export function getBasePlacement(placement) {
-    return placement.split('-')[0];
-}

package/v2/floating-ui/core/utils/getCrossAxis.js

@@ -1,3 +0,0 @@
-export function getCrossAxis(axis) {
-    return axis === 'x' ? 'y' : 'x';
-}

package/v2/floating-ui/core/utils/getExpandedPlacements.js

@@ -1,10 +0,0 @@
-import { getOppositePlacement } from './getOppositePlacement';
-import { getOppositeAlignmentPlacement } from './getOppositeAlignmentPlacement';
-export function getExpandedPlacements(placement) {
-    const oppositePlacement = getOppositePlacement(placement);
-    return [
-        getOppositeAlignmentPlacement(placement),
-        oppositePlacement,
-        getOppositeAlignmentPlacement(oppositePlacement),
-    ];
-}

package/v2/floating-ui/core/utils/getLengthFromAxis.js

@@ -1,3 +0,0 @@
-export function getLengthFromAxis(axis) {
-    return axis === 'y' ? 'height' : 'width';
-}

package/v2/floating-ui/core/utils/getMainAxisFromPlacement.js

@@ -1,4 +0,0 @@
-import { getBasePlacement } from './getBasePlacement';
-export function getMainAxisFromPlacement(placement) {
-    return ['top', 'bottom'].includes(getBasePlacement(placement)) ? 'x' : 'y';
-}

package/v2/floating-ui/core/utils/getOppositeAlignmentPlacement.js

@@ -1,4 +0,0 @@
-const hash = { start: 'end', end: 'start' };
-export function getOppositeAlignmentPlacement(placement) {
-    return placement.replace(/start|end/g, (matched) => hash[matched]);
-}

package/v2/floating-ui/core/utils/getOppositePlacement.js

@@ -1,4 +0,0 @@
-const hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
-export function getOppositePlacement(placement) {
-    return placement.replace(/left|right|bottom|top/g, (matched) => hash[matched]);
-}

package/v2/floating-ui/core/utils/getPaddingObject.js

@@ -1,6 +0,0 @@
-import { expandPaddingObject } from './expandPaddingObject';
-export function getSideObjectFromPadding(padding) {
-    return typeof padding !== 'number'
-        ? expandPaddingObject(padding)
-        : { top: padding, right: padding, bottom: padding, left: padding };
-}

package/v2/floating-ui/core/utils/math.js

@@ -1,2 +0,0 @@
-export const min = Math.min;
-export const max = Math.max;

package/v2/floating-ui/core/utils/rectToClientRect.js

@@ -1,9 +0,0 @@
-export function rectToClientRect(rect) {
-    return {
-        ...rect,
-        top: rect.y,
-        left: rect.x,
-        right: rect.x + rect.width,
-        bottom: rect.y + rect.height,
-    };
-}

package/v2/floating-ui/core/utils/within.js

@@ -1,4 +0,0 @@
-import { max as mathMax, min as mathMin } from './math';
-export function within(min, value, max) {
-    return mathMax(min, mathMin(value, max));
-}

package/v2/floating-ui/dom/index.js

@@ -1,5 +0,0 @@
-import { computePosition as computePositionCore, } from '../core/index';
-import { platform } from './platform';
-export const computePosition = (reference, floating, options) => computePositionCore(reference, floating, { platform, ...options });
-export { arrow, autoPlacement, flip, hide, offset, shift, limitShift, size, inline, detectOverflow, } from '../core/index';
-export { getScrollParents } from './utils/getScrollParents';

package/v2/floating-ui/dom/platform.js

@@ -1,20 +0,0 @@
-import { getRectRelativeToOffsetParent } from './utils/getRectRelativeToOffsetParent';
-import { getOffsetParent } from './utils/getOffsetParent';
-import { getDimensions } from './utils/getDimensions';
-import { convertOffsetParentRelativeRectToViewportRelativeRect } from './utils/convertOffsetParentRelativeRectToViewportRelativeRect';
-import { isElement } from './utils/is';
-import { getDocumentElement } from './utils/getDocumentElement';
-import { getClippingClientRect } from './utils/getClippingClientRect';
-export const platform = {
-    getElementRects: ({ reference, floating, strategy }) => ({
-        reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
-        floating: { ...getDimensions(floating), x: 0, y: 0 },
-    }),
-    convertOffsetParentRelativeRectToViewportRelativeRect: (args) => convertOffsetParentRelativeRectToViewportRelativeRect(args),
-    getOffsetParent: ({ element }) => getOffsetParent(element),
-    isElement: (value) => isElement(value),
-    getDocumentElement: ({ element }) => getDocumentElement(element),
-    getClippingClientRect: (args) => getClippingClientRect(args),
-    getDimensions: ({ element }) => getDimensions(element),
-    getClientRects: ({ element }) => element.getClientRects(),
-};