@wix/site-ui 1.30.0 → 1.32.0

package/dist/3319.js

@@ -0,0 +1,400 @@
+import { ARROW_LEFT, ARROW_UP, ARROW_DOWN, ARROW_RIGHT } from "./4745.js";
+import { stopEvent } from "./6330.js";
+import { getComputedStyle } from "./3829.js";
+const sides = [
+    'top',
+    'right',
+    'bottom',
+    'left'
+];
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v)=>({
+        x: v,
+        y: v
+    });
+const oppositeSideMap = {
+    left: 'right',
+    right: 'left',
+    bottom: 'top',
+    top: 'bottom'
+};
+function clamp(start, value, end) {
+    return max(start, min(value, end));
+}
+function evaluate(value, param) {
+    return 'function' == typeof value ? value(param) : value;
+}
+function getSide(placement) {
+    return placement.split('-')[0];
+}
+function getAlignment(placement) {
+    return placement.split('-')[1];
+}
+function getOppositeAxis(axis) {
+    return 'x' === axis ? 'y' : 'x';
+}
+function getAxisLength(axis) {
+    return 'y' === axis ? 'height' : 'width';
+}
+function getSideAxis(placement) {
+    const firstChar = placement[0];
+    return 't' === firstChar || 'b' === firstChar ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+    return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+    if (void 0 === rtl) rtl = false;
+    const alignment = getAlignment(placement);
+    const alignmentAxis = getAlignmentAxis(placement);
+    const length = getAxisLength(alignmentAxis);
+    let mainAlignmentSide = 'x' === alignmentAxis ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : 'start' === alignment ? 'bottom' : 'top';
+    if (rects.reference[length] > rects.floating[length]) mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+    return [
+        mainAlignmentSide,
+        getOppositePlacement(mainAlignmentSide)
+    ];
+}
+function getExpandedPlacements(placement) {
+    const oppositePlacement = getOppositePlacement(placement);
+    return [
+        getOppositeAlignmentPlacement(placement),
+        oppositePlacement,
+        getOppositeAlignmentPlacement(oppositePlacement)
+    ];
+}
+function getOppositeAlignmentPlacement(placement) {
+    return placement.includes('start') ? placement.replace('start', 'end') : placement.replace('end', 'start');
+}
+const lrPlacement = [
+    'left',
+    'right'
+];
+const rlPlacement = [
+    'right',
+    'left'
+];
+const tbPlacement = [
+    'top',
+    'bottom'
+];
+const btPlacement = [
+    'bottom',
+    'top'
+];
+function getSideList(side, isStart, rtl) {
+    switch(side){
+        case 'top':
+        case 'bottom':
+            if (rtl) return isStart ? rlPlacement : lrPlacement;
+            return isStart ? lrPlacement : rlPlacement;
+        case 'left':
+        case 'right':
+            return isStart ? tbPlacement : btPlacement;
+        default:
+            return [];
+    }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+    const alignment = getAlignment(placement);
+    let list = getSideList(getSide(placement), 'start' === direction, rtl);
+    if (alignment) {
+        list = list.map((side)=>side + "-" + alignment);
+        if (flipAlignment) list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+    return list;
+}
+function getOppositePlacement(placement) {
+    const side = getSide(placement);
+    return oppositeSideMap[side] + placement.slice(side.length);
+}
+function expandPaddingObject(padding) {
+    return {
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0,
+        ...padding
+    };
+}
+function getPaddingObject(padding) {
+    return 'number' != typeof padding ? expandPaddingObject(padding) : {
+        top: padding,
+        right: padding,
+        bottom: padding,
+        left: padding
+    };
+}
+function rectToClientRect(rect) {
+    const { x, y, width, height } = rect;
+    return {
+        width,
+        height,
+        top: y,
+        left: x,
+        right: x + width,
+        bottom: y + height,
+        x,
+        y
+    };
+}
+function isDifferentGridRow(index, cols, prevRow) {
+    return Math.floor(index / cols) !== prevRow;
+}
+function isIndexOutOfListBounds(list, index) {
+    return index < 0 || index >= list.length;
+}
+function getMinListIndex(listRef, disabledIndices) {
+    return findNonDisabledListIndex(listRef.current, {
+        disabledIndices
+    });
+}
+function getMaxListIndex(listRef, disabledIndices) {
+    return findNonDisabledListIndex(listRef.current, {
+        decrement: true,
+        startingIndex: listRef.current.length,
+        disabledIndices
+    });
+}
+function findNonDisabledListIndex(list, { startingIndex = -1, decrement = false, disabledIndices, amount = 1 } = {}) {
+    let index = startingIndex;
+    do index += decrement ? -amount : amount;
+    while (index >= 0 && index <= list.length - 1 && isListIndexDisabled(list, index, disabledIndices));
+    return index;
+}
+function getGridNavigatedIndex(list, { event, orientation, loopFocus, onLoop, rtl, cols, disabledIndices, minIndex, maxIndex, prevIndex, stopEvent: stop = false }) {
+    let nextIndex = prevIndex;
+    let verticalDirection;
+    if (event.key === ARROW_UP) verticalDirection = 'up';
+    else if (event.key === ARROW_DOWN) verticalDirection = 'down';
+    if (verticalDirection) {
+        const rows = [];
+        const rowIndexMap = [];
+        let hasRoleRow = false;
+        let visibleItemCount = 0;
+        {
+            let currentRowEl = null;
+            let currentRowIndex = -1;
+            list.forEach((el, idx)=>{
+                if (null == el) return;
+                visibleItemCount += 1;
+                const rowEl = el.closest('[role="row"]');
+                if (rowEl) hasRoleRow = true;
+                if (rowEl !== currentRowEl || -1 === currentRowIndex) {
+                    currentRowEl = rowEl;
+                    currentRowIndex += 1;
+                    rows[currentRowIndex] = [];
+                }
+                rows[currentRowIndex].push(idx);
+                rowIndexMap[idx] = currentRowIndex;
+            });
+        }
+        let hasDomRows = false;
+        let inferredDomCols = 0;
+        if (hasRoleRow) for (const row of rows){
+            const rowLength = row.length;
+            if (rowLength > inferredDomCols) inferredDomCols = rowLength;
+            if (rowLength !== cols) hasDomRows = true;
+        }
+        const hasVirtualizedGaps = hasDomRows && visibleItemCount < list.length;
+        const verticalCols = inferredDomCols || cols;
+        const navigateVertically = (direction)=>{
+            if (!hasDomRows || -1 === prevIndex) return;
+            const currentRow = rowIndexMap[prevIndex];
+            if (null == currentRow) return;
+            const colInRow = rows[currentRow].indexOf(prevIndex);
+            const step = 'up' === direction ? -1 : 1;
+            for(let nextRow = currentRow + step, i = 0; i < rows.length; i += 1, nextRow += step){
+                if (nextRow < 0 || nextRow >= rows.length) {
+                    if (!loopFocus || hasVirtualizedGaps) return;
+                    nextRow = nextRow < 0 ? rows.length - 1 : 0;
+                    if (onLoop) {
+                        const clampedCol = Math.min(colInRow, rows[nextRow].length - 1);
+                        const targetItemIndex = rows[nextRow][clampedCol] ?? rows[nextRow][0];
+                        const returnedItemIndex = onLoop(event, prevIndex, targetItemIndex);
+                        nextRow = rowIndexMap[returnedItemIndex] ?? nextRow;
+                    }
+                }
+                const targetRow = rows[nextRow];
+                for(let col = Math.min(colInRow, targetRow.length - 1); col >= 0; col -= 1){
+                    const candidate = targetRow[col];
+                    if (!isListIndexDisabled(list, candidate, disabledIndices)) return candidate;
+                }
+            }
+        };
+        const navigateVerticallyWithInferredRows = (direction)=>{
+            if (!hasVirtualizedGaps || -1 === prevIndex) return;
+            const colInRow = prevIndex % verticalCols;
+            const rowStep = 'up' === direction ? -verticalCols : verticalCols;
+            const lastRowStart = maxIndex - maxIndex % verticalCols;
+            const rowCount = floor(maxIndex / verticalCols) + 1;
+            for(let rowStart = prevIndex - colInRow + rowStep, i = 0; i < rowCount; i += 1, rowStart += rowStep){
+                if (rowStart < 0 || rowStart > maxIndex) {
+                    if (!loopFocus) return;
+                    rowStart = rowStart < 0 ? lastRowStart : 0;
+                }
+                const rowEnd = Math.min(rowStart + verticalCols - 1, maxIndex);
+                for(let candidate = Math.min(rowStart + colInRow, rowEnd); candidate >= rowStart; candidate -= 1)if (!isListIndexDisabled(list, candidate, disabledIndices)) return candidate;
+            }
+        };
+        if (stop) stopEvent(event);
+        const verticalCandidate = navigateVertically(verticalDirection) ?? navigateVerticallyWithInferredRows(verticalDirection);
+        if (void 0 !== verticalCandidate) nextIndex = verticalCandidate;
+        else if (-1 === prevIndex) nextIndex = 'up' === verticalDirection ? maxIndex : minIndex;
+        else {
+            nextIndex = findNonDisabledListIndex(list, {
+                startingIndex: prevIndex,
+                amount: verticalCols,
+                decrement: 'up' === verticalDirection,
+                disabledIndices
+            });
+            if (loopFocus) {
+                if ('up' === verticalDirection && (prevIndex - verticalCols < minIndex || nextIndex < 0)) {
+                    const col = prevIndex % verticalCols;
+                    const maxCol = maxIndex % verticalCols;
+                    const offset = maxIndex - (maxCol - col);
+                    nextIndex = maxCol === col ? maxIndex : maxCol > col ? offset : offset - verticalCols;
+                    if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+                }
+                if ('down' === verticalDirection && prevIndex + verticalCols > maxIndex) {
+                    nextIndex = findNonDisabledListIndex(list, {
+                        startingIndex: prevIndex % verticalCols - verticalCols,
+                        amount: verticalCols,
+                        disabledIndices
+                    });
+                    if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+                }
+            }
+        }
+        if (isIndexOutOfListBounds(list, nextIndex)) nextIndex = prevIndex;
+    }
+    if ('both' === orientation) {
+        const prevRow = floor(prevIndex / cols);
+        if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {
+            if (stop) stopEvent(event);
+            if (prevIndex % cols !== cols - 1) {
+                nextIndex = findNonDisabledListIndex(list, {
+                    startingIndex: prevIndex,
+                    disabledIndices
+                });
+                if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
+                    nextIndex = findNonDisabledListIndex(list, {
+                        startingIndex: prevIndex - prevIndex % cols - 1,
+                        disabledIndices
+                    });
+                    if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+                }
+            } else if (loopFocus) {
+                nextIndex = findNonDisabledListIndex(list, {
+                    startingIndex: prevIndex - prevIndex % cols - 1,
+                    disabledIndices
+                });
+                if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+            }
+            if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+        }
+        if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {
+            if (stop) stopEvent(event);
+            if (prevIndex % cols !== 0) {
+                nextIndex = findNonDisabledListIndex(list, {
+                    startingIndex: prevIndex,
+                    decrement: true,
+                    disabledIndices
+                });
+                if (loopFocus && isDifferentGridRow(nextIndex, cols, prevRow)) {
+                    nextIndex = findNonDisabledListIndex(list, {
+                        startingIndex: prevIndex + (cols - prevIndex % cols),
+                        decrement: true,
+                        disabledIndices
+                    });
+                    if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+                }
+            } else if (loopFocus) {
+                nextIndex = findNonDisabledListIndex(list, {
+                    startingIndex: prevIndex + (cols - prevIndex % cols),
+                    decrement: true,
+                    disabledIndices
+                });
+                if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+            }
+            if (isDifferentGridRow(nextIndex, cols, prevRow)) nextIndex = prevIndex;
+        }
+        const lastRow = floor(maxIndex / cols) === prevRow;
+        if (isIndexOutOfListBounds(list, nextIndex)) if (loopFocus && lastRow) {
+            nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledListIndex(list, {
+                startingIndex: prevIndex - prevIndex % cols - 1,
+                disabledIndices
+            });
+            if (onLoop) nextIndex = onLoop(event, prevIndex, nextIndex);
+        } else nextIndex = prevIndex;
+    }
+    return nextIndex;
+}
+function createGridCellMap(sizes, cols, dense) {
+    const cellMap = [];
+    let startIndex = 0;
+    sizes.forEach(({ width, height }, index)=>{
+        if (width > cols) {
+            if ('production' !== process.env.NODE_ENV) throw new Error(`[Floating UI]: Invalid grid - item width at index ${index} is greater than grid columns`);
+        }
+        let itemPlaced = false;
+        if (dense) startIndex = 0;
+        while(!itemPlaced){
+            const targetCells = [];
+            for(let i = 0; i < width; i += 1)for(let j = 0; j < height; j += 1)targetCells.push(startIndex + i + j * cols);
+            if (startIndex % cols + width <= cols && targetCells.every((cell)=>null == cellMap[cell])) {
+                targetCells.forEach((cell)=>{
+                    cellMap[cell] = index;
+                });
+                itemPlaced = true;
+            } else startIndex += 1;
+        }
+    });
+    return [
+        ...cellMap
+    ];
+}
+function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
+    if (-1 === index) return -1;
+    const firstCellIndex = cellMap.indexOf(index);
+    const sizeItem = sizes[index];
+    switch(corner){
+        case 'tl':
+            return firstCellIndex;
+        case 'tr':
+            if (!sizeItem) return firstCellIndex;
+            return firstCellIndex + sizeItem.width - 1;
+        case 'bl':
+            if (!sizeItem) return firstCellIndex;
+            return firstCellIndex + (sizeItem.height - 1) * cols;
+        case 'br':
+            return cellMap.lastIndexOf(index);
+        default:
+            return -1;
+    }
+}
+function getGridCellIndices(indices, cellMap) {
+    return cellMap.flatMap((index, cellIndex)=>indices.includes(index) ? [
+            cellIndex
+        ] : []);
+}
+function isListIndexDisabled(list, index, disabledIndices) {
+    const isExplicitlyDisabled = 'function' == typeof disabledIndices ? disabledIndices(index) : disabledIndices?.includes(index) ?? false;
+    if (isExplicitlyDisabled) return true;
+    const element = list[index];
+    if (!element) return false;
+    if (!isElementVisible(element)) return true;
+    return !disabledIndices && (element.hasAttribute('disabled') || 'true' === element.getAttribute('aria-disabled'));
+}
+function isHiddenByStyles(styles) {
+    return 'hidden' === styles.visibility || 'collapse' === styles.visibility;
+}
+function isElementVisible(element, styles = element ? getComputedStyle(element) : null) {
+    if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) return false;
+    if ('function' == typeof element.checkVisibility) return element.checkVisibility();
+    return 'none' !== styles.display && 'contents' !== styles.display;
+}
+export { clamp, createCoords, createGridCellMap, evaluate, findNonDisabledListIndex, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getGridCellIndexOfCorner, getGridCellIndices, getGridNavigatedIndex, getMaxListIndex, getMinListIndex, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, isElementVisible, isIndexOutOfListBounds, isListIndexDisabled, max, min, rectToClientRect, round, sides };

package/dist/3395.js

@@ -0,0 +1,4 @@
+function valueToPercent(value, min, max) {
+    return (value - min) * 100 / (max - min);
+}
+export { valueToPercent };