Skip to content

The Open Standard for Generative UI

5.3 KB
Raw Blame
import * as SliderPrimitive from "@radix-ui/react-slider";
import clsx from "clsx";
import { forwardRef, ReactNode, useMemo, useState } from "react";

const formatNumber = (num: number | undefined): string => {
  if (num === undefined) {
    return "";
  }
  // format number to k, m, b
  if (num >= 1000) {
    return new Intl.NumberFormat("en-US", {
      notation: "compact",
      compactDisplay: "short",
    })
      .format(num)
      .toLowerCase();
  }
  return String(num);
};

export interface SliderProps extends Omit<
  React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>,
  "value" | "defaultValue"
> {
  variant: "continuous" | "discrete";
  min: number;
  max: number;
  step?: number;
  disabled?: boolean;
  value?: number[];
  defaultValue?: number[];
  className?: string;
  style?: React.CSSProperties;
  leftContent?: ReactNode;
  rightContent?: ReactNode;
}

export const Slider = forwardRef<React.ComponentRef<typeof SliderPrimitive.Root>, SliderProps>(
  (
    {
      variant,
      min,
      max,
      step,
      disabled,
      value,
      defaultValue,
      onValueChange,
      className,
      style,
      leftContent,
      rightContent,
      ...props
    },
    ref,
  ) => {
    // used to show the correct value on thumb
    const [internalValue, setInternalValue] = useState(
      defaultValue && defaultValue.length > 0 ? defaultValue : [min],
    );

    const isControlled = value !== undefined;
    const valueToShow = isControlled ? value : internalValue;

    const isRange = valueToShow && valueToShow.length > 1;

    const thumbs = useMemo(() => {
      const thumbClass = "openui-slider-thumb-handle";
      const valueIndicatorClass = "openui-slider-thumb-value";

      if (isRange) {
        return (
          <>
            {valueToShow?.map((v, i) => (
              <SliderPrimitive.Thumb key={i} className="openui-slider-thumb">
                <div className={thumbClass}>
                  <div className="openui-slider-thumb-handle-inner">
                    <div className="openui-slider-thumb-handle-inner-dot" />
                  </div>
                  {!disabled && <div className={valueIndicatorClass}>{formatNumber(v)}</div>}
                </div>
              </SliderPrimitive.Thumb>
            ))}
          </>
        );
      }

      return (
        <SliderPrimitive.Thumb className="openui-slider-thumb">
          <div className={thumbClass}>
            <div className="openui-slider-thumb-handle-inner">
              <div className="openui-slider-thumb-handle-inner-dot" />
            </div>
            {!disabled && (
              <div className={valueIndicatorClass}>{formatNumber(valueToShow?.[0])}</div>
            )}
          </div>
        </SliderPrimitive.Thumb>
      );
    }, [disabled, valueToShow, isRange]);

    const renderDots = () => {
      if (variant === "discrete" && step) {
        const numSteps = Math.floor((max - min) / step);
        const currentValue = valueToShow?.[0] ?? min;

        return Array.from({ length: numSteps + 1 }, (_, index) => {
          const value = min + step * index;
          const position = ((value - min) / (max - min)) * 100;
          const isActive = isRange
            ? value >= (valueToShow?.[0] ?? min) && value <= (valueToShow?.[1] ?? max)
            : value <= currentValue;

          return (
            <div
              key={value}
              className={clsx("openui-slider-dots-dot", {
                "openui-slider-dots-dot--active": isActive,
              })}
              style={{ left: `${position}%` }}
            />
          );
        });
      }
      return null;
    };

    return (
      <div className="openui-slider-wrapper">
        {leftContent && <div className="openui-slider-left-content">{leftContent}</div>}
        <div className="openui-slider-container-wrapper">
          <div className="openui-slider-container">
            <SliderPrimitive.Root
              ref={ref}
              className={clsx(
                "openui-slider-root",
                { "openui-slider--disabled": disabled },
                className,
              )}
              {...props}
              min={min}
              max={max}
              step={step}
              value={valueToShow}
              onValueChange={(val) => {
                if (!isControlled) {
                  setInternalValue(val);
                }
                onValueChange?.(val);
              }}
              minStepsBetweenThumbs={1}
              disabled={disabled}
              key={variant}
              style={style}
            >
              <SliderPrimitive.Track className="openui-slider-track">
                <SliderPrimitive.Range
                  className={clsx("openui-slider-range", {
                    "openui-slider-range--at-min": !isRange && valueToShow?.[0] === min,
                  })}
                />
                {variant === "discrete" && renderDots()}
              </SliderPrimitive.Track>
              {thumbs}
            </SliderPrimitive.Root>
          </div>
          <div className="openui-slider-labels">
            <span>{formatNumber(min)}</span>
            <span>{formatNumber(max)}</span>
          </div>
        </div>
        {rightContent && <div className="openui-slider-right-content">{rightContent}</div>}
      </div>
    );
  },
);