@tamagui/slider 1.114.4 → 1.115.1

package/dist/cjs/Slider.cjs

@@ -0,0 +1,509 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var Slider_exports = {};
+__export(Slider_exports, {
+  Range: () => Range,
+  Slider: () => Slider,
+  SliderThumb: () => SliderThumb,
+  SliderThumbFrame: () => SliderThumbFrame,
+  SliderTrack: () => SliderTrack,
+  SliderTrackActive: () => SliderTrackActive,
+  SliderTrackActiveFrame: () => SliderTrackActiveFrame,
+  SliderTrackFrame: () => SliderTrackFrame,
+  Thumb: () => Thumb,
+  Track: () => Track
+});
+module.exports = __toCommonJS(Slider_exports);
+var import_compose_refs = require("@tamagui/compose-refs"),
+  import_constants = require("@tamagui/constants"),
+  import_core = require("@tamagui/core"),
+  import_get_token = require("@tamagui/get-token"),
+  import_helpers = require("@tamagui/helpers"),
+  import_helpers2 = require("@tamagui/helpers"),
+  import_stacks = require("@tamagui/stacks"),
+  import_use_controllable_state = require("@tamagui/use-controllable-state"),
+  import_use_direction = require("@tamagui/use-direction"),
+  React = __toESM(require("react")),
+  import_constants2 = require("./constants.cjs"),
+  import_helpers3 = require("./helpers.cjs"),
+  import_SliderImpl = require("./SliderImpl.cjs"),
+  import_jsx_runtime = require("react/jsx-runtime");
+const activeSliderMeasureListeners = /* @__PURE__ */new Set();
+import_constants.isWeb && import_constants.isClient && (process.env.TAMAGUI_DISABLE_SLIDER_INTERVAL || setInterval?.(() => {
+  activeSliderMeasureListeners.forEach(cb => cb());
+},
+// really doesn't need to be super often
+1e3));
+const SliderHorizontal = React.forwardRef((props, forwardedRef) => {
+  const {
+      min,
+      max,
+      dir,
+      onSlideStart,
+      onSlideMove,
+      onStepKeyDown,
+      onSlideEnd,
+      ...sliderProps
+    } = props,
+    direction = (0, import_use_direction.useDirection)(dir),
+    isDirectionLTR = direction === "ltr",
+    sliderRef = React.useRef(null),
+    [state, setState_] = React.useState(() => ({
+      size: 0,
+      offset: 0
+    })),
+    setState = (0, import_core.createShallowSetState)(setState_);
+  function getValueFromPointer(pointerPosition) {
+    const input = [0, state.size];
+    return (0, import_helpers3.linearScale)(input, isDirectionLTR ? [min, max] : [max, min])(pointerPosition);
+  }
+  const measure = () => {
+    sliderRef.current?.measure((_x, _y, width, _height, pageX, _pageY) => {
+      setState({
+        size: width,
+        offset: pageX
+      });
+    });
+  };
+  return import_constants.isClient && (useOnDebouncedWindowResize(measure), React.useEffect(() => {
+    const node = sliderRef.current;
+    if (!node) return;
+    let measureTm;
+    const debouncedMeasure = () => {
+        clearTimeout(measureTm), measureTm = setTimeout(() => {
+          measure();
+        }, 200);
+      },
+      io = new IntersectionObserver(entries => {
+        debouncedMeasure(), entries?.[0].isIntersecting ? activeSliderMeasureListeners.add(debouncedMeasure) : activeSliderMeasureListeners.delete(debouncedMeasure);
+      }, {
+        root: null,
+        // Use the viewport as the container.
+        rootMargin: "0px",
+        threshold: [0, 0.5, 1]
+      });
+    return io.observe(node), () => {
+      activeSliderMeasureListeners.delete(debouncedMeasure), io.disconnect();
+    };
+  }, [])), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_constants2.SliderOrientationProvider, {
+    scope: props.__scopeSlider,
+    startEdge: isDirectionLTR ? "left" : "right",
+    endEdge: isDirectionLTR ? "right" : "left",
+    direction: isDirectionLTR ? 1 : -1,
+    sizeProp: "width",
+    size: state.size,
+    children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_SliderImpl.SliderImpl, {
+      ref: (0, import_compose_refs.composeRefs)(forwardedRef, sliderRef),
+      dir: direction,
+      ...sliderProps,
+      orientation: "horizontal",
+      onLayout: measure,
+      onSlideStart: (event, target) => {
+        const value = getValueFromPointer(event.nativeEvent.locationX);
+        value && onSlideStart?.(value, target, event);
+      },
+      onSlideMove: event => {
+        const value = getValueFromPointer(event.nativeEvent.pageX - state.offset);
+        value && onSlideMove?.(value, event);
+      },
+      onSlideEnd: event => {
+        const value = getValueFromPointer(event.nativeEvent.pageX - state.offset);
+        value && onSlideEnd?.(event, value);
+      },
+      onStepKeyDown: event => {
+        const isBackKey = import_constants2.BACK_KEYS[direction].includes(event.key);
+        onStepKeyDown?.({
+          event,
+          direction: isBackKey ? -1 : 1
+        });
+      }
+    })
+  });
+});
+function useOnDebouncedWindowResize(callback, amt = 200) {
+  React.useEffect(() => {
+    let last;
+    const onResize = () => {
+      clearTimeout(last), last = setTimeout(callback, amt);
+    };
+    return window.addEventListener("resize", onResize), () => {
+      clearTimeout(last), window.removeEventListener("resize", onResize);
+    };
+  }, []);
+}
+const SliderVertical = React.forwardRef((props, forwardedRef) => {
+    const {
+        min,
+        max,
+        onSlideStart,
+        onSlideMove,
+        onStepKeyDown,
+        onSlideEnd,
+        ...sliderProps
+      } = props,
+      [state, setState_] = React.useState(() => ({
+        size: 0,
+        offset: 0
+      })),
+      setState = (0, import_core.createShallowSetState)(setState_),
+      sliderRef = React.useRef(null);
+    function getValueFromPointer(pointerPosition) {
+      const input = [0, state.size];
+      return (0, import_helpers3.linearScale)(input, [max, min])(pointerPosition);
+    }
+    const measure = () => {
+      sliderRef.current?.measure((_x, _y, _width, height, _pageX, pageY) => {
+        setState({
+          size: height,
+          offset: pageY
+        });
+      });
+    };
+    return import_constants.isClient && useOnDebouncedWindowResize(measure), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_constants2.SliderOrientationProvider, {
+      scope: props.__scopeSlider,
+      startEdge: "bottom",
+      endEdge: "top",
+      sizeProp: "height",
+      size: state.size,
+      direction: 1,
+      children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_SliderImpl.SliderImpl, {
+        ref: (0, import_compose_refs.composeRefs)(forwardedRef, sliderRef),
+        ...sliderProps,
+        orientation: "vertical",
+        onLayout: measure,
+        onSlideStart: (event, target) => {
+          const value = getValueFromPointer(event.nativeEvent.locationY);
+          value && onSlideStart?.(value, target, event);
+        },
+        onSlideMove: event => {
+          const value = getValueFromPointer(event.nativeEvent.pageY - state.offset);
+          value && onSlideMove?.(value, event);
+        },
+        onSlideEnd: event => {
+          const value = getValueFromPointer(event.nativeEvent.pageY - state.offset);
+          onSlideEnd?.(event, value);
+        },
+        onStepKeyDown: event => {
+          const isBackKey = import_constants2.BACK_KEYS.ltr.includes(event.key);
+          onStepKeyDown?.({
+            event,
+            direction: isBackKey ? -1 : 1
+          });
+        }
+      })
+    });
+  }),
+  TRACK_NAME = "SliderTrack",
+  SliderTrackFrame = (0, import_core.styled)(import_SliderImpl.SliderFrame, {
+    name: "SliderTrack",
+    variants: {
+      unstyled: {
+        false: {
+          height: "100%",
+          width: "100%",
+          backgroundColor: "$background",
+          position: "relative",
+          borderRadius: 1e5,
+          overflow: "hidden"
+        }
+      }
+    },
+    defaultVariants: {
+      unstyled: process.env.TAMAGUI_HEADLESS === "1"
+    }
+  }),
+  SliderTrack = React.forwardRef((props, forwardedRef) => {
+    const {
+        __scopeSlider,
+        ...trackProps
+      } = props,
+      context = (0, import_constants2.useSliderContext)(TRACK_NAME, __scopeSlider);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(SliderTrackFrame, {
+      "data-disabled": context.disabled ? "" : void 0,
+      "data-orientation": context.orientation,
+      orientation: context.orientation,
+      size: context.size,
+      ...trackProps,
+      ref: forwardedRef
+    });
+  });
+SliderTrack.displayName = TRACK_NAME;
+const RANGE_NAME = "SliderTrackActive",
+  SliderTrackActiveFrame = (0, import_core.styled)(import_SliderImpl.SliderFrame, {
+    name: "SliderTrackActive",
+    backgroundColor: "$background",
+    position: "absolute"
+  }),
+  SliderTrackActive = React.forwardRef((props, forwardedRef) => {
+    const {
+        __scopeSlider,
+        ...rangeProps
+      } = props,
+      context = (0, import_constants2.useSliderContext)(RANGE_NAME, __scopeSlider),
+      orientation = (0, import_constants2.useSliderOrientationContext)(RANGE_NAME, __scopeSlider),
+      ref = React.useRef(null),
+      composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, ref),
+      valuesCount = context.values.length,
+      percentages = context.values.map(value => (0, import_helpers3.convertValueToPercentage)(value, context.min, context.max)),
+      offsetStart = valuesCount > 1 ? Math.min(...percentages) : 0,
+      offsetEnd = 100 - Math.max(...percentages);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(SliderTrackActiveFrame, {
+      orientation: context.orientation,
+      "data-orientation": context.orientation,
+      "data-disabled": context.disabled ? "" : void 0,
+      size: context.size,
+      animateOnly: ["left", "top", "right", "bottom"],
+      ...rangeProps,
+      ref: composedRefs,
+      [orientation.startEdge]: `${offsetStart}%`,
+      [orientation.endEdge]: `${offsetEnd}%`,
+      ...(orientation.sizeProp === "width" ? {
+        height: "100%"
+      } : {
+        left: 0,
+        right: 0
+      })
+    });
+  });
+SliderTrackActive.displayName = RANGE_NAME;
+const THUMB_NAME = "SliderThumb",
+  getThumbSize = val => {
+    const tokens = (0, import_core.getTokens)(),
+      size = typeof val == "number" ? val : (0, import_get_token.getSize)(tokens.size[val], {
+        shift: -1
+      });
+    return {
+      width: size,
+      height: size,
+      minWidth: size,
+      minHeight: size
+    };
+  },
+  SliderThumbFrame = (0, import_core.styled)(import_stacks.ThemeableStack, {
+    name: "SliderThumb",
+    variants: {
+      size: {
+        "...size": getThumbSize
+      },
+      unstyled: {
+        false: {
+          position: "absolute",
+          bordered: 2,
+          borderWidth: 2,
+          backgrounded: !0,
+          pressTheme: import_constants.isWeb,
+          focusTheme: import_constants.isWeb,
+          hoverTheme: import_constants.isWeb
+        }
+      }
+    },
+    defaultVariants: {
+      unstyled: process.env.TAMAGUI_HEADLESS === "1"
+    }
+  }),
+  SliderThumb = React.memo(SliderThumbFrame.styleable(function (props, forwardedRef) {
+    const {
+        __scopeSlider,
+        index,
+        size: sizeProp,
+        ...thumbProps
+      } = props,
+      context = (0, import_constants2.useSliderContext)(THUMB_NAME, __scopeSlider),
+      orientation = (0, import_constants2.useSliderOrientationContext)(THUMB_NAME, __scopeSlider),
+      [thumb, setThumb] = React.useState(null),
+      composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, setThumb),
+      value = context.values[index],
+      percent = value === void 0 ? 0 : (0, import_helpers3.convertValueToPercentage)(value, context.min, context.max),
+      label = (0, import_helpers3.getLabel)(index, context.values.length),
+      sizeIn = sizeProp ?? context.size ?? "$true",
+      [size, setSize] = React.useState(() => (0, import_core.getVariableValue)(getThumbSize(sizeIn).width)),
+      thumbInBoundsOffset = size ? (0, import_helpers3.getThumbInBoundsOffset)(size, percent, orientation.direction) : 0;
+    React.useEffect(() => {
+      if (thumb) return context.thumbs.set(thumb, index), () => {
+        context.thumbs.delete(thumb);
+      };
+    }, [thumb, context.thumbs, index]);
+    const positionalStyles = context.orientation === "horizontal" ? {
+      x: thumbInBoundsOffset - size / 2,
+      y: -size / 2,
+      top: "50%",
+      ...(size === 0 && {
+        top: "auto",
+        bottom: "auto"
+      })
+    } : {
+      x: -size / 2,
+      y: size / 2,
+      left: "50%",
+      ...(size === 0 && {
+        left: "auto",
+        right: "auto"
+      })
+    };
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(SliderThumbFrame, {
+      ref: composedRefs,
+      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,
+      animateOnly: ["transform", "left", "top", "right", "bottom"],
+      ...positionalStyles,
+      [orientation.startEdge]: `${percent}%`,
+      size: sizeIn,
+      ...thumbProps,
+      onLayout: e => {
+        setSize(e.nativeEvent.layout[orientation.sizeProp]);
+      },
+      onFocus: (0, import_helpers2.composeEventHandlers)(props.onFocus, () => {
+        context.valueIndexToChangeRef.current = index;
+      })
+    });
+  })),
+  SliderComponent = React.forwardRef((props, forwardedRef) => {
+    const {
+        name,
+        min = 0,
+        max = 100,
+        step = 1,
+        orientation = "horizontal",
+        disabled = !1,
+        minStepsBetweenThumbs = 0,
+        defaultValue = [min],
+        value,
+        onValueChange = () => {},
+        size: sizeProp,
+        onSlideEnd,
+        onSlideMove,
+        onSlideStart,
+        ...sliderProps
+      } = props,
+      sliderRef = React.useRef(null),
+      composedRefs = (0, import_compose_refs.useComposedRefs)(sliderRef, forwardedRef),
+      thumbRefs = React.useRef(/* @__PURE__ */new Map()),
+      valueIndexToChangeRef = React.useRef(0),
+      isHorizontal = orientation === "horizontal",
+      [values = [], setValues] = (0, import_use_controllable_state.useControllableState)({
+        prop: value,
+        defaultProp: defaultValue,
+        transition: !0,
+        onChange: value2 => {
+          updateThumbFocus(valueIndexToChangeRef.current), onValueChange(value2);
+        }
+      });
+    import_constants.isWeb && React.useEffect(() => {
+      const node = sliderRef.current;
+      if (!node) return;
+      const preventDefault = e => {
+        e.preventDefault();
+      };
+      return node.addEventListener("touchstart", preventDefault), () => {
+        node.removeEventListener("touchstart", preventDefault);
+      };
+    }, []);
+    function updateThumbFocus(focusIndex) {
+      if (import_constants.isWeb) {
+        for (const [node, index] of thumbRefs.current.entries()) if (index === focusIndex) {
+          node.focus();
+          return;
+        }
+      }
+    }
+    function handleSlideMove(value2, event) {
+      updateValues(value2, valueIndexToChangeRef.current), onSlideMove?.(event, value2);
+    }
+    function updateValues(value2, atIndex) {
+      const decimalCount = (0, import_helpers3.getDecimalCount)(step),
+        snapToStep = (0, import_helpers3.roundValue)(Math.round((value2 - min) / step) * step + min, decimalCount),
+        nextValue = (0, import_helpers2.clamp)(snapToStep, [min, max]);
+      setValues((prevValues = []) => {
+        const nextValues = (0, import_helpers3.getNextSortedValues)(prevValues, nextValue, atIndex);
+        return (0, import_helpers3.hasMinStepsBetweenValues)(nextValues, minStepsBetweenThumbs * step) ? (valueIndexToChangeRef.current = nextValues.indexOf(nextValue), String(nextValues) === String(prevValues) ? prevValues : nextValues) : prevValues;
+      });
+    }
+    const SliderOriented = isHorizontal ? SliderHorizontal : SliderVertical;
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_constants2.SliderProvider, {
+      scope: props.__scopeSlider,
+      disabled,
+      min,
+      max,
+      valueIndexToChangeRef,
+      thumbs: thumbRefs.current,
+      values,
+      orientation,
+      size: sizeProp,
+      children: /* @__PURE__ */(0, import_jsx_runtime.jsx)(SliderOriented, {
+        "aria-disabled": disabled,
+        "data-disabled": disabled ? "" : void 0,
+        ...sliderProps,
+        ref: composedRefs,
+        min,
+        max,
+        onSlideEnd,
+        onSlideStart: disabled ? void 0 : (value2, target, event) => {
+          if (target !== "thumb") {
+            const closestIndex = (0, import_helpers3.getClosestValueIndex)(values, value2);
+            updateValues(value2, closestIndex);
+          }
+          onSlideStart?.(event, value2, target);
+        },
+        onSlideMove: disabled ? void 0 : handleSlideMove,
+        onHomeKeyDown: () => !disabled && updateValues(min, 0),
+        onEndKeyDown: () => !disabled && updateValues(max, values.length - 1),
+        onStepKeyDown: ({
+          event,
+          direction: stepDirection
+        }) => {
+          if (!disabled) {
+            const multiplier = import_constants2.PAGE_KEYS.includes(event.key) || event.shiftKey && import_constants2.ARROW_KEYS.includes(event.key) ? 10 : 1,
+              atIndex = valueIndexToChangeRef.current,
+              value2 = values[atIndex],
+              stepInDirection = step * multiplier * stepDirection;
+            updateValues(value2 + stepInDirection, atIndex);
+          }
+        }
+      })
+    });
+  }),
+  Slider = (0, import_helpers.withStaticProperties)(SliderComponent, {
+    Track: SliderTrack,
+    TrackActive: SliderTrackActive,
+    Thumb: SliderThumb
+  });
+Slider.displayName = import_constants2.SLIDER_NAME;
+const Track = SliderTrack,
+  Range = SliderTrackActive,
+  Thumb = SliderThumb;

package/dist/cjs/SliderImpl.cjs

@@ -0,0 +1,110 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var SliderImpl_exports = {};
+__export(SliderImpl_exports, {
+  SliderFrame: () => SliderFrame,
+  SliderImpl: () => SliderImpl
+});
+module.exports = __toCommonJS(SliderImpl_exports);
+var import_constants = require("@tamagui/constants"),
+  import_core = require("@tamagui/core"),
+  import_get_token = require("@tamagui/get-token"),
+  import_helpers = require("@tamagui/helpers"),
+  import_stacks = require("@tamagui/stacks"),
+  React = __toESM(require("react")),
+  import_constants2 = require("./constants.cjs"),
+  import_jsx_runtime = require("react/jsx-runtime");
+const SliderFrame = (0, import_core.styled)(import_stacks.YStack, {
+    position: "relative",
+    variants: {
+      orientation: {
+        horizontal: {},
+        vertical: {}
+      },
+      size: (val, extras) => {
+        if (!val) return;
+        const orientation = extras.props.orientation,
+          size = Math.round((0, import_core.getVariableValue)((0, import_get_token.getSize)(val)) / 6);
+        return orientation === "horizontal" ? {
+          height: size,
+          borderRadius: size,
+          justifyContent: "center"
+        } : {
+          width: size,
+          borderRadius: size,
+          alignItems: "center"
+        };
+      }
+    }
+  }),
+  SliderImpl = React.forwardRef((props, forwardedRef) => {
+    const {
+        __scopeSlider,
+        onSlideStart,
+        onSlideMove,
+        onSlideEnd,
+        onHomeKeyDown,
+        onEndKeyDown,
+        onStepKeyDown,
+        ...sliderProps
+      } = props,
+      context = (0, import_constants2.useSliderContext)(import_constants2.SLIDER_NAME, __scopeSlider);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(SliderFrame, {
+      size: "$4",
+      ...sliderProps,
+      "data-orientation": sliderProps.orientation,
+      ref: forwardedRef,
+      ...(import_constants.isWeb && {
+        onKeyDown: event => {
+          event.key === "Home" ? (onHomeKeyDown(event), event.preventDefault()) : event.key === "End" ? (onEndKeyDown(event), event.preventDefault()) : import_constants2.PAGE_KEYS.concat(import_constants2.ARROW_KEYS).includes(event.key) && (onStepKeyDown(event), event.preventDefault());
+        }
+      }),
+      onMoveShouldSetResponderCapture: () => !0,
+      onScrollShouldSetResponder: () => !0,
+      onScrollShouldSetResponderCapture: () => !0,
+      onMoveShouldSetResponder: () => !0,
+      onStartShouldSetResponder: () => !0,
+      onResponderTerminationRequest: () => !1,
+      onResponderGrant: (0, import_helpers.composeEventHandlers)(props.onResponderGrant, event => {
+        const target = event.target,
+          thumbIndex = context.thumbs.get(target),
+          isStartingOnThumb = thumbIndex !== void 0;
+        import_constants.isWeb && target instanceof HTMLElement && context.thumbs.has(target) && target.focus(), !import_constants.isWeb && isStartingOnThumb && (context.valueIndexToChangeRef.current = thumbIndex), onSlideStart(event, isStartingOnThumb ? "thumb" : "track");
+      }),
+      onResponderMove: (0, import_helpers.composeEventHandlers)(props.onResponderMove, event => {
+        event.stopPropagation(), onSlideMove(event);
+      }),
+      onResponderRelease: (0, import_helpers.composeEventHandlers)(props.onResponderRelease, event => {
+        onSlideEnd(event);
+      })
+    });
+  });

package/dist/cjs/constants.cjs

@@ -0,0 +1,51 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  ARROW_KEYS: () => ARROW_KEYS,
+  BACK_KEYS: () => BACK_KEYS,
+  PAGE_KEYS: () => PAGE_KEYS,
+  SLIDER_NAME: () => SLIDER_NAME,
+  SliderOrientationProvider: () => SliderOrientationProvider,
+  SliderProvider: () => SliderProvider,
+  createSliderContext: () => createSliderContext,
+  createSliderScope: () => createSliderScope,
+  useSliderContext: () => useSliderContext,
+  useSliderOrientationContext: () => useSliderOrientationContext
+});
+module.exports = __toCommonJS(constants_exports);
+var import_create_context = require("@tamagui/create-context");
+const SLIDER_NAME = "Slider",
+  [createSliderContext, createSliderScope] = (0, import_create_context.createContextScope)(SLIDER_NAME),
+  [SliderProvider, useSliderContext] = createSliderContext(SLIDER_NAME),
+  [SliderOrientationProvider, useSliderOrientationContext] = createSliderContext(SLIDER_NAME, {
+    startEdge: "left",
+    endEdge: "right",
+    sizeProp: "width",
+    size: 0,
+    direction: 1
+  }),
+  PAGE_KEYS = ["PageUp", "PageDown"],
+  ARROW_KEYS = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"],
+  BACK_KEYS = {
+    ltr: ["ArrowDown", "Home", "ArrowLeft", "PageDown"],
+    rtl: ["ArrowDown", "Home", "ArrowRight", "PageDown"]
+  };