Logo for jsDocs.io

nouislider

  • Version 15.8.1
  • Published
  • 397 kB
  • No dependencies
  • MIT license

Install

npm i nouislider
yarn add nouislider
pnpm add nouislider

Overview

noUiSlider is a lightweight JavaScript range slider.

Index

Variables

Functions

Interfaces

Enums

Variables

variable _default

const _default: {
    __spectrum: typeof Spectrum;
    cssClasses: CssClasses;
    create: typeof initialize;
};

    variable cssClasses

    const cssClasses: CssClasses;

      Functions

      function create

      create: (target: TargetElement, originalOptions: Options) => API;

        Interfaces

        interface API

        interface API {}

          property destroy

          destroy: () => void;

            property disable

            disable: (handleNumber?: number) => void;

              property enable

              enable: (handleNumber?: number) => void;

                property get

                get: (unencoded?: boolean) => GetResult;

                  property getOrigins

                  getOrigins: () => HTMLElement[];

                    property getPositions

                    getPositions: () => number[];

                      property getTooltips

                      getTooltips: () => (HTMLElement | false)[] | null;

                        property off

                        off: (eventName: string) => void;

                          property on

                          on: (eventName: string, callback: EventCallback) => void;

                            property options

                            options: Options;

                              property pips

                              pips: (grid: Pips) => HTMLElement;

                                property removePips

                                removePips: () => void;

                                  property removeTooltips

                                  removeTooltips: () => void;

                                    property reset

                                    reset: (fireSetEvent?: boolean) => void;

                                      property set

                                      set: (
                                          input: ValueArgument | ValueArgument[],
                                          fireSetEvent?: boolean,
                                          exactInput?: boolean
                                      ) => void;

                                        property setHandle

                                        setHandle: (
                                            handleNumber: number,
                                            value: ValueArgument,
                                            fireSetEvent?: boolean,
                                            exactInput?: boolean
                                        ) => void;

                                          property steps

                                          steps: () => NextStepsForHandle[];

                                            property target

                                            target: HTMLElement;

                                              property updateOptions

                                              updateOptions: (
                                                  optionsToUpdate: UpdatableOptions,
                                                  fireSetEvent: boolean
                                              ) => void;

                                                interface Formatter

                                                interface Formatter extends PartialFormatter {}

                                                  property from

                                                  from: (value: string) => number | false;

                                                    interface Options

                                                    interface Options extends UpdatableOptions {}

                                                      property animationDuration

                                                      animationDuration?: number;

                                                        property ariaFormat

                                                        ariaFormat?: PartialFormatter;

                                                          property behaviour

                                                          behaviour?: string;

                                                            property cssClasses

                                                            cssClasses?: CssClasses;

                                                              property cssPrefix

                                                              cssPrefix?: string;

                                                                property direction

                                                                direction?: 'ltr' | 'rtl';

                                                                  property documentElement

                                                                  documentElement?: HTMLElement;

                                                                    property handleAttributes

                                                                    handleAttributes?: HandleAttributes[];

                                                                      property keyboardDefaultStep

                                                                      keyboardDefaultStep?: number;

                                                                        property keyboardMultiplier

                                                                        keyboardMultiplier?: number;

                                                                          property keyboardPageMultiplier

                                                                          keyboardPageMultiplier?: number;

                                                                            property keyboardSupport

                                                                            keyboardSupport?: boolean;

                                                                              property orientation

                                                                              orientation?: 'vertical' | 'horizontal';

                                                                                property range

                                                                                range: Range;

                                                                                  interface PartialFormatter

                                                                                  interface PartialFormatter {}

                                                                                    property from

                                                                                    from?: (value: string) => number | false;

                                                                                      property to

                                                                                      to: (value: number) => string | number;

                                                                                        interface target

                                                                                        interface TargetElement extends HTMLElement {}

                                                                                          property noUiSlider

                                                                                          noUiSlider?: API;

                                                                                            Enums

                                                                                            enum PipsMode

                                                                                            enum PipsMode {
                                                                                                Range = 'range',
                                                                                                Steps = 'steps',
                                                                                                Positions = 'positions',
                                                                                                Count = 'count',
                                                                                                Values = 'values',
                                                                                            }

                                                                                              member Count

                                                                                              Count = 'count'

                                                                                                member Positions

                                                                                                Positions = 'positions'

                                                                                                  member Range

                                                                                                  Range = 'range'

                                                                                                    member Steps

                                                                                                    Steps = 'steps'

                                                                                                      member Values

                                                                                                      Values = 'values'

                                                                                                        enum PipsType

                                                                                                        enum PipsType {
                                                                                                            None = -1,
                                                                                                            NoValue = 0,
                                                                                                            LargeValue = 1,
                                                                                                            SmallValue = 2,
                                                                                                        }

                                                                                                          member LargeValue

                                                                                                          LargeValue = 1

                                                                                                            member None

                                                                                                            None = -1

                                                                                                              member NoValue

                                                                                                              NoValue = 0

                                                                                                                member SmallValue

                                                                                                                SmallValue = 2

                                                                                                                  Package Files (1)

                                                                                                                  Dependencies (0)

                                                                                                                  No dependencies.

                                                                                                                  Dev Dependencies (10)

                                                                                                                  Peer Dependencies (0)

                                                                                                                  No peer dependencies.

                                                                                                                  Badge

                                                                                                                  To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/nouislider.

                                                                                                                  • Markdown
                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/nouislider)
                                                                                                                  • HTML
                                                                                                                    <a href="https://www.jsdocs.io/package/nouislider"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>