@bloomreach/react-banana-ui 1.36.0 → 1.38.0

package/dist/components/inputs/autocomplete/autocomplete.stories.d.ts

@@ -6,12 +6,22 @@ export default meta;
 export type Story<Value extends NonNullable<unknown> = string, Multiple extends boolean = false, FreeSolo extends boolean = false> = StoryObj<typeof Autocomplete<Value, Multiple, FreeSolo>>;
 declare const fruits: string[];
 export declare const Basic: Story;
+export declare const CustomWidth: Story;
 export declare const AutoSelect: Story;
 export declare const AutoSelectFreeSoloMultiple: Story<string, true, true>;
 export declare const DefaultValue: Story;
 export declare const ControlledSingleValue: Story;
 export declare const Multiple: Story<(typeof fruits)[0], true>;
+export declare const SelectAll: Story<(typeof fruits)[0], true>;
+export declare const SelectAllWithDisabledOptions: Story<{
+    id: number;
+    label: string;
+}, true>;
 export declare const DefaultValueMultiple: Story<(typeof fruits)[0], true>;
+export declare const LimitTags: Story<(typeof fruits)[0], true>;
+export declare const LimitTagsCustomText: Story<(typeof fruits)[0], true>;
+export declare const MaxRows: Story<(typeof fruits)[0], true>;
+export declare const LimitTagsWithMaxRows: Story<(typeof fruits)[0], true>;
 export declare const ControlledMultipleValue: Story<(typeof fruits)[0], true>;
 export declare const Disabled: Story;
 export declare const DisabledMultiple: Story<(typeof fruits)[0], true>;

package/dist/components/inputs/autocomplete/autocomplete.types.d.ts

@@ -49,6 +49,13 @@ export interface AutocompleteProps<AutocompleteOption extends NonNullable<unknow
      * If `true`, the Autocomplete is free solo, meaning that the user input is not bound to provided options.
      */
     freeSolo?: FreeSolo;
+    /**
+     * Customize the overflow text shown when tags are truncated by `limitTags`.
+     * @param more The number of hidden tags
+     * @returns Content to render as the overflow indicator
+     * @default (more) => `+${more}`
+     */
+    getLimitTagsText?: (more: number) => ReactNode;
     /**
      * Used to determine if an option is disabled.
      */
@@ -81,6 +88,12 @@ export interface AutocompleteProps<AutocompleteOption extends NonNullable<unknow
      * Icon or any element displayed at the start of the input.
      */
     leftElement?: ReactNode;
+    /**
+     * The maximum number of tags visible when the popup is closed.
+     * Set to `-1` to show all tags. Only works when `multiple` is `true`.
+     * @default -1
+     */
+    limitTags?: number;
     /**
      * If `true`, the component is in a loading state.
      * @default false
@@ -91,6 +104,11 @@ export interface AutocompleteProps<AutocompleteOption extends NonNullable<unknow
      * @default "Loading..."
      */
     loadingText?: string;
+    /**
+     * The maximum number of visible tag rows before the tag area becomes scrollable while the popup is closed.
+     * Only works when `multiple` is `true`.
+     */
+    maxRows?: number;
     /**
      * If `true`, the component allows multiple selections.
      * @default false
@@ -179,12 +197,30 @@ export interface AutocompleteProps<AutocompleteOption extends NonNullable<unknow
      * Icon or any element displayed at the end of the input, before the clear button and chevron.
      */
     rightElement?: ReactNode;
+    /**
+     * If `true`, a "Select all" checkbox is shown at the top of the listbox
+     * that toggles all currently visible (filtered) enabled options.
+     * Only works when `multiple` is `true`.
+     * @default false
+     */
+    selectAll?: boolean;
+    /**
+     * The label for the select all checkbox.
+     * Only applicable when both `selectAll` and `multiple` are `true`.
+     * @default "Select all"
+     */
+    selectAllLabel?: string;
     /**
      * The selected value.
      * Set to `null` in case of single select and `[]` in case of multiple select to clear the selection.
      * If the value is an object it must have reference equality with the option in order to be selected.
      */
     value?: AutocompleteValue<AutocompleteOption, Multiple, FreeSolo>;
+    /**
+     * The width of the autocomplete input. Accepts any valid CSS width value.
+     * @example '100%', '400px', 'auto'
+     */
+    width?: number | string;
 }
 export interface AutocompleteRenderGroupParams extends AutocompleteGroupedOption<object> {
     children: ReactNode;

package/dist/components/inputs/field-label/field-label.types.d.ts

@@ -1,5 +1,5 @@
-import { ReactNode } from 'react';
-export interface FieldLabelProps {
+import { HTMLAttributes, ReactNode } from 'react';
+export interface FieldLabelProps extends HTMLAttributes<HTMLLabelElement> {
     /**
      * The content of the component.
      */

package/dist/components/inputs/index.d.ts

@@ -9,5 +9,6 @@ export * from './radio-field';
 export * from './radio-group';
 export * from './select-field';
 export * from './select-option';
+export * from './slider';
 export * from './text-field';
 export * from './toggle-field';

package/dist/components/inputs/internal.d.ts

@@ -4,4 +4,5 @@ export * from './base-input';
 export * from './checkbox';
 export * from './field-label';
 export * from './select';
+export * from './slider';
 export * from './toggle';

package/dist/components/inputs/slider/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Slider } from './slider';
+export { default as SliderField } from './slider-field';
+export type { SliderFieldProps } from './slider-field/slider-field.types';
+export type { Mark, SliderChangeCommittedHandler, SliderChangeHandler, SliderNumberInputAttributes, SliderProps, SliderValue, } from './slider/slider.types';

package/dist/components/inputs/slider/internal/components/index.d.ts

@@ -0,0 +1,4 @@
+export { SliderMarkList } from './slider-mark-list';
+export { SliderNumberInput } from './slider-number-input';
+export { SliderThumb } from './slider-thumb';
+export { SliderTickmarks } from './slider-tickmarks';

package/dist/components/inputs/slider/internal/components/slider-mark-list.d.ts

@@ -0,0 +1,20 @@
+import { ReactElement } from 'react';
+import { Axis, AxisProps, Mark, SliderProps } from '../types';
+interface SliderMarkListProps {
+    axis: Axis;
+    axisProps: AxisProps;
+    markLevels: number[];
+    markRenderKeys: string[];
+    marks: Mark[];
+    max: number;
+    min: number;
+    range: boolean;
+    track: SliderProps['track'];
+    trackLeap: number;
+    trackOffset: number;
+}
+export declare const SliderMarkList: {
+    ({ axis, axisProps, markLevels, markRenderKeys, marks, max, min, range, track, trackLeap, trackOffset, }: SliderMarkListProps): ReactElement;
+    displayName: string;
+};
+export {};

package/dist/components/inputs/slider/internal/components/slider-number-input.d.ts

@@ -0,0 +1,32 @@
+import { ChangeEvent, FocusEvent, KeyboardEvent, ReactElement } from 'react';
+import { SliderNumberInputAttributes } from '../../slider/slider.types';
+/** Props for the visible `<input type="number">` rendered when `withNumberInput` is enabled. */
+export interface SliderNumberInputProps {
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    disabled?: boolean;
+    error?: boolean;
+    inputProps?: SliderNumberInputAttributes;
+    max: number;
+    min: number;
+    onBlur: (event: FocusEvent<HTMLInputElement>) => void;
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown: (event: KeyboardEvent<HTMLInputElement>) => void;
+    readOnly?: boolean;
+    step: 'any' | number;
+    value: string;
+}
+/**
+ * A compact `<input type="number">` rendered alongside the slider when `withNumberInput`
+ * is enabled. Allows users to type an exact value instead of dragging.
+ *
+ * For range sliders, two instances are rendered (one per thumb). The input respects
+ * all slider constraints (min, max, step, marks, snap) via the parent's change handlers.
+ *
+ * Merges any user-provided `inputProps` (including custom `onBlur`/`onChange` handlers)
+ * with the slider's internal handlers.
+ */
+export declare const SliderNumberInput: {
+    ({ ariaLabel, ariaLabelledby, disabled, error, inputProps, max, min, onBlur, onChange, onKeyDown, readOnly, step, value, }: SliderNumberInputProps): ReactElement;
+    displayName: string;
+};

package/dist/components/inputs/slider/internal/components/slider-thumb.d.ts

@@ -0,0 +1,31 @@
+import { ReactElement } from 'react';
+import { Axis, AxisProps, GetHiddenInputProps, GetThumbProps, SliderProps } from '../types';
+import type * as React from 'react';
+interface SliderThumbProps {
+    active: number;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaValuetext?: string;
+    axis: Axis;
+    axisProps: AxisProps;
+    focusedThumbIndex: number;
+    getAriaValueText?: (value: number, index: number) => string;
+    getHiddenInputProps: GetHiddenInputProps;
+    getThumbProps: GetThumbProps;
+    getThumbStyle: (index: number) => React.CSSProperties;
+    index: number;
+    max: number;
+    min: number;
+    open: number;
+    readOnly: boolean;
+    scale?: (value: number) => number;
+    value: number;
+    valueLabelDisplay: SliderProps['valueLabelDisplay'];
+    valueLabelFormat?: SliderProps['valueLabelFormat'];
+    values: number[];
+}
+export declare const SliderThumb: {
+    ({ active, ariaLabel, ariaLabelledby, ariaValuetext, axis, axisProps, focusedThumbIndex, getAriaValueText, getHiddenInputProps, getThumbProps, getThumbStyle, index, max, min, open, readOnly, scale, value, valueLabelDisplay, valueLabelFormat, values, }: SliderThumbProps): ReactElement;
+    displayName: string;
+};
+export {};

package/dist/components/inputs/slider/internal/components/slider-tickmarks.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from 'react';
+interface SliderTickmarksProps {
+    isActiveLayer: boolean;
+    tickmarkMeta: Array<{
+        isMajor: boolean;
+        percent: number;
+    }>;
+}
+export declare const SliderTickmarks: {
+    ({ isActiveLayer, tickmarkMeta }: SliderTickmarksProps): ReactElement;
+    displayName: string;
+};
+export {};

package/dist/components/inputs/slider/internal/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export { default as useSlider } from './use-slider';
+export { default as useSliderBase } from './use-slider-base';
+export { default as useSliderHiddenInputProps } from './use-slider-hidden-input-props';
+export { useSliderMarks } from './use-slider-marks';
+export { default as useSliderPointerInteraction } from './use-slider-pointer-interaction';

package/dist/components/inputs/slider/internal/hooks/use-slider-base.d.ts

@@ -0,0 +1,18 @@
+import { UseSliderBaseParameters, UseSliderBaseReturnValue } from '../types';
+/**
+ * Core slider hook that manages all fundamental slider behavior:
+ * - **Controlled/uncontrolled state** via `useControlledValue`.
+ * - **Pointer interactions** (mouse/touch drag) via `useSliderPointerInteraction`.
+ * - **Keyboard navigation** via `useSliderHiddenInputProps`.
+ * - **Track position** calculation (`trackOffset` and `trackLeap`).
+ * - **Mark generation** from the `marks` prop.
+ * - **Thumb focus and hover** state tracking.
+ *
+ * This hook does NOT handle snap-to-marks, center-track, or number input logic —
+ * those are layered on top by `useSlider`.
+ *
+ * @param parameters - Base slider configuration.
+ * @returns State values, prop getter functions, and refs for building the slider UI.
+ */
+declare const useSliderBase: (parameters: UseSliderBaseParameters) => UseSliderBaseReturnValue;
+export default useSliderBase;

package/dist/components/inputs/slider/internal/hooks/use-slider-hidden-input-props.d.ts

@@ -0,0 +1,47 @@
+import { GetHiddenInputProps, Mark, SliderValue } from '../types';
+import type * as React from 'react';
+interface UseSliderHiddenInputPropsParameters {
+    ariaLabelledby?: string;
+    disabled: boolean;
+    disableSwap: boolean;
+    handleChange?: (event: Event | React.SyntheticEvent, value: SliderValue, activeThumb: number) => void;
+    isRtl: boolean;
+    marks: Mark[];
+    marksValues: number[];
+    max: number;
+    min: number;
+    minDistance: number;
+    name?: string;
+    onChangeCommitted?: (event: Event | React.SyntheticEvent, value: SliderValue) => void;
+    orientation: 'horizontal' | 'vertical';
+    range: boolean;
+    readOnly: boolean;
+    resolveKeyboardValue?: (currentValue: number, nextValue: number) => number;
+    scale: (value: number) => number;
+    setFocusedThumbIndex: (index: number) => void;
+    setOpen: (index: number) => void;
+    setValueState: (value: SliderValue) => void;
+    shiftStep: number;
+    sliderRef: React.RefObject<HTMLSpanElement | null>;
+    step: null | number;
+    tabIndex?: number;
+    valueDerived: SliderValue;
+    values: number[];
+}
+/**
+ * Builds the props getter for the hidden `<input type="range">` elements that
+ * provide native keyboard accessibility for each slider thumb.
+ *
+ * Each thumb renders a visually hidden range input. This hook handles:
+ * - **Arrow key navigation** with `step` and `shiftStep` increments.
+ * - **Page Up/Down** for large jumps.
+ * - **Mark-only mode** (`step === null`) — arrow keys jump between marks.
+ * - **RTL support** — reverses left/right arrow directions.
+ * - **Range constraints** — enforces `minDistance` and `disableSwap` on keyboard moves.
+ * - **Focus tracking** — updates `focusedThumbIndex` and `open` state for value labels.
+ *
+ * @returns A `getHiddenInputProps` function that merges external props with the
+ *          generated accessibility and event handler props.
+ */
+declare const useSliderHiddenInputProps: ({ ariaLabelledby, disabled, disableSwap, handleChange, isRtl, marks, marksValues, max, min, minDistance, name, onChangeCommitted, orientation, range, readOnly, resolveKeyboardValue, scale, setFocusedThumbIndex, setOpen, setValueState, shiftStep, sliderRef, step, tabIndex, valueDerived, values, }: UseSliderHiddenInputPropsParameters) => GetHiddenInputProps;
+export default useSliderHiddenInputProps;

package/dist/components/inputs/slider/internal/hooks/use-slider-marks.d.ts

@@ -0,0 +1,14 @@
+import { Mark, SliderProps } from '../types';
+interface UseSliderMarksParams {
+    marks: Mark[];
+    max: number;
+    min: number;
+    orientation: SliderProps['orientation'];
+}
+interface UseSliderMarksResult {
+    hasStaggeredLabels: boolean;
+    markLevels: number[];
+    markRenderKeys: string[];
+}
+export declare const useSliderMarks: ({ marks, max, min, orientation }: UseSliderMarksParams) => UseSliderMarksResult;
+export default useSliderMarks;

package/dist/components/inputs/slider/internal/hooks/use-slider-pointer-interaction.d.ts

@@ -0,0 +1,47 @@
+import { EventHandlers } from '../../../../../utils/dom';
+import { Axis, Mark, SliderValue } from '../types';
+import type * as React from 'react';
+interface UseSliderPointerInteractionParameters {
+    axis: Axis;
+    disabled: boolean;
+    disableSwap: boolean;
+    handleChange?: (event: Event | React.SyntheticEvent, value: SliderValue, activeThumb: number) => void;
+    marks: Mark[];
+    marksValues: number[];
+    max: number;
+    min: number;
+    minDistance: number;
+    onChangeCommitted?: (event: Event | React.SyntheticEvent, value: SliderValue) => void;
+    range: boolean;
+    readOnly: boolean;
+    setActive: (index: number) => void;
+    setDragging: (value: boolean) => void;
+    setOpen: (index: number) => void;
+    setValueState: (value: SliderValue) => void;
+    sliderRef: React.RefObject<HTMLSpanElement | null>;
+    step: null | number;
+    valueDerived: SliderValue;
+    values: number[];
+}
+interface UseSliderPointerInteractionResult {
+    createHandleMouseDown: (otherHandlers: EventHandlers) => (event: React.MouseEvent<HTMLSpanElement>) => void;
+}
+/**
+ * Manages mouse and touch pointer interactions for the slider.
+ *
+ * Handles the full drag lifecycle:
+ * 1. **Pointer down** (mousedown/touchstart) — determines the clicked position,
+ *    finds the closest thumb, jumps it to the pointer, and starts listening for moves.
+ * 2. **Pointer move** (mousemove/touchmove) — tracks the finger position, updates
+ *    the thumb value in real-time, and triggers the dragging visual state after
+ *    `INTENTIONAL_DRAG_COUNT_THRESHOLD` moves.
+ * 3. **Pointer up** (mouseup/touchend) — commits the final value and cleans up listeners.
+ *
+ * Touch events are attached directly to the slider DOM element (not via React)
+ * to control `passive` behavior for scroll prevention.
+ *
+ * @returns `createHandleMouseDown` — a factory that produces the `onMouseDown` handler
+ *          for the slider root, composable with external event handlers.
+ */
+declare const useSliderPointerInteraction: ({ axis, disabled, disableSwap, handleChange, marks, marksValues, max, min, minDistance, onChangeCommitted, range, readOnly, setActive, setDragging, setOpen, setValueState, sliderRef, step, valueDerived, values, }: UseSliderPointerInteractionParameters) => UseSliderPointerInteractionResult;
+export default useSliderPointerInteraction;

package/dist/components/inputs/slider/internal/hooks/use-slider.d.ts

@@ -0,0 +1,17 @@
+import { UseSliderParameters, UseSliderReturnValue } from '../types';
+/**
+ * Primary hook for the Slider component. Wraps `useSliderBase` and adds:
+ * - **Snap-to-marks** — magnetically snaps thumb values to nearby marks during
+ *   pointer drag, keyboard navigation, and number input entry.
+ * - **Track metrics** — recomputes `trackOffset`/`trackLeap` for `center` track
+ *   mode and snap-adjusted values.
+ * - **Number input handling** — keeps visible number inputs in a transient text
+ *   state while the user types, then commits normalized values on blur or Enter.
+ * - **Read-only enforcement** — blocks hidden input changes in read-only mode
+ *   by intercepting `onChangeCapture` and `onKeyDownCapture`.
+ *
+ * @param parameters - Slider configuration (extends `UseSliderBaseParameters`).
+ * @returns State, props getters, and handlers needed by the `Slider` component.
+ */
+export declare const useSlider: (parameters: UseSliderParameters) => UseSliderReturnValue;
+export default useSlider;

package/dist/components/inputs/slider/internal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components';
+export * from './hooks';
+export * from './types';
+export * from './utils';

package/dist/components/inputs/slider/internal/types/index.d.ts

@@ -0,0 +1,2 @@
+export type { Mark, SliderProps, SliderValue } from '../../slider/slider.types';
+export type { Axis, AxisConfig, AxisProps, EmptyProps, GetHiddenInputProps, GetRootProps, GetThumbProps, UseSliderBaseParameters, UseSliderBaseReturnValue, UseSliderHiddenInputProps, UseSliderParameters, UseSliderReturnValue, UseSliderRootSlotProps, UseSliderThumbSlotProps, } from './slider.internal-types';

package/dist/components/inputs/slider/internal/types/slider.internal-types.d.ts

@@ -0,0 +1,97 @@
+import { Mark, SliderProps, SliderValue } from '../../slider/slider.types';
+import type * as React from 'react';
+/** The resolved axis direction for CSS positioning. RTL horizontal layout uses `horizontal-reverse`. */
+export type Axis = 'horizontal' | 'horizontal-reverse' | 'vertical';
+/** CSS property generators for positioning and sizing elements along a single axis. */
+export interface AxisConfig {
+    /** Returns CSS properties for setting the track/thumb length (e.g. `{ width }` or `{ height }`). */
+    leap: (percent: number) => React.CSSProperties;
+    /** Returns CSS properties for setting the track/thumb position (e.g. `{ left }` or `{ bottom }`). */
+    offset: (percent: number) => React.CSSProperties;
+}
+/** Maps each axis direction to its CSS positioning/sizing configuration. */
+export type AxisProps = Record<Axis, AxisConfig>;
+/** An empty props object type, used as the default for generic prop getter type parameters. */
+export type EmptyProps = Record<string, never>;
+type SlotExternalProps<ExternalProps extends Record<string, unknown>> = Omit<ExternalProps, 'children' | 'key'>;
+export type UseSliderRootSlotProps<ExternalProps extends Record<string, unknown> = EmptyProps> = Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> & SlotExternalProps<ExternalProps> & {
+    ref?: null | React.RefCallback<Element>;
+};
+export type UseSliderThumbSlotProps<ExternalProps extends Record<string, unknown> = EmptyProps> = Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> & SlotExternalProps<ExternalProps>;
+export type UseSliderHiddenInputProps<ExternalProps extends Record<string, unknown> = EmptyProps> = ExternalProps & React.InputHTMLAttributes<HTMLInputElement>;
+/** Props getter for the visually hidden `<input type="range">` per thumb. */
+export type GetHiddenInputProps = <ExternalProps extends Record<string, unknown> = EmptyProps>(externalProps?: ExternalProps) => UseSliderHiddenInputProps<ExternalProps>;
+/** Props getter for the slider root `<span>` element. */
+export type GetRootProps = <ExternalProps extends Record<string, unknown> = EmptyProps>(externalProps?: ExternalProps) => UseSliderRootSlotProps<ExternalProps>;
+/** Props getter for each thumb `<span>` wrapper element. */
+export type GetThumbProps = <ExternalProps extends Record<string, unknown> = EmptyProps>(externalProps?: ExternalProps) => UseSliderThumbSlotProps<ExternalProps>;
+/**
+ * Optional transform applied to keyboard-driven value changes before they are committed.
+ * Used by snap-to-marks to override the raw step-based value with a snapped value.
+ */
+export type ResolveKeyboardValue = (currentValue: number, nextValue: number) => number;
+/** Parameters for the `useSliderBase` hook — the foundation of all slider behavior. */
+export interface UseSliderBaseParameters {
+    'aria-labelledby'?: string;
+    defaultValue?: SliderValue;
+    disabled?: boolean;
+    disableSwap?: boolean;
+    isRtl?: boolean;
+    marks?: boolean | ReadonlyArray<Mark>;
+    max?: number;
+    min?: number;
+    minDistance?: number;
+    name?: string;
+    onChange?: (event: Event, value: SliderValue, activeThumb: number) => void;
+    onChangeCommitted?: (event: Event | React.SyntheticEvent, value: SliderValue) => void;
+    orientation?: 'horizontal' | 'vertical';
+    readOnly?: boolean;
+    resolveKeyboardValue?: ResolveKeyboardValue;
+    rootRef?: React.Ref<Element>;
+    scale?: (value: number) => number;
+    shiftStep?: number;
+    step?: null | number;
+    tabIndex?: number;
+    value?: SliderValue;
+}
+/** Return value from `useSliderBase` — provides all state and prop getters for the slider. */
+export interface UseSliderBaseReturnValue {
+    active: number;
+    axis: Axis;
+    axisProps: AxisProps;
+    dragging: boolean;
+    focusedThumbIndex: number;
+    getHiddenInputProps: GetHiddenInputProps;
+    getRootProps: GetRootProps;
+    getThumbProps: GetThumbProps;
+    getThumbStyle: (index: number) => React.CSSProperties;
+    marks: Mark[];
+    open: number;
+    range: boolean;
+    rootRef: null | React.RefCallback<Element>;
+    setValueState: (value: SliderValue) => void;
+    trackLeap: number;
+    trackOffset: number;
+    values: number[];
+}
+/** Parameters for `useSlider` — extends base parameters with snap, track mode, and input features. */
+export interface UseSliderParameters extends UseSliderBaseParameters {
+    snapToMarks?: SliderProps['snapToMarks'];
+    track?: SliderProps['track'];
+    withNumberInput?: boolean;
+}
+/** Return value from `useSlider` — extends the base return with snap, number input, and track metrics. */
+export type UseSliderReturnValue = Omit<UseSliderBaseReturnValue, 'getHiddenInputProps' | 'trackLeap' | 'trackOffset'> & {
+    customMarks?: Mark[];
+    getHiddenInputProps: GetHiddenInputProps;
+    handleNumberInputBlur: (event: React.FocusEvent<HTMLInputElement>, thumbIndex: number) => void;
+    handleNumberInputChange: (event: React.ChangeEvent<HTMLInputElement>, thumbIndex: number) => void;
+    handleNumberInputKeyDown: (event: React.KeyboardEvent<HTMLInputElement>, thumbIndex: number) => void;
+    inputValues: string[];
+    renderValues: number[];
+    resolvedStep: null | number;
+    resolvedTrack: SliderProps['track'];
+    trackLeap: number;
+    trackOffset: number;
+};
+export {};

package/dist/components/inputs/slider/internal/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './slider.helpers';
+export * from './slider.utils';