@shtabapp/ui-kit 1.84.0 → 1.85.1

package/dist/composables/connectedPosition/computeArrowPosition.js

@@ -0,0 +1,51 @@
+import { EAnchorSide } from "./types.js";
+import { parseAnchor } from "./parseAnchor.js";
+//#region src/composables/connectedPosition/computeArrowPosition.ts
+var clamp = (min, value, max) => Math.min(Math.max(value, min), max);
+var getStaticSide = (side) => {
+	if (side === EAnchorSide.TOP) return "bottom";
+	if (side === EAnchorSide.BOTTOM) return "top";
+	if (side === EAnchorSide.LEFT) return "right";
+	return "left";
+};
+var resolveCrossAxisArrowPosition = ({ referenceCenter, floatingStart, floatingLength, crossAxisProperty, staticSide, staticOffset, arrowSize, arrowPadding }) => {
+	const idealCenter = referenceCenter - floatingStart - arrowSize / 2;
+	const clampedCenter = clamp(arrowPadding, idealCenter, floatingLength - arrowSize - arrowPadding);
+	const centerOffset = idealCenter - clampedCenter;
+	return {
+		crossAxisPosition: clampedCenter,
+		crossAxisProperty,
+		staticSide,
+		staticOffset,
+		centerOffset,
+		isOverflow: Math.abs(centerOffset) > arrowSize / 2
+	};
+};
+var computeArrowPosition = (input) => {
+	const { referenceRect, floatingCoordinates, floatingSize, arrowSize, arrowPadding } = input;
+	const anchor = parseAnchor(input.resolvedPlacement);
+	const staticSide = getStaticSide(anchor.side);
+	const staticOffset = -(arrowSize / 2);
+	if (anchor.side === EAnchorSide.TOP || anchor.side === EAnchorSide.BOTTOM) return resolveCrossAxisArrowPosition({
+		referenceCenter: referenceRect.left + referenceRect.width / 2,
+		floatingStart: floatingCoordinates.x,
+		floatingLength: floatingSize.width,
+		crossAxisProperty: "left",
+		staticSide,
+		staticOffset,
+		arrowSize,
+		arrowPadding
+	});
+	return resolveCrossAxisArrowPosition({
+		referenceCenter: referenceRect.top + referenceRect.height / 2,
+		floatingStart: floatingCoordinates.y,
+		floatingLength: floatingSize.height,
+		crossAxisProperty: "top",
+		staticSide,
+		staticOffset,
+		arrowSize,
+		arrowPadding
+	});
+};
+//#endregion
+export { computeArrowPosition };

package/dist/composables/connectedPosition/computeConnectedPosition.cjs

@@ -0,0 +1,96 @@
+const require_types = require("./types.cjs");
+const require_parseAnchor = require("./parseAnchor.cjs");
+const require_getOverflow = require("./getOverflow.cjs");
+const require_flipSide = require("./flipSide.cjs");
+const require_positionCoordinates = require("./positionCoordinates.cjs");
+//#region src/composables/connectedPosition/computeConnectedPosition.ts
+var getMainAxisSide = (side) => {
+	if (side === require_types.EAnchorSide.TOP) return "top";
+	if (side === require_types.EAnchorSide.BOTTOM) return "bottom";
+	if (side === require_types.EAnchorSide.LEFT) return "left";
+	return "right";
+};
+var computeViewportMaxHeight = (coordinates, viewportRect, viewportPadding) => {
+	const viewportBottom = viewportRect.bottom - viewportPadding;
+	return Math.max(0, Math.floor(viewportBottom - coordinates.y));
+};
+var selectAnchorByFlip = (input) => {
+	const preferredAnchor = require_parseAnchor.parseAnchor(input.placement);
+	const candidates = input.flip ? [preferredAnchor, require_flipSide.flipMainAxis(preferredAnchor)] : [preferredAnchor];
+	let bestSelection = null;
+	let bestMainAxisOverflow = Number.POSITIVE_INFINITY;
+	for (const candidate of candidates) {
+		const candidateCoordinates = require_positionCoordinates.computeAnchorCoordinates(input.referenceRect, input.floatingSize, candidate, input.offset);
+		const overflow = require_getOverflow.getOverflow(require_positionCoordinates.toContentBox(candidateCoordinates, input.floatingSize), input.viewportRect, input.viewportPadding);
+		const selection = {
+			anchor: candidate,
+			coordinates: candidateCoordinates,
+			strategy: candidate === preferredAnchor ? require_types.EConnectedPositionStrategy.PREFERRED : require_types.EConnectedPositionStrategy.FLIP
+		};
+		if (!require_getOverflow.hasMainAxisOverflow(overflow, getMainAxisSide(candidate.side))) return selection;
+		const mainAxisOverflow = require_getOverflow.getMainAxisOverflow(overflow, candidate.side);
+		if (mainAxisOverflow < bestMainAxisOverflow) {
+			bestMainAxisOverflow = mainAxisOverflow;
+			bestSelection = selection;
+		}
+	}
+	return bestSelection ?? {
+		anchor: preferredAnchor,
+		coordinates: require_positionCoordinates.computeAnchorCoordinates(input.referenceRect, input.floatingSize, preferredAnchor, input.offset),
+		strategy: require_types.EConnectedPositionStrategy.PREFERRED
+	};
+};
+var applyShift = (input, selection) => {
+	if (!input.shift) return selection;
+	if (!require_getOverflow.hasAnyOverflow(require_getOverflow.getOverflow(require_positionCoordinates.toContentBox(selection.coordinates, input.floatingSize), input.viewportRect, input.viewportPadding))) return selection;
+	return {
+		...selection,
+		coordinates: require_positionCoordinates.shiftCoordinates(selection.coordinates, input.floatingSize, {
+			anchorSide: selection.anchor.side,
+			referenceRect: input.referenceRect,
+			viewportRect: input.viewportRect,
+			viewportPadding: input.viewportPadding
+		}),
+		strategy: require_types.EConnectedPositionStrategy.SHIFT
+	};
+};
+var applyViewportFit = (input, selection) => {
+	if (!input.fitViewport) return {
+		coordinates: selection.coordinates,
+		strategy: selection.strategy,
+		maxHeight: void 0
+	};
+	let availableHeight = computeViewportMaxHeight(selection.coordinates, input.viewportRect, input.viewportPadding);
+	const anchorBottom = input.referenceRect.top - input.offset;
+	if (selection.anchor.side === require_types.EAnchorSide.TOP) {
+		const viewportTop = input.viewportRect.top + input.viewportPadding;
+		const maxFromTopBoundary = Math.max(0, Math.floor(anchorBottom - viewportTop));
+		availableHeight = Math.min(availableHeight, maxFromTopBoundary);
+	}
+	if (availableHeight >= input.floatingSize.height) return {
+		coordinates: selection.coordinates,
+		strategy: selection.strategy,
+		maxHeight: void 0
+	};
+	return {
+		coordinates: selection.anchor.side === require_types.EAnchorSide.TOP ? {
+			...selection.coordinates,
+			y: anchorBottom - availableHeight
+		} : selection.coordinates,
+		strategy: require_types.EConnectedPositionStrategy.SIZE,
+		maxHeight: availableHeight
+	};
+};
+var computeConnectedPosition = (input) => {
+	const selection = applyShift(input, selectAnchorByFlip(input));
+	const fitted = applyViewportFit(input, selection);
+	return {
+		x: fitted.coordinates.x,
+		y: fitted.coordinates.y,
+		resolvedPlacement: require_parseAnchor.toDropdownPlacement(selection.anchor),
+		strategy: fitted.strategy,
+		maxHeight: fitted.maxHeight
+	};
+};
+//#endregion
+exports.computeConnectedPosition = computeConnectedPosition;

package/dist/composables/connectedPosition/computeConnectedPosition.js

@@ -0,0 +1,96 @@
+import { EAnchorSide, EConnectedPositionStrategy } from "./types.js";
+import { parseAnchor, toDropdownPlacement } from "./parseAnchor.js";
+import { getMainAxisOverflow, getOverflow, hasAnyOverflow, hasMainAxisOverflow } from "./getOverflow.js";
+import { flipMainAxis } from "./flipSide.js";
+import { computeAnchorCoordinates, shiftCoordinates, toContentBox } from "./positionCoordinates.js";
+//#region src/composables/connectedPosition/computeConnectedPosition.ts
+var getMainAxisSide = (side) => {
+	if (side === EAnchorSide.TOP) return "top";
+	if (side === EAnchorSide.BOTTOM) return "bottom";
+	if (side === EAnchorSide.LEFT) return "left";
+	return "right";
+};
+var computeViewportMaxHeight = (coordinates, viewportRect, viewportPadding) => {
+	const viewportBottom = viewportRect.bottom - viewportPadding;
+	return Math.max(0, Math.floor(viewportBottom - coordinates.y));
+};
+var selectAnchorByFlip = (input) => {
+	const preferredAnchor = parseAnchor(input.placement);
+	const candidates = input.flip ? [preferredAnchor, flipMainAxis(preferredAnchor)] : [preferredAnchor];
+	let bestSelection = null;
+	let bestMainAxisOverflow = Number.POSITIVE_INFINITY;
+	for (const candidate of candidates) {
+		const candidateCoordinates = computeAnchorCoordinates(input.referenceRect, input.floatingSize, candidate, input.offset);
+		const overflow = getOverflow(toContentBox(candidateCoordinates, input.floatingSize), input.viewportRect, input.viewportPadding);
+		const selection = {
+			anchor: candidate,
+			coordinates: candidateCoordinates,
+			strategy: candidate === preferredAnchor ? EConnectedPositionStrategy.PREFERRED : EConnectedPositionStrategy.FLIP
+		};
+		if (!hasMainAxisOverflow(overflow, getMainAxisSide(candidate.side))) return selection;
+		const mainAxisOverflow = getMainAxisOverflow(overflow, candidate.side);
+		if (mainAxisOverflow < bestMainAxisOverflow) {
+			bestMainAxisOverflow = mainAxisOverflow;
+			bestSelection = selection;
+		}
+	}
+	return bestSelection ?? {
+		anchor: preferredAnchor,
+		coordinates: computeAnchorCoordinates(input.referenceRect, input.floatingSize, preferredAnchor, input.offset),
+		strategy: EConnectedPositionStrategy.PREFERRED
+	};
+};
+var applyShift = (input, selection) => {
+	if (!input.shift) return selection;
+	if (!hasAnyOverflow(getOverflow(toContentBox(selection.coordinates, input.floatingSize), input.viewportRect, input.viewportPadding))) return selection;
+	return {
+		...selection,
+		coordinates: shiftCoordinates(selection.coordinates, input.floatingSize, {
+			anchorSide: selection.anchor.side,
+			referenceRect: input.referenceRect,
+			viewportRect: input.viewportRect,
+			viewportPadding: input.viewportPadding
+		}),
+		strategy: EConnectedPositionStrategy.SHIFT
+	};
+};
+var applyViewportFit = (input, selection) => {
+	if (!input.fitViewport) return {
+		coordinates: selection.coordinates,
+		strategy: selection.strategy,
+		maxHeight: void 0
+	};
+	let availableHeight = computeViewportMaxHeight(selection.coordinates, input.viewportRect, input.viewportPadding);
+	const anchorBottom = input.referenceRect.top - input.offset;
+	if (selection.anchor.side === EAnchorSide.TOP) {
+		const viewportTop = input.viewportRect.top + input.viewportPadding;
+		const maxFromTopBoundary = Math.max(0, Math.floor(anchorBottom - viewportTop));
+		availableHeight = Math.min(availableHeight, maxFromTopBoundary);
+	}
+	if (availableHeight >= input.floatingSize.height) return {
+		coordinates: selection.coordinates,
+		strategy: selection.strategy,
+		maxHeight: void 0
+	};
+	return {
+		coordinates: selection.anchor.side === EAnchorSide.TOP ? {
+			...selection.coordinates,
+			y: anchorBottom - availableHeight
+		} : selection.coordinates,
+		strategy: EConnectedPositionStrategy.SIZE,
+		maxHeight: availableHeight
+	};
+};
+var computeConnectedPosition = (input) => {
+	const selection = applyShift(input, selectAnchorByFlip(input));
+	const fitted = applyViewportFit(input, selection);
+	return {
+		x: fitted.coordinates.x,
+		y: fitted.coordinates.y,
+		resolvedPlacement: toDropdownPlacement(selection.anchor),
+		strategy: fitted.strategy,
+		maxHeight: fitted.maxHeight
+	};
+};
+//#endregion
+export { computeConnectedPosition };

package/dist/composables/connectedPosition/flipSide.cjs

@@ -0,0 +1,22 @@
+const require_types = require("./types.cjs");
+//#region src/composables/connectedPosition/flipSide.ts
+var flipMainAxis = (anchor) => {
+	if (anchor.side === require_types.EAnchorSide.TOP) return {
+		...anchor,
+		side: require_types.EAnchorSide.BOTTOM
+	};
+	if (anchor.side === require_types.EAnchorSide.BOTTOM) return {
+		...anchor,
+		side: require_types.EAnchorSide.TOP
+	};
+	if (anchor.side === require_types.EAnchorSide.LEFT) return {
+		...anchor,
+		side: require_types.EAnchorSide.RIGHT
+	};
+	return {
+		...anchor,
+		side: require_types.EAnchorSide.LEFT
+	};
+};
+//#endregion
+exports.flipMainAxis = flipMainAxis;

package/dist/composables/connectedPosition/flipSide.js

@@ -0,0 +1,22 @@
+import { EAnchorSide } from "./types.js";
+//#region src/composables/connectedPosition/flipSide.ts
+var flipMainAxis = (anchor) => {
+	if (anchor.side === EAnchorSide.TOP) return {
+		...anchor,
+		side: EAnchorSide.BOTTOM
+	};
+	if (anchor.side === EAnchorSide.BOTTOM) return {
+		...anchor,
+		side: EAnchorSide.TOP
+	};
+	if (anchor.side === EAnchorSide.LEFT) return {
+		...anchor,
+		side: EAnchorSide.RIGHT
+	};
+	return {
+		...anchor,
+		side: EAnchorSide.LEFT
+	};
+};
+//#endregion
+export { flipMainAxis };

package/dist/composables/connectedPosition/getBoundaryRect.cjs

@@ -0,0 +1,37 @@
+const require_getViewportRect = require("./getViewportRect.cjs");
+//#region src/composables/connectedPosition/getBoundaryRect.ts
+var clippingOverflowPattern = /auto|scroll|overlay|hidden|clip/;
+var isClippingElement = (element) => {
+	const computedStyle = window.getComputedStyle(element);
+	return [
+		computedStyle.overflow,
+		computedStyle.overflowX,
+		computedStyle.overflowY
+	].some((value) => clippingOverflowPattern.test(value));
+};
+var intersectRects = (first, second) => {
+	const top = Math.max(first.top, second.top);
+	const left = Math.max(first.left, second.left);
+	const right = Math.min(first.right, second.right);
+	const bottom = Math.min(first.bottom, second.bottom);
+	return {
+		top,
+		left,
+		right,
+		bottom,
+		width: Math.max(0, right - left),
+		height: Math.max(0, bottom - top)
+	};
+};
+var getBoundaryRect = (element) => {
+	let boundary = require_getViewportRect.getViewportRect();
+	if (!element) return boundary;
+	let currentElement = element.parentElement;
+	while (currentElement) {
+		if (isClippingElement(currentElement)) boundary = intersectRects(boundary, currentElement.getBoundingClientRect());
+		currentElement = currentElement.parentElement;
+	}
+	return boundary;
+};
+//#endregion
+exports.getBoundaryRect = getBoundaryRect;

package/dist/composables/connectedPosition/getBoundaryRect.js

@@ -0,0 +1,37 @@
+import { getViewportRect } from "./getViewportRect.js";
+//#region src/composables/connectedPosition/getBoundaryRect.ts
+var clippingOverflowPattern = /auto|scroll|overlay|hidden|clip/;
+var isClippingElement = (element) => {
+	const computedStyle = window.getComputedStyle(element);
+	return [
+		computedStyle.overflow,
+		computedStyle.overflowX,
+		computedStyle.overflowY
+	].some((value) => clippingOverflowPattern.test(value));
+};
+var intersectRects = (first, second) => {
+	const top = Math.max(first.top, second.top);
+	const left = Math.max(first.left, second.left);
+	const right = Math.min(first.right, second.right);
+	const bottom = Math.min(first.bottom, second.bottom);
+	return {
+		top,
+		left,
+		right,
+		bottom,
+		width: Math.max(0, right - left),
+		height: Math.max(0, bottom - top)
+	};
+};
+var getBoundaryRect = (element) => {
+	let boundary = getViewportRect();
+	if (!element) return boundary;
+	let currentElement = element.parentElement;
+	while (currentElement) {
+		if (isClippingElement(currentElement)) boundary = intersectRects(boundary, currentElement.getBoundingClientRect());
+		currentElement = currentElement.parentElement;
+	}
+	return boundary;
+};
+//#endregion
+export { getBoundaryRect };

package/dist/composables/connectedPosition/getOverflow.cjs

@@ -0,0 +1,60 @@
+const require_types = require("./types.cjs");
+//#region src/composables/connectedPosition/getOverflow.ts
+var OVERFLOW_EPSILON = .5;
+var isOverflowing = (value) => value > OVERFLOW_EPSILON;
+var getOverflow = (contentBox, viewportRect, viewportPadding) => {
+	const viewportTop = viewportRect.top + viewportPadding;
+	const viewportLeft = viewportRect.left + viewportPadding;
+	const viewportRight = viewportRect.right - viewportPadding;
+	const viewportBottom = viewportRect.bottom - viewportPadding;
+	return {
+		top: viewportTop - contentBox.top,
+		bottom: contentBox.bottom - viewportBottom,
+		left: viewportLeft - contentBox.left,
+		right: contentBox.right - viewportRight
+	};
+};
+var hasMainAxisOverflow = (overflow, side) => {
+	if (side === "top") return isOverflowing(overflow.top);
+	if (side === "bottom") return isOverflowing(overflow.bottom);
+	if (side === "left") return isOverflowing(overflow.left);
+	return isOverflowing(overflow.right);
+};
+var getMainAxisOverflow = (overflow, anchorSide) => {
+	if (anchorSide === require_types.EAnchorSide.TOP) return overflow.top;
+	if (anchorSide === require_types.EAnchorSide.BOTTOM) return overflow.bottom;
+	if (anchorSide === require_types.EAnchorSide.LEFT) return overflow.left;
+	return overflow.right;
+};
+var hasAnyOverflow = (overflow) => {
+	return isOverflowing(overflow.top) || isOverflowing(overflow.bottom) || isOverflowing(overflow.left) || isOverflowing(overflow.right);
+};
+var hasShiftMainAxisOverflow = (overflow, anchorSide) => {
+	if (anchorSide === require_types.EAnchorSide.TOP || anchorSide === require_types.EAnchorSide.BOTTOM) return isOverflowing(overflow.left) || isOverflowing(overflow.right);
+	return isOverflowing(overflow.top) || isOverflowing(overflow.bottom);
+};
+var isRectIntersecting = (firstRect, secondRect) => {
+	return firstRect.bottom > secondRect.top && firstRect.top < secondRect.bottom && firstRect.right > secondRect.left && firstRect.left < secondRect.right;
+};
+var getPaddedBoundaryRect = (boundaryRect, padding) => {
+	const paddedTop = boundaryRect.top + padding;
+	const paddedLeft = boundaryRect.left + padding;
+	const paddedRight = boundaryRect.right - padding;
+	const paddedBottom = boundaryRect.bottom - padding;
+	return {
+		top: paddedTop,
+		left: paddedLeft,
+		right: paddedRight,
+		bottom: paddedBottom,
+		width: Math.max(0, paddedRight - paddedLeft),
+		height: Math.max(0, paddedBottom - paddedTop)
+	};
+};
+//#endregion
+exports.getMainAxisOverflow = getMainAxisOverflow;
+exports.getOverflow = getOverflow;
+exports.getPaddedBoundaryRect = getPaddedBoundaryRect;
+exports.hasAnyOverflow = hasAnyOverflow;
+exports.hasMainAxisOverflow = hasMainAxisOverflow;
+exports.hasShiftMainAxisOverflow = hasShiftMainAxisOverflow;
+exports.isRectIntersecting = isRectIntersecting;

package/dist/composables/connectedPosition/getOverflow.js

@@ -0,0 +1,54 @@
+import { EAnchorSide } from "./types.js";
+//#region src/composables/connectedPosition/getOverflow.ts
+var OVERFLOW_EPSILON = .5;
+var isOverflowing = (value) => value > OVERFLOW_EPSILON;
+var getOverflow = (contentBox, viewportRect, viewportPadding) => {
+	const viewportTop = viewportRect.top + viewportPadding;
+	const viewportLeft = viewportRect.left + viewportPadding;
+	const viewportRight = viewportRect.right - viewportPadding;
+	const viewportBottom = viewportRect.bottom - viewportPadding;
+	return {
+		top: viewportTop - contentBox.top,
+		bottom: contentBox.bottom - viewportBottom,
+		left: viewportLeft - contentBox.left,
+		right: contentBox.right - viewportRight
+	};
+};
+var hasMainAxisOverflow = (overflow, side) => {
+	if (side === "top") return isOverflowing(overflow.top);
+	if (side === "bottom") return isOverflowing(overflow.bottom);
+	if (side === "left") return isOverflowing(overflow.left);
+	return isOverflowing(overflow.right);
+};
+var getMainAxisOverflow = (overflow, anchorSide) => {
+	if (anchorSide === EAnchorSide.TOP) return overflow.top;
+	if (anchorSide === EAnchorSide.BOTTOM) return overflow.bottom;
+	if (anchorSide === EAnchorSide.LEFT) return overflow.left;
+	return overflow.right;
+};
+var hasAnyOverflow = (overflow) => {
+	return isOverflowing(overflow.top) || isOverflowing(overflow.bottom) || isOverflowing(overflow.left) || isOverflowing(overflow.right);
+};
+var hasShiftMainAxisOverflow = (overflow, anchorSide) => {
+	if (anchorSide === EAnchorSide.TOP || anchorSide === EAnchorSide.BOTTOM) return isOverflowing(overflow.left) || isOverflowing(overflow.right);
+	return isOverflowing(overflow.top) || isOverflowing(overflow.bottom);
+};
+var isRectIntersecting = (firstRect, secondRect) => {
+	return firstRect.bottom > secondRect.top && firstRect.top < secondRect.bottom && firstRect.right > secondRect.left && firstRect.left < secondRect.right;
+};
+var getPaddedBoundaryRect = (boundaryRect, padding) => {
+	const paddedTop = boundaryRect.top + padding;
+	const paddedLeft = boundaryRect.left + padding;
+	const paddedRight = boundaryRect.right - padding;
+	const paddedBottom = boundaryRect.bottom - padding;
+	return {
+		top: paddedTop,
+		left: paddedLeft,
+		right: paddedRight,
+		bottom: paddedBottom,
+		width: Math.max(0, paddedRight - paddedLeft),
+		height: Math.max(0, paddedBottom - paddedTop)
+	};
+};
+//#endregion
+export { getMainAxisOverflow, getOverflow, getPaddedBoundaryRect, hasAnyOverflow, hasMainAxisOverflow, hasShiftMainAxisOverflow, isRectIntersecting };

package/dist/composables/connectedPosition/getScrollParents.cjs

@@ -0,0 +1,21 @@
+//#region src/composables/connectedPosition/getScrollParents.ts
+var scrollableOverflowPattern = /auto|scroll|overlay/;
+var isScrollableElement = (element) => {
+	const computedStyle = window.getComputedStyle(element);
+	return [
+		computedStyle.overflow,
+		computedStyle.overflowX,
+		computedStyle.overflowY
+	].some((value) => scrollableOverflowPattern.test(value));
+};
+var getScrollParents = (element) => {
+	const scrollParents = [];
+	let currentElement = element?.parentElement ?? null;
+	while (currentElement) {
+		if (isScrollableElement(currentElement)) scrollParents.push(currentElement);
+		currentElement = currentElement.parentElement;
+	}
+	return scrollParents;
+};
+//#endregion
+exports.getScrollParents = getScrollParents;

package/dist/composables/connectedPosition/getScrollParents.js

@@ -0,0 +1,21 @@
+//#region src/composables/connectedPosition/getScrollParents.ts
+var scrollableOverflowPattern = /auto|scroll|overlay/;
+var isScrollableElement = (element) => {
+	const computedStyle = window.getComputedStyle(element);
+	return [
+		computedStyle.overflow,
+		computedStyle.overflowX,
+		computedStyle.overflowY
+	].some((value) => scrollableOverflowPattern.test(value));
+};
+var getScrollParents = (element) => {
+	const scrollParents = [];
+	let currentElement = element?.parentElement ?? null;
+	while (currentElement) {
+		if (isScrollableElement(currentElement)) scrollParents.push(currentElement);
+		currentElement = currentElement.parentElement;
+	}
+	return scrollParents;
+};
+//#endregion
+export { getScrollParents };

package/dist/composables/connectedPosition/getViewportRect.cjs

@@ -0,0 +1,33 @@
+//#region src/composables/connectedPosition/getViewportRect.ts
+var getViewportRect = () => {
+	const visualViewport = window.visualViewport;
+	if (visualViewport) return {
+		top: visualViewport.offsetTop,
+		left: visualViewport.offsetLeft,
+		right: visualViewport.offsetLeft + visualViewport.width,
+		bottom: visualViewport.offsetTop + visualViewport.height,
+		width: visualViewport.width,
+		height: visualViewport.height
+	};
+	return {
+		top: 0,
+		left: 0,
+		right: window.innerWidth,
+		bottom: window.innerHeight,
+		width: window.innerWidth,
+		height: window.innerHeight
+	};
+};
+var toRectBox = (rect) => {
+	return {
+		top: rect.top,
+		left: rect.left,
+		right: rect.right,
+		bottom: rect.bottom,
+		width: rect.width,
+		height: rect.height
+	};
+};
+//#endregion
+exports.getViewportRect = getViewportRect;
+exports.toRectBox = toRectBox;

package/dist/composables/connectedPosition/getViewportRect.js

@@ -0,0 +1,32 @@
+//#region src/composables/connectedPosition/getViewportRect.ts
+var getViewportRect = () => {
+	const visualViewport = window.visualViewport;
+	if (visualViewport) return {
+		top: visualViewport.offsetTop,
+		left: visualViewport.offsetLeft,
+		right: visualViewport.offsetLeft + visualViewport.width,
+		bottom: visualViewport.offsetTop + visualViewport.height,
+		width: visualViewport.width,
+		height: visualViewport.height
+	};
+	return {
+		top: 0,
+		left: 0,
+		right: window.innerWidth,
+		bottom: window.innerHeight,
+		width: window.innerWidth,
+		height: window.innerHeight
+	};
+};
+var toRectBox = (rect) => {
+	return {
+		top: rect.top,
+		left: rect.left,
+		right: rect.right,
+		bottom: rect.bottom,
+		width: rect.width,
+		height: rect.height
+	};
+};
+//#endregion
+export { getViewportRect, toRectBox };

package/dist/composables/connectedPosition/parseAnchor.cjs

@@ -0,0 +1,78 @@
+const require_types = require("./types.cjs");
+//#region src/composables/connectedPosition/parseAnchor.ts
+var parseAnchor = (placement) => {
+	switch (placement) {
+		case require_types.ESDropdownPlacement.TOP: return {
+			side: require_types.EAnchorSide.TOP,
+			align: require_types.EAnchorAlign.CENTER
+		};
+		case require_types.ESDropdownPlacement.TOP_START: return {
+			side: require_types.EAnchorSide.TOP,
+			align: require_types.EAnchorAlign.START
+		};
+		case require_types.ESDropdownPlacement.TOP_END: return {
+			side: require_types.EAnchorSide.TOP,
+			align: require_types.EAnchorAlign.END
+		};
+		case require_types.ESDropdownPlacement.BOTTOM: return {
+			side: require_types.EAnchorSide.BOTTOM,
+			align: require_types.EAnchorAlign.CENTER
+		};
+		case require_types.ESDropdownPlacement.BOTTOM_START: return {
+			side: require_types.EAnchorSide.BOTTOM,
+			align: require_types.EAnchorAlign.START
+		};
+		case require_types.ESDropdownPlacement.BOTTOM_END: return {
+			side: require_types.EAnchorSide.BOTTOM,
+			align: require_types.EAnchorAlign.END
+		};
+		case require_types.ESDropdownPlacement.LEFT: return {
+			side: require_types.EAnchorSide.LEFT,
+			align: require_types.EAnchorAlign.CENTER
+		};
+		case require_types.ESDropdownPlacement.LEFT_START: return {
+			side: require_types.EAnchorSide.LEFT,
+			align: require_types.EAnchorAlign.START
+		};
+		case require_types.ESDropdownPlacement.LEFT_END: return {
+			side: require_types.EAnchorSide.LEFT,
+			align: require_types.EAnchorAlign.END
+		};
+		case require_types.ESDropdownPlacement.RIGHT: return {
+			side: require_types.EAnchorSide.RIGHT,
+			align: require_types.EAnchorAlign.CENTER
+		};
+		case require_types.ESDropdownPlacement.RIGHT_START: return {
+			side: require_types.EAnchorSide.RIGHT,
+			align: require_types.EAnchorAlign.START
+		};
+		case require_types.ESDropdownPlacement.RIGHT_END: return {
+			side: require_types.EAnchorSide.RIGHT,
+			align: require_types.EAnchorAlign.END
+		};
+		default: return placement;
+	}
+};
+var toDropdownPlacement = (anchor) => {
+	if (anchor.side === require_types.EAnchorSide.TOP) {
+		if (anchor.align === require_types.EAnchorAlign.START) return require_types.ESDropdownPlacement.TOP_START;
+		if (anchor.align === require_types.EAnchorAlign.END) return require_types.ESDropdownPlacement.TOP_END;
+		return require_types.ESDropdownPlacement.TOP;
+	}
+	if (anchor.side === require_types.EAnchorSide.BOTTOM) {
+		if (anchor.align === require_types.EAnchorAlign.START) return require_types.ESDropdownPlacement.BOTTOM_START;
+		if (anchor.align === require_types.EAnchorAlign.END) return require_types.ESDropdownPlacement.BOTTOM_END;
+		return require_types.ESDropdownPlacement.BOTTOM;
+	}
+	if (anchor.side === require_types.EAnchorSide.LEFT) {
+		if (anchor.align === require_types.EAnchorAlign.START) return require_types.ESDropdownPlacement.LEFT_START;
+		if (anchor.align === require_types.EAnchorAlign.END) return require_types.ESDropdownPlacement.LEFT_END;
+		return require_types.ESDropdownPlacement.LEFT;
+	}
+	if (anchor.align === require_types.EAnchorAlign.START) return require_types.ESDropdownPlacement.RIGHT_START;
+	if (anchor.align === require_types.EAnchorAlign.END) return require_types.ESDropdownPlacement.RIGHT_END;
+	return require_types.ESDropdownPlacement.RIGHT;
+};
+//#endregion
+exports.parseAnchor = parseAnchor;
+exports.toDropdownPlacement = toDropdownPlacement;