@types/yallist

  • Version 4.0.1
  • Published
  • 7.48 kB
  • No dependencies
  • MIT license

Install

npm i @types/yallist
yarn add @types/yallist
pnpm add @types/yallist

Overview

TypeScript definitions for yallist

Index

Classes

class Yallist

class Yallist<T> implements Iterable<T> {}

    constructor

    constructor();

      constructor

      constructor(list: Yallist.ForEachIterable<T>);

        constructor

        constructor(...items: T[]);

          property head

          head: Yallist.Node<T>;

            property length

            length: number;

              property Node

              static Node: Yallist.NodeConstructor;

                property tail

                tail: Yallist.Node<T>;

                  method [Symbol.iterator]

                  [Symbol.iterator]: () => Iterator<T>;

                    method create

                    static create: {
                    <T>(): Yallist<T>;
                    <T>(list: Yallist.ForEachIterable<T>): Yallist<T>;
                    <T>(...items: T[]): Yallist<T>;
                    };

                      method forEach

                      forEach: <U = this>(
                      callbackFn: (this: U, value: T, index: number, list: this) => void,
                      thisArg?: U
                      ) => void;

                        method forEachReverse

                        forEachReverse: <U = this>(
                        callbackFn: (this: U, value: T, index: number, list: this) => void,
                        thisArg?: U
                        ) => void;

                          method get

                          get: (n: number) => T | undefined;

                            method getReverse

                            getReverse: (n: number) => T | undefined;

                              method map

                              map: <U = this, R = T>(
                              callbackFn: (this: U, value: T, list: this) => R,
                              thisArg?: U
                              ) => Yallist<R>;

                                method mapReverse

                                mapReverse: <U = this, R = T>(
                                callbackFn: (this: U, value: T, list: this) => R,
                                thisArg?: U
                                ) => Yallist<R>;

                                  method pop

                                  pop: () => T | undefined;

                                    method push

                                    push: (...items: T[]) => number;

                                      method pushNode

                                      pushNode: (node: Yallist.Node<T>) => void;

                                        method reduce

                                        reduce: <U = T>(
                                        fn: (previousValue: U, currentValue: T, index: number) => U,
                                        initialValue?: U
                                        ) => U;

                                          method reduceReverse

                                          reduceReverse: <U = T>(
                                          fn: (previousValue: U, currentValue: T, index: number) => U,
                                          initialValue?: U
                                          ) => U;

                                            method removeNode

                                            removeNode: (node: Yallist.Node<T>) => void;

                                              method reverse

                                              reverse: () => this;

                                                method shift

                                                shift: () => T | undefined;

                                                  method slice

                                                  slice: (from?: number, to?: number) => Yallist<T>;

                                                    method sliceReverse

                                                    sliceReverse: (from?: number, to?: number) => Yallist<T>;

                                                      method splice

                                                      splice: (start: number, deleteCount: number, ...nodes: T[]) => T[];

                                                        method toArray

                                                        toArray: () => T[];

                                                          method toArrayReverse

                                                          toArrayReverse: () => T[];

                                                            method unshift

                                                            unshift: (...items: T[]) => number;

                                                              method unshiftNode

                                                              unshiftNode: (node: Yallist.Node<T>) => void;

                                                                Interfaces

                                                                interface ForEachIterable

                                                                interface ForEachIterable<T> {}

                                                                  method forEach

                                                                  forEach: (callbackFn: (item: T) => void) => void;

                                                                    interface Node

                                                                    interface Node<T> {}

                                                                      property list

                                                                      list?: Yallist<T> | undefined;

                                                                        property next

                                                                        next: Node<T> | null;

                                                                          property prev

                                                                          prev: Node<T> | null;

                                                                            property value

                                                                            value: T;

                                                                              interface NodeConstructor

                                                                              interface NodeConstructor {}

                                                                                construct signature

                                                                                new <T>(value: T, prev?: Node<T>, next?: Node<T>, list?: Yallist<T>): Node<T>;

                                                                                  call signature

                                                                                  <T>(value: T, prev?: Node<T>, next?: Node<T>, list?: Yallist<T>): Node<T>;

                                                                                    Package Files (1)

                                                                                    Dependencies (0)

                                                                                    No dependencies.

                                                                                    Dev Dependencies (0)

                                                                                    No dev dependencies.

                                                                                    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/@types/yallist.

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