Skip to contentShopify logoPolaris

Range slider

A range slider is an input field that merchants can use to select a numeric value within a given range (minimum and maximum values).

Use when a single value between 0 and 100 needs to be selected.

import {Card, RangeSlider} from '@shopify/polaris';
import {useState, useCallback} from 'react';

function RangeSliderExample() {
  const [rangeValue, setRangeValue] = useState(32);

  const handleRangeSliderChange = useCallback(
    (value) => setRangeValue(value),
    [],
  );

  return (
    <Card sectioned title="Background color">
      <RangeSlider
        label="Opacity percentage"
        value={rangeValue}
        onChange={handleRangeSliderChange}
        output
      />
    </Card>
  );
}

Use when a single value needs to be selected from a number range with a specific minimum and maximum.

import {Card, RangeSlider} from '@shopify/polaris';
import {useState, useCallback} from 'react';

function RangeSliderWithPreciseRangeControlExample() {
  const [rangeValue, setRangeValue] = useState(0);

  const handleRangeSliderChange = useCallback(
    (value) => setRangeValue(value),
    [],
  );

  return (
    <Card sectioned title="Navigation branding">
      <RangeSlider
        output
        label="Logo offset"
        min={-20}
        max={20}
        value={rangeValue}
        onChange={handleRangeSliderChange}
      />
    </Card>
  );
}

Use when a single value of a specific increment needs to be selected from a range of numbers.

import {Card, RangeSlider} from '@shopify/polaris';
import {useState, useCallback} from 'react';

function RangeSliderWithPreciseRangeControlExample() {
  const [rangeValue, setRangeValue] = useState(4);

  const handleRangeSliderChange = useCallback(
    (value) => setRangeValue(value),
    [],
  );

  return (
    <Card sectioned title="Navigation branding">
      <RangeSlider
        output
        label="Logo offset"
        min={-20}
        max={20}
        step={4}
        value={rangeValue}
        onChange={handleRangeSliderChange}
      />
    </Card>
  );
}

Use when the start or end of the range input benefits from additional content. The height of the range slider component varies based on the presence or absence of props like label and helpText. Setting a React element on the prefix and suffix props is supported to enable control of spacing and alignment.

import {Card, RangeSlider} from '@shopify/polaris';
import {useState, useCallback} from 'react';

function RangeSliderWithPrefixAndSuffixExample() {
  const [rangeValue, setRangeValue] = useState(100);

  const handleRangeSliderChange = useCallback(
    (value) => setRangeValue(value),
    [],
  );

  const suffixStyles = {
    minWidth: '24px',
    textAlign: 'right',
  };

  return (
    <Card sectioned title="Text color">
      <RangeSlider
        output
        label="Hue color mix"
        min={0}
        max={360}
        value={rangeValue}
        onChange={handleRangeSliderChange}
        prefix={<p>Hue</p>}
        suffix={<p style={suffixStyles}>{rangeValue}</p>}
      />
    </Card>
  );
}

Use when two values need to be selected from a range of numbers.

import {Card, RangeSlider, Stack, TextField} from '@shopify/polaris';
import {useState, useCallback} from 'react';

function DualThumbRangeSliderExample() {
  const initialValue = [900, 1000];
  const prefix = '$';
  const min = 0;
  const max = 2000;
  const step = 10;

  const [intermediateTextFieldValue, setIntermediateTextFieldValue] =
    useState(initialValue);
  const [rangeValue, setRangeValue] = useState(initialValue);

  const handleRangeSliderChange = useCallback((value) => {
    setRangeValue(value);
    setIntermediateTextFieldValue(value);
  }, []);

  const handleLowerTextFieldChange = useCallback(
    (value) => {
      const upperValue = rangeValue[1];
      setIntermediateTextFieldValue([parseInt(value, 10), upperValue]);
    },
    [rangeValue],
  );

  const handleUpperTextFieldChange = useCallback(
    (value) => {
      const lowerValue = rangeValue[0];
      setIntermediateTextFieldValue([lowerValue, parseInt(value, 10)]);
    },
    [rangeValue],
  );

  const handleLowerTextFieldBlur = useCallback(() => {
    const upperValue = rangeValue[1];
    const value = intermediateTextFieldValue[0];

    setRangeValue([parseInt(value, 10), upperValue]);
  }, [intermediateTextFieldValue, rangeValue]);

  const handleUpperTextFieldBlur = useCallback(() => {
    const lowerValue = rangeValue[0];
    const value = intermediateTextFieldValue[1];

    setRangeValue([lowerValue, parseInt(value, 10)]);
  }, [intermediateTextFieldValue, rangeValue]);

  const handleEnterKeyPress = useCallback(
    (event) => {
      const newValue = intermediateTextFieldValue;
      const oldValue = rangeValue;

      if (event.keyCode === Key.Enter && newValue !== oldValue) {
        setRangeValue(newValue);
      }
    },
    [intermediateTextFieldValue, rangeValue],
  );

  const lowerTextFieldValue =
    intermediateTextFieldValue[0] === rangeValue[0]
      ? rangeValue[0]
      : intermediateTextFieldValue[0];

  const upperTextFieldValue =
    intermediateTextFieldValue[1] === rangeValue[1]
      ? rangeValue[1]
      : intermediateTextFieldValue[1];

  return (
    <Card sectioned title="Minimum requirements">
      <div onKeyDown={handleEnterKeyPress}>
        <RangeSlider
          output
          label="Money spent is between"
          value={rangeValue}
          prefix={prefix}
          min={min}
          max={max}
          step={step}
          onChange={handleRangeSliderChange}
        />
        <Stack distribution="equalSpacing" spacing="extraLoose">
          <TextField
            label="Min money spent"
            type="number"
            value={`${lowerTextFieldValue}`}
            prefix={prefix}
            min={min}
            max={max}
            step={step}
            onChange={handleLowerTextFieldChange}
            onBlur={handleLowerTextFieldBlur}
            autoComplete="off"
          />
          <TextField
            label="Max money spent"
            type="number"
            value={`${upperTextFieldValue}`}
            prefix={prefix}
            min={min}
            max={max}
            step={step}
            onChange={handleUpperTextFieldChange}
            onBlur={handleUpperTextFieldBlur}
            autoComplete="off"
          />
        </Stack>
      </div>
    </Card>
  );
}

Props

Want to help make this feature better? Please share your feedback.

interface RangeSliderProps
labelReactNode

Label for the range input.

labelAction?

Adds an action to the label.

labelHidden?boolean

Visually hide the label.

id?string

ID for range input.

valuenumber | ([number, number])

Initial value for range input.

min?number

Minimum possible value for range input.

max?number

Maximum possible value for range input.

step?number

Increment value for range input changes.

output?boolean

Provide a tooltip while sliding, indicating the current value.

helpText?ReactNode

Additional text to aid in use.

error?any

Display an error message.

disabled?boolean

Disable input.

prefix?ReactNode

Element to display before the input.

suffix?ReactNode

Element to display after the input.

onChange(value: number | ([number, number]), id: string) => void

Callback when the range input is changed.

onFocus?() => void

Callback when range input is focused.

onBlur?() => void

Callback when focus is removed.

Best practices

Range sliders should:

  • Always be used with a label, even if that label is hidden.
  • When a label is visible, it should clearly communicate the purpose of the range input and its values (min, max, step, value)
  • Be labeled as “Optional” when you need to request input that’s not required
  • Validate input as soon as merchants have finished interacting with a field (but not before)
  • Always be used with two text field components when range slider has dual thumbs, to provide accessible alternatives to both the lower and upper thumbs

Content guidelines

Range label

A label is a short description of the requested input. Labels are not instructional text but they should be meaningful and clearly indicate what is expected. Labels should be:

  • Placed above the form field
  • Short and succinct (1–3 words)
  • Written in sentence case (the first word capitalized, the rest lowercase)

Do

  • Saturation percentage
  • Banner width

Don’t

  • What is the saturation value?
  • The banner width is:

Designating optional fields

Try to only ask for information that’s required. If you need to ask merchants to provide optional information, mark the field optional by placing the text “(optional)” at the end of the field’s label. Don’t mark required fields with asterisks.

Do

  • Banner width (optional)

Don’t

  • Banner width

Help text

Help text provides extra guidance or instruction to people filling out a form field. It can also be used to clarify how the information will be used. As with all form content, help text should be succinct and easy to read.

Do

  • Video duration is calculated in seconds

Don’t

  • Example: 134 seconds

Validation error messages

Error messages should:

  • Clearly explain what went wrong and how to fix it
  • Be short and concise, no more than a single sentence
  • Use passive voice so merchants don’t feel like they’re being blamed for the error

Do

  • Video duration is required

Don’t

  • You didn’t enter a duration


Accessibility

The range slider provides a large click and tap target for the slider thumbs. Merchants can also tap or click on the slider track to move the closest slider thumb.

Single-thumb slider

The default range slider component uses the ARIA 1.1 slider pattern to build upon the default HTML <input type="range">. The required label prop provides a label for the field that’s conveyed to assistive technologies when it receives focus. When the slider is used, the value prop should update visually and programmatically to reflect the current value.

To consistently provide the current value to assistive technologies, use the min and max props to provide the minimum and maximum values for the slider.

Dual-thumb slider

The dual-thumb range slider component uses the ARIA 1.1 slider (multi-thumb) pattern. However, the pattern isn’t consistently supported by screen readers, especially on mobile devices. Because of this, it’s best to pair the dual-thumb slider with a set of text fields for each value, or to provide another accessible method for entering information.

Keyboard

  • To move focus to a slider thumb, press the tab key to move forward and or shift + tab to move backward
  • When a thumb has focus, use the up and down or left and right arrow keys to move the thumb and update the associated value.