vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-10-04 14:57:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #14332 from ProbablePrime/fix_gsap_api

Browse Source 
Fix various typings and issues with gsap and greensock
This commit is contained in:
Mine Starks
2017-03-09 11:36:40 -08:00
committed by GitHub
parent 021efcf470 2bcf79509a
commit abb322f2b2
13 changed files with 563 additions and 686 deletions
Download Patch File Download Diff File Expand all files Collapse all files
greensock/index.d.ts
Vendored
-352
View File
@@ -1,352 +0,0 @@
// Type definitions for GreenSock Animation Platform 1.15.1
// Project: http://www.greensock.com/get-started-js/
// Definitions by: Robert S <https://github.com/codebelt>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// JavaScript Docs http://api.greensock.com/js/
// Version 1.15.1 (TypeScript 1.4)
interface IDispatcher {
addEventListener(type:string, callback:Function, scope?:Object, useParam?:boolean, priority?:number):void;
removeEventListener(type:string, callback:Function):void;
}
declare type Tween = TweenLite | TweenMax;
declare type Timeline = SimpleTimeline | TimelineLite | TimelineMax;
declare type TweenConfig = {
[tweenProp: string]: any;
delay?: number;
ease?: Ease;
repeat?: number;
repeatDelay?: number;
yoyo?: boolean;
paused?: boolean;
overwrite?: string|number;
onComplete?: Function;
immediateRender?: boolean;
onCompleteParams?: any[];
onCompleteScope?: Object;
onRepeat?: Function;
onRepeatScope?: Object;
onReverseComplete?: Function;
onReverseCompleteParams?: any[];
onReverseCompleteScope?: Object;
onStart?: Function;
onStartParams?: any[];
onStartScope?: Object;
onUpdate?: Function;
onUpdateParams?: any[];
onUpdateScope?: Object;
startAt?: Object;
useFrames?: boolean;
lazy?: boolean;
onOverwrite?: Function;
autoCSS?: boolean;
callbackScope?: Object;
}
//com.greensock.core
declare class Animation {
static ticker: IDispatcher;
data: any;
timeline: SimpleTimeline;
vars: Object;
constructor(duration?: number, vars?: Object);
delay(): number;
delay(value: number): Animation;
duration(): number;
duration(value: number): Animation;
eventCallback(type: string): Function;
eventCallback(type: string, callback: Function, params?: any[], scope?: any): Animation;
invalidate(): Animation;
isActive(): boolean;
kill(vars?: Object, target?: Object): Animation;
pause(atTime?: any, suppressEvents?: boolean): Animation;
paused(): boolean;
paused(value: boolean): Animation;
play(from?: any, suppressEvents?: boolean): Animation;
progress(): number;
progress(value: number, supressEvents?: boolean): Animation;
restart(includeDelay?: boolean, suppressEvents?: boolean): Animation;
resume(from?: any, suppressEvents?: boolean): Animation;
reverse(from?: any, suppressEvents?: boolean): Animation;
reversed(): boolean;
reversed(value: boolean): Animation;
seek(time: any, suppressEvents?: boolean): Animation;
startTime(): number;
startTime(value: number): Animation;
time(): number;
time(value: number, suppressEvents?: boolean): Animation;
timeScale(): number;
timeScale(value: number): Animation;
totalDuration(): number;
totalDuration(value: number): Animation;
totalProgress(): number;
totalProgress(value: number): Animation;
totalTime(): number;
totalTime(time: number, suppressEvents?: boolean): Animation;
}
declare class SimpleTimeline extends Animation {
autoRemoveChildren: boolean;
smoothChildTiming: boolean;
constructor(vars?: Object);
add(value: any, position?: any, align?: string, stagger?: number): SimpleTimeline;
render(time: number, suppressEvents?: boolean, force?: boolean): void;
}
//com.greensock
declare class TweenLite extends Animation {
static defaultEase: Ease;
static defaultOverwrite: string;
static selector: any;
target: Object;
constructor(target: Object, duration: number, vars: Object);
static delayedCall(delay: number, callback: Function, params?: any[], scope?: any, useFrames?: boolean): TweenLite;
endTime(includeRepeats?: boolean): number;
static from(target: Object | Object[], duration: number, vars: Object): TweenLite;
static fromTo(target: Object | Object[], duration: number, fromVars: Object, toVars: Object): TweenLite;
static getTweensOf(target: Object, onlyActive: boolean): Tween[];
static killDelayedCallsTo(func: Function): void;
static killTweensOf(target: Object, onlyActive?: boolean, vars?: Object): void;
static lagSmoothing(threshold: number, adjustedLag: number): void;
static set(target: Object, vars: Object): TweenLite;
static to(target: Object, duration: number, vars: TweenConfig): TweenLite;
}
declare class TweenMax extends TweenLite {
constructor(target: Object, duration: number, vars: Object);
static delayedCall(delay: number, callback: Function, params?: any[], scope?: Object, useFrames?: boolean): TweenMax;
static from(target: Object, duration: number, vars: Object): TweenMax;
static fromTo(target: Object, duration: number, fromVars: Object, toVars: Object): TweenMax;
static getAllTweens(includeTimelines?: boolean): Tween[];
static getTweensOf(target: Object): Tween[];
static isTweening(target: Object): boolean;
static killAll(complete?: boolean, tweens?: boolean, delayedCalls?: boolean, timelines?: boolean): void;
static killChildTweensOf(parent: any, complete?: boolean): void;
static killDelayedCallsTo(func: Function): void;
static killTweensOf(target: Object, vars?: Object): void;
static pauseAll(tweens?: boolean, delayedCalls?: boolean, timelines?: boolean): void;
repeat(): number;
repeat(value: number): TweenMax;
repeatDelay(): number;
repeatDelay(value: number): TweenMax;
static resumeAll(tweens?: boolean, delayedCalls?: boolean, timelines?: boolean): void;
static set(target: Object, vars: Object): TweenMax;
static staggerFrom(targets: any, duration: number, vars: Object, stagger: number, onCompleteAll?: Function, onCompleteAllParams?: any[], onCompleteAllScope?: any): any[];
static staggerFromTo(targets: any, duration: number, fromVars: Object, toVars: Object, stagger: number, onCompleteAll?: Function, onCompleteAllParams?: any[], onCompleteAllScope?: any): any[];
static staggerTo(targets: any, duration: number, vars: Object, stagger: number, onCompleteAll?: Function, onCompleteAllParams?: any[], onCompleteAllScope?: any): any[];
static to(target:Object, duration:number, vars:TweenConfig):TweenMax;
updateTo(vars: Object, resetDuration?: boolean): TweenMax;
yoyo(): boolean;
yoyo(value?: boolean): TweenMax;
}
declare class TimelineLite extends SimpleTimeline {
constructor(vars?: Object);
add(value: any, position?: any, align?: string, stagger?: number): TimelineLite;
addLabel(label: string, position: any): TimelineLite;
addPause(position?: any, callback?: Function, params?: any[], scope?: any): TimelineLite;
call(callback: Function, params?: any[], scope?: any, position?: any): TimelineLite;
clear(labels?: boolean): TimelineLite;
endTime(includeRepeats?: boolean): number;
static exportRoot(vars?: Object, omitDelayedCalls?: boolean): TimelineLite;
from(target: Object, duration: number, vars: Object, position?: any): TimelineLite;
fromTo(target: Object, duration: number, fromVars: Object, toVars: Object, position?: any): TimelineLite;
getChildren(nested?: boolean, tweens?: boolean, timelines?: boolean, ignoreBeforeTime?: number): (Tween | Timeline)[];
getLabelTime(label: string): number;
getTweensOf(target: Object, nested?: boolean): Tween[];
recent(): Animation;
remove(value: any): TimelineLite;
removeLabel(label: string): any;
set(target: Object, vars: Object, position?: any): TimelineLite;
shiftChildren(amount: number, adjustLabels?: boolean, ignoreBeforeTime?: number): TimelineLite;
staggerFrom(targets: any, duration: number, vars: Object, stagger?: number, position?: any, onCompleteAll?: Function, onCompleteAllParams?: any[], onCompleteScope?: any): TimelineLite;
staggerFromTo(targets: any, duration: number, fromVars: Object, toVars: Object, stagger?: number, position?: any, onCompleteAll?: Function, onCompleteAllParams?: any[], onCompleteAllScope?: any): TimelineLite;
staggerTo(targets: any, duration: number, vars: Object, stagger: number, position?: any, onCompleteAll?: Function, onCompleteAllParams?: any[], onCompleteAllScope?: any): TimelineLite;
to(target: Object, duration: number, vars: Object, position?: any): TimelineLite;
usesFrames(): boolean;
}
declare class TimelineMax extends TimelineLite {
constructor(vars?: Object);
addCallback(callback: Function, position: any, params?: any[], scope?: any): TimelineMax;
currentLabel(): string;
currentLabel(value: string): TimelineMax;
getActive(nested?: boolean, tweens?: boolean, timelines?: boolean): Tween | Timeline[];
getLabelAfter(time: number): string;
getLabelBefore(time: number): string;
getLabelsArray(): {name: string; time: number;}[];
removeCallback(callback: Function, timeOrLabel?: any): TimelineMax;
removePause(position: any): TimelineMax;
repeat(): number;
repeat(value: number): TimelineMax;
repeatDelay(): number;
repeatDelay(value: number): TimelineMax;
tweenFromTo(fromPosition: any, toPosition: any, vars?: Object): TweenLite;
tweenTo(position: any, vars?: Object): TweenLite;
yoyo(): boolean;
yoyo(value: boolean): TimelineMax;
}
//com.greensock.easing
declare class Ease {
constructor(func:Function, extraParams:any[], type:number, power:number);
public getRatio(p: number): number;
}
declare class EaseLookup {
public static find(name: string): Ease;
}
declare class Back extends Ease {
public static easeIn: Back;
public static easeInOut: Back;
public static easeOut: Back;
public config(overshoot: number): Elastic;
}
declare class Bounce extends Ease {
public static easeIn: Bounce;
public static easeInOut: Bounce;
public static easeOut: Bounce;
}
declare class Circ extends Ease {
public static easeIn: Circ;
public static easeInOut: Circ;
public static easeOut: Circ;
}
declare class Cubic extends Ease {
public static easeIn: Cubic;
public static easeInOut: Cubic;
public static easeOut: Cubic;
}
declare class Elastic extends Ease {
public static easeIn: Elastic;
public static easeInOut: Elastic;
public static easeOut: Elastic;
public config(amplitude: number, period: number): Elastic;
}
declare class Expo extends Ease {
public static easeIn: Expo;
public static easeInOut: Expo;
public static easeOut: Expo;
}
declare class Linear extends Ease {
public static ease: Linear;
public static easeIn: Linear;
public static easeInOut: Linear;
public static easeNone: Linear;
public static easeOut: Linear;
}
declare class Quad extends Ease {
public static easeIn: Quad;
public static easeInOut: Quad;
public static easeOut: Quad;
}
declare class Quart extends Ease {
public static easeIn: Quart;
public static easeInOut: Quart;
public static easeOut: Quart;
}
declare class Quint extends Ease {
public static easeIn: Quint;
public static easeInOut: Quint;
public static easeOut: Quint;
}
declare class Sine extends Ease {
public static easeIn: Sine;
public static easeInOut: Sine;
public static easeOut: Sine;
}
declare class SlowMo extends Ease {
public static ease: SlowMo;
public config(linearRatio: number, power: number, yoyoMode: boolean): SlowMo;
}
declare class SteppedEase extends Ease {
constructor(staps: number);
public config(steps: number): SteppedEase;
}
declare type RoughEaseConfig = {
clamp?: boolean;
points?: number;
randomize?: boolean;
strength?: number;
taper?: string; /* one of "in" | "out" | "both" | "none" */
template?: Ease;
}
declare class RoughEase extends Ease {
public static ease: RoughEase;
constructor(vars: RoughEaseConfig);
public config(steps: number): SteppedEase;
}
//com.greensock.plugins
interface BezierPlugin extends TweenPlugin {
bezierThrough(values:any[], curviness?:number, quadratic?:boolean, correlate?:string, prepend?:Object, calcDifs?:boolean):Object;
cubicToQuadratic(a:number, b:number, c:number, d:number):any[];
quadraticToCubic(a:number, b:number, c:number):Object;
}
interface ColorPropsPlugin extends TweenPlugin {
}
interface CSSPlugin extends TweenPlugin {
}
interface CSSRulePlugin extends TweenPlugin {
getRule(selector:string):Object;
}
interface EaselPlugin extends TweenPlugin {
}
interface RaphaelPlugin extends TweenPlugin {
}
interface RoundPropsPlugin extends TweenPlugin {
}
interface ScrollToPlugin extends TweenPlugin {
}
interface TweenPlugin {
activate(plugins:any[]):boolean;
}
//com.greensock.easing
declare var Power0: typeof Linear;
declare var Power1: typeof Quad;
declare var Power2: typeof Cubic;
declare var Power3: typeof Quart;
declare var Power4: typeof Quint;
declare var Strong: typeof Quint;
//com.greensock.plugins
declare var BezierPlugin:BezierPlugin;
declare var ColorPropsPlugin:ColorPropsPlugin;
declare var CSSPlugin:CSSPlugin;
declare var CSSRulePlugin:CSSRulePlugin;
declare var EaselPlugin:EaselPlugin;
declare var RaphaelPlugin:RaphaelPlugin;
declare var RoundPropsPlugin:RoundPropsPlugin;
declare var ScrollToPlugin:ScrollToPlugin;
declare var TweenPlugin:TweenPlugin;
greensock/tsconfig.json
-21
View File
@@ -1,21 +0,0 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts"
]
}
gsap/Animation.d.ts
Vendored
+90
View File
@@ -0,0 +1,90 @@
declare namespace gsap {
export class Animation {
/** Base class for all TweenLite, TweenMax, TimelineLite, and TimelineMax classes, providing core methods/properties/() => voidality, but there is no reason to create an instance of this class directly. */
constructor(duration?: number, vars?: any);
/** A place to store any data you want (initially populated with vars.data if it exists). */
data: any;
/** [Read-only] Parent timeline. */
timeline: SimpleTimeline;
/** The vars object passed into the constructor which stores configuration variables like onComplete, onUpdate, etc. */
vars: {};
/** Gets or sets the animation's initial delay which is the length of time in seconds (or frames for frames-based tweens) before the animation should begin. */
delay(): number;
delay(value: number): Animation;
/** Gets or sets the animation's duration, not including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
duration(): number;
duration(value: number): Animation;
/** Gets or sets an event callback like "onComplete", "onUpdate", "onStart", "onReverseComplete" or "onRepeat" (onRepeat only applies to TweenMax or TimelineMax instances) along with any parameters that should be passed to that callback. */
eventCallback(type: string): () => void;
eventCallback(type: string, callback: () => void, params?: any[], scope?: any): Animation;
/** Clears any initialization data (like starting/ending values in tweens) which can be useful if, for example, you want to restart a tween without reverting to any previously recorded starting values. */
invalidate(): Animation;
/** Indicates whether or not the animation is currently active (meaning the virtual playhead is actively moving across this instance's time span and it is not paused, nor are any of its ancestor timelines). */
isActive(): boolean;
/** Kills the animation entirely or in part depending on the parameters. */
kill(vars?: {}, target?: {}): Animation;
/** Pauses the instance, optionally jumping to a specific time. */
pause(atTime?: any, suppressEvents?: boolean): Animation;
/** Gets or sets the animation's paused state which indicates whether or not the animation is currently paused. */
paused(): boolean;
paused(value: boolean): Animation;
/** Begins playing forward, optionally from a specific time (by default playback begins from wherever the playhead currently is). */
play(from?: any, suppressEvents?: boolean): Animation;
/** Gets or sets the animations's progress which is a value between 0 and 1 indicating the position of the virtual playhead (excluding repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
progress(): number;
progress(value: number, suppressEvents?: boolean): Animation;
/** Restarts and begins playing forward from the beginning. */
restart(includeDelay?: boolean, suppressEvents?: boolean): Animation;
/** Resumes playing without altering direction (forward or reversed), optionally jumping to a specific time first. */
resume(from?: any, suppressEvents?: boolean): Animation;
/** Reverses playback so that all aspects of the animation are oriented backwards including, for example, a tween's ease. */
reverse(from?: any, suppressEvents?: boolean): Animation;
/** Gets or sets the animation's reversed state which indicates whether or not the animation should be played backwards. */
reversed(): boolean;
reversed(value: boolean): Animation;
/** Jumps to a specific time without affecting whether or not the instance is paused or reversed. */
seek(time: any, suppressEvents?: boolean): Animation;
/** Gets or sets the time at which the animation begins on its parent timeline (after any delay that was defined). */
startTime(): number;
startTime(value: number): Animation;
/** Gets or sets the local position of the playhead (essentially the current time), described in seconds (or frames for frames-based animations) which will never be less than 0 or greater than the animation's duration. */
time(): number;
time(value: number, suppressEvents?: boolean): Animation;
/** Factor that's used to scale time in the animation where 1 = normal speed (the default), 0.5 = half speed, 2 = double speed, etc. */
timeScale(): number;
timeScale(value: number): Animation;
/** Gets or sets the animation's total duration including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
totalDuration(): number;
totalDuration(value: number): Animation;
/** Gets or sets the animation's total progress which is a value between 0 and 1 indicating the position of the virtual playhead (including repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
totalProgress(): number;
totalProgress(value: number, suppressEvents?: boolean): Animation;
/** Gets or sets the position of the playhead according to the totalDuration which includes any repeats and repeatDelays (only available in TweenMax and TimelineMax). */
totalTime(): number;
totalTime(time: number, suppressEvents?: boolean): Animation;
}
}
gsap/Core.d.ts
Vendored
-179
View File
@@ -1,179 +0,0 @@
declare class Animation {
/** Base class for all TweenLite, TweenMax, TimelineLite, and TimelineMax classes, providing core methods/properties/functionality, but there is no reason to create an instance of this class directly. */
constructor(duration?: number, vars?: any);
/** A place to store any data you want (initially populated with vars.data if it exists). */
data: any;
/** [Read-only] Parent timeline. */
timeline: SimpleTimeLine;
/** The vars object passed into the constructor which stores configuration variables like onComplete, onUpdate, etc. */
vars: any;
/** Gets or sets the animation's initial delay which is the length of time in seconds (or frames for frames-based tweens) before the animation should begin. */
delay(): number;
delay(value: number): Animation;
/** Gets or sets the animation's duration, not including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
duration(): number;
duration(value: number): Animation;
/** Gets or sets an event callback like "onComplete", "onUpdate", "onStart", "onReverseComplete" or "onRepeat" (onRepeat only applies to TweenMax or TimelineMax instances) along with any parameters that should be passed to that callback. */
eventCallback(type: string): Function;
eventCallback(type: string, callback: Function, params?: any[], scope?: any): Animation;
/** Clears any initialization data (like starting/ending values in tweens) which can be useful if, for example, you want to restart a tween without reverting to any previously recorded starting values. */
invalidate(): Animation;
/** Indicates whether or not the animation is currently active (meaning the virtual playhead is actively moving across this instance's time span and it is not paused, nor are any of its ancestor timelines). */
isActive(): boolean;
/** Kills the animation entirely or in part depending on the parameters. */
kill(vars?: any, target?: any): Animation;
/** Pauses the instance, optionally jumping to a specific time. */
pause(atTime?: any, suppressEvents?: boolean): Animation;
/** Gets or sets the animation's paused state which indicates whether or not the animation is currently paused. */
paused(): boolean;
paused(value: boolean): Animation;
/** Begins playing forward, optionally from a specific time (by default playback begins from wherever the playhead currently is). */
play(from?: any, suppressEvents?: boolean): Animation;
/** Gets or sets the animations's progress which is a value between 0 and 1 indicating the position of the virtual playhead (excluding repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
progress(): number;
progress(value: number, suppressEvents?: boolean): Animation;
/** Restarts and begins playing forward from the beginning. */
restart(includeDelay?: boolean, suppressEvents?: boolean): Animation;
/** Resumes playing without altering direction (forward or reversed), optionally jumping to a specific time first. */
resume(from?: any, suppressEvents?: boolean): Animation;
/** Reverses playback so that all aspects of the animation are oriented backwards including, for example, a tween's ease. */
reverse(from?: any, suppressEvents?: boolean): Animation;
/** Gets or sets the animation's reversed state which indicates whether or not the animation should be played backwards. */
reversed(): boolean;
reversed(value: boolean): Animation;
/** Jumps to a specific time without affecting whether or not the instance is paused or reversed. */
seek(time: any, suppressEvents?: boolean): Animation;
/** Gets or sets the time at which the animation begins on its parent timeline (after any delay that was defined). */
startTime(): number;
startTime(value: number): Animation;
/** Gets or sets the local position of the playhead (essentially the current time), described in seconds (or frames for frames-based animations) which will never be less than 0 or greater than the animation's duration. */
time(): number;
time(value: number, suppressEvents?: boolean): Animation;
/** Factor that's used to scale time in the animation where 1 = normal speed (the default), 0.5 = half speed, 2 = double speed, etc. */
timeScale(): number;
timeScale(value: number): Animation;
/** Gets or sets the animation's total duration including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
totalDuration(): number;
totalDuration(value: number): Animation;
/** Gets or sets the animation's total progress which is a value between 0 and 1 indicating the position of the virtual playhead (including repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
totalProgress(): number;
totalProgress(value: number, suppressEvents?: boolean): Animation;
/** Gets or sets the position of the playhead according to the totalDuration which includes any repeats and repeatDelays (only available in TweenMax and TimelineMax). */
totalTime(): number;
totalTime(time: number, suppressEvents?: boolean): Animation;
}
declare class SimpleTimeLine extends Animation {
/** SimpleTimeline is the base class for TimelineLite and TimelineMax, providing the most basic timeline functionality and it is used for the root timelines in TweenLite but is only intended for internal use in the GreenSock tweening platform. It is meant to be very fast and lightweight. */
constructor(vars?: any);
/** If true, child tweens/timelines will be removed as soon as they complete. */
autoRemoveChildren: boolean;
/** Controls whether or not child tweens/timelines are repositioned automatically (changing their startTime) in order to maintain smooth playback when properties are changed on-the-fly. */
smoothChildTiming: boolean;
/** Adds a TweenLite, TweenMax, TimelineLite, or TimelineMax instance to the timeline at a specific time. */
add(child: any, position?: any, align?: string, stagger?: number): SimpleTimeLine;
/** renders */
render(time: number, suppressEvents?: boolean, force?: boolean): SimpleTimeLine;
// INHERITANCE FROM ANIMATION
/** Gets or sets the animation's initial delay which is the length of time in seconds (or frames for frames-based tweens) before the animation should begin. */
delay(): number;
delay(value: number): SimpleTimeLine;
/** Gets or sets the animation's duration, not including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
duration(): number;
duration(value: number): SimpleTimeLine;
/** Gets or sets an event callback like "onComplete", "onUpdate", "onStart", "onReverseComplete" or "onRepeat" (onRepeat only applies to TweenMax or TimelineMax instances) along with any parameters that should be passed to that callback. */
eventCallback(type: string): Function;
eventCallback(type: string, callback: Function, params?: any[], scope?: any): SimpleTimeLine;
/** Clears any initialization data (like starting/ending values in tweens) which can be useful if, for example, you want to restart a tween without reverting to any previously recorded starting values. */
invalidate(): SimpleTimeLine;
/** Kills the animation entirely or in part depending on the parameters. */
kill(vars?: any, target?: any): SimpleTimeLine;
/** Pauses the instance, optionally jumping to a specific time. */
pause(atTime?: any, suppressEvents?: boolean): SimpleTimeLine;
/** Gets or sets the animation's paused state which indicates whether or not the animation is currently paused. */
paused(): boolean;
paused(value: boolean): SimpleTimeLine;
/** Begins playing forward, optionally from a specific time (by default playback begins from wherever the playhead currently is). */
play(from?: any, suppressEvents?: boolean): SimpleTimeLine;
/** Gets or sets the animations's progress which is a value between 0 and 1 indicating the position of the virtual playhead (excluding repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
progress(): number;
progress(value: number, suppressEvents?: boolean): SimpleTimeLine;
/** Restarts and begins playing forward from the beginning. */
restart(includeDelay?: boolean, suppressEvents?: boolean): SimpleTimeLine;
/** Resumes playing without altering direction (forward or reversed), optionally jumping to a specific time first. */
resume(from?: any, suppressEvents?: boolean): SimpleTimeLine;
/** Reverses playback so that all aspects of the animation are oriented backwards including, for example, a tween's ease. */
reverse(from?: any, suppressEvents?: boolean): SimpleTimeLine;
/** Gets or sets the animation's reversed state which indicates whether or not the animation should be played backwards. */
reversed(): boolean;
reversed(value: boolean): SimpleTimeLine;
/** Jumps to a specific time without affecting whether or not the instance is paused or reversed. */
seek(time: any, suppressEvents?: boolean): SimpleTimeLine;
/** Gets or sets the time at which the animation begins on its parent timeline (after any delay that was defined). */
startTime(): number;
startTime(value: number): SimpleTimeLine;
/** Gets or sets the local position of the playhead (essentially the current time), described in seconds (or frames for frames-based animations) which will never be less than 0 or greater than the animation's duration. */
time(): number;
time(value: number, suppressEvents?: boolean): SimpleTimeLine;
/** Factor that's used to scale time in the animation where 1 = normal speed (the default), 0.5 = half speed, 2 = double speed, etc. */
timeScale(): number;
timeScale(value: number): SimpleTimeLine;
/** Gets or sets the animation's total duration including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
totalDuration(): number;
totalDuration(value: number): SimpleTimeLine;
/** Gets or sets the animation's total progress which is a value between 0 and 1 indicating the position of the virtual playhead (including repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
totalProgress(): number;
totalProgress(value: number, suppressEvents?: boolean): SimpleTimeLine;
/** Gets or sets the position of the playhead according to the totalDuration which includes any repeats and repeatDelays (only available in TweenMax and TimelineMax). */
totalTime(): number;
totalTime(time: number, suppressEvents?: boolean): SimpleTimeLine;
}
gsap/Ease.d.ts
Vendored
+112 -5
View File
@@ -1,6 +1,113 @@
declare class Ease {
constructor(func?: Function, extraParams?: any[], type?: number, power?: number);
declare namespace gsap {
export class Ease {
constructor(func?: () => void, extraParams?: any[], type?: number, power?: number);
/** Translates the tween's progress ratio into the corresponding ease ratio. */
getRatio(p: number): number;
}
/** Translates the tween's progress ratio into the corresponding ease ratio. */
getRatio(p: number): number;
}
export class EaseLookup {
static find(name: string): Ease;
}
export class Back extends Ease {
static easeIn: Back;
static easeInOut: Back;
static easeOut: Back;
config(overshoot: number): Elastic;
}
export class Bounce extends Ease {
static easeIn: Bounce;
static easeInOut: Bounce;
static easeOut: Bounce;
}
export class Circ extends Ease {
static easeIn: Circ;
static easeInOut: Circ;
static easeOut: Circ;
}
export class Cubic extends Ease {
static easeIn: Cubic;
static easeInOut: Cubic;
static easeOut: Cubic;
}
export class Elastic extends Ease {
static easeIn: Elastic;
static easeInOut: Elastic;
static easeOut: Elastic;
config(amplitude: number, period: number): Elastic;
}
export class Expo extends Ease {
static easeIn: Expo;
static easeInOut: Expo;
static easeOut: Expo;
}
export class Linear extends Ease {
static ease: Linear;
static easeIn: Linear;
static easeInOut: Linear;
static easeNone: Linear;
static easeOut: Linear;
}
export class Quad extends Ease {
static easeIn: Quad;
static easeInOut: Quad;
static easeOut: Quad;
}
export class Quart extends Ease {
static easeIn: Quart;
static easeInOut: Quart;
static easeOut: Quart;
}
export class Quint extends Ease {
static easeIn: Quint;
static easeInOut: Quint;
static easeOut: Quint;
}
export class Sine extends Ease {
static easeIn: Sine;
static easeInOut: Sine;
static easeOut: Sine;
}
export class SlowMo extends Ease {
static ease: SlowMo;
config(linearRatio: number, power: number, yoyoMode: boolean): SlowMo;
}
export class SteppedEase extends Ease {
constructor(staps: number);
config(steps: number): SteppedEase;
}
export interface RoughEaseConfig {
clamp?: boolean;
points?: number;
randomize?: boolean;
strength?: number;
taper?: 'in' | 'out' | 'both' | 'none';
template?: Ease;
}
export class RoughEase extends Ease {
static ease: RoughEase;
constructor(vars: RoughEaseConfig);
config(steps?: number): RoughEase;
}
export var Power0: typeof Linear;
export var Power1: typeof Quad;
export var Power2: typeof Cubic;
export var Power3: typeof Quart;
export var Power4: typeof Quint;
export var Strong: typeof Quint;
}
gsap/Plugins.d.ts
Vendored
+15
View File
@@ -0,0 +1,15 @@
declare namespace gsap {
export interface BezierPlugin extends TweenPlugin {
bezierThrough(values: any[], curviness?: number, quadratic?: boolean, correlate?: string, prepend?: {}, calcDifs?: boolean): {};
cubicToQuadratic(a: number, b: number, c: number, d: number): any[];
quadraticToCubic(a: number, b: number, c: number): {};
}
export interface CSSRulePlugin extends TweenPlugin {
getRule(selector: string): {};
}
export interface TweenPlugin {
activate(plugins: any[]): boolean;
}
}
gsap/Timeline.d.ts
Vendored
+119
View File
@@ -0,0 +1,119 @@
declare namespace gsap {
export type Timeline = SimpleTimeline | TimelineLite | TimelineMax;
export class SimpleTimeline extends Animation {
/** SimpleTimeline is the base class for TimelineLite and TimelineMax, providing the most basic timeline () => voidality and it is used for the root timelines in TweenLite but is only intended for internal use in the GreenSock tweening platform. It is meant to be very fast and lightweight. */
constructor(vars?: any);
/** If true, child tweens/timelines will be removed as soon as they complete. */
autoRemoveChildren: boolean;
/** Controls whether or not child tweens/timelines are repositioned automatically (changing their startTime) in order to maintain smooth playback when properties are changed on-the-fly. */
smoothChildTiming: boolean;
/** Adds a TweenLite, TweenMax, TimelineLite, or TimelineMax instance to the timeline at a specific time. */
add(child: any, position?: any, align?: string, stagger?: number): SimpleTimeline;
/** renders */
render(time: number, suppressEvents?: boolean, force?: boolean): SimpleTimeline;
}
export class TimelineLite extends SimpleTimeline {
constructor(vars?: {});
/** Adds a tween, timeline, callback, or label (or an array of them) to the timeline. */
add(value: any, position?: any, align?: string, stagger?: number): TimelineLite;
/** Adds a label to the timeline, making it easy to mark important positions/times. */
addLabel(label: string, position: any): TimelineLite;
/** Inserts a special callback that pauses playback of the timeline at a particular time or label. */
addPause(position?: any, callback?: () => void, params?: any[], scope?: any): TimelineLite;
/** Adds a callback to the end of the timeline (or elsewhere using the "position" parameter) - this is a convenience method that accomplishes exactly the same thing as add( TweenLite.delayedCall(...) ) but with less code. */
call(callback: () => void, params?: any[], scope?: any, position?: any): TimelineLite;
/** Empties the timeline of all tweens, timelines, and callbacks (and optionally labels too). */
clear(labels?: boolean): TimelineLite;
/** Returns the time at which the animation will finish according to the parent timeline's local time. */
endTime(includeRepeats?: boolean): number;
/** Seamlessly transfers all tweens, timelines, and [optionally] delayed calls from the root timeline into a new TimelineLite so that you can perform advanced tasks on a seemingly global basis without affecting tweens/timelines that you create after the export. */
static exportRoot(vars?: {}, omitDelayedCalls?: boolean): TimelineLite;
/** Adds a TweenLite.from() tween to the end of the timeline (or elsewhere using the "position" parameter) - this is a convenience method that accomplishes exactly the same thing as add( TweenLite.from(...) ) but with less code. */
from(target: {}, duration: number, vars: {}, position?: any): TimelineLite;
/** Adds a TweenLite.fromTo() tween to the end of the timeline - this is a convenience method that accomplishes exactly the same thing as add( TweenLite.fromTo(...) ) but with less code. */
fromTo(target: {}, duration: number, fromVars: {}, toVars: {}, position?: any): TimelineLite;
/** Returns an array containing all the tweens and/or timelines nested in this timeline. */
getChildren(nested?: boolean, tweens?: boolean, timelines?: boolean, ignoreBeforeTime?: number): Array<Tween | Timeline>;
/** Returns the time associated with a particular label. */
getLabelTime(label: string): number;
/** Returns the tweens of a particular object that are inside this timeline. */
getTweensOf(target: {}, nested?: boolean): Tween[];
/** Clears any initialization data (like starting/ending values in tweens) which can be useful if, for example, you want to restart a tween without reverting to any previously recorded starting values. */
invalidate(): TimelineLite;
/** Returns the most recently added child tween/timeline/callback regardless of its position in the timeline. */
recent(): Animation;
/** Removes a tween, timeline, callback, or label (or array of them) from the timeline. */
remove(value: any): TimelineLite;
/** Removes a label from the timeline and returns the time of that label. */
removeLabel(label: string): any;
/** Jumps to a specific time (or label) without affecting whether or not the instance is paused or reversed. */
seek(position: string | number, supressEvents: boolean): TimelineLite;
/** Adds a zero-duration tween to the end of the timeline (or elsewhere using the "position" parameter) that sets values immediately (when the virtual playhead reaches that position on the timeline) - this is a convenience method that accomplishes exactly the same thing as add( TweenLite.to(target, 0, {...}) ) but with less code. */
set(target: {}, vars: {}, position?: any): TimelineLite;
/** Shifts the startTime of the timeline's children by a certain amount and optionally adjusts labels too. */
shiftChildren(amount: number, adjustLabels?: boolean, ignoreBeforeTime?: number): TimelineLite;
/** Tweens an array of targets from a common set of destination values (using the current values as the destination), but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. */
staggerFrom(targets: any, duration: number, vars: {}, stagger?: number, position?: any, onCompleteAll?: () => void, onCompleteAllParams?: any[], onCompleteScope?: any): TimelineLite;
/** Tweens an array of targets from and to a common set of values, but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. */
staggerFromTo(targets: any, duration: number, fromVars: {}, toVars: {}, stagger?: number, position?: any, onCompleteAll?: () => void, onCompleteAllParams?: any[], onCompleteAllScope?: any): TimelineLite;
/** Tweens an array of targets to a common set of destination values, but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. */
staggerTo(targets: any, duration: number, vars: {}, stagger: number, position?: any, onCompleteAll?: () => void, onCompleteAllParams?: any[], onCompleteAllScope?: any): TimelineLite;
/** Adds a TweenLite.to() tween to the end of the timeline (or elsewhere using the "position" parameter) - this is a convenience method that accomplishes exactly the same thing as add( TweenLite.to(...) ) but with less code. */
to(target: {}, duration: number, vars: {}, position?: any): TimelineLite;
usesFrames(): boolean;
/** If true, the timeline's timing mode is frames-based instead of seconds. */
useFrames(): boolean;
}
export class TimelineMax extends TimelineLite {
constructor(vars?: {});
addCallback(callback: () => void, position: any, params?: any[], scope?: any): TimelineMax;
currentLabel(): string;
currentLabel(value: string): TimelineMax;
getActive(nested?: boolean, tweens?: boolean, timelines?: boolean): Tween | Timeline[];
getLabelAfter(time: number): string;
getLabelBefore(time: number): string;
getLabelsArray(): Array<{ name: string; time: number; }>;
removeCallback(callback: () => void, timeOrLabel?: any): TimelineMax;
removePause(position: any): TimelineMax;
repeat(): number;
repeat(value: number): TimelineMax;
repeatDelay(): number;
repeatDelay(value: number): TimelineMax;
tweenFromTo(fromPosition: any, toPosition: any, vars?: {}): TweenLite;
tweenTo(position: any, vars?: {}): TweenLite;
yoyo(): boolean;
yoyo(value: boolean): TimelineMax;
}
}
gsap/Tween.d.ts
Vendored
+127
View File
@@ -0,0 +1,127 @@
declare namespace gsap {
export type Tween = TweenLite | TweenMax;
export class TweenLite extends Animation {
constructor(target: any, duration: number, vars: any);
/** Provides An easy way to change the default easing equation. */
static defaultEase: Ease;
/** Provides An easy way to change the default overwrite mode. */
static defaultOverwrite: string;
/** The selector engine (like jQuery) that should be used when a tween receives a string as its target, like TweenLite.to("#myID", 1, {x:"100px"}). */
static selector: (query: string) => any;
/** Target object (or array of objects) whose properties the tween affects. */
readonly target: any;
/** The object that dispatches a "tick" event each time the engine updates, making it easy for you to add your own listener(s) to run custom logic after each update (great for game developers). */
static ticker: any;
/** Provides a simple way to call a () => void after a set amount of time (or frames). */
static delayedCall(delay: number, callback: () => void, params?: any[], scope?: any, useFrames?: boolean): TweenLite;
/** Static method for creating a TweenLite instance that tweens backwards - you define the BEGINNING values and the current values are used as the destination values which is great for doing things like animating objects onto the screen because you can set them up initially the way you want them to look at the end of the tween and then animate in from elsewhere. */
static from(target: any, duration: number, vars: any): TweenLite;
/** Static method for creating a TweenLite instance that allows you to define both the starting and ending values (as opposed to to() and from() tweens which are based on the target's current values at one end or the other). */
static fromTo(target: any, duration: number, fromVars: any, toVars: any): TweenLite;
/** Returns an array containing all the tweens of a particular target (or group of targets) that have not been released for garbage collection yet which typically happens within a few seconds after the tween completes. */
static getTweensOf(target: any, onlyActive?: boolean): TweenLite[];
/** [override] Clears any initialization data (like starting/ending values in tweens) which can be useful if, for example, you want to restart a tween without reverting to any previously recorded starting values. */
invalidate(): TweenLite;
/** Immediately kills all of the delayedCalls to a particular () => void. */
static killDelayedCallsTo(func: () => void): void;
/** Kills all the tweens (or specific tweening properties) of a particular object or delayedCalls to a particular () => void. */
static killTweensOf(target: any, onlyActive?: boolean, vars?: any): void;
/** Permits you to control what happens when too much time elapses between two ticks (updates) of the engine, adjusting the core timing mechanism to compensate and avoid "jumps". */
static lagSmoothing(threshold: number, adjustedLag: number): void;
/** Forces a render of all active tweens which can be useful if, for example, you set up a bunch of from() tweens and then you need to force an immediate render (even of "lazy" tweens) to avoid a brief delay before things render on the very next tick. */
static render(): void;
/** Immediately sets properties of the target accordingly - essentially a zero-duration to() tween with a more intuitive name. */
static set(target: any, vars: any): TweenLite;
/** Static method for creating a TweenLite instance that animates to the specified destination values (from the current values). */
static to(target: any, duration: number, vars: any): TweenLite;
}
export class TweenMax extends TweenLite {
constructor(target: {}, duration: number, vars: {});
/** Provides a simple way to call a () => void after a set amount of time (or frames). */
static delayedCall(delay: number, callback: () => void, params?: any[], scope?: {}, useFrames?: boolean): TweenMax;
/** Static method for creating a TweenMax instance that tweens backwards - you define the BEGINNING values and the current values are used as the destination values which is great for doing things like animating objects onto the screen because you can set them up initially the way you want them to look at the end of the tween and then animate in from elsewhere. */
static from(target: {}, duration: number, vars: {}): TweenMax;
/** Static method for creating a TweenMax instance that allows you to define both the starting and ending values (as opposed to to() and from() tweens which are based on the target's current values at one end or the other). */
static fromTo(target: {}, duration: number, fromVars: {}, toVars: {}): TweenMax;
/** Returns an array containing all tweens (and optionally timelines too, excluding the root timelines). */
static getAllTweens(includeTimelines?: boolean): Tween[];
/** Returns an array containing all the tweens of a particular target (or group of targets) that have not been released for garbage collection yet which typically happens within a few seconds after the tween completes. */
static getTweensOf(target: {}): Tween[];
/** Gets or sets the global timeScale which is a multiplier that affects ALL animations equally. This is a great way to globally speed up or slow down all animations at once. */
static globalTimeScale(value: number): void;
/** Reports whether or not a particular object is actively tweening. */
static isTweening(target: {}): boolean;
/** Kills all tweens and/or delayedCalls/callbacks, and/or timelines, optionally forcing them to completion first. */
static killAll(complete?: boolean, tweens?: boolean, delayedCalls?: boolean, timelines?: boolean): void;
/** Kills all tweens of the children of a particular DOM element, optionally forcing them to completion first. */
static killChildTweensOf(parent: any, complete?: boolean): void;
/** Immediately kills all of the delayedCalls to a particular () => void. */
static killDelayedCallsTo(func: () => void): void;
/** Kills all the tweens (or specific tweening properties) of a particular object or the delayedCalls to a particular () => void. */
static killTweensOf(target: {}, vars?: {}): void;
/** Pauses all tweens and/or delayedCalls/callbacks and/or timelines. */
static pauseAll(tweens?: boolean, delayedCalls?: boolean, timelines?: boolean): void;
/** Gets or sets the tween's progress which is a value between 0 and 1 indicating the position of the virtual playhead (excluding repeats) where 0 is at the beginning, 0.5 is halfway complete, and 1 is complete. */
repeat(): number;
repeat(value: number): TweenMax;
/** Gets or sets the amount of time in seconds (or frames for frames-based tweens) between repeats. */
repeatDelay(): number;
repeatDelay(value: number): TweenMax;
/** Resumes all paused tweens and/or delayedCalls/callbacks and/or timelines. */
static resumeAll(tweens?: boolean, delayedCalls?: boolean, timelines?: boolean): void;
/** Immediately sets properties of the target accordingly - essentially a zero-duration to() tween with a more intuitive name. */
static set(target: {}, vars: {}): TweenMax;
/** Tweens an array of targets from a common set of destination values (using the current values as the destination), but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. */
static staggerFrom(targets: any, duration: number, vars: {}, stagger: number, onCompleteAll?: () => void, onCompleteAllParams?: any[], onCompleteAllScope?: any): any[];
/** Tweens an array of targets from a common set of destination values to a common set of destination values, but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. */
static staggerFromTo(targets: any, duration: number, fromVars: {}, toVars: {}, stagger: number, onCompleteAll?: () => void, onCompleteAllParams?: any[], onCompleteAllScope?: any): any[];
/** Tweens an array of targets to a common set of destination values, but staggers their start times by a specified amount of time, creating an evenly-spaced sequence with a surprisingly small amount of code. */
static staggerTo(targets: any, duration: number, vars: {}, stagger: number, onCompleteAll?: () => void, onCompleteAllParams?: any[], onCompleteAllScope?: any): any[];
/** Static method for creating a TweenMax instance that animates to the specified destination values (from the current values). */
static to(target: {}, duration: number, vars: TweenConfig): TweenMax;
/** Updates tweening values on the fly so that they appear to seamlessly change course even if the tween is in-progress. */
updateTo(vars: {}, resetDuration?: boolean): TweenMax;
/** Gets or sets the tween's yoyo state, where true causes the tween to go back and forth, alternating backward and forward on each repeat. */
yoyo(): boolean;
yoyo(value?: boolean): TweenMax;
}
}
gsap/TweenConfig.d.ts
Vendored
+82
View File
@@ -0,0 +1,82 @@
declare namespace gsap {
export interface TweenConfig {
/** Amount of delay in seconds (or frames for frames-based tweens) before the animation should begin.*/
delay?: number;
/** Ease (or () => void or String) - You can choose from various eases to control the rate of change during the animation, giving it a specific "feel". */
ease?: Ease;
yoyo?: boolean;
/** If true, the tween will pause itself immediately upon creation. */
paused?: boolean;
/** Controls how (and if) other tweens of the same target are overwritten. There are several modes to choose from, but "auto" is the default (although you can change the default mode using theTweenLite.defaultOverwrite property) */
overwrite?: string | number;
/** A () => void that should be called when the animation has completed. */
onComplete?: () => void;
/** An Array of parameters to pass the onComplete () => void */
onCompleteParams?: any[];
/** Defines the scope of the onComplete () => void (what "this" refers to inside that () => void). */
onCompleteScope?: {};
/** Normally when you create a tween, it begins rendering on the very next frame (update cycle) unless you specify a delay. However, if you prefer to force the tween to render immediately when it is created, setimmediateRender to true. Or to prevent a from() from rendering immediately, set immediateRender to false. By default, from() tweens set immediateRender to true. */
immediateRender?: boolean;
/** A () => void that should be called when the tween has reached its beginning again from the reverse direction. */
onReverseComplete?: () => void;
/** An Array of parameters to pass the onReverseComplete () => void. */
onReverseCompleteParams?: any[];
/** Defines the scope of the onReverseComplete () => void (what "this" refers to inside that () => void). */
onReverseCompleteScope?: {};
/** A () => void that should be called when the tween begins (when its time changes from 0 to some other value which can happen more than once if the tween is restarted multiple times). */
onStart?: () => void;
/** An Array of parameters to pass the onStart () => void. */
onStartParams?: any[];
/** Defines the scope of the onStart () => void (what "this" refers to inside that () => void). */
onStartScope?: {};
/** A () => void that should be called every time the animation updates (on every frame while the animation is active). */
onUpdate?: () => void;
/** An Array of parameters to pass the onUpdate () => void. */
onUpdateParams?: any[];
/** Defines the scope of the onUpdate () => void (what "this" refers to inside that () => void). */
onUpdateScope?: {};
/** If useFrames is true, the tweens's timing will be based on frames instead of seconds because it is intially added to the root frames-based timeline. This causes both its duration and delay to be based on frames. An animations's timing mode is always determined by its parent timeline. */
useFrames?: boolean;
/** When a tween renders for the very first time and reads its starting values, GSAP will automatically "lazy render" that particular tick by default, meaning it will try to delay the rendering (writing of values) until the very end of the "tick" cycle which can improve performance because it avoids the read/write/read/write layout thrashing that some browsers do. If you would like to disable lazy rendering for a particular tween, you can set lazy:false. Or, since zero-duration tweens do not lazy-render by default, you can specifically give it permission to lazy-render by setting lazy:true like TweenLite.set(element, {opacity:0, lazy:true});. In most cases, you won't need to set lazy. */
lazy?: boolean;
/** A () => void that should be called when the tween gets overwritten by another tween. */
onOverwrite?: () => void;
/** If true atuomatically populates the css property for tween on DOM elements */
autoCSS?: boolean;
/** The scope to be used for all of the callbacks (onStart, onUpdate, onComplete, etc.). The scope is what "this" refers to inside any of the callbacks. */
callbackScope?: {};
startAt?: {};
repeat?: number;
repeatDelay?: number;
onRepeat?: () => void;
onRepeatScope?: {};
}
}
gsap/TweenLite.d.ts
Vendored
-122
View File
@@ -1,122 +0,0 @@
declare class TweenLite {
constructor(target: any, duration: number, vars: any);
/** Provides An easy way to change the default easing equation. */
static defaultEase: Ease;
/** Provides An easy way to change the default overwrite mode. */
static defaultOverwrite: string;
/** The selector engine (like jQuery) that should be used when a tween receives a string as its target, like TweenLite.to("#myID", 1, {x:"100px"}). */
static selector: (query: string) => any;
/** [READ-ONLY] Target object (or array of objects) whose properties the tween affects. */
target: any;
/** The object that dispatches a "tick" event each time the engine updates, making it easy for you to add your own listener(s) to run custom logic after each update (great for game developers). */
static ticker: any;
/** Provides a simple way to call a function after a set amount of time (or frames). */
static delayedCall(delay: number, callback: Function, params?: any[], scope?: any, useFrames?: boolean): TweenLite;
/** Static method for creating a TweenLite instance that tweens backwards - you define the BEGINNING values and the current values are used as the destination values which is great for doing things like animating objects onto the screen because you can set them up initially the way you want them to look at the end of the tween and then animate in from elsewhere. */
static from(target: any, duration: number, vars: any): TweenLite;
/** Static method for creating a TweenLite instance that allows you to define both the starting and ending values (as opposed to to() and from() tweens which are based on the target's current values at one end or the other). */
static fromTo(target: any, duration: number, fromVars: any, toVars: any): TweenLite;
/** Returns an array containing all the tweens of a particular target (or group of targets) that have not been released for garbage collection yet which typically happens within a few seconds after the tween completes. */
static getTweensOf(target: any, onlyActive?: boolean): TweenLite[];
/** [override] Clears any initialization data (like starting/ending values in tweens) which can be useful if, for example, you want to restart a tween without reverting to any previously recorded starting values. */
invalidate(): TweenLite;
/** Immediately kills all of the delayedCalls to a particular function. */
static killDelayedCallsTo(func: Function): void;
/** Kills all the tweens (or specific tweening properties) of a particular object or delayedCalls to a particular function. */
static killTweensOf(target: any, onlyActive?: boolean, vars?: any): void;
/** Permits you to control what happens when too much time elapses between two ticks (updates) of the engine, adjusting the core timing mechanism to compensate and avoid "jumps". */
static lagSmoothing(threshold: number, adjustedLag: number): void;
/** Forces a render of all active tweens which can be useful if, for example, you set up a bunch of from() tweens and then you need to force an immediate render (even of "lazy" tweens) to avoid a brief delay before things render on the very next tick. */
static render(): void;
/** Immediately sets properties of the target accordingly - essentially a zero-duration to() tween with a more intuitive name. */
static set(target: any, vars: any): TweenLite;
/** Static method for creating a TweenLite instance that animates to the specified destination values (from the current values). */
static to(target: any, duration: number, vars: any): TweenLite;
// INHERITANCE FROM ANIMATION
/** Gets or sets the animation's initial delay which is the length of time in seconds (or frames for frames-based tweens) before the animation should begin. */
delay(): number;
delay(value: number): TweenLite;
/** Gets or sets the animation's duration, not including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
duration(): number;
duration(value: number): TweenLite;
/** Gets or sets an event callback like "onComplete", "onUpdate", "onStart", "onReverseComplete" or "onRepeat" (onRepeat only applies to TweenMax or TimelineMax instances) along with any parameters that should be passed to that callback. */
eventCallback(type: string): Function;
eventCallback(type: string, callback: Function, params?: any[], scope?: any): TweenLite;
/** Kills the animation entirely or in part depending on the parameters. */
kill(vars?: any, target?: any): TweenLite;
/** Pauses the instance, optionally jumping to a specific time. */
pause(atTime?: any, suppressEvents?: boolean): TweenLite;
/** Gets or sets the animation's paused state which indicates whether or not the animation is currently paused. */
paused(): boolean;
paused(value: boolean): TweenLite;
/** Begins playing forward, optionally from a specific time (by default playback begins from wherever the playhead currently is). */
play(from?: any, suppressEvents?: boolean): TweenLite;
/** Gets or sets the animations's progress which is a value between 0 and 1 indicating the position of the virtual playhead (excluding repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
progress(): number;
progress(value: number, suppressEvents?: boolean): TweenLite;
/** Restarts and begins playing forward from the beginning. */
restart(includeDelay?: boolean, suppressEvents?: boolean): TweenLite;
/** Resumes playing without altering direction (forward or reversed), optionally jumping to a specific time first. */
resume(from?: any, suppressEvents?: boolean): TweenLite;
/** Reverses playback so that all aspects of the animation are oriented backwards including, for example, a tween's ease. */
reverse(from?: any, suppressEvents?: boolean): TweenLite;
/** Gets or sets the animation's reversed state which indicates whether or not the animation should be played backwards. */
reversed(): boolean;
reversed(value: boolean): TweenLite;
/** Jumps to a specific time without affecting whether or not the instance is paused or reversed. */
seek(time: any, suppressEvents?: boolean): TweenLite;
/** Gets or sets the time at which the animation begins on its parent timeline (after any delay that was defined). */
startTime(): number;
startTime(value: number): TweenLite;
/** Gets or sets the local position of the playhead (essentially the current time), described in seconds (or frames for frames-based animations) which will never be less than 0 or greater than the animation's duration. */
time(): number;
time(value: number, suppressEvents?: boolean): TweenLite;
/** Factor that's used to scale time in the animation where 1 = normal speed (the default), 0.5 = half speed, 2 = double speed, etc. */
timeScale(): number;
timeScale(value: number): TweenLite;
/** Gets or sets the animation's total duration including any repeats or repeatDelays (which are only available in TweenMax and TimelineMax). */
totalDuration(): number;
totalDuration(value: number): TweenLite;
/** Gets or sets the animation's total progress which is a value between 0 and 1 indicating the position of the virtual playhead (including repeats) where 0 is at the beginning, 0.5 is at the halfway point, and 1 is at the end (complete). */
totalProgress(): number;
totalProgress(value: number, suppressEvents?: boolean): TweenLite;
/** Gets or sets the position of the playhead according to the totalDuration which includes any repeats and repeatDelays (only available in TweenMax and TimelineMax). */
totalTime(): number;
totalTime(time: number, suppressEvents?: boolean): TweenLite;
}
gsap/gsap-tests.ts
+2 -2
View File
@@ -1,8 +1,8 @@
import { TweenLite } from 'gsap';
var tween = TweenLite
.to(document.getElementById('some-div'), 1, {
width: '200px',
height: '200px'
})
.seek(0.5);
.seek(0.5);
gsap/index.d.ts
Vendored
+10 -5
View File
@@ -1,10 +1,15 @@
// Type definitions for GSAP v1.19
// Type definitions for GSAP 1.19
// Project: http://greensock.com/
// Definitions by: VILIC VANE <https://vilic.github.io/>
// Definitions by: VILIC VANE <https://vilic.github.io/>, Robert S <https://github.com/codebelt>, Richard Fox <https://github.com/ProbablePrime>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference path="Core.d.ts"/>
/// <reference path="Animation.d.ts"/>
/// <reference path="Ease.d.ts"/>
/// <reference path="TweenLite.d.ts"/>
/// <reference path="TweenConfig.d.ts"/>
/// <reference path="Tween.d.ts"/>
/// <reference path="Timeline.d.ts"/>
/// <reference path="Plugins.d.ts"/>
export = TweenLite;
declare module 'gsap' {
export = gsap;
}
gsap/tslint.json
+6
View File
@@ -0,0 +1,6 @@
{
"extends": "../tslint.json",
"rules": {
"no-single-declare-module": false
}
}