@octanejs/radix 0.1.32 → 0.1.34

package/dist/cjs/Separator.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Separator_exports = {};
+__export(Separator_exports, {
+  Root: () => Separator,
+  Separator: () => Separator
+});
+module.exports = __toCommonJS(Separator_exports);
+var import_octane = require("octane");
+var import_Primitive = require("./Primitive.cjs");
+const DEFAULT_ORIENTATION = "horizontal";
+const ORIENTATIONS = ["horizontal", "vertical"];
+function isValidOrientation(orientation) {
+  return ORIENTATIONS.includes(orientation);
+}
+function Separator(props) {
+  const {
+    decorative,
+    orientation: orientationProp = DEFAULT_ORIENTATION,
+    ...domProps
+  } = props ?? {};
+  const orientation = isValidOrientation(orientationProp) ? orientationProp : DEFAULT_ORIENTATION;
+  const ariaOrientation = orientation === "vertical" ? orientation : void 0;
+  const semanticProps = decorative ? { role: "none" } : { "aria-orientation": ariaOrientation, role: "separator" };
+  return (0, import_octane.createElement)(import_Primitive.Primitive.div, {
+    "data-orientation": orientation,
+    ...semanticProps,
+    ...domProps
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Root,
+  Separator
+});

package/dist/cjs/Slider.cjs

@@ -0,0 +1,634 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Slider_exports = {};
+__export(Slider_exports, {
+  BubbleInput: () => BubbleInput,
+  Range: () => Range,
+  Root: () => Root,
+  Slider: () => Root,
+  SliderBubbleInput: () => BubbleInput,
+  SliderRange: () => Range,
+  SliderThumb: () => Thumb,
+  SliderThumbProvider: () => ThumbProvider,
+  SliderThumbTrigger: () => ThumbTrigger,
+  SliderTrack: () => Track,
+  Thumb: () => Thumb,
+  Track: () => Track,
+  createSliderScope: () => createSliderScope
+});
+module.exports = __toCommonJS(Slider_exports);
+var import_octane = require("octane");
+var import_collection = require("./collection.cjs");
+var import_compose_event_handlers = require("./compose-event-handlers.cjs");
+var import_compose_refs = require("./compose-refs.cjs");
+var import_context = require("./context.cjs");
+var import_direction = require("./direction.cjs");
+var import_internal = require("./internal.cjs");
+var import_Primitive = require("./Primitive.cjs");
+var import_use_previous = require("./use-previous.cjs");
+var import_use_size = require("./use-size.cjs");
+var import_useControllableState = require("./useControllableState.cjs");
+const PAGE_KEYS = ["PageUp", "PageDown"];
+const ARROW_KEYS = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
+const BACK_KEYS = {
+  "from-left": ["Home", "PageDown", "ArrowDown", "ArrowLeft"],
+  "from-right": ["Home", "PageDown", "ArrowDown", "ArrowRight"],
+  "from-bottom": ["Home", "PageDown", "ArrowDown", "ArrowLeft"],
+  "from-top": ["Home", "PageDown", "ArrowUp", "ArrowLeft"]
+};
+const SLIDER_NAME = "Slider";
+const [Collection, useCollection, createCollectionScope] = (0, import_collection.createCollection)(SLIDER_NAME);
+const [createSliderContext, createSliderScope] = (0, import_context.createContextScope)(SLIDER_NAME, [
+  createCollectionScope
+]);
+const [SliderProvider, useSliderContext] = createSliderContext(SLIDER_NAME);
+function Root(props) {
+  const slot = (0, import_internal.S)("Slider.Root");
+  const {
+    __scopeSlider,
+    name,
+    min = 0,
+    max = 100,
+    step = 1,
+    orientation = "horizontal",
+    disabled = false,
+    minStepsBetweenThumbs = 0,
+    defaultValue = [min],
+    value,
+    onValueChange = () => {
+    },
+    onValueCommit = () => {
+    },
+    inverted = false,
+    form,
+    ref: forwardedRef,
+    ...sliderProps
+  } = props ?? {};
+  const thumbRefs = (0, import_octane.useRef)(/* @__PURE__ */ new Set(), (0, import_internal.subSlot)(slot, "thumbs"));
+  const valueIndexToChangeRef = (0, import_octane.useRef)(0, (0, import_internal.subSlot)(slot, "index"));
+  const isKeyboardInteractionRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "keyboard"));
+  const isHorizontal = orientation === "horizontal";
+  const SliderOrientation = isHorizontal ? SliderHorizontal : SliderVertical;
+  const [valuesState, setValues] = (0, import_useControllableState.useControllableState)(
+    {
+      prop: value,
+      defaultProp: defaultValue,
+      onChange: (value2) => {
+        const thumbs = [...thumbRefs.current];
+        thumbs[valueIndexToChangeRef.current]?.focus({
+          preventScroll: true,
+          focusVisible: isKeyboardInteractionRef.current
+        });
+        isKeyboardInteractionRef.current = false;
+        onValueChange(value2);
+      }
+    },
+    (0, import_internal.subSlot)(slot, "values")
+  );
+  const values = valuesState ?? [];
+  const valuesBeforeSlideStartRef = (0, import_octane.useRef)(values, (0, import_internal.subSlot)(slot, "before"));
+  function handleSlideStart(value2) {
+    const closestIndex = getClosestValueIndex(values, value2);
+    updateValues(value2, closestIndex);
+  }
+  function handleSlideMove(value2) {
+    updateValues(value2, valueIndexToChangeRef.current);
+  }
+  function handleSlideEnd() {
+    const prevValue = valuesBeforeSlideStartRef.current[valueIndexToChangeRef.current];
+    const nextValue = values[valueIndexToChangeRef.current];
+    const hasChanged = nextValue !== prevValue;
+    if (hasChanged) onValueCommit(values);
+  }
+  function updateValues(value2, atIndex, { commit } = { commit: false }) {
+    const decimalCount = getDecimalCount(step);
+    const snapToStep = roundValue(Math.round((value2 - min) / step) * step + min, decimalCount);
+    const nextValue = clamp(snapToStep, [min, max]);
+    setValues((prevValues = []) => {
+      const nextValues = getNextSortedValues(prevValues, nextValue, atIndex);
+      if (hasMinStepsBetweenValues(nextValues, minStepsBetweenThumbs * step)) {
+        valueIndexToChangeRef.current = nextValues.indexOf(nextValue);
+        const hasChanged = String(nextValues) !== String(prevValues);
+        if (hasChanged && commit) onValueCommit(nextValues);
+        return hasChanged ? nextValues : prevValues;
+      } else {
+        return prevValues;
+      }
+    });
+  }
+  return (0, import_octane.createElement)(SliderProvider, {
+    scope: __scopeSlider,
+    name,
+    disabled,
+    min,
+    max,
+    valueIndexToChangeRef,
+    thumbs: thumbRefs.current,
+    values,
+    orientation,
+    form,
+    children: (0, import_octane.createElement)(Collection.Provider, {
+      scope: __scopeSlider,
+      children: (0, import_octane.createElement)(Collection.Slot, {
+        scope: __scopeSlider,
+        children: (0, import_octane.createElement)(SliderOrientation, {
+          "aria-disabled": disabled,
+          "data-disabled": disabled ? "" : void 0,
+          ...sliderProps,
+          __scopeSlider,
+          ref: forwardedRef,
+          onPointerDown: (0, import_compose_event_handlers.composeEventHandlers)(sliderProps.onPointerDown, () => {
+            if (!disabled) {
+              valuesBeforeSlideStartRef.current = values;
+              isKeyboardInteractionRef.current = false;
+            }
+          }),
+          min,
+          max,
+          inverted,
+          onSlideStart: disabled ? void 0 : handleSlideStart,
+          onSlideMove: disabled ? void 0 : handleSlideMove,
+          onSlideEnd: disabled ? void 0 : handleSlideEnd,
+          onHomeKeyDown: () => {
+            if (!disabled) {
+              isKeyboardInteractionRef.current = true;
+              updateValues(min, 0, { commit: true });
+            }
+          },
+          onEndKeyDown: () => {
+            if (!disabled) {
+              isKeyboardInteractionRef.current = true;
+              updateValues(max, values.length - 1, { commit: true });
+            }
+          },
+          onStepKeyDown: ({
+            event,
+            direction: stepDirection
+          }) => {
+            if (!disabled) {
+              isKeyboardInteractionRef.current = true;
+              const isPageKey = PAGE_KEYS.includes(event.key);
+              const isSkipKey = isPageKey || event.shiftKey && ARROW_KEYS.includes(event.key);
+              const multiplier = isSkipKey ? 10 : 1;
+              const atIndex = valueIndexToChangeRef.current;
+              const value2 = values[atIndex];
+              const stepInDirection = step * multiplier * stepDirection;
+              updateValues(value2 + stepInDirection, atIndex, { commit: true });
+            }
+          }
+        })
+      })
+    })
+  });
+}
+const [SliderOrientationProvider, useSliderOrientationContext] = createSliderContext(SLIDER_NAME, {
+  startEdge: "left",
+  endEdge: "right",
+  size: "width",
+  direction: 1
+});
+function SliderHorizontal(props) {
+  const slot = (0, import_internal.S)("Slider.Horizontal");
+  const {
+    min,
+    max,
+    dir,
+    inverted,
+    onSlideStart,
+    onSlideMove,
+    onSlideEnd,
+    onStepKeyDown,
+    ref: forwardedRef,
+    ...sliderProps
+  } = props;
+  const [slider, setSlider] = (0, import_octane.useState)(null, (0, import_internal.subSlot)(slot, "slider"));
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, setSlider, (0, import_internal.subSlot)(slot, "refs"));
+  const rectRef = (0, import_octane.useRef)(void 0, (0, import_internal.subSlot)(slot, "rect"));
+  const direction = (0, import_direction.useDirection)(dir);
+  const isDirectionLTR = direction === "ltr";
+  const isSlidingFromLeft = isDirectionLTR && !inverted || !isDirectionLTR && inverted;
+  function getValueFromPointer(pointerPosition) {
+    const rect = rectRef.current || slider.getBoundingClientRect();
+    const input = [0, rect.width];
+    const output = isSlidingFromLeft ? [min, max] : [max, min];
+    const value = linearScale(input, output);
+    rectRef.current = rect;
+    return value(pointerPosition - rect.left);
+  }
+  return (0, import_octane.createElement)(SliderOrientationProvider, {
+    scope: props.__scopeSlider,
+    startEdge: isSlidingFromLeft ? "left" : "right",
+    endEdge: isSlidingFromLeft ? "right" : "left",
+    direction: isSlidingFromLeft ? 1 : -1,
+    size: "width",
+    children: (0, import_octane.createElement)(SliderImpl, {
+      dir: direction,
+      "data-orientation": "horizontal",
+      ...sliderProps,
+      ref: composedRefs,
+      style: {
+        ...sliderProps.style,
+        "--radix-slider-thumb-transform": "translateX(-50%)"
+      },
+      onSlideStart: (event) => {
+        const value = getValueFromPointer(event.clientX);
+        onSlideStart?.(value);
+      },
+      onSlideMove: (event) => {
+        const value = getValueFromPointer(event.clientX);
+        onSlideMove?.(value);
+      },
+      onSlideEnd: () => {
+        rectRef.current = void 0;
+        onSlideEnd?.();
+      },
+      onStepKeyDown: (event) => {
+        const slideDirection = isSlidingFromLeft ? "from-left" : "from-right";
+        const isBackKey = BACK_KEYS[slideDirection].includes(event.key);
+        onStepKeyDown?.({ event, direction: isBackKey ? -1 : 1 });
+      }
+    })
+  });
+}
+function SliderVertical(props) {
+  const slot = (0, import_internal.S)("Slider.Vertical");
+  const {
+    min,
+    max,
+    inverted,
+    onSlideStart,
+    onSlideMove,
+    onSlideEnd,
+    onStepKeyDown,
+    ref: forwardedRef,
+    ...sliderProps
+  } = props;
+  const sliderRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ref"));
+  const ref = (0, import_compose_refs.useComposedRefs)(forwardedRef, sliderRef, (0, import_internal.subSlot)(slot, "refs"));
+  const rectRef = (0, import_octane.useRef)(void 0, (0, import_internal.subSlot)(slot, "rect"));
+  const isSlidingFromBottom = !inverted;
+  function getValueFromPointer(pointerPosition) {
+    const rect = rectRef.current || sliderRef.current.getBoundingClientRect();
+    const input = [0, rect.height];
+    const output = isSlidingFromBottom ? [max, min] : [min, max];
+    const value = linearScale(input, output);
+    rectRef.current = rect;
+    return value(pointerPosition - rect.top);
+  }
+  return (0, import_octane.createElement)(SliderOrientationProvider, {
+    scope: props.__scopeSlider,
+    startEdge: isSlidingFromBottom ? "bottom" : "top",
+    endEdge: isSlidingFromBottom ? "top" : "bottom",
+    size: "height",
+    direction: isSlidingFromBottom ? 1 : -1,
+    children: (0, import_octane.createElement)(SliderImpl, {
+      "data-orientation": "vertical",
+      ...sliderProps,
+      ref,
+      style: {
+        ...sliderProps.style,
+        "--radix-slider-thumb-transform": "translateY(50%)"
+      },
+      onSlideStart: (event) => {
+        const value = getValueFromPointer(event.clientY);
+        onSlideStart?.(value);
+      },
+      onSlideMove: (event) => {
+        const value = getValueFromPointer(event.clientY);
+        onSlideMove?.(value);
+      },
+      onSlideEnd: () => {
+        rectRef.current = void 0;
+        onSlideEnd?.();
+      },
+      onStepKeyDown: (event) => {
+        const slideDirection = isSlidingFromBottom ? "from-bottom" : "from-top";
+        const isBackKey = BACK_KEYS[slideDirection].includes(event.key);
+        onStepKeyDown?.({ event, direction: isBackKey ? -1 : 1 });
+      }
+    })
+  });
+}
+function SliderImpl(props) {
+  const {
+    __scopeSlider,
+    onSlideStart,
+    onSlideMove,
+    onSlideEnd,
+    onHomeKeyDown,
+    onEndKeyDown,
+    onStepKeyDown,
+    ref: forwardedRef,
+    ...sliderProps
+  } = props;
+  const context = useSliderContext(SLIDER_NAME, __scopeSlider);
+  return (0, import_octane.createElement)(import_Primitive.Primitive.span, {
+    ...sliderProps,
+    ref: forwardedRef,
+    onKeyDown: (0, import_compose_event_handlers.composeEventHandlers)(props.onKeyDown, (event) => {
+      if (event.key === "Home") {
+        onHomeKeyDown(event);
+        event.preventDefault();
+      } else if (event.key === "End") {
+        onEndKeyDown(event);
+        event.preventDefault();
+      } else if (PAGE_KEYS.concat(ARROW_KEYS).includes(event.key)) {
+        onStepKeyDown(event);
+        event.preventDefault();
+      }
+    }),
+    onPointerDown: (0, import_compose_event_handlers.composeEventHandlers)(props.onPointerDown, (event) => {
+      const target = event.target;
+      target.setPointerCapture(event.pointerId);
+      event.preventDefault();
+      if (context.thumbs.has(target)) {
+        target.focus({ preventScroll: true, focusVisible: false });
+      } else {
+        onSlideStart(event);
+      }
+    }),
+    onPointerMove: (0, import_compose_event_handlers.composeEventHandlers)(props.onPointerMove, (event) => {
+      const target = event.target;
+      if (target.hasPointerCapture(event.pointerId)) onSlideMove(event);
+    }),
+    onPointerUp: (0, import_compose_event_handlers.composeEventHandlers)(props.onPointerUp, (event) => {
+      const target = event.target;
+      if (target.hasPointerCapture(event.pointerId)) {
+        target.releasePointerCapture(event.pointerId);
+        onSlideEnd(event);
+      }
+    })
+  });
+}
+function Track(props) {
+  const { __scopeSlider, ...trackProps } = props ?? {};
+  const context = useSliderContext("SliderTrack", __scopeSlider);
+  return (0, import_octane.createElement)(import_Primitive.Primitive.span, {
+    "data-disabled": context.disabled ? "" : void 0,
+    "data-orientation": context.orientation,
+    ...trackProps
+  });
+}
+function Range(props) {
+  const slot = (0, import_internal.S)("Slider.Range");
+  const { __scopeSlider, ref: forwardedRef, ...rangeProps } = props ?? {};
+  const context = useSliderContext("SliderRange", __scopeSlider);
+  const orientation = useSliderOrientationContext("SliderRange", __scopeSlider);
+  const ref = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ref"));
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, ref, (0, import_internal.subSlot)(slot, "refs"));
+  const valuesCount = context.values.length;
+  const percentages = context.values.map(
+    (value) => convertValueToPercentage(value, context.min, context.max)
+  );
+  const offsetStart = valuesCount > 1 ? Math.min(...percentages) : 0;
+  const offsetEnd = 100 - Math.max(...percentages);
+  return (0, import_octane.createElement)(import_Primitive.Primitive.span, {
+    "data-orientation": context.orientation,
+    "data-disabled": context.disabled ? "" : void 0,
+    ...rangeProps,
+    ref: composedRefs,
+    style: {
+      ...props?.style,
+      [orientation.startEdge]: offsetStart + "%",
+      [orientation.endEdge]: offsetEnd + "%"
+    }
+  });
+}
+const THUMB_NAME = "SliderThumb";
+const [SliderThumbContextProvider, useSliderThumbContext] = createSliderContext(THUMB_NAME);
+function ThumbProvider(props) {
+  const slot = (0, import_internal.S)("Slider.ThumbProvider");
+  const { __scopeSlider, name, children, internal_do_not_use_render } = props;
+  const context = useSliderContext("SliderThumbProvider", __scopeSlider);
+  const getItems = useCollection(__scopeSlider, (0, import_internal.subSlot)(slot, "items"));
+  const [thumb, setThumb] = (0, import_octane.useState)(null, (0, import_internal.subSlot)(slot, "thumb"));
+  const index = (0, import_octane.useMemo)(
+    () => thumb ? getItems().findIndex((item) => item.ref.current === thumb) : -1,
+    [getItems, thumb],
+    (0, import_internal.subSlot)(slot, "index")
+  );
+  const size = (0, import_use_size.useSize)(thumb, (0, import_internal.subSlot)(slot, "size"));
+  const isFormControl = thumb ? !!context.form || !!thumb.closest("form") : true;
+  const value = context.values[index];
+  const resolvedName = name ?? (context.name ? context.name + (context.values.length > 1 ? "[]" : "") : void 0);
+  const percent = value === void 0 ? 0 : convertValueToPercentage(value, context.min, context.max);
+  (0, import_octane.useEffect)(
+    () => {
+      if (thumb) {
+        context.thumbs.add(thumb);
+        return () => {
+          context.thumbs.delete(thumb);
+        };
+      }
+    },
+    [thumb, context.thumbs],
+    (0, import_internal.subSlot)(slot, "e:thumb")
+  );
+  const thumbContext = {
+    value,
+    name: resolvedName,
+    form: context.form,
+    isFormControl,
+    index,
+    thumb,
+    onThumbChange: setThumb,
+    percent,
+    size
+  };
+  return (0, import_octane.createElement)(SliderThumbContextProvider, {
+    scope: __scopeSlider,
+    ...thumbContext,
+    children: isFunction(internal_do_not_use_render) ? internal_do_not_use_render(thumbContext) : children
+  });
+}
+function ThumbTrigger(props) {
+  const slot = (0, import_internal.S)("Slider.ThumbTrigger");
+  const { __scopeSlider, ref: forwardedRef, ...thumbProps } = props;
+  const context = useSliderContext("SliderThumbTrigger", __scopeSlider);
+  const orientation = useSliderOrientationContext("SliderThumbTrigger", __scopeSlider);
+  const { index, value, percent, size, onThumbChange } = useSliderThumbContext(
+    "SliderThumbTrigger",
+    __scopeSlider
+  );
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, onThumbChange, (0, import_internal.subSlot)(slot, "refs"));
+  const label = getLabel(index, context.values.length);
+  const orientationSize = size?.[orientation.size];
+  const thumbInBoundsOffset = orientationSize ? getThumbInBoundsOffset(orientationSize, percent, orientation.direction) : 0;
+  return (0, import_octane.createElement)("span", {
+    style: {
+      transform: "var(--radix-slider-thumb-transform)",
+      position: "absolute",
+      [orientation.startEdge]: `calc(${percent}% + ${thumbInBoundsOffset}px)`
+    },
+    children: (0, import_octane.createElement)(Collection.ItemSlot, {
+      scope: __scopeSlider,
+      children: (0, import_octane.createElement)(import_Primitive.Primitive.span, {
+        role: "slider",
+        "aria-label": props["aria-label"] || label,
+        "aria-valuemin": context.min,
+        "aria-valuenow": value,
+        "aria-valuemax": context.max,
+        "aria-orientation": context.orientation,
+        "data-orientation": context.orientation,
+        "data-disabled": context.disabled ? "" : void 0,
+        tabIndex: context.disabled ? void 0 : 0,
+        ...thumbProps,
+        ref: composedRefs,
+        // There will be no value on initial render while we work out the index so
+        // we hide thumbs without a value; otherwise SSR would render them in the
+        // wrong position before they snap into place during hydration.
+        style: value === void 0 ? { display: "none" } : props.style,
+        onFocus: (0, import_compose_event_handlers.composeEventHandlers)(props.onFocus, () => {
+          context.valueIndexToChangeRef.current = index;
+        })
+      })
+    })
+  });
+}
+function Thumb(props) {
+  const { __scopeSlider, name, ref: forwardedRef, ...thumbProps } = props ?? {};
+  return (0, import_octane.createElement)(ThumbProvider, {
+    __scopeSlider,
+    name,
+    internal_do_not_use_render: ({ index, isFormControl }) => [
+      (0, import_octane.createElement)(ThumbTrigger, {
+        key: "trigger",
+        ...thumbProps,
+        ref: forwardedRef,
+        __scopeSlider
+      }),
+      isFormControl ? (0, import_octane.createElement)(BubbleInput, { key: "bubble-" + index, __scopeSlider }) : null
+    ]
+  });
+}
+function BubbleInput(props) {
+  const slot = (0, import_internal.S)("Slider.BubbleInput");
+  const { __scopeSlider, ref: forwardedRef, ...inputProps } = props ?? {};
+  const { value, name, form } = useSliderThumbContext("SliderBubbleInput", __scopeSlider);
+  const ref = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ref"));
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(ref, forwardedRef, (0, import_internal.subSlot)(slot, "refs"));
+  const prevValue = (0, import_use_previous.usePrevious)(value, (0, import_internal.subSlot)(slot, "prev"));
+  (0, import_octane.useEffect)(
+    () => {
+      const input = ref.current;
+      if (!input) return;
+      if (prevValue !== value) {
+        input.dispatchEvent(new Event("input", { bubbles: true }));
+      }
+    },
+    [prevValue, value],
+    (0, import_internal.subSlot)(slot, "e:bubble")
+  );
+  return (0, import_octane.createElement)(import_Primitive.Primitive.input, {
+    style: { display: "none" },
+    name,
+    form,
+    ...inputProps,
+    ref: composedRefs,
+    value
+  });
+}
+function getNextSortedValues(prevValues = [], nextValue, atIndex) {
+  const nextValues = [...prevValues];
+  nextValues[atIndex] = nextValue;
+  return nextValues.sort((a, b) => a - b);
+}
+function convertValueToPercentage(value, min, max) {
+  const maxSteps = max - min;
+  const percentPerStep = 100 / maxSteps;
+  const percentage = percentPerStep * (value - min);
+  return clamp(percentage, [0, 100]);
+}
+function getLabel(index, totalValues) {
+  if (totalValues > 2) {
+    return `Value ${index + 1} of ${totalValues}`;
+  } else if (totalValues === 2) {
+    return ["Minimum", "Maximum"][index];
+  } else {
+    return void 0;
+  }
+}
+function getClosestValueIndex(values, nextValue) {
+  if (values.length === 1) return 0;
+  const distances = values.map((value) => Math.abs(value - nextValue));
+  const closestDistance = Math.min(...distances);
+  return distances.indexOf(closestDistance);
+}
+function getThumbInBoundsOffset(width, left, direction) {
+  const halfWidth = width / 2;
+  const halfPercent = 50;
+  const offset = linearScale([0, halfPercent], [0, halfWidth]);
+  return (halfWidth - offset(left) * direction) * direction;
+}
+function getStepsBetweenValues(values) {
+  return values.slice(0, -1).map((value, index) => values[index + 1] - value);
+}
+function hasMinStepsBetweenValues(values, minStepsBetweenValues) {
+  if (minStepsBetweenValues > 0) {
+    const stepsBetweenValues = getStepsBetweenValues(values);
+    const actualMinStepsBetweenValues = Math.min(...stepsBetweenValues);
+    return actualMinStepsBetweenValues >= minStepsBetweenValues;
+  }
+  return true;
+}
+function linearScale(input, output) {
+  return (value) => {
+    if (input[0] === input[1] || output[0] === output[1]) return output[0];
+    const ratio = (output[1] - output[0]) / (input[1] - input[0]);
+    return output[0] + ratio * (value - input[0]);
+  };
+}
+function getDecimalCount(value) {
+  if (!Number.isFinite(value)) return 0;
+  const str = value.toString();
+  if (str.includes("e")) {
+    const [coefficient, exponent] = str.split("e");
+    const decimalPart2 = coefficient.split(".")[1] || "";
+    const exponentNum = Number(exponent);
+    return Math.max(0, decimalPart2.length - exponentNum);
+  }
+  const decimalPart = str.split(".")[1];
+  return decimalPart ? decimalPart.length : 0;
+}
+function roundValue(value, decimalCount) {
+  const rounder = Math.pow(10, decimalCount);
+  return Math.round(value * rounder) / rounder;
+}
+function clamp(value, [min, max]) {
+  return Math.min(max, Math.max(min, value));
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BubbleInput,
+  Range,
+  Root,
+  Slider,
+  SliderBubbleInput,
+  SliderRange,
+  SliderThumb,
+  SliderThumbProvider,
+  SliderThumbTrigger,
+  SliderTrack,
+  Thumb,
+  Track,
+  createSliderScope
+});