react-native-system-ui 0.0.1 → 0.0.2

package/dist/cjs/slider/Slider.js

@@ -0,0 +1,561 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Slider = void 0;
+function _slider() {
+  const data = require("@react-native-aria/slider");
+  _slider = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@react-native-aria/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _slider2() {
+  const data = require("@react-stately/slider");
+  _slider2 = function () {
+    return data;
+  };
+  return data;
+}
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function () {
+    return data;
+  };
+  return data;
+}
+function _reactNative() {
+  const data = require("react-native");
+  _reactNative = function () {
+    return data;
+  };
+  return data;
+}
+var _tokens = require("./tokens");
+var _number = require("../../utils/number");
+var _validate = require("../../utils/validate");
+var _hooks = require("../../hooks");
+var _utils2 = require("./utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+const START_KEYS = ['onResponderGrant', 'onPanResponderGrant'];
+const MOVE_KEYS = ['onResponderMove', 'onPanResponderMove'];
+const END_KEYS = ['onResponderRelease', 'onResponderTerminate', 'onPanResponderRelease', 'onPanResponderTerminate'];
+const ThumbNode = /*#__PURE__*/_react().default.memo(({
+  index,
+  orientation,
+  ariaReverse,
+  trackLayout,
+  isDisabled,
+  state,
+  size,
+  activeColor,
+  content,
+  visualPercent,
+  thumbBackgroundColor,
+  thumbElevation,
+  indicatorSize,
+  indicatorColor,
+  webGestureStyle,
+  enhanceHandlers
+}) => {
+  const inputRef = (0, _react().useRef)(null);
+  const {
+    thumbProps,
+    inputProps
+  } = (0, _slider().useSliderThumb)({
+    index,
+    trackLayout,
+    inputRef,
+    isDisabled,
+    orientation
+  }, state, ariaReverse);
+  const rawThumbViewProps = thumbProps;
+  const handlers = enhanceHandlers(rawThumbViewProps, index) ?? rawThumbViewProps ?? {};
+  const translate = (0, _react().useMemo)(() => -size / 2, [size]);
+  const thumbStyle = (0, _react().useMemo)(() => {
+    const next = {
+      width: size,
+      height: size,
+      borderRadius: size / 2,
+      borderColor: activeColor,
+      transform: [{
+        translateX: translate
+      }, {
+        translateY: translate
+      }]
+    };
+    if (orientation === 'vertical') {
+      next.top = `${visualPercent}%`;
+      next.left = '50%';
+    } else {
+      next.left = `${visualPercent}%`;
+      next.top = '50%';
+    }
+    if (!content) {
+      next.backgroundColor = thumbBackgroundColor;
+      next.elevation = thumbElevation;
+    }
+    return next;
+  }, [activeColor, content, orientation, size, thumbBackgroundColor, thumbElevation, translate, visualPercent]);
+  const indicatorStyle = (0, _react().useMemo)(() => ({
+    width: indicatorSize,
+    height: indicatorSize,
+    borderRadius: indicatorSize / 2,
+    backgroundColor: indicatorColor
+  }), [indicatorColor, indicatorSize]);
+  const accessibilityProps = (0, _utils2.createAccessibilityProps)(inputProps);
+  return /*#__PURE__*/_react().default.createElement(_reactNative().View, _extends({}, handlers, accessibilityProps, {
+    pointerEvents: isDisabled ? 'none' : 'auto',
+    style: [content ? styles.thumbWrapper : styles.thumb, webGestureStyle, thumbStyle]
+  }), content ?? /*#__PURE__*/_react().default.createElement(_reactNative().View, {
+    style: indicatorStyle
+  }));
+});
+ThumbNode.displayName = 'ThumbNode';
+const Slider = props => {
+  const {
+    value: valueProp,
+    min = 0,
+    max = 100,
+    step = 1,
+    range = false,
+    vertical = false,
+    reverse = false,
+    disabled = false,
+    readOnly = false,
+    activeColor,
+    inactiveColor,
+    barHeight,
+    trackHeight,
+    buttonSize,
+    thumbSize,
+    tokensOverride,
+    button,
+    leftButton,
+    rightButton,
+    thumb,
+    leftThumb,
+    rightThumb,
+    ariaLabel,
+    onChange,
+    onChangeAfter,
+    onDragStart,
+    onDragEnd,
+    style,
+    onLayout: containerOnLayout,
+    ...rest
+  } = props;
+  const tokens = (0, _tokens.useSliderTokens)(tokensOverride);
+  const orientation = vertical ? 'vertical' : 'horizontal';
+  const trackRef = (0, _react().useRef)(null);
+  const measureRafRef = (0, _react().useRef)(null);
+  const resolvedMin = (0, _number.parseNumber)(min, 0);
+  const resolvedMax = (0, _number.parseNumber)(max, 100);
+  const resolvedStepRaw = (0, _number.parseNumber)(step, 1);
+  const resolvedStep = resolvedStepRaw > 0 ? resolvedStepRaw : 1;
+  const resolvedTrackHeight = Math.max(0, (0, _number.parseNumber)(barHeight ?? trackHeight, tokens.track.height));
+  const resolvedThumbSize = Math.max(0, (0, _number.parseNumber)(buttonSize ?? thumbSize, tokens.thumb.size));
+  const ariaDisabled = disabled || readOnly;
+  const resolvedActiveColor = activeColor ?? tokens.colors.active;
+  const resolvedInactiveColor = inactiveColor ?? tokens.colors.inactive;
+  const scope = Math.max(resolvedMax - resolvedMin, 0.00001);
+  const normalized = (0, _react().useMemo)(() => (0, _utils2.normalizeValue)(valueProp, range, resolvedMin, resolvedMax), [valueProp, range, resolvedMin, resolvedMax]);
+  const isControlled = valueProp !== undefined;
+  const formatOutput = (0, _react().useCallback)(values => (0, _utils2.toSliderValue)(values, range, resolvedMin), [range, resolvedMin]);
+  const handleStateChange = (0, _react().useCallback)(values => {
+    onChange?.(formatOutput(values));
+  }, [formatOutput, onChange]);
+  const handleStateChangeEnd = (0, _react().useCallback)(values => {
+    onChangeAfter?.(formatOutput(values));
+  }, [formatOutput, onChangeAfter]);
+  const sliderStateOptions = (0, _react().useMemo)(() => ({
+    minValue: resolvedMin,
+    maxValue: resolvedMax,
+    step: resolvedStep,
+    isDisabled: ariaDisabled,
+    numberFormatter: _utils2.defaultNumberFormatter,
+    orientation,
+    value: isControlled ? normalized : undefined,
+    defaultValue: !isControlled ? normalized : undefined,
+    onChange: handleStateChange,
+    onChangeEnd: handleStateChangeEnd
+  }), [ariaDisabled, handleStateChange, handleStateChangeEnd, isControlled, normalized, orientation, resolvedMax, resolvedMin, resolvedStep]);
+  const state = (0, _slider2().useSliderState)(sliderStateOptions);
+  const [trackLayout, setTrackLayout] = (0, _react().useState)({
+    width: 0,
+    height: 0,
+    x: 0,
+    y: 0
+  });
+  const handleTrackLayout = (0, _react().useCallback)(event => {
+    const {
+      layout
+    } = event.nativeEvent;
+    const next = {
+      width: Math.max(layout.width, 1),
+      height: Math.max(layout.height, 1),
+      x: layout.x ?? 0,
+      y: layout.y ?? 0
+    };
+    setTrackLayout(prev => (0, _utils2.isSameLayout)(prev, next) ? prev : next);
+    if (_reactNative().Platform.OS !== 'web' || typeof requestAnimationFrame === 'undefined') return;
+    if (measureRafRef.current != null) return;
+    measureRafRef.current = requestAnimationFrame(() => {
+      measureRafRef.current = null;
+      const node = trackRef.current;
+      if (!node?.measureInWindow) return;
+      node.measureInWindow((x, y, width, height) => {
+        const measured = {
+          width: Math.max(width, 1),
+          height: Math.max(height, 1),
+          x,
+          y
+        };
+        setTrackLayout(prev => (0, _utils2.isSameLayout)(prev, measured) ? prev : measured);
+      });
+    });
+  }, []);
+  (0, _react().useEffect)(() => {
+    return () => {
+      if (measureRafRef.current != null && typeof cancelAnimationFrame === 'function') {
+        cancelAnimationFrame(measureRafRef.current);
+      }
+      measureRafRef.current = null;
+    };
+  }, []);
+  const reverseX = orientation === 'horizontal' ? reverse || (0, _utils().isRTL)() : reverse;
+  const ariaReverse = orientation === 'horizontal' ? reverseX : reverse;
+  const {
+    trackProps
+  } = (0, _slider().useSlider)({
+    orientation,
+    isDisabled: ariaDisabled,
+    'aria-label': ariaLabel ?? 'Slider'
+  }, state, trackLayout, ariaReverse);
+  const trackPressableProps = trackProps;
+  const {
+    style: trackAriaStyle,
+    onLayout: trackAriaOnLayout,
+    ...restTrackProps
+  } = trackPressableProps;
+  const handleTrackPress = (0, _react().useCallback)(event => {
+    if (ariaDisabled) return;
+    if (!state.values.every((_, i) => !state.isThumbDragging(i))) return;
+    const {
+      locationX,
+      locationY,
+      pageX,
+      pageY
+    } = event.nativeEvent;
+    const localX = (0, _validate.isFiniteNumber)(locationX) ? locationX : (0, _validate.isFiniteNumber)(pageX) ? pageX - (trackLayout.x ?? 0) : 0;
+    const localY = (0, _validate.isFiniteNumber)(locationY) ? locationY : (0, _validate.isFiniteNumber)(pageY) ? pageY - (trackLayout.y ?? 0) : 0;
+    const size = orientation === 'vertical' ? trackLayout.height : trackLayout.width;
+    const local = orientation === 'vertical' ? localY : localX;
+    const raw = local / Math.max(size, 1);
+    const percent = orientation === 'vertical' ? reverse ? raw : 1 - raw : reverseX ? 1 - raw : raw;
+    const value = state.getPercentValue(Math.min(1, Math.max(0, percent)));
+    const closestThumb = state.values.reduce((best, v, i) => Math.abs(v - value) < Math.abs(state.values[best] - value) ? i : best, 0);
+    if (closestThumb >= 0 && state.isThumbEditable(closestThumb)) {
+      ;
+      event.preventDefault?.();
+      state.setFocusedThumb(closestThumb);
+      state.setThumbDragging(closestThumb, true);
+      state.setThumbValue(closestThumb, value);
+      state.setThumbDragging(closestThumb, false);
+    }
+  }, [ariaDisabled, orientation, reverse, reverseX, state, trackLayout.height, trackLayout.width, trackLayout.x, trackLayout.y]);
+  const {
+    interactionProps: trackInteractionProps
+  } = (0, _hooks.useAriaPress)({
+    disabled: ariaDisabled,
+    onPress: handleTrackPress,
+    extraProps: restTrackProps
+  });
+  const currentValue = formatOutput(state.values);
+  const currentValueRef = (0, _react().useRef)(currentValue);
+  currentValueRef.current = currentValue;
+  const dragStartedRef = (0, _react().useRef)([]);
+  const dragStartValueRef = (0, _react().useRef)([]);
+  const moveRafIdRef = (0, _react().useRef)([]);
+  const movePendingArgsRef = (0, _react().useRef)([]);
+  const enhancedHandlersCacheRef = (0, _react().useRef)(new WeakMap());
+  (0, _react().useEffect)(() => {
+    enhancedHandlersCacheRef.current = new WeakMap();
+  }, [onDragStart, onDragEnd]);
+  (0, _react().useEffect)(() => {
+    return () => {
+      const cancel = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;
+      if (!cancel) return;
+      for (const id of moveRafIdRef.current) {
+        if (id != null) cancel(id);
+      }
+      moveRafIdRef.current = [];
+      movePendingArgsRef.current = [];
+    };
+  }, []);
+  const enhanceHandlers = (0, _react().useCallback)((handlers, index) => {
+    if (!handlers) return handlers;
+    if (!onDragStart && !onDragEnd) {
+      return handlers;
+    }
+    const cached = enhancedHandlersCacheRef.current.get(handlers);
+    const found = cached?.get(index);
+    if (found) return found;
+    const hasAny = START_KEYS.some(k => (0, _validate.isFunction)(handlers[k])) || MOVE_KEYS.some(k => (0, _validate.isFunction)(handlers[k])) || END_KEYS.some(k => (0, _validate.isFunction)(handlers[k]));
+    if (!hasAny) return handlers;
+    const wrapped = {
+      ...handlers
+    };
+    const raf = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined;
+    const caf = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;
+    for (const key of MOVE_KEYS) {
+      const original = wrapped[key];
+      if (!(0, _validate.isFunction)(original)) continue;
+      const originalFn = original;
+      wrapped[key] = (...args) => {
+        if (!raf) {
+          originalFn(...args);
+          return;
+        }
+        movePendingArgsRef.current[index] = args;
+        if (moveRafIdRef.current[index] != null) return;
+        moveRafIdRef.current[index] = raf(() => {
+          moveRafIdRef.current[index] = null;
+          const pending = movePendingArgsRef.current[index];
+          if (!pending) return;
+          movePendingArgsRef.current[index] = null;
+          originalFn(...pending);
+        });
+      };
+    }
+    const wrapAfter = (key, callback) => {
+      if (!callback) return;
+      const original = wrapped[key];
+      wrapped[key] = (...args) => {
+        if ((0, _validate.isFunction)(original)) {
+          ;
+          original(...args);
+        }
+        callback(args[0]);
+      };
+    };
+    const wrapBefore = (key, callback) => {
+      if (!callback) return;
+      const original = wrapped[key];
+      wrapped[key] = (...args) => {
+        callback(args[0]);
+        if ((0, _validate.isFunction)(original)) {
+          ;
+          original(...args);
+        }
+      };
+    };
+    for (const key of START_KEYS) {
+      wrapAfter(key, () => {
+        dragStartedRef.current[index] = false;
+        dragStartValueRef.current[index] = currentValueRef.current;
+      });
+    }
+    for (const key of MOVE_KEYS) {
+      wrapBefore(key, event => {
+        if (!dragStartedRef.current[index]) {
+          dragStartedRef.current[index] = true;
+          onDragStart?.(event, dragStartValueRef.current[index] ?? currentValueRef.current);
+        }
+      });
+    }
+    const emitEnd = event => {
+      if (dragStartedRef.current[index]) {
+        dragStartedRef.current[index] = false;
+        dragStartValueRef.current[index] = undefined;
+        onDragEnd?.(event, currentValueRef.current);
+      }
+      const rafId = moveRafIdRef.current[index];
+      if (rafId != null && caf) {
+        caf(rafId);
+        moveRafIdRef.current[index] = null;
+      }
+      movePendingArgsRef.current[index] = null;
+    };
+    for (const key of END_KEYS) {
+      wrapAfter(key, emitEnd);
+    }
+    const map = cached ?? new Map();
+    map.set(index, wrapped);
+    if (!cached) {
+      enhancedHandlersCacheRef.current.set(handlers, map);
+    }
+    return wrapped;
+  }, [onDragStart, onDragEnd]);
+  const values = state.values;
+  const thumbPercents = (0, _react().useMemo)(() => values.map(value => ((value ?? resolvedMin) - resolvedMin) / scope * 100), [resolvedMin, scope, values]);
+  const thumbVisualPercents = (0, _react().useMemo)(() => thumbPercents.map(percent => orientation === 'vertical' ? reverse ? percent : 100 - percent : reverseX ? 100 - percent : percent), [orientation, reverse, reverseX, thumbPercents]);
+  const activeRange = (0, _react().useMemo)(() => {
+    const first = thumbVisualPercents[0] ?? 0;
+    const second = thumbVisualPercents[1] ?? first;
+    return range && thumbVisualPercents.length > 1 ? {
+      offset: Math.min(first, second),
+      size: Math.max(first, second) - Math.min(first, second)
+    } : (orientation === 'horizontal' ? !reverseX : reverse) ? {
+      offset: 0,
+      size: first
+    } : {
+      offset: first,
+      size: 100 - first
+    };
+  }, [orientation, range, reverse, reverseX, thumbVisualPercents]);
+  const activeTrackStyle = (0, _react().useMemo)(() => {
+    const next = {
+      backgroundColor: resolvedActiveColor,
+      borderRadius: tokens.track.radius
+    };
+    if (orientation === 'vertical') {
+      next.left = 0;
+      next.width = '100%';
+      next.height = `${Math.max(activeRange.size, 0)}%`;
+      next.top = `${Math.max(activeRange.offset, 0)}%`;
+    } else {
+      next.top = 0;
+      next.height = '100%';
+      next.width = `${Math.max(activeRange.size, 0)}%`;
+      next.left = `${Math.max(activeRange.offset, 0)}%`;
+    }
+    return next;
+  }, [activeRange.offset, activeRange.size, orientation, resolvedActiveColor, tokens.track.radius]);
+  const trackBaseStyle = (0, _react().useMemo)(() => orientation === 'vertical' ? [styles.trackVertical, {
+    width: resolvedTrackHeight,
+    backgroundColor: resolvedInactiveColor,
+    alignSelf: 'center'
+  }] : [styles.trackHorizontal, {
+    height: resolvedTrackHeight,
+    backgroundColor: resolvedInactiveColor
+  }], [orientation, resolvedInactiveColor, resolvedTrackHeight]);
+  const isButtonFunction = (0, _validate.isFunction)(button);
+  const sharedThumb = isButtonFunction ? button({
+    value: currentValue
+  }) : button ?? thumb;
+  const leftThumbContent = leftButton ?? leftThumb ?? sharedThumb;
+  const rightThumbContent = rightButton ?? rightThumb ?? sharedThumb;
+  const resolveThumbContent = (0, _react().useCallback)((index, total) => total > 1 ? index === 0 ? leftThumbContent : rightThumbContent : sharedThumb, [leftThumbContent, rightThumbContent, sharedThumb]);
+  const webGestureStyle = (0, _react().useMemo)(() => _reactNative().Platform.OS === 'web' ? {
+    touchAction: orientation === 'horizontal' ? 'pan-y' : 'none',
+    userSelect: 'none'
+  } : undefined, [orientation]);
+  const baseTrackPressableStyle = (0, _react().useMemo)(() => [styles.trackPressable, orientation === 'vertical' ? styles.trackPressableVertical : null, webGestureStyle], [orientation, webGestureStyle]);
+  const trackPressableStyleFn = (0, _react().useCallback)(pressableState => [baseTrackPressableStyle, trackAriaStyle(pressableState)], [baseTrackPressableStyle, trackAriaStyle]);
+  const trackPressableStyle = (0, _react().useMemo)(() => trackAriaStyle && (0, _validate.isFunction)(trackAriaStyle) ? trackPressableStyleFn : [baseTrackPressableStyle, trackAriaStyle], [baseTrackPressableStyle, trackAriaStyle, trackPressableStyleFn]);
+  const containerStyles = (0, _react().useMemo)(() => [styles.container, {
+    paddingVertical: tokens.spacing.containerPaddingVertical
+  }, orientation === 'vertical' && [styles.verticalContainer, {
+    minHeight: tokens.layout.verticalMinHeight,
+    width: tokens.layout.verticalWidth
+  }], disabled && {
+    opacity: tokens.states.disabledOpacity
+  }, style], [disabled, orientation, style, tokens.layout.verticalMinHeight, tokens.layout.verticalWidth, tokens.spacing.containerPaddingVertical, tokens.states.disabledOpacity]);
+  return /*#__PURE__*/_react().default.createElement(_reactNative().View, _extends({
+    style: containerStyles,
+    onLayout: containerOnLayout
+  }, rest), /*#__PURE__*/_react().default.createElement(_reactNative().View, {
+    style: [styles.trackWrapper, orientation === 'vertical' && styles.trackWrapperVertical]
+  }, /*#__PURE__*/_react().default.createElement(_reactNative().Pressable, _extends({
+    ref: trackRef
+  }, trackInteractionProps, {
+    disabled: ariaDisabled,
+    onLayout: event => {
+      handleTrackLayout(event);
+      trackAriaOnLayout?.(event);
+    },
+    style: trackPressableStyle
+  }), /*#__PURE__*/_react().default.createElement(_reactNative().View, {
+    style: [styles.trackBase, {
+      borderRadius: tokens.track.radius
+    }, ...trackBaseStyle]
+  }, /*#__PURE__*/_react().default.createElement(_reactNative().View, {
+    style: [styles.active, activeTrackStyle]
+  }))), values.map((_, index) => /*#__PURE__*/_react().default.createElement(ThumbNode, {
+    key: `thumb-${index}`,
+    index: index,
+    orientation: orientation,
+    ariaReverse: ariaReverse,
+    trackLayout: trackLayout,
+    isDisabled: ariaDisabled,
+    state: state,
+    size: resolvedThumbSize,
+    activeColor: resolvedActiveColor,
+    content: resolveThumbContent(index, values.length),
+    visualPercent: thumbVisualPercents[index] ?? 0,
+    thumbBackgroundColor: tokens.colors.thumbBackground,
+    thumbElevation: tokens.thumb.elevation,
+    indicatorSize: tokens.thumb.indicatorSize,
+    indicatorColor: tokens.colors.thumbIndicator,
+    webGestureStyle: webGestureStyle,
+    enhanceHandlers: enhanceHandlers
+  }))));
+};
+exports.Slider = Slider;
+const styles = _reactNative().StyleSheet.create({
+  container: {
+    position: 'relative',
+    justifyContent: 'center',
+    width: '100%'
+  },
+  verticalContainer: {
+    height: '100%',
+    alignItems: 'center',
+    paddingVertical: 0
+  },
+  trackWrapper: {
+    width: '100%',
+    justifyContent: 'center',
+    position: 'relative'
+  },
+  trackWrapperVertical: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    width: '100%'
+  },
+  trackPressable: {
+    width: '100%',
+    justifyContent: 'center'
+  },
+  trackPressableVertical: {
+    flex: 1,
+    alignItems: 'center'
+  },
+  trackBase: {
+    overflow: 'hidden',
+    position: 'relative'
+  },
+  trackHorizontal: {
+    width: '100%'
+  },
+  trackVertical: {
+    height: '100%'
+  },
+  active: {
+    position: 'absolute'
+  },
+  thumb: {
+    position: 'absolute',
+    borderWidth: _reactNative().StyleSheet.hairlineWidth,
+    alignItems: 'center',
+    justifyContent: 'center'
+  },
+  thumbWrapper: {
+    position: 'absolute',
+    alignItems: 'center',
+    justifyContent: 'center'
+  }
+});
+Slider.displayName = 'Slider';
+var _default = exports.default = Slider;

package/dist/cjs/slider/utils.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toSliderValue = exports.normalizeValue = exports.isSameLayout = exports.defaultNumberFormatter = exports.createAccessibilityProps = exports.clampValue = void 0;
+var _utils = require("../../utils");
+const clampValue = (value, min, max) => {
+  if (!(0, _utils.isFiniteNumber)(value)) {
+    return min;
+  }
+  return (0, _utils.clamp)(value, min, max);
+};
+exports.clampValue = clampValue;
+const isSameLayout = (a, b) => a.width === b.width && a.height === b.height && a.x === b.x && a.y === b.y;
+exports.isSameLayout = isSameLayout;
+const normalizeValue = (value, range, min, max) => {
+  if (range) {
+    const raw = Array.isArray(value) ? value : (0, _utils.isFiniteNumber)(value) ? [min, value] : [min, min];
+    const first = clampValue(raw[0], min, max);
+    const second = clampValue(raw[1] ?? raw[0], min, max);
+    return first <= second ? [first, second] : [second, first];
+  }
+  const single = Array.isArray(value) ? value[0] : value;
+  return [clampValue(single, min, max)];
+};
+exports.normalizeValue = normalizeValue;
+const toSliderValue = (values, range, fallback) => {
+  if (range) {
+    const start = values[0] ?? fallback;
+    const end = values[1] ?? start;
+    return [start, end];
+  }
+  return values[0] ?? fallback;
+};
+exports.toSliderValue = toSliderValue;
+const createAccessibilityProps = inputProps => {
+  if (!inputProps) return {};
+  const {
+    role,
+    ['aria-value']: ariaValue,
+    accessibilityActions,
+    onAccessibilityAction,
+    disabled
+  } = inputProps;
+  return {
+    accessible: true,
+    accessibilityRole: role ?? 'adjustable',
+    accessibilityValue: ariaValue,
+    accessibilityActions,
+    onAccessibilityAction,
+    accessibilityState: {
+      disabled
+    }
+  };
+};
+exports.createAccessibilityProps = createAccessibilityProps;
+const defaultNumberFormatter = exports.defaultNumberFormatter = typeof Intl !== 'undefined' && (0, _utils.isFunction)(Intl.NumberFormat) ? new Intl.NumberFormat() : {
+  format: val => String(val)
+};