@stevederico/skateboard-ui 3.12.0 → 4.0.0

package/dist/shadcn/lib/base-ui/_chunk-kw8nnq00.js

@@ -1,546 +0,0 @@
-import {
-  ARROW_DOWN,
-  ARROW_LEFT,
-  ARROW_RIGHT,
-  ARROW_UP,
-  isAndroid,
-  isJSDOM
-} from "./_chunk-rrh8rt4v.js";
-import {
-  getComputedStyle
-} from "./_chunk-000kmre8.js";
-
-// node_modules/@base-ui/react/esm/floating-ui-react/utils/event.js
-function stopEvent(event) {
-  event.preventDefault();
-  event.stopPropagation();
-}
-function isReactEvent(event) {
-  return "nativeEvent" in event;
-}
-function isVirtualClick(event) {
-  if (event.pointerType === "" && event.isTrusted) {
-    return true;
-  }
-  if (isAndroid && event.pointerType) {
-    return event.type === "click" && event.buttons === 1;
-  }
-  return event.detail === 0 && !event.pointerType;
-}
-function isVirtualPointerEvent(event) {
-  if (isJSDOM) {
-    return false;
-  }
-  return !isAndroid && event.width === 0 && event.height === 0 || isAndroid && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
-}
-function isMouseLikePointerType(pointerType, strict) {
-  const values = ["mouse", "pen"];
-  if (!strict) {
-    values.push("", undefined);
-  }
-  return values.includes(pointerType);
-}
-function isClickLikeEvent(event) {
-  const type = event.type;
-  return type === "click" || type === "mousedown" || type === "keydown" || type === "keyup";
-}
-
-// node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
-var sides = ["top", "right", "bottom", "left"];
-var min = Math.min;
-var max = Math.max;
-var round = Math.round;
-var floor = Math.floor;
-var createCoords = (v) => ({
-  x: v,
-  y: v
-});
-var 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 typeof value === "function" ? value(param) : value;
-}
-function getSide(placement) {
-  return placement.split("-")[0];
-}
-function getAlignment(placement) {
-  return placement.split("-")[1];
-}
-function getOppositeAxis(axis) {
-  return axis === "x" ? "y" : "x";
-}
-function getAxisLength(axis) {
-  return axis === "y" ? "height" : "width";
-}
-function getSideAxis(placement) {
-  const firstChar = placement[0];
-  return firstChar === "t" || firstChar === "b" ? "y" : "x";
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === undefined) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const length = getAxisLength(alignmentAxis);
-  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "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");
-}
-var lrPlacement = ["left", "right"];
-var rlPlacement = ["right", "left"];
-var tbPlacement = ["top", "bottom"];
-var 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), direction === "start", 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 typeof padding !== "number" ? 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
-  };
-}
-
-// node_modules/@base-ui/react/esm/floating-ui-react/utils/composite.js
-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 (el == null) {
-          return;
-        }
-        visibleItemCount += 1;
-        const rowEl = el.closest('[role="row"]');
-        if (rowEl) {
-          hasRoleRow = true;
-        }
-        if (rowEl !== currentRowEl || currentRowIndex === -1) {
-          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 || prevIndex === -1) {
-        return;
-      }
-      const currentRow = rowIndexMap[prevIndex];
-      if (currentRow == null) {
-        return;
-      }
-      const colInRow = rows[currentRow].indexOf(prevIndex);
-      const step = direction === "up" ? -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;
-          }
-        }
-      }
-      return;
-    };
-    const navigateVerticallyWithInferredRows = (direction) => {
-      if (!hasVirtualizedGaps || prevIndex === -1) {
-        return;
-      }
-      const colInRow = prevIndex % verticalCols;
-      const rowStep = direction === "up" ? -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;
-          }
-        }
-      }
-      return;
-    };
-    if (stop) {
-      stopEvent(event);
-    }
-    const verticalCandidate = navigateVertically(verticalDirection) ?? navigateVerticallyWithInferredRows(verticalDirection);
-    if (verticalCandidate !== undefined) {
-      nextIndex = verticalCandidate;
-    } else if (prevIndex === -1) {
-      nextIndex = verticalDirection === "up" ? maxIndex : minIndex;
-    } else {
-      nextIndex = findNonDisabledListIndex(list, {
-        startingIndex: prevIndex,
-        amount: verticalCols,
-        decrement: verticalDirection === "up",
-        disabledIndices
-      });
-      if (loopFocus) {
-        if (verticalDirection === "up" && (prevIndex - verticalCols < minIndex || nextIndex < 0)) {
-          const col = prevIndex % verticalCols;
-          const maxCol = maxIndex % verticalCols;
-          const offset = maxIndex - (maxCol - col);
-          if (maxCol === col) {
-            nextIndex = maxIndex;
-          } else {
-            nextIndex = maxCol > col ? offset : offset - verticalCols;
-          }
-          if (onLoop) {
-            nextIndex = onLoop(event, prevIndex, nextIndex);
-          }
-        }
-        if (verticalDirection === "down" && 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 (orientation === "both") {
-    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 (true) {
-        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) => cellMap[cell] == null)) {
-        targetCells.forEach((cell) => {
-          cellMap[cell] = index;
-        });
-        itemPlaced = true;
-      } else {
-        startIndex += 1;
-      }
-    }
-  });
-  return [...cellMap];
-}
-function getGridCellIndexOfCorner(index, sizes, cellMap, cols, corner) {
-  if (index === -1) {
-    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 = typeof disabledIndices === "function" ? 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") || element.getAttribute("aria-disabled") === "true");
-}
-function isHiddenByStyles(styles) {
-  return styles.visibility === "hidden" || styles.visibility === "collapse";
-}
-function isElementVisible(element, styles = element ? getComputedStyle(element) : null) {
-  if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) {
-    return false;
-  }
-  if (typeof element.checkVisibility === "function") {
-    return element.checkVisibility();
-  }
-  return styles.display !== "none" && styles.display !== "contents";
-}
-
-export { stopEvent, isReactEvent, isVirtualClick, isVirtualPointerEvent, isMouseLikePointerType, isClickLikeEvent, sides, min, max, round, floor, createCoords, clamp, evaluate, getSide, getAlignment, getOppositeAxis, getAxisLength, getSideAxis, getAlignmentAxis, getAlignmentSides, getExpandedPlacements, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, rectToClientRect, isIndexOutOfListBounds, getMinListIndex, getMaxListIndex, findNonDisabledListIndex, getGridNavigatedIndex, createGridCellMap, getGridCellIndexOfCorner, getGridCellIndices, isListIndexDisabled, isElementVisible };

package/dist/shadcn/lib/base-ui/_chunk-m307wpdj.js

@@ -1,18 +0,0 @@
-// node_modules/@base-ui/utils/esm/usePreviousValue.js
-import * as React from "react";
-"use client";
-function usePreviousValue(value) {
-  const [state, setState] = React.useState({
-    current: value,
-    previous: null
-  });
-  if (value !== state.current) {
-    setState({
-      current: value,
-      previous: state.current
-    });
-  }
-  return state.previous;
-}
-
-export { usePreviousValue };

package/dist/shadcn/lib/base-ui/_chunk-mnd0j7v9.js

@@ -1,15 +0,0 @@
-// node_modules/@base-ui/react/esm/toolbar/root/ToolbarRootContext.js
-import * as React from "react";
-"use client";
-var ToolbarRootContext = /* @__PURE__ */ React.createContext(undefined);
-if (true)
-  ToolbarRootContext.displayName = "ToolbarRootContext";
-function useToolbarRootContext(optional) {
-  const context = React.useContext(ToolbarRootContext);
-  if (context === undefined && !optional) {
-    throw new Error("Base UI: ToolbarRootContext is missing. Toolbar parts must be placed within <Toolbar.Root>.");
-  }
-  return context;
-}
-
-export { useToolbarRootContext };

package/dist/shadcn/lib/base-ui/_chunk-n11h505c.js

@@ -1,32 +0,0 @@
-import {
-  useRenderElement
-} from "./_chunk-x8xehj6d.js";
-
-// node_modules/@base-ui/react/esm/separator/Separator.js
-import * as React from "react";
-"use client";
-var Separator = /* @__PURE__ */ React.forwardRef(function SeparatorComponent(componentProps, forwardedRef) {
-  const {
-    className,
-    render,
-    orientation = "horizontal",
-    style,
-    ...elementProps
-  } = componentProps;
-  const state = {
-    orientation
-  };
-  const element = useRenderElement("div", componentProps, {
-    state,
-    ref: forwardedRef,
-    props: [{
-      role: "separator",
-      "aria-orientation": orientation
-    }, elementProps]
-  });
-  return element;
-});
-if (true)
-  Separator.displayName = "Separator";
-
-export { Separator };

package/dist/shadcn/lib/base-ui/_chunk-p0e2qacz.js

@@ -1,26 +0,0 @@
-import {
-  require_shim
-} from "./_chunk-1vw45v38.js";
-import {
-  NOOP
-} from "./_chunk-x8xehj6d.js";
-import {
-  __toESM
-} from "./_chunk-svxv97ph.js";
-
-// node_modules/@base-ui/react/esm/utils/useIsHydrating.js
-var import_shim = __toESM(require_shim(), 1);
-function subscribe() {
-  return NOOP;
-}
-function getSnapshot() {
-  return false;
-}
-function getServerSnapshot() {
-  return true;
-}
-function useIsHydrating() {
-  return import_shim.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-}
-
-export { useIsHydrating };