Logo for jsDocs.io

@types/animejs

  • Version 3.1.13
  • Published
  • 8.62 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

Functions

Interfaces

Type Aliases

Variables

variable easings

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

    variable running

    const running: AnimeInstance[];

      variable speed

      const speed: number;

        variable suspendWhenDocumentHidden

        let suspendWhenDocumentHidden: boolean;

          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, unit?: 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 | readonly 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 | readonly 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: readonly 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?: readonly AnimeAnimParams[] | undefined;

                                                                          property round

                                                                          round?: number | boolean | FunctionBasedParameter | undefined;

                                                                            property targets

                                                                            targets?: AnimeTarget | readonly 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: readonly Animatable[];

                                                                                                      property animations

                                                                                                      animations: readonly 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?: readonly 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>