dune-react 0.0.1 → 0.0.2

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/control/SliderControl.js

@@ -0,0 +1,384 @@
+import * as React from "react";
+import { isElement } from "../../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { ownerDocument } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/owner.js";
+import { useAnimationFrame } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useAnimationFrame.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useValueAsRef } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useValueAsRef.js";
+import { clamp } from "../../utils/clamp.js";
+import { createChangeEventDetails, createGenericEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useDirection } from "../../direction-provider/DirectionContext.js";
+import { useSliderRootContext } from "../root/SliderRootContext.js";
+import { sliderStateAttributesMapping } from "../root/stateAttributesMapping.js";
+import { getMidpoint } from "../utils/getMidpoint.js";
+import { roundValueToStep } from "../utils/roundValueToStep.js";
+import { validateMinimumDistance } from "../utils/validateMinimumDistance.js";
+import { resolveThumbCollision } from "../utils/resolveThumbCollision.js";
+import { drag, trackPress } from "../../utils/reason-parts.js";
+import { contains, activeElement } from "../../floating-ui-react/utils/element.js";
+const INTENTIONAL_DRAG_COUNT_THRESHOLD = 2;
+function getControlOffset(styles, vertical) {
+  if (!styles) {
+    return {
+      start: 0,
+      end: 0
+    };
+  }
+  function parseSize(value) {
+    const parsed = value != null ? parseFloat(value) : 0;
+    return Number.isNaN(parsed) ? 0 : parsed;
+  }
+  const start = !vertical ? "InlineStart" : "Top";
+  const end = !vertical ? "InlineEnd" : "Bottom";
+  return {
+    start: parseSize(styles[`border${start}Width`]) + parseSize(styles[`padding${start}`]),
+    end: parseSize(styles[`border${end}Width`]) + parseSize(styles[`padding${end}`])
+  };
+}
+function getFingerCoords(event, touchIdRef) {
+  if (touchIdRef.current != null && event.changedTouches) {
+    const touchEvent = event;
+    for (let i = 0; i < touchEvent.changedTouches.length; i += 1) {
+      const touch = touchEvent.changedTouches[i];
+      if (touch.identifier === touchIdRef.current) {
+        return {
+          x: touch.clientX,
+          y: touch.clientY
+        };
+      }
+    }
+    return null;
+  }
+  return {
+    x: event.clientX,
+    y: event.clientY
+  };
+}
+const SliderControl = /* @__PURE__ */ React.forwardRef(function SliderControl2(componentProps, forwardedRef) {
+  const {
+    render: renderProp,
+    className,
+    ...elementProps
+  } = componentProps;
+  const {
+    disabled,
+    dragging,
+    inset,
+    lastChangedValueRef,
+    lastChangeReasonRef,
+    max,
+    min,
+    minStepsBetweenValues,
+    onValueCommitted,
+    orientation,
+    pressedInputRef,
+    pressedThumbCenterOffsetRef,
+    pressedThumbIndexRef,
+    pressedValuesRef,
+    registerFieldControlRef,
+    renderBeforeHydration,
+    setActive,
+    setDragging,
+    setValue,
+    state,
+    step,
+    thumbCollisionBehavior,
+    thumbRefs,
+    values
+  } = useSliderRootContext();
+  const direction = useDirection();
+  const range = values.length > 1;
+  const vertical = orientation === "vertical";
+  const controlRef = React.useRef(null);
+  const stylesRef = React.useRef(null);
+  const setStylesRef = useStableCallback((element2) => {
+    if (element2 && stylesRef.current == null) {
+      if (stylesRef.current == null) {
+        stylesRef.current = getComputedStyle(element2);
+      }
+    }
+  });
+  const touchIdRef = React.useRef(null);
+  const moveCountRef = React.useRef(0);
+  const insetThumbOffsetRef = React.useRef(0);
+  const latestValuesRef = useValueAsRef(values);
+  const updatePressedThumb = useStableCallback((nextIndex) => {
+    if (pressedThumbIndexRef.current !== nextIndex) {
+      pressedThumbIndexRef.current = nextIndex;
+    }
+    const thumbElement = thumbRefs.current[nextIndex];
+    if (!thumbElement) {
+      pressedThumbCenterOffsetRef.current = null;
+      pressedInputRef.current = null;
+      return;
+    }
+    pressedInputRef.current = thumbElement.querySelector('input[type="range"]');
+  });
+  const getFingerState = useStableCallback((fingerCoords) => {
+    const control = controlRef.current;
+    if (!control) {
+      return null;
+    }
+    const {
+      width,
+      height,
+      bottom,
+      left,
+      right
+    } = control.getBoundingClientRect();
+    const controlOffset = getControlOffset(stylesRef.current, vertical);
+    const insetThumbOffset = insetThumbOffsetRef.current;
+    const controlSize = (vertical ? height : width) - controlOffset.start - controlOffset.end - insetThumbOffset * 2;
+    const thumbCenterOffset = pressedThumbCenterOffsetRef.current ?? 0;
+    const fingerX = fingerCoords.x - thumbCenterOffset;
+    const fingerY = fingerCoords.y - thumbCenterOffset;
+    const valueSize = vertical ? bottom - fingerY - controlOffset.end : (direction === "rtl" ? right - fingerX : fingerX - left) - controlOffset.start;
+    const valueRescaled = clamp((valueSize - insetThumbOffset) / controlSize, 0, 1);
+    let newValue = (max - min) * valueRescaled + min;
+    newValue = roundValueToStep(newValue, step, min);
+    newValue = clamp(newValue, min, max);
+    if (!range) {
+      return {
+        value: newValue,
+        thumbIndex: 0,
+        didSwap: false
+      };
+    }
+    const thumbIndex = pressedThumbIndexRef.current;
+    if (thumbIndex < 0) {
+      return null;
+    }
+    const collisionResult = resolveThumbCollision({
+      behavior: thumbCollisionBehavior,
+      values,
+      currentValues: latestValuesRef.current ?? values,
+      initialValues: pressedValuesRef.current,
+      pressedIndex: thumbIndex,
+      nextValue: newValue,
+      min,
+      max,
+      step,
+      minStepsBetweenValues
+    });
+    if (thumbCollisionBehavior === "swap" && collisionResult.didSwap) {
+      updatePressedThumb(collisionResult.thumbIndex);
+    } else {
+      pressedThumbIndexRef.current = collisionResult.thumbIndex;
+    }
+    return collisionResult;
+  });
+  const startPressing = useStableCallback((fingerCoords) => {
+    pressedValuesRef.current = range ? values.slice() : null;
+    latestValuesRef.current = values;
+    const pressedThumbIndex = pressedThumbIndexRef.current;
+    let closestThumbIndex = pressedThumbIndex;
+    if (pressedThumbIndex > -1 && pressedThumbIndex < values.length) {
+      if (values[pressedThumbIndex] === max) {
+        let candidateIndex = pressedThumbIndex;
+        while (candidateIndex > 0 && values[candidateIndex - 1] === max) {
+          candidateIndex -= 1;
+        }
+        closestThumbIndex = candidateIndex;
+      }
+    } else {
+      const axis = !vertical ? "x" : "y";
+      let minDistance;
+      closestThumbIndex = -1;
+      for (let i = 0; i < thumbRefs.current.length; i += 1) {
+        const thumbEl = thumbRefs.current[i];
+        if (isElement(thumbEl)) {
+          const midpoint = getMidpoint(thumbEl);
+          const distance = Math.abs(fingerCoords[axis] - midpoint[axis]);
+          if (minDistance === void 0 || distance <= minDistance) {
+            closestThumbIndex = i;
+            minDistance = distance;
+          }
+        }
+      }
+    }
+    if (closestThumbIndex > -1 && closestThumbIndex !== pressedThumbIndex) {
+      updatePressedThumb(closestThumbIndex);
+    }
+    if (inset) {
+      const thumbEl = thumbRefs.current[closestThumbIndex];
+      if (isElement(thumbEl)) {
+        const thumbRect = thumbEl.getBoundingClientRect();
+        const side = !vertical ? "width" : "height";
+        insetThumbOffsetRef.current = thumbRect[side] / 2;
+      }
+    }
+  });
+  const focusThumb = useStableCallback((thumbIndex) => {
+    var _a, _b, _c;
+    (_c = (_b = (_a = thumbRefs.current) == null ? void 0 : _a[thumbIndex]) == null ? void 0 : _b.querySelector('input[type="range"]')) == null ? void 0 : _c.focus({
+      preventScroll: true
+    });
+  });
+  const handleTouchMove = useStableCallback((nativeEvent) => {
+    const fingerCoords = getFingerCoords(nativeEvent, touchIdRef);
+    if (fingerCoords == null) {
+      return;
+    }
+    moveCountRef.current += 1;
+    if (nativeEvent.type === "pointermove" && nativeEvent.buttons === 0) {
+      handleTouchEnd(nativeEvent);
+      return;
+    }
+    const finger = getFingerState(fingerCoords);
+    if (finger == null) {
+      return;
+    }
+    if (validateMinimumDistance(finger.value, step, minStepsBetweenValues)) {
+      if (!dragging && moveCountRef.current > INTENTIONAL_DRAG_COUNT_THRESHOLD) {
+        setDragging(true);
+      }
+      setValue(finger.value, createChangeEventDetails(drag, nativeEvent, void 0, {
+        activeThumbIndex: finger.thumbIndex
+      }));
+      latestValuesRef.current = Array.isArray(finger.value) ? finger.value : [finger.value];
+      if (finger.didSwap) {
+        focusThumb(finger.thumbIndex);
+      }
+    }
+  });
+  function handleTouchEnd(nativeEvent) {
+    var _a, _b;
+    setActive(-1);
+    setDragging(false);
+    pressedInputRef.current = null;
+    pressedThumbCenterOffsetRef.current = null;
+    const fingerCoords = getFingerCoords(nativeEvent, touchIdRef);
+    const finger = fingerCoords != null ? getFingerState(fingerCoords) : null;
+    if (finger != null) {
+      const commitReason = lastChangeReasonRef.current;
+      onValueCommitted(lastChangedValueRef.current ?? finger.value, createGenericEventDetails(commitReason, nativeEvent));
+    }
+    if ("pointerType" in nativeEvent && ((_a = controlRef.current) == null ? void 0 : _a.hasPointerCapture(nativeEvent.pointerId))) {
+      (_b = controlRef.current) == null ? void 0 : _b.releasePointerCapture(nativeEvent.pointerId);
+    }
+    pressedThumbIndexRef.current = -1;
+    touchIdRef.current = null;
+    pressedValuesRef.current = null;
+    stopListening();
+  }
+  const handleTouchStart = useStableCallback((nativeEvent) => {
+    if (disabled) {
+      return;
+    }
+    const touch = nativeEvent.changedTouches[0];
+    if (touch != null) {
+      touchIdRef.current = touch.identifier;
+    }
+    const fingerCoords = getFingerCoords(nativeEvent, touchIdRef);
+    if (fingerCoords != null) {
+      startPressing(fingerCoords);
+      const finger = getFingerState(fingerCoords);
+      if (finger == null) {
+        return;
+      }
+      focusThumb(finger.thumbIndex);
+      setValue(finger.value, createChangeEventDetails(trackPress, nativeEvent, void 0, {
+        activeThumbIndex: finger.thumbIndex
+      }));
+      latestValuesRef.current = Array.isArray(finger.value) ? finger.value : [finger.value];
+      if (finger.didSwap) {
+        focusThumb(finger.thumbIndex);
+      }
+    }
+    moveCountRef.current = 0;
+    const doc = ownerDocument(controlRef.current);
+    doc.addEventListener("touchmove", handleTouchMove, {
+      passive: true
+    });
+    doc.addEventListener("touchend", handleTouchEnd, {
+      passive: true
+    });
+  });
+  const stopListening = useStableCallback(() => {
+    const doc = ownerDocument(controlRef.current);
+    doc.removeEventListener("pointermove", handleTouchMove);
+    doc.removeEventListener("pointerup", handleTouchEnd);
+    doc.removeEventListener("touchmove", handleTouchMove);
+    doc.removeEventListener("touchend", handleTouchEnd);
+    pressedValuesRef.current = null;
+  });
+  const focusFrame = useAnimationFrame();
+  React.useEffect(() => {
+    const control = controlRef.current;
+    if (!control) {
+      return () => stopListening();
+    }
+    control.addEventListener("touchstart", handleTouchStart, {
+      passive: true
+    });
+    return () => {
+      control.removeEventListener("touchstart", handleTouchStart);
+      focusFrame.cancel();
+      stopListening();
+    };
+  }, [stopListening, handleTouchStart, controlRef, focusFrame]);
+  React.useEffect(() => {
+    if (disabled) {
+      stopListening();
+    }
+  }, [disabled, stopListening]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, registerFieldControlRef, controlRef, setStylesRef],
+    props: [{
+      ["data-base-ui-slider-control"]: renderBeforeHydration ? "" : void 0,
+      onPointerDown(event) {
+        const control = controlRef.current;
+        if (!control || disabled || event.defaultPrevented || !isElement(event.target) || // Only handle left clicks
+        event.button !== 0) {
+          return;
+        }
+        const fingerCoords = getFingerCoords(event, touchIdRef);
+        if (fingerCoords != null) {
+          startPressing(fingerCoords);
+          const finger = getFingerState(fingerCoords);
+          if (finger == null) {
+            return;
+          }
+          const pressedOnFocusedThumb = contains(thumbRefs.current[finger.thumbIndex], activeElement(ownerDocument(control)));
+          if (pressedOnFocusedThumb) {
+            event.preventDefault();
+          } else {
+            focusFrame.request(() => {
+              focusThumb(finger.thumbIndex);
+            });
+          }
+          setDragging(true);
+          const pressedOnAnyThumb = pressedThumbCenterOffsetRef.current != null;
+          if (!pressedOnAnyThumb) {
+            setValue(finger.value, createChangeEventDetails(trackPress, event.nativeEvent, void 0, {
+              activeThumbIndex: finger.thumbIndex
+            }));
+            latestValuesRef.current = Array.isArray(finger.value) ? finger.value : [finger.value];
+            if (finger.didSwap) {
+              focusThumb(finger.thumbIndex);
+            }
+          }
+        }
+        if (event.nativeEvent.pointerId) {
+          control.setPointerCapture(event.nativeEvent.pointerId);
+        }
+        moveCountRef.current = 0;
+        const doc = ownerDocument(controlRef.current);
+        doc.addEventListener("pointermove", handleTouchMove, {
+          passive: true
+        });
+        doc.addEventListener("pointerup", handleTouchEnd, {
+          once: true
+        });
+      },
+      tabIndex: -1
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") SliderControl.displayName = "SliderControl";
+export {
+  SliderControl
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/slider/indicator/SliderIndicator.js

@@ -0,0 +1,82 @@
+import * as React from "react";
+import { useOnMount } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useOnMount.js";
+import { valueToPercent } from "../../utils/valueToPercent.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useSliderRootContext } from "../root/SliderRootContext.js";
+import { sliderStateAttributesMapping } from "../root/stateAttributesMapping.js";
+function getInsetStyles(vertical, range, start, end, renderBeforeHydration, mounted) {
+  const visibility = start === void 0 || range && end === void 0 ? "hidden" : void 0;
+  const startEdge = vertical ? "bottom" : "insetInlineStart";
+  const mainSide = vertical ? "height" : "width";
+  const crossSide = vertical ? "width" : "height";
+  const styles = {
+    visibility: renderBeforeHydration && !mounted ? "hidden" : visibility,
+    position: vertical ? "absolute" : "relative",
+    [crossSide]: "inherit"
+  };
+  styles["--start-position"] = `${start ?? 0}%`;
+  if (!range) {
+    styles[startEdge] = 0;
+    styles[mainSide] = "var(--start-position)";
+    return styles;
+  }
+  styles["--relative-size"] = `${(end ?? 0) - (start ?? 0)}%`;
+  styles[startEdge] = "var(--start-position)";
+  styles[mainSide] = "var(--relative-size)";
+  return styles;
+}
+function getCenteredStyles(vertical, range, start, end) {
+  const startEdge = vertical ? "bottom" : "insetInlineStart";
+  const mainSide = vertical ? "height" : "width";
+  const crossSide = vertical ? "width" : "height";
+  const styles = {
+    position: vertical ? "absolute" : "relative",
+    [crossSide]: "inherit"
+  };
+  if (!range) {
+    styles[startEdge] = 0;
+    styles[mainSide] = `${start}%`;
+    return styles;
+  }
+  const size = end - start;
+  styles[startEdge] = `${start}%`;
+  styles[mainSide] = `${size}%`;
+  return styles;
+}
+const SliderIndicator = /* @__PURE__ */ React.forwardRef(function SliderIndicator2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    ...elementProps
+  } = componentProps;
+  const {
+    indicatorPosition,
+    inset,
+    max,
+    min,
+    orientation,
+    renderBeforeHydration,
+    state,
+    values
+  } = useSliderRootContext();
+  const [isMounted, setIsMounted] = React.useState(false);
+  useOnMount(() => setIsMounted(true));
+  const vertical = orientation === "vertical";
+  const range = values.length > 1;
+  const style = inset ? getInsetStyles(vertical, range, indicatorPosition[0], indicatorPosition[1], renderBeforeHydration, isMounted) : getCenteredStyles(vertical, range, valueToPercent(values[0], min, max), valueToPercent(values[values.length - 1], min, max));
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      ["data-base-ui-slider-indicator"]: renderBeforeHydration ? "" : void 0,
+      style,
+      suppressHydrationWarning: renderBeforeHydration || void 0
+    }, elementProps],
+    stateAttributesMapping: sliderStateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") SliderIndicator.displayName = "SliderIndicator";
+export {
+  SliderIndicator
+};