-
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */
+const computePosition$1 = async (reference, floating, config) => {
+ const {
+ placement = 'bottom',
+ strategy = 'absolute',
+ middleware = [],
+ platform
+ } = config;
+ const validMiddleware = middleware.filter(Boolean);
+ const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+ let rects = await platform.getElementRects({
+ reference,
+ floating,
+ strategy
+ });
+ let {
+ x,
+ y
+ } = computeCoordsFromPlacement(rects, placement, rtl);
+ let statefulPlacement = placement;
+ let middlewareData = {};
+ let resetCount = 0;
+ for (let i = 0; i < validMiddleware.length; i++) {
+ const {
+ name,
+ fn
+ } = validMiddleware[i];
+ const {
+ x: nextX,
+ y: nextY,
+ data,
+ reset
+ } = await fn({
+ x,
+ y,
+ initialPlacement: placement,
+ placement: statefulPlacement,
+ strategy,
+ middlewareData,
+ rects,
+ platform,
+ elements: {
+ reference,
+ floating
+ }
+ });
+ x = nextX != null ? nextX : x;
+ y = nextY != null ? nextY : y;
+ middlewareData = {
+ ...middlewareData,
+ [name]: {
+ ...middlewareData[name],
+ ...data
+ }
+ };
+ if (reset && resetCount <= 50) {
+ resetCount++;
+ if (typeof reset === 'object') {
+ if (reset.placement) {
+ statefulPlacement = reset.placement;
+ }
+ if (reset.rects) {
+ rects = reset.rects === true ? await platform.getElementRects({
+ reference,
+ floating,
+ strategy
+ }) : reset.rects;
+ }
+ ({
+ x,
+ y
+ } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+ }
+ i = -1;
+ }
+ }
+ return {
+ x,
+ y,
+ placement: statefulPlacement,
+ strategy,
+ middlewareData
+ };
+};
-
-
-
- ${(_a = this.dayNamesOfTheWeek) === null || _a === void 0 ? void 0 : _a.map(dayNameOfWeek => this.renderDayOfWeek(dayNameOfWeek))}
-
-
-
- ${(_b = this.daysOfMonth) === null || _b === void 0 ? void 0 : _b.map(week => this.renderWeek(week))}
-
-
-
- `;
+/**
+ * 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 = {};
}
- /* eslint-enable */
+ 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
+ };
}
-if (!customElements.get('auro-calendar-month')) {
- customElements.define('auro-calendar-month', AuroCalendarMonth);
+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 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$1 = function (options) {
+ if (options === void 0) {
+ options = {};
+ }
+ return {
+ name: 'autoPlacement',
+ options,
+ async fn(state) {
+ var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
+ const {
+ rects,
+ middlewareData,
+ placement,
+ platform,
+ elements
+ } = state;
+ const {
+ crossAxis = false,
+ alignment,
+ allowedPlacements = placements,
+ autoAlignment = true,
+ ...detectOverflowOptions
+ } = evaluate(options, state);
+ const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
+ const overflow = await 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 alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
-/* eslint-disable no-underscore-dangle, no-magic-numbers, no-underscore-dangle, no-void, init-declarations, no-extra-parens, no-unused-expressions */
-
-class RangeDatepicker extends r$2 {
- constructor() {
- super();
-
- /**
- * Array of disabled days. Format is Unix timestamp.
- */
- this.disabledDays = [];
-
- /**
- * Display a select year control.
- */
- this.enableYearChange = false;
+ // Make `computeCoords` start from the right place.
+ if (placement !== currentPlacement) {
+ return {
+ reset: {
+ placement: placements$1[0]
+ }
+ };
+ }
+ 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];
- /**
- * Force display of only one month.
- */
- this.forceNarrow = false;
+ // There are more placements to check.
+ if (nextPlacement) {
+ return {
+ data: {
+ index: currentIndex + 1,
+ overflows: allOverflows
+ },
+ reset: {
+ placement: nextPlacement
+ }
+ };
+ }
+ 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
+ }
+ };
+ }
+ return {};
+ }
+ };
+};
- /**
- * Set locale of the calendar.
- */
- this.locale = null;
+/**
+ * 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$1 = function (options) {
+ if (options === void 0) {
+ options = {};
+ }
+ return {
+ name: 'flip',
+ options,
+ async fn(state) {
+ var _middlewareData$arrow, _middlewareData$flip;
+ const {
+ placement,
+ middlewareData,
+ rects,
+ initialPlacement,
+ platform,
+ elements
+ } = state;
+ const {
+ mainAxis: checkMainAxis = true,
+ crossAxis: checkCrossAxis = true,
+ fallbackPlacements: specifiedFallbackPlacements,
+ fallbackStrategy = 'bestFit',
+ fallbackAxisSideDirection = 'none',
+ flipAlignment = 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) {
+ 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 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]);
+ }
+ if (checkCrossAxis) {
+ const sides = getAlignmentSides(placement, rects, rtl);
+ overflows.push(overflow[sides[0]], overflow[sides[1]]);
+ }
+ overflowsData = [...overflowsData, {
+ placement,
+ overflows
+ }];
- /**
- * Max date. Format is Unix timestamp.
- */
- this.max = '8640000000000';
+ // 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) {
+ // Try next placement and re-run the lifecycle.
+ return {
+ data: {
+ index: nextIndex,
+ overflows: overflowsData
+ },
+ reset: {
+ placement: nextPlacement
+ }
+ };
+ }
- /**
- * Minimal date. Format is Unix timestamp.
- */
- this.min = '-8640000000000';
+ // 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 'initialPlacement':
+ resetPlacement = initialPlacement;
+ break;
+ }
+ }
+ if (placement !== resetPlacement) {
+ return {
+ reset: {
+ placement: resetPlacement
+ }
+ };
+ }
+ }
+ return {};
+ }
+ };
+};
- /**
- * If true only one date can be selected.
- */
- this.noRange = false;
- this.dateFrom = null;
- this.dateTo = null;
- this.hoveredDate = null;
- this.monthPlus = null;
- this.yearPlus = null;
- this.narrow = false;
- const now = new Date();
- this.month = getMonth(now) + 1;
- this.year = getYear(now);
- this.monthChanged(this.month, this.year);
+// For type backwards-compatibility, the `OffsetOptions` type was also
+// Derivable.
+
+async function convertValueToCoords(state, options) {
+ const {
+ placement,
+ platform,
+ elements
+ } = state;
+ const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+ const side = getSide(placement);
+ const alignment = getAlignment(placement);
+ const isVertical = getSideAxis(placement) === 'y';
+ const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
+ const crossAxisMulti = rtl && isVertical ? -1 : 1;
+ const rawValue = evaluate(options, state);
+
+ // eslint-disable-next-line prefer-const
+ let {
+ mainAxis,
+ crossAxis,
+ alignmentAxis
+ } = typeof rawValue === 'number' ? {
+ mainAxis: rawValue,
+ crossAxis: 0,
+ alignmentAxis: null
+ } : {
+ mainAxis: rawValue.mainAxis || 0,
+ crossAxis: rawValue.crossAxis || 0,
+ alignmentAxis: rawValue.alignmentAxis
+ };
+ if (alignment && typeof alignmentAxis === 'number') {
+ crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
}
+ return isVertical ? {
+ x: crossAxis * crossAxisMulti,
+ y: mainAxis * mainAxisMulti
+ } : {
+ x: mainAxis * mainAxisMulti,
+ y: crossAxis * crossAxisMulti
+ };
+}
- render() {
- return this.isNarrow(this.forceNarrow, this.narrow)
- ? this.renderNarrow()
- : this.renderNormal();
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset$1 = function (options) {
+ if (options === void 0) {
+ options = 0;
}
+ return {
+ name: 'offset',
+ options,
+ async fn(state) {
+ var _middlewareData$offse, _middlewareData$arrow;
+ const {
+ x,
+ y,
+ placement,
+ middlewareData
+ } = state;
+ const diffCoords = await convertValueToCoords(state, options);
+
+ // If the placement is the same and the arrow caused an alignment offset
+ // then we don't need to change the positioning coordinates.
+ if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+ return {};
+ }
+ return {
+ x: x + diffCoords.x,
+ y: y + diffCoords.y,
+ data: {
+ ...diffCoords,
+ placement
+ }
+ };
+ }
+ };
+};
- renderNormal() {
- return x`
-