@types/animejs

  • Version 3.1.4
  • Published
  • 8.96 kB
  • No dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for animejs

Index

Variables

variable easings

const easings: { [EasingFunction: string]: (t: number) => any };

    variable running

    const running: AnimeInstance[];

      variable speed

      const speed: number;

        variable version

        const version: string;

          Functions

          function anime

          anime: typeof anime;

            function bezier

            bezier: (
            x1: number,
            y1: number,
            x2: number,
            y2: number
            ) => (t: number) => number;

              function get

              get: (targets: AnimeTarget, prop: string) => string | number;

                function path

                path: (
                path: string | HTMLElement | SVGElement | null,
                percent?: number
                ) => (prop: string) => {
                el: HTMLElement | SVGElement;
                property: string;
                totalLength: number;
                };

                  function random

                  random: (min: number, max: number) => number;

                    function remove

                    remove: (targets: AnimeTarget | ReadonlyArray<AnimeTarget>) => void;

                      function set

                      set: (
                      targets: AnimeTarget,
                      value: { [AnyAnimatedProperty: string]: any }
                      ) => void;

                        function setDashoffset

                        setDashoffset: (el: HTMLElement | SVGElement | null) => number;

                          function stagger

                          stagger: (
                          value: number | string | ReadonlyArray<number | string>,
                          options?: StaggerOptions
                          ) => FunctionBasedParameter;

                            function timeline

                            timeline: (
                            params?: AnimeParams | ReadonlyArray<AnimeInstance>
                            ) => AnimeTimelineInstance;

                              Interfaces

                              interface Animatable

                              interface Animatable {}

                                property id

                                id: number;

                                  property target

                                  target: HTMLElement;

                                    property total

                                    total: number;

                                      property transforms

                                      transforms: object;

                                        interface Animation

                                        interface Animation {}

                                          property animatable

                                          animatable: Animatable;

                                            property currentValue

                                            currentValue: string;

                                              property delay

                                              delay: number;

                                                property duration

                                                duration: number;

                                                  property endDelay

                                                  endDelay: number;

                                                    property property

                                                    property: string;

                                                      property tweens

                                                      tweens: ReadonlyArray<object>;

                                                        property type

                                                        type: string;

                                                          interface AnimeAnimParams

                                                          interface AnimeAnimParams extends AnimeCallBack {}

                                                            property delay

                                                            delay?: number | FunctionBasedParameter | undefined;

                                                              property duration

                                                              duration?: number | FunctionBasedParameter | undefined;

                                                                property easing

                                                                easing?:
                                                                | EasingOptions
                                                                | string
                                                                | CustomEasingFunction
                                                                | ((el: HTMLElement) => string)
                                                                | undefined;

                                                                  property elasticity

                                                                  elasticity?: number | FunctionBasedParameter | undefined;

                                                                    property endDelay

                                                                    endDelay?: number | FunctionBasedParameter | undefined;

                                                                      property keyframes

                                                                      keyframes?: ReadonlyArray<AnimeAnimParams> | undefined;

                                                                        property round

                                                                        round?: number | boolean | FunctionBasedParameter | undefined;

                                                                          property targets

                                                                          targets?: AnimeTarget | ReadonlyArray<AnimeTarget> | undefined;

                                                                            index signature

                                                                            [AnyAnimatedProperty: string]: any;

                                                                              interface AnimeCallBack

                                                                              interface AnimeCallBack {}

                                                                                property begin

                                                                                begin?: AnimeCallbackFunction | undefined;

                                                                                  property change

                                                                                  change?: AnimeCallbackFunction | undefined;

                                                                                    property changeBegin

                                                                                    changeBegin?: AnimeCallbackFunction | undefined;

                                                                                      property changeComplete

                                                                                      changeComplete?: AnimeCallbackFunction | undefined;

                                                                                        property complete

                                                                                        complete?: AnimeCallbackFunction | undefined;

                                                                                          property loopBegin

                                                                                          loopBegin?: AnimeCallbackFunction | undefined;

                                                                                            property loopComplete

                                                                                            loopComplete?: AnimeCallbackFunction | undefined;

                                                                                              property update

                                                                                              update?: AnimeCallbackFunction | undefined;

                                                                                                interface AnimeInstance

                                                                                                interface AnimeInstance extends AnimeCallBack {}

                                                                                                  property animatables

                                                                                                  animatables: ReadonlyArray<Animatable>;

                                                                                                    property animations

                                                                                                    animations: ReadonlyArray<Animation>;

                                                                                                      property autoplay

                                                                                                      autoplay: boolean;

                                                                                                        property began

                                                                                                        began: boolean;

                                                                                                          property completed

                                                                                                          completed: boolean;

                                                                                                            property currentTime

                                                                                                            currentTime: number;

                                                                                                              property delay

                                                                                                              delay: number;

                                                                                                                property direction

                                                                                                                direction: string;

                                                                                                                  property duration

                                                                                                                  duration: number;

                                                                                                                    property finished

                                                                                                                    finished: Promise<void>;

                                                                                                                      property loop

                                                                                                                      loop: number | boolean;

                                                                                                                        property paused

                                                                                                                        paused: boolean;

                                                                                                                          property progress

                                                                                                                          progress: number;

                                                                                                                            property remaining

                                                                                                                            remaining: number;

                                                                                                                              property reversed

                                                                                                                              reversed: boolean;

                                                                                                                                property timelineOffset

                                                                                                                                timelineOffset: number;

                                                                                                                                  method pause

                                                                                                                                  pause: () => void;

                                                                                                                                    method play

                                                                                                                                    play: () => void;

                                                                                                                                      method restart

                                                                                                                                      restart: () => void;

                                                                                                                                        method reverse

                                                                                                                                        reverse: () => void;

                                                                                                                                          method seek

                                                                                                                                          seek: (time: number) => void;

                                                                                                                                            method tick

                                                                                                                                            tick: (time: number) => void;

                                                                                                                                              interface AnimeInstanceParams

                                                                                                                                              interface AnimeInstanceParams extends AnimeCallBack {}

                                                                                                                                                property autoplay

                                                                                                                                                autoplay?: boolean | undefined;

                                                                                                                                                  property direction

                                                                                                                                                  direction?: DirectionOptions | string | undefined;

                                                                                                                                                    property loop

                                                                                                                                                    loop?: number | boolean | undefined;

                                                                                                                                                      interface AnimeParams

                                                                                                                                                      interface AnimeParams extends AnimeInstanceParams, AnimeAnimParams {}

                                                                                                                                                        interface AnimeTimelineAnimParams

                                                                                                                                                        interface AnimeTimelineAnimParams extends AnimeAnimParams {}

                                                                                                                                                          property timelineOffset

                                                                                                                                                          timelineOffset: number | string | FunctionBasedParameter;

                                                                                                                                                            interface AnimeTimelineInstance

                                                                                                                                                            interface AnimeTimelineInstance extends AnimeInstance {}

                                                                                                                                                              method add

                                                                                                                                                              add: (
                                                                                                                                                              params: AnimeAnimParams,
                                                                                                                                                              timelineOffset?: string | number
                                                                                                                                                              ) => AnimeTimelineInstance;

                                                                                                                                                                interface StaggerOptions

                                                                                                                                                                interface StaggerOptions {}

                                                                                                                                                                  property axis

                                                                                                                                                                  axis?: 'x' | 'y' | undefined;

                                                                                                                                                                    property direction

                                                                                                                                                                    direction?: 'normal' | 'reverse' | undefined;

                                                                                                                                                                      property easing

                                                                                                                                                                      easing?: CustomEasingFunction | string | EasingOptions | undefined;

                                                                                                                                                                        property from

                                                                                                                                                                        from?: 'first' | 'last' | 'center' | number | undefined;

                                                                                                                                                                          property grid

                                                                                                                                                                          grid?: ReadonlyArray<number> | undefined;

                                                                                                                                                                            property start

                                                                                                                                                                            start?: number | string | undefined;

                                                                                                                                                                              Type Aliases

                                                                                                                                                                              type DirectionOptions

                                                                                                                                                                              type DirectionOptions = 'reverse' | 'alternate' | 'normal';

                                                                                                                                                                                type EasingOptions

                                                                                                                                                                                type EasingOptions =
                                                                                                                                                                                | 'linear'
                                                                                                                                                                                | 'easeInQuad'
                                                                                                                                                                                | 'easeInCubic'
                                                                                                                                                                                | 'easeInQuart'
                                                                                                                                                                                | 'easeInQuint'
                                                                                                                                                                                | 'easeInSine'
                                                                                                                                                                                | 'easeInExpo'
                                                                                                                                                                                | 'easeInCirc'
                                                                                                                                                                                | 'easeInBack'
                                                                                                                                                                                | 'easeInElastic'
                                                                                                                                                                                | 'easeInBounce'
                                                                                                                                                                                | 'easeOutQuad'
                                                                                                                                                                                | 'easeOutCubic'
                                                                                                                                                                                | 'easeOutQuart'
                                                                                                                                                                                | 'easeOutQuint'
                                                                                                                                                                                | 'easeOutSine'
                                                                                                                                                                                | 'easeOutExpo'
                                                                                                                                                                                | 'easeOutCirc'
                                                                                                                                                                                | 'easeOutBack'
                                                                                                                                                                                | 'easeOutElastic'
                                                                                                                                                                                | 'easeOutBounce'
                                                                                                                                                                                | 'easeInOutQuad'
                                                                                                                                                                                | 'easeInOutCubic'
                                                                                                                                                                                | 'easeInOutQuart'
                                                                                                                                                                                | 'easeInOutQuint'
                                                                                                                                                                                | 'easeInOutSine'
                                                                                                                                                                                | 'easeInOutExpo'
                                                                                                                                                                                | 'easeInOutCirc'
                                                                                                                                                                                | 'easeInOutBack'
                                                                                                                                                                                | 'easeInOutElastic'
                                                                                                                                                                                | 'easeInOutBounce';

                                                                                                                                                                                  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/animejs.

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