@itwin/itwinui-react 3.0.0-dev.0 → 3.0.0-dev.10

package/esm/core/Slider/Slider.js

@@ -5,232 +5,386 @@
 import cx from 'classnames';
 import * as React from 'react';
 import { getBoundedValue, useEventListener, Box } from '../utils/index.js';
-import '@itwin/itwinui-css/css/slider.css';
 import { Track } from './Track.js';
 import { Thumb } from './Thumb.js';
 const getPercentageOfRectangle = (rect, pointerX, pointerY, orientation) => {
-    if (orientation === 'horizontal') {
-        const position = getBoundedValue(pointerX, rect.left, rect.right);
-        return (position - rect.left) / rect.width;
-    }
-    const position = getBoundedValue(pointerY, rect.top, rect.bottom);
-    return (rect.bottom - position) / rect.height;
+  if (orientation === 'horizontal') {
+    const position = getBoundedValue(pointerX, rect.left, rect.right);
+    return (position - rect.left) / rect.width;
+  }
+  const position = getBoundedValue(pointerY, rect.top, rect.bottom);
+  return (rect.bottom - position) / rect.height;
 };
 const getClosestValueIndex = (values, pointerValue) => {
-    if (1 === values.length) {
-        return 0;
-    }
-    const distances = values.map((value) => Math.abs(value - pointerValue));
-    const smallest = Math.min(...distances);
-    return distances.indexOf(smallest);
+  if (1 === values.length) {
+    return 0;
+  }
+  const distances = values.map((value) => Math.abs(value - pointerValue));
+  const smallest = Math.min(...distances);
+  return distances.indexOf(smallest);
 };
 const getDefaultTrackDisplay = (trackDisplayMode, values) => {
-    if ('auto' !== trackDisplayMode) {
-        return trackDisplayMode;
-    }
-    return values.length % 2 ? 'even-segments' : 'odd-segments';
+  if ('auto' !== trackDisplayMode) {
+    return trackDisplayMode;
+  }
+  return values.length % 2 ? 'even-segments' : 'odd-segments';
 };
 const roundValueToClosestStep = (value, step, min) => {
-    return Math.round((value - min) / step) * step + min;
+  return Math.round((value - min) / step) * step + min;
 };
 const formatNumberValue = (value, step, numDecimals) => {
-    if (Number.isInteger(step)) {
-        return value.toFixed(0);
-    }
-    return value.toFixed(numDecimals);
+  if (Number.isInteger(step)) {
+    return value.toFixed(0);
+  }
+  return value.toFixed(numDecimals);
 };
 /**
  * Focus specified thumb on Slider control
  */
 const focusThumb = (sliderContainer, activeIndex) => {
-    var _a;
-    const doc = sliderContainer.ownerDocument;
-    if (!sliderContainer.contains(doc.activeElement) ||
-        Number((_a = doc.activeElement) === null || _a === void 0 ? void 0 : _a.getAttribute('data-index')) !== activeIndex) {
-        const thumbToFocus = sliderContainer.querySelector(`[data-index="${activeIndex}"]`);
-        thumbToFocus && thumbToFocus.focus();
-    }
+  const doc = sliderContainer.ownerDocument;
+  if (
+    !sliderContainer.contains(doc.activeElement) ||
+    Number(doc.activeElement?.getAttribute('data-index')) !== activeIndex
+  ) {
+    const thumbToFocus = sliderContainer.querySelector(
+      `[data-index="${activeIndex}"]`,
+    );
+    thumbToFocus && thumbToFocus.focus();
+  }
 };
 /**
  * Slider component that display Thumbs for each value specified along a Rail.
  * @example
  * <Slider values={[10]} min={0} max={60} disabled />
  * <Slider values={[10, 20]} min={0} max={50} step={2} />
- * <Slider values={[10, 20, 30, 40]} min={0} max={60} setFocus
+ * <Slider values={[10, 20, 30, 40]} min={0} max={60}
  *   thumbMode='allow-crossing' />
  */
 export const Slider = React.forwardRef((props, ref) => {
-    var _a, _b;
-    const { min = 0, max = 100, values, step = 1, setFocus = false, tooltipProps, disabled = false, tickLabels, minLabel, maxLabel, trackDisplayMode = 'auto', thumbMode = 'inhibit-crossing', onChange, onUpdate, thumbProps, className, railContainerProps, orientation = 'horizontal', ...rest } = props;
-    const [currentValues, setCurrentValues] = React.useState(values);
-    React.useEffect(() => {
-        setCurrentValues(values);
-    }, [values]);
-    const [minValueLabel, setMinValueLabel] = React.useState(() => minLabel !== null && minLabel !== void 0 ? minLabel : min.toString());
-    React.useEffect(() => {
-        setMinValueLabel(minLabel !== null && minLabel !== void 0 ? minLabel : min.toString());
-    }, [minLabel, min]);
-    const [maxValueLabel, setMaxValueLabel] = React.useState(() => maxLabel !== null && maxLabel !== void 0 ? maxLabel : max.toString());
-    React.useEffect(() => {
-        setMaxValueLabel(maxLabel !== null && maxLabel !== void 0 ? maxLabel : max.toString());
-    }, [maxLabel, max]);
-    const [trackDisplay, setTrackDisplay] = React.useState(() => getDefaultTrackDisplay(trackDisplayMode, currentValues));
-    React.useEffect(() => {
-        setTrackDisplay(getDefaultTrackDisplay(trackDisplayMode, currentValues));
-    }, [trackDisplayMode, currentValues]);
-    const containerRef = React.useRef(null);
-    React.useEffect(() => {
-        if (containerRef.current && setFocus) {
-            focusThumb(containerRef.current, 0);
-        }
-    }, [setFocus]);
-    const getNumDecimalPlaces = React.useMemo(() => {
-        const stepString = step.toString();
-        const decimalIndex = stepString.indexOf('.');
-        return stepString.length - (decimalIndex + 1);
-    }, [step]);
-    const getAllowableThumbRange = React.useCallback((index) => {
-        if (thumbMode === 'inhibit-crossing') {
-            const minVal = index === 0 ? min : currentValues[index - 1] + step;
-            const maxVal = index < currentValues.length - 1
-                ? currentValues[index + 1] - step
-                : max;
-            return [minVal, maxVal];
-        }
-        return [min, max];
-    }, [max, min, step, thumbMode, currentValues]);
-    const [activeThumbIndex, setActiveThumbIndex] = React.useState(undefined);
-    const updateThumbValue = React.useCallback((event, callbackType) => {
-        if (containerRef.current && undefined !== activeThumbIndex) {
-            const percent = getPercentageOfRectangle(containerRef.current.getBoundingClientRect(), event.clientX, event.clientY, orientation);
-            let pointerValue = min + (max - min) * percent;
-            pointerValue = roundValueToClosestStep(pointerValue, step, min);
-            const [minVal, maxVal] = getAllowableThumbRange(activeThumbIndex);
-            pointerValue = getBoundedValue(pointerValue, minVal, maxVal);
-            if (pointerValue !== currentValues[activeThumbIndex]) {
-                const newValues = [...currentValues];
-                newValues[activeThumbIndex] = pointerValue;
-                setCurrentValues(newValues);
-                'onChange' === callbackType
-                    ? onChange === null || onChange === void 0 ? void 0 : onChange(newValues)
-                    : onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(newValues);
-            }
-            else if ('onChange' === callbackType) {
-                onChange === null || onChange === void 0 ? void 0 : onChange(currentValues);
-            }
-        }
-    }, [
-        activeThumbIndex,
-        min,
-        max,
-        step,
-        getAllowableThumbRange,
-        currentValues,
-        onUpdate,
-        onChange,
-        orientation,
-    ]);
-    const handlePointerMove = React.useCallback((event) => {
-        if (activeThumbIndex === undefined) {
-            return;
-        }
-        event.preventDefault();
-        event.stopPropagation();
-        updateThumbValue(event, 'onUpdate');
-    }, [activeThumbIndex, updateThumbValue]);
-    // function called by Thumb keyboard processing
-    const onThumbValueChanged = React.useCallback((index, value, keyboardReleased) => {
-        if (currentValues[index] === value && !keyboardReleased) {
-            return;
-        }
-        if (keyboardReleased) {
-            onChange === null || onChange === void 0 ? void 0 : onChange(currentValues); // currentValues since key up should not change value but only stop continuous value selection
+  const {
+    min = 0,
+    max = 100,
+    values,
+    step = 1,
+    tooltipProps,
+    disabled = false,
+    tickLabels,
+    minLabel,
+    maxLabel,
+    trackDisplayMode = 'auto',
+    thumbMode = 'inhibit-crossing',
+    onChange,
+    onUpdate,
+    thumbProps,
+    className,
+    railContainerProps,
+    minProps,
+    maxProps,
+    railProps,
+    trackProps,
+    tickProps,
+    ticksProps,
+    orientation = 'horizontal',
+    ...rest
+  } = props;
+  const [currentValues, setCurrentValues] = React.useState(values);
+  React.useEffect(() => {
+    setCurrentValues(values);
+  }, [values]);
+  const [minValueLabel, setMinValueLabel] = React.useState(
+    () => minLabel ?? min.toString(),
+  );
+  React.useEffect(() => {
+    setMinValueLabel(minLabel ?? min.toString());
+  }, [minLabel, min]);
+  const [maxValueLabel, setMaxValueLabel] = React.useState(
+    () => maxLabel ?? max.toString(),
+  );
+  React.useEffect(() => {
+    setMaxValueLabel(maxLabel ?? max.toString());
+  }, [maxLabel, max]);
+  const [trackDisplay, setTrackDisplay] = React.useState(() =>
+    getDefaultTrackDisplay(trackDisplayMode, currentValues),
+  );
+  React.useEffect(() => {
+    setTrackDisplay(getDefaultTrackDisplay(trackDisplayMode, currentValues));
+  }, [trackDisplayMode, currentValues]);
+  const containerRef = React.useRef(null);
+  const getNumDecimalPlaces = React.useMemo(() => {
+    const stepString = step.toString();
+    const decimalIndex = stepString.indexOf('.');
+    return stepString.length - (decimalIndex + 1);
+  }, [step]);
+  const getAllowableThumbRange = React.useCallback(
+    (index) => {
+      if (thumbMode === 'inhibit-crossing') {
+        const minVal = index === 0 ? min : currentValues[index - 1] + step;
+        const maxVal =
+          index < currentValues.length - 1
+            ? currentValues[index + 1] - step
+            : max;
+        return [minVal, maxVal];
+      }
+      return [min, max];
+    },
+    [max, min, step, thumbMode, currentValues],
+  );
+  const [activeThumbIndex, setActiveThumbIndex] = React.useState(undefined);
+  const updateThumbValue = React.useCallback(
+    (event, callbackType) => {
+      if (containerRef.current && undefined !== activeThumbIndex) {
+        const percent = getPercentageOfRectangle(
+          containerRef.current.getBoundingClientRect(),
+          event.clientX,
+          event.clientY,
+          orientation,
+        );
+        let pointerValue = min + (max - min) * percent;
+        pointerValue = roundValueToClosestStep(pointerValue, step, min);
+        const [minVal, maxVal] = getAllowableThumbRange(activeThumbIndex);
+        pointerValue = getBoundedValue(pointerValue, minVal, maxVal);
+        if (pointerValue !== currentValues[activeThumbIndex]) {
+          const newValues = [...currentValues];
+          newValues[activeThumbIndex] = pointerValue;
+          setCurrentValues(newValues);
+          'onChange' === callbackType
+            ? onChange?.(newValues)
+            : onUpdate?.(newValues);
+        } else if ('onChange' === callbackType) {
+          onChange?.(currentValues);
         }
-        else {
-            const newValues = [...currentValues]; // newValues since key down should change value
-            newValues[index] = value;
-            onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(newValues);
-            setCurrentValues(newValues);
+      }
+    },
+    [
+      activeThumbIndex,
+      min,
+      max,
+      step,
+      getAllowableThumbRange,
+      currentValues,
+      onUpdate,
+      onChange,
+      orientation,
+    ],
+  );
+  const handlePointerMove = React.useCallback(
+    (event) => {
+      if (activeThumbIndex === undefined) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      updateThumbValue(event, 'onUpdate');
+    },
+    [activeThumbIndex, updateThumbValue],
+  );
+  // function called by Thumb keyboard processing
+  const onThumbValueChanged = React.useCallback(
+    (index, value, keyboardReleased) => {
+      if (currentValues[index] === value && !keyboardReleased) {
+        return;
+      }
+      if (keyboardReleased) {
+        onChange?.(currentValues); // currentValues since key up should not change value but only stop continuous value selection
+      } else {
+        const newValues = [...currentValues]; // newValues since key down should change value
+        newValues[index] = value;
+        onUpdate?.(newValues);
+        setCurrentValues(newValues);
+      }
+    },
+    [currentValues, onUpdate, onChange],
+  );
+  const onThumbActivated = React.useCallback((index) => {
+    setActiveThumbIndex(index);
+  }, []);
+  const handlePointerUp = React.useCallback(
+    (event) => {
+      if (activeThumbIndex === undefined) {
+        return;
+      }
+      updateThumbValue(event, 'onChange');
+      setActiveThumbIndex(undefined);
+      event.preventDefault();
+      event.stopPropagation();
+    },
+    [activeThumbIndex, updateThumbValue],
+  );
+  const handlePointerDownOnSlider = React.useCallback(
+    (event) => {
+      if (containerRef.current) {
+        const percent = getPercentageOfRectangle(
+          containerRef.current.getBoundingClientRect(),
+          event.clientX,
+          event.clientY,
+          orientation,
+        );
+        let pointerValue = min + (max - min) * percent;
+        pointerValue = roundValueToClosestStep(pointerValue, step, min);
+        const closestValueIndex = getClosestValueIndex(
+          currentValues,
+          pointerValue,
+        );
+        const [minVal, maxVal] = getAllowableThumbRange(closestValueIndex);
+        pointerValue = getBoundedValue(pointerValue, minVal, maxVal);
+        if (pointerValue === currentValues[closestValueIndex]) {
+          return;
         }
-    }, [currentValues, onUpdate, onChange]);
-    const onThumbActivated = React.useCallback((index) => {
-        setActiveThumbIndex(index);
-    }, []);
-    const handlePointerUp = React.useCallback((event) => {
-        if (activeThumbIndex === undefined) {
-            return;
-        }
-        updateThumbValue(event, 'onChange');
-        setActiveThumbIndex(undefined);
+        const newValues = [...currentValues];
+        newValues[closestValueIndex] = pointerValue;
+        setCurrentValues(newValues);
+        onChange?.(newValues);
+        onUpdate?.(newValues);
+        focusThumb(containerRef.current, closestValueIndex);
         event.preventDefault();
         event.stopPropagation();
-    }, [activeThumbIndex, updateThumbValue]);
-    const handlePointerDownOnSlider = React.useCallback((event) => {
-        if (containerRef.current) {
-            const percent = getPercentageOfRectangle(containerRef.current.getBoundingClientRect(), event.clientX, event.clientY, orientation);
-            let pointerValue = min + (max - min) * percent;
-            pointerValue = roundValueToClosestStep(pointerValue, step, min);
-            const closestValueIndex = getClosestValueIndex(currentValues, pointerValue);
-            const [minVal, maxVal] = getAllowableThumbRange(closestValueIndex);
-            pointerValue = getBoundedValue(pointerValue, minVal, maxVal);
-            if (pointerValue === currentValues[closestValueIndex]) {
-                return;
-            }
-            const newValues = [...currentValues];
-            newValues[closestValueIndex] = pointerValue;
-            setCurrentValues(newValues);
-            onChange === null || onChange === void 0 ? void 0 : onChange(newValues);
-            onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(newValues);
-            focusThumb(containerRef.current, closestValueIndex);
-            event.preventDefault();
-            event.stopPropagation();
-        }
-    }, [
-        min,
-        max,
-        step,
-        currentValues,
-        getAllowableThumbRange,
-        onChange,
-        onUpdate,
-        orientation,
-    ]);
-    useEventListener('pointermove', handlePointerMove, (_a = containerRef.current) === null || _a === void 0 ? void 0 : _a.ownerDocument);
-    useEventListener('pointerup', handlePointerUp, (_b = containerRef.current) === null || _b === void 0 ? void 0 : _b.ownerDocument);
-    const tickMarkArea = React.useMemo(() => {
-        if (!tickLabels) {
-            return null;
-        }
-        if (Array.isArray(tickLabels)) {
-            return (React.createElement(Box, { className: 'iui-slider-ticks' }, tickLabels.map((label, index) => (React.createElement(Box, { as: 'span', key: index, className: 'iui-slider-tick' }, label)))));
-        }
-        return tickLabels;
-    }, [tickLabels]);
-    const generateTooltipProps = React.useCallback((index, val) => {
-        const outProps = tooltipProps
-            ? tooltipProps(index, val, step)
-            : {};
-        return {
-            ...outProps,
-            content: outProps.content
-                ? outProps.content
-                : formatNumberValue(val, step, getNumDecimalPlaces),
-        };
-    }, [getNumDecimalPlaces, step, tooltipProps]);
-    return (React.createElement(Box, { ref: ref, className: cx('iui-slider-component-container', `iui-slider-${orientation}`, { 'iui-disabled': disabled }, className), ...rest },
-        minValueLabel && (React.createElement(Box, { as: 'span', className: 'iui-slider-min' }, minValueLabel)),
-        React.createElement(Box, { ref: containerRef, className: cx('iui-slider-container', {
-                'iui-grabbing': undefined !== activeThumbIndex,
-            }), onPointerDown: handlePointerDownOnSlider, ...railContainerProps },
-            React.createElement(Box, { className: 'iui-slider-rail' }),
-            currentValues.map((thumbValue, index) => {
-                var _a;
-                const [minVal, maxVal] = getAllowableThumbRange(index);
-                const thisThumbProps = thumbProps === null || thumbProps === void 0 ? void 0 : thumbProps(index);
-                return (React.createElement(Thumb, { key: (_a = thisThumbProps === null || thisThumbProps === void 0 ? void 0 : thisThumbProps.id) !== null && _a !== void 0 ? _a : index, index: index, disabled: disabled, isActive: activeThumbIndex === index, onThumbActivated: onThumbActivated, onThumbValueChanged: onThumbValueChanged, minVal: minVal, maxVal: maxVal, value: thumbValue, tooltipProps: generateTooltipProps(index, thumbValue), thumbProps: thisThumbProps, step: step, sliderMin: min, sliderMax: max, orientation: orientation }));
-            }),
-            React.createElement(Track, { trackDisplayMode: trackDisplay, sliderMin: min, sliderMax: max, values: currentValues, orientation: orientation }),
-            tickMarkArea),
-        maxValueLabel && (React.createElement(Box, { as: 'span', className: 'iui-slider-max' }, maxValueLabel))));
+      }
+    },
+    [
+      min,
+      max,
+      step,
+      currentValues,
+      getAllowableThumbRange,
+      onChange,
+      onUpdate,
+      orientation,
+    ],
+  );
+  useEventListener(
+    'pointermove',
+    handlePointerMove,
+    containerRef.current?.ownerDocument,
+  );
+  useEventListener(
+    'pointerup',
+    handlePointerUp,
+    containerRef.current?.ownerDocument,
+  );
+  const tickMarkArea = React.useMemo(() => {
+    if (!tickLabels) {
+      return null;
+    }
+    if (Array.isArray(tickLabels)) {
+      return React.createElement(
+        Box,
+        {
+          as: 'div',
+          ...ticksProps,
+          className: cx('iui-slider-ticks', ticksProps?.className),
+        },
+        tickLabels.map((label, index) =>
+          React.createElement(
+            Box,
+            {
+              as: 'span',
+              ...tickProps,
+              key: index,
+              className: cx('iui-slider-tick', tickProps?.className),
+            },
+            label,
+          ),
+        ),
+      );
+    }
+    return tickLabels;
+  }, [tickLabels, tickProps, ticksProps]);
+  const generateTooltipProps = React.useCallback(
+    (index, val) => {
+      const outProps = tooltipProps ? tooltipProps(index, val, step) : {};
+      return {
+        ...outProps,
+        content: outProps.content
+          ? outProps.content
+          : formatNumberValue(val, step, getNumDecimalPlaces),
+      };
+    },
+    [getNumDecimalPlaces, step, tooltipProps],
+  );
+  return React.createElement(
+    Box,
+    {
+      ref: ref,
+      className: cx(
+        'iui-slider-component-container',
+        `iui-slider-${orientation}`,
+        { 'iui-disabled': disabled },
+        className,
+      ),
+      ...rest,
+    },
+    minValueLabel &&
+      React.createElement(
+        Box,
+        {
+          as: 'span',
+          ...minProps,
+          className: cx('iui-slider-min', minProps?.className),
+        },
+        minValueLabel,
+      ),
+    React.createElement(
+      Box,
+      {
+        as: 'div',
+        ref: containerRef,
+        ...railContainerProps,
+        className: cx(
+          'iui-slider-container',
+          {
+            'iui-grabbing': undefined !== activeThumbIndex,
+          },
+          railContainerProps?.className,
+        ),
+        onPointerDown: handlePointerDownOnSlider,
+      },
+      React.createElement(Box, {
+        as: 'div',
+        ...railProps,
+        className: cx('iui-slider-rail', railProps?.className),
+      }),
+      currentValues.map((thumbValue, index) => {
+        const [minVal, maxVal] = getAllowableThumbRange(index);
+        const thisThumbProps = thumbProps?.(index);
+        return React.createElement(Thumb, {
+          key: thisThumbProps?.id ?? index,
+          index: index,
+          disabled: disabled,
+          isActive: activeThumbIndex === index,
+          onThumbActivated: onThumbActivated,
+          onThumbValueChanged: onThumbValueChanged,
+          minVal: minVal,
+          maxVal: maxVal,
+          value: thumbValue,
+          tooltipProps: generateTooltipProps(index, thumbValue),
+          thumbProps: thisThumbProps,
+          step: step,
+          sliderMin: min,
+          sliderMax: max,
+          orientation: orientation,
+        });
+      }),
+      React.createElement(Track, {
+        trackDisplayMode: trackDisplay,
+        sliderMin: min,
+        sliderMax: max,
+        values: currentValues,
+        orientation: orientation,
+        ...trackProps,
+      }),
+      tickMarkArea,
+    ),
+    maxValueLabel &&
+      React.createElement(
+        Box,
+        {
+          as: 'span',
+          ...maxProps,
+          className: cx('iui-slider-max', maxProps?.className),
+        },
+        maxValueLabel,
+      ),
+  );
 });
 export default Slider;

package/esm/core/Slider/Thumb.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
-import type { TooltipProps } from '../Tooltip/Tooltip.js';
+import { Tooltip } from '../Tooltip/index.js';
 import type { SliderProps } from './Slider.js';
-declare type ThumbProps = {
+type ThumbProps = {
     /**
      * Thumb value.
      */
@@ -49,7 +49,7 @@ declare type ThumbProps = {
     /**
      * Additional tooltip props.
      */
-    tooltipProps: Omit<TooltipProps, 'children'>;
+    tooltipProps: Omit<React.ComponentProps<typeof Tooltip>, 'children'>;
     /**
      * Additional props for Thumb.
      */
@@ -60,5 +60,5 @@ declare type ThumbProps = {
  * Only one Thumb can be active at a time. A Thumb is made active when the user selects
  * it with pointer. Whenever a Thumb is active, focused, or hovered its tooltip is shown.
  */
-export declare const Thumb: (props: ThumbProps) => JSX.Element;
+export declare const Thumb: (props: ThumbProps) => React.JSX.Element;
 export {};