From b3d5f7e64a34a6637198502c58b4b63bb8d114fb Mon Sep 17 00:00:00 2001 From: Arthur Langereis Date: Tue, 6 Oct 2015 14:50:10 +0200 Subject: [PATCH 001/184] add missing optional attributes parameter for getContext() and missing context attribute defs, thanks to @ander-nz --- webgl-ext/webgl-ext.d.ts | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/webgl-ext/webgl-ext.d.ts b/webgl-ext/webgl-ext.d.ts index c6a8cb34a1..42a4ee21b8 100644 --- a/webgl-ext/webgl-ext.d.ts +++ b/webgl-ext/webgl-ext.d.ts @@ -6,9 +6,19 @@ // These definitions go beyond those already defined in TS 1.6.2 stdlib // All non-draft WebGL 1.0 extensions and prefixed extension names are // covered. +// Some missing parameters for getContext and fields for +// WebGLContextAttributes are added as well, copied over from +// Shane Anderson's webgl interfaces. + + +interface WebGLContextAttributes { + preferLowPowerToHighPerformance?: boolean; + failIfMajorPerformanceCaveat?: boolean; +} interface HTMLCanvasElement { - getContext(contextId: "webgl"): WebGLRenderingContext; + getContext(contextId: "experimental-webgl", attributes?: WebGLContextAttributes): WebGLRenderingContext; + getContext(contextId: "webgl", attributes?: WebGLContextAttributes): WebGLRenderingContext; } interface WebGLRenderingContext { From 09218a9c29af6d9b887c8b9bf593001e737addf2 Mon Sep 17 00:00:00 2001 From: Arthur Langereis Date: Wed, 7 Oct 2015 10:55:34 +0200 Subject: [PATCH 002/184] name update --- webgl-ext/webgl-ext.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/webgl-ext/webgl-ext.d.ts b/webgl-ext/webgl-ext.d.ts index 42a4ee21b8..5be2ee07c3 100644 --- a/webgl-ext/webgl-ext.d.ts +++ b/webgl-ext/webgl-ext.d.ts @@ -8,7 +8,7 @@ // covered. // Some missing parameters for getContext and fields for // WebGLContextAttributes are added as well, copied over from -// Shane Anderson's webgl interfaces. +// Shane S. Anderson's definitions file. interface WebGLContextAttributes { From 09ca290d319700137d9a5fc66ce9f39f5813fee5 Mon Sep 17 00:00:00 2001 From: Arthur Langereis Date: Wed, 7 Oct 2015 11:15:03 +0200 Subject: [PATCH 003/184] add pre-defined attrs and link to spec for WebGLContextAttributes --- webgl-ext/webgl-ext.d.ts | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/webgl-ext/webgl-ext.d.ts b/webgl-ext/webgl-ext.d.ts index 5be2ee07c3..f29d2c98d2 100644 --- a/webgl-ext/webgl-ext.d.ts +++ b/webgl-ext/webgl-ext.d.ts @@ -6,14 +6,28 @@ // These definitions go beyond those already defined in TS 1.6.2 stdlib // All non-draft WebGL 1.0 extensions and prefixed extension names are // covered. -// Some missing parameters for getContext and fields for +// Some missing parameters for getContext and attributes for // WebGLContextAttributes are added as well, copied over from // Shane S. Anderson's definitions file. interface WebGLContextAttributes { + // The following attributes are missing from TypeScript 1.6.2's lib.d.ts preferLowPowerToHighPerformance?: boolean; failIfMajorPerformanceCaveat?: boolean; + + // All others duplicated here for reference + /* + alpha?: boolean; + depth?: boolean; + stencil?: boolean; + antialias?: boolean; + premultipliedAlpha?: boolean; + preserveDrawingBuffer?: boolean; + */ + + // For the meanings and default values of these attributes, see the full spec at: + // https://www.khronos.org/registry/webgl/specs/latest/1.0/index.html#5.2 } interface HTMLCanvasElement { From b8cf52577da3742ff0310d5748ec74b8bf6143d4 Mon Sep 17 00:00:00 2001 From: Leonardo Melo Date: Mon, 15 Oct 2018 11:13:50 +0100 Subject: [PATCH 004/184] Update TweenMax.globalTimeScale typing As per the code in [gsap's repo](https://github.com/greensock/GreenSock-JS/blob/1.20.5/src/uncompressed/TweenMax.js#L545-L558) the type defition for TweenMax.globalTimeScale needed updating. --- types/gsap/Tween.d.ts | 2 +- types/gsap/index.d.ts | 10 +++++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/types/gsap/Tween.d.ts b/types/gsap/Tween.d.ts index b11260ef4c..b587ea3e75 100644 --- a/types/gsap/Tween.d.ts +++ b/types/gsap/Tween.d.ts @@ -71,7 +71,7 @@ declare namespace gsap { 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; + static globalTimeScale(value?: number): number; /** Reports whether or not a particular object is actively tweening. */ static isTweening(target: {}): boolean; diff --git a/types/gsap/index.d.ts b/types/gsap/index.d.ts index 77d589603a..5e3081cc6a 100644 --- a/types/gsap/index.d.ts +++ b/types/gsap/index.d.ts @@ -1,6 +1,10 @@ -// Type definitions for GSAP 1.19 +// Type definitions for GSAP 1.20.6 // Project: http://greensock.com/ -// Definitions by: VILIC VANE , Robert S , Richard Fox , Philip Bulley +// Definitions by: VILIC VANE , +// Robert S , +// Richard Fox , +// Philip Bulley , +// Leonardo Melo // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// @@ -10,6 +14,6 @@ /// /// -declare module 'gsap' { +declare module "gsap" { export = gsap; } From f8a1d6645d5995315fa510e30bd76232bad92890 Mon Sep 17 00:00:00 2001 From: Leonardo Melo Date: Tue, 16 Oct 2018 11:09:50 +0100 Subject: [PATCH 005/184] Multiple linter fixes to gsap definition files --- types/gsap/Animation.d.ts | 66 ++++++++++------- types/gsap/Ease.d.ts | 52 +++++++------- types/gsap/Plugins.d.ts | 6 +- types/gsap/Timeline.d.ts | 122 +++++++++++++++++++++---------- types/gsap/Tween.d.ts | 139 ++++++++++++++++++++++++------------ types/gsap/TweenConfig.d.ts | 59 ++++++++------- 6 files changed, 282 insertions(+), 162 deletions(-) diff --git a/types/gsap/Animation.d.ts b/types/gsap/Animation.d.ts index 3c58f9b12a..8307392b11 100644 --- a/types/gsap/Animation.d.ts +++ b/types/gsap/Animation.d.ts @@ -1,89 +1,103 @@ 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. */ + 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). */ + /* A place to store any data you want (initially populated with vars.data if it exists). */ data: any; - /** [Read-only] Parent timeline. */ + /* [Read-only] Parent timeline. */ timeline: SimpleTimeline; - /** The vars object passed into the constructor which stores configuration variables like onComplete, onUpdate, etc. */ + /* 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. */ + /* 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). */ + /* 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. */ + /* 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. */ + /* 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). */ + /* 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. */ + /* Kills the animation entirely or in part depending on the parameters. */ kill(vars?: {}, target?: {}): Animation; - /** Pauses the instance, optionally jumping to a specific time. */ + /* 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. */ + /* 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). */ + /* 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). */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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). */ + /* 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. */ + /* 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. */ + /* 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). */ + /* 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). */ + /* 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). */ + /* 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; } diff --git a/types/gsap/Ease.d.ts b/types/gsap/Ease.d.ts index ea2d7e1d84..56603b5ed1 100644 --- a/types/gsap/Ease.d.ts +++ b/types/gsap/Ease.d.ts @@ -1,52 +1,51 @@ declare namespace gsap { - export class Ease { + 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; } - export class EaseLookup { - static find(name: string): Ease; + interface EaseLookup { + find(name: string): Ease; } - export class Back extends Ease { + class Back extends Ease { static easeIn: Back; static easeInOut: Back; static easeOut: Back; config(overshoot: number): Elastic; - } - export class Bounce extends Ease { + class Bounce extends Ease { static easeIn: Bounce; static easeInOut: Bounce; static easeOut: Bounce; } - export class Circ extends Ease { + class Circ extends Ease { static easeIn: Circ; static easeInOut: Circ; static easeOut: Circ; } - export class Cubic extends Ease { + class Cubic extends Ease { static easeIn: Cubic; static easeInOut: Cubic; static easeOut: Cubic; } - export class Elastic extends Ease { + class Elastic extends Ease { static easeIn: Elastic; static easeInOut: Elastic; static easeOut: Elastic; config(amplitude: number, period: number): Elastic; } - export class Expo extends Ease { + class Expo extends Ease { static easeIn: Expo; static easeInOut: Expo; static easeOut: Expo; } - export class Linear extends Ease { + class Linear extends Ease { static ease: Linear; static easeIn: Linear; static easeInOut: Linear; @@ -54,60 +53,59 @@ declare namespace gsap { static easeOut: Linear; } - export class Quad extends Ease { + class Quad extends Ease { static easeIn: Quad; static easeInOut: Quad; static easeOut: Quad; } - export class Quart extends Ease { + class Quart extends Ease { static easeIn: Quart; static easeInOut: Quart; static easeOut: Quart; } - export class Quint extends Ease { + class Quint extends Ease { static easeIn: Quint; static easeInOut: Quint; static easeOut: Quint; } - export class Sine extends Ease { + class Sine extends Ease { static easeIn: Sine; static easeInOut: Sine; static easeOut: Sine; } - export class SlowMo extends Ease { + class SlowMo extends Ease { static ease: SlowMo; config(linearRatio: number, power: number, yoyoMode: boolean): SlowMo; } - export class SteppedEase extends Ease { + class SteppedEase extends Ease { constructor(staps: number); config(steps: number): SteppedEase; } - export interface RoughEaseConfig { + interface RoughEaseConfig { clamp?: boolean; points?: number; randomize?: boolean; strength?: number; - taper?: 'in' | 'out' | 'both' | 'none'; + taper?: "in" | "out" | "both" | "none"; template?: Ease; } - export class RoughEase extends Ease { + 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; + const Power0: typeof Linear; + const Power1: typeof Quad; + const Power2: typeof Cubic; + const Power3: typeof Quart; + const Power4: typeof Quint; + const Strong: typeof Quint; } diff --git a/types/gsap/Plugins.d.ts b/types/gsap/Plugins.d.ts index d7ceca7bf8..3d6e3db73e 100644 --- a/types/gsap/Plugins.d.ts +++ b/types/gsap/Plugins.d.ts @@ -1,15 +1,15 @@ declare namespace gsap { - export interface BezierPlugin extends TweenPlugin { + 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 { + interface CSSRulePlugin extends TweenPlugin { getRule(selector: string): {}; } - export interface TweenPlugin { + interface TweenPlugin { activate(plugins: any[]): boolean; } } diff --git a/types/gsap/Timeline.d.ts b/types/gsap/Timeline.d.ts index 9d14b2d4c5..a51876375d 100644 --- a/types/gsap/Timeline.d.ts +++ b/types/gsap/Timeline.d.ts @@ -1,101 +1,149 @@ declare namespace gsap { - export type Timeline = SimpleTimeline | TimelineLite | TimelineMax; + 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. */ + 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. */ + /* 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. */ + /* 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. */ + /* 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 */ + /* renders */ render(time: number, suppressEvents?: boolean, force?: boolean): SimpleTimeline; } - export class TimelineLite extends SimpleTimeline { + class TimelineLite extends SimpleTimeline { constructor(vars?: {}); - /** Adds a tween, timeline, callback, or label (or an array of them) to the timeline. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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). */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* Returns an array containing all the tweens and/or timelines nested in this timeline. */ getChildren(nested?: boolean, tweens?: boolean, timelines?: boolean, ignoreBeforeTime?: number): Array; - /** Returns the time associated with a particular label. */ + /* Returns the time associated with a particular label. */ getLabelTime(label: string): number; - /** Returns the tweens of a particular object that are inside this timeline. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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 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 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; + /* 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. */ + /* 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. */ + /* If true, the timeline's timing mode is frames-based instead of seconds. */ useFrames(): boolean; } - export class TimelineMax extends TimelineLite { + class TimelineMax extends TimelineLite { constructor(vars?: {}); addCallback(callback: () => void, position: any, params?: any[], scope?: any): TimelineMax; @@ -104,7 +152,7 @@ declare namespace gsap { getActive(nested?: boolean, tweens?: boolean, timelines?: boolean): Tween | Timeline[]; getLabelAfter(time: number): string; getLabelBefore(time: number): string; - getLabelsArray(): Array<{ name: string; time: number; }>; + getLabelsArray(): Array<{ name: string; time: number }>; removeCallback(callback: () => void, timeOrLabel?: any): TimelineMax; removePause(position: any): TimelineMax; repeat(): number; diff --git a/types/gsap/Tween.d.ts b/types/gsap/Tween.d.ts index b587ea3e75..8481819567 100644 --- a/types/gsap/Tween.d.ts +++ b/types/gsap/Tween.d.ts @@ -1,126 +1,177 @@ declare namespace gsap { - export type Tween = TweenLite | TweenMax; - export class TweenLite extends Animation { + type Tween = TweenLite | TweenMax; + class TweenLite extends Animation { constructor(target: any, duration: number, vars: any); - /** Provides An easy way to change the default easing equation. */ + /* Provides An easy way to change the default easing equation. */ static defaultEase: Ease; - /** Provides An easy way to change the default overwrite mode. */ + /* 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"}). */ + /* 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. */ + /* 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). */ + /* 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). */ + /* 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 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 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. */ + /* 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. */ + /* [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. */ + /* 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. */ + /* 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". */ + /* 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. */ + /* 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. */ + /* 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 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 { + 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). */ + /* 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 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 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). */ + /* 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. */ + /* 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. */ + /* 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): number; - /** Reports whether or not a particular object is actively tweening. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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 (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 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[]; + /* 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 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. */ + /* 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. */ + /* 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; } diff --git a/types/gsap/TweenConfig.d.ts b/types/gsap/TweenConfig.d.ts index 33cde9c6ae..e99060fef9 100644 --- a/types/gsap/TweenConfig.d.ts +++ b/types/gsap/TweenConfig.d.ts @@ -1,75 +1,84 @@ declare namespace gsap { - export interface TweenConfig { - - /** Any tweenable property */ + interface TweenConfig { + /* Any tweenable property */ [p: string]: any; - /** Amount of delay in seconds (or frames for frames-based tweens) before the animation should begin.*/ + /* 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 (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. */ + /* 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) */ + /* 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. */ + /* A () => void that should be called when the animation has completed. */ onComplete?: () => void; - /** An Array of parameters to pass the 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). */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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). */ + /* 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). */ + /* 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. */ + /* 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). */ + /* 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). */ + /* 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. */ + /* 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). */ + /* 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. */ + /* 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. */ + /* 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. */ + /* 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 */ + /* 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. */ + /* 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?: {}; From 2a4a6d66af7020298689e7be6e2fa0398ef27b53 Mon Sep 17 00:00:00 2001 From: Eunchong Yu Date: Thu, 18 Oct 2018 00:41:51 +0900 Subject: [PATCH 006/184] [koa-websocket] Fix to match with its implementation (#29611) * Fix koa-websocket to match with its implementation The major change is about `Middleware`. Koa-websocket doesn't inject `this` argument to its middlewares. Instead, additional properties are appended on the Koa context. https://github.com/kudos/koa-websocket/blob/master/index.js * Extract Context.websocket It's necessary to use well with other middlewares, like koa-router or else. * Add Context.app to be able to access ctx.app.ws * Add a test about Context.app * Remove the target requirement --- types/koa-websocket/index.d.ts | 27 ++++++++++++++-------- types/koa-websocket/koa-websocket-tests.ts | 14 ++++++++--- types/koa-websocket/tsconfig.json | 2 +- 3 files changed, 30 insertions(+), 13 deletions(-) diff --git a/types/koa-websocket/index.d.ts b/types/koa-websocket/index.d.ts index 91b50b5ace..c23c9036b8 100644 --- a/types/koa-websocket/index.d.ts +++ b/types/koa-websocket/index.d.ts @@ -3,32 +3,41 @@ // Definitions by: Maël Lavault // Jaco Greeff // Martin Ždila +// Eunchong Yu // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.3 import Koa = require('koa'); +import compose = require('koa-compose'); import * as ws from 'ws'; import * as http from 'http'; import * as https from 'https'; -declare namespace KoaWebsocket { - type ConnectionHandler = (socket: ws) => void; - - type Middleware = (this: MiddlewareContext, context: Koa.Context, next: () => Promise) => any; - - interface MiddlewareContext extends Koa.Context { +declare module "koa" { + interface Context { websocket: ws; path: string; } +} + +declare namespace KoaWebsocket { + type Middleware = compose.Middleware; + + interface MiddlewareContext extends Koa.Context { + // Limitation: Declaration merging cannot overwrap existing properties. + // That's why this property is here, not in the merged declaration above. + app: App; + } class Server { - app: Koa; - middleware: Koa.Middleware[]; + app: App; + middleware: Middleware[]; + server?: ws.Server; constructor(app: Koa); listen(options: ws.ServerOptions): ws.Server; - onConnection(handler: ConnectionHandler): void; + onConnection(socket: ws, request: http.IncomingMessage): void; use(middleware: Middleware): this; } diff --git a/types/koa-websocket/koa-websocket-tests.ts b/types/koa-websocket/koa-websocket-tests.ts index bd99c3d17e..502b366652 100644 --- a/types/koa-websocket/koa-websocket-tests.ts +++ b/types/koa-websocket/koa-websocket-tests.ts @@ -3,11 +3,19 @@ import websocket = require('koa-websocket'); const app = websocket(new Koa()); -app.ws.use(async function(context, next) { - this.websocket.on('message', (message) => { +app.ws.use(async (ctx, next) => { + ctx.websocket.on('message', (message) => { console.log(message); + const server = ctx.app.ws.server; + if (server) { + server.clients.forEach(client => { + if (client !== ctx.websocket) { + client.send(message); + } + }); + } }); - this.websocket.send('Hello world'); + ctx.websocket.send('Hello world'); await next(); }); diff --git a/types/koa-websocket/tsconfig.json b/types/koa-websocket/tsconfig.json index 87c9225d08..ffe283f2ad 100644 --- a/types/koa-websocket/tsconfig.json +++ b/types/koa-websocket/tsconfig.json @@ -20,4 +20,4 @@ "index.d.ts", "koa-websocket-tests.ts" ] -} \ No newline at end of file +} From fb1a9771d48ef02d8cf7c1fe38930c5acefcc0ed Mon Sep 17 00:00:00 2001 From: Dimitry Date: Wed, 17 Oct 2018 18:44:11 +0300 Subject: [PATCH 007/184] react-native-video: add tolerance to seek method (#29640) * react-native-video: add tolerance to seek method * react-native-video: add allowsExternalPlayback prop --- types/react-native-video/index.d.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/types/react-native-video/index.d.ts b/types/react-native-video/index.d.ts index ad1be7a0b4..190d731394 100644 --- a/types/react-native-video/index.d.ts +++ b/types/react-native-video/index.d.ts @@ -68,6 +68,7 @@ export interface VideoProperties extends ViewProps { currentTime?: number; progressUpdateInterval?: number; useTextureView?: boolean; + allowsExternalPlayback?: boolean; onLoadStart?(): void; onLoad?(data: OnLoadData): void; onBuffer?(): void; @@ -99,7 +100,7 @@ export interface VideoProperties extends ViewProps { } export default class Video extends React.Component { - seek(time: number): void; + seek(time: number, tolerance?: number): void; presentFullscreenPlayer(): void; dismissFullscreenPlayer(): void; } From 33f3666a20a6d8d9d04b7fb19debada7dd585bc7 Mon Sep 17 00:00:00 2001 From: Oscar Busk Date: Wed, 17 Oct 2018 17:45:47 +0200 Subject: [PATCH 008/184] Fix issue with properties clashing with jqueryui --- types/angular-ui-sortable/index.d.ts | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/types/angular-ui-sortable/index.d.ts b/types/angular-ui-sortable/index.d.ts index aa81038346..9ecf06e112 100644 --- a/types/angular-ui-sortable/index.d.ts +++ b/types/angular-ui-sortable/index.d.ts @@ -2,12 +2,16 @@ // Project: https://github.com/angular-ui/ui-sortable // Definitions by: Thodoris Greasidis // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped -// TypeScript Version: 2.3 +// TypeScript Version: 2.4 /// +/// import * as ng from 'angular'; +// Diff / Omit taken from https://github.com/Microsoft/TypeScript/issues/12215#issuecomment-311923766 +type Omit = Pick; + declare module 'angular' { export namespace ui { @@ -79,11 +83,11 @@ declare module 'angular' { isCustomHelperUsed(): Boolean; } - interface UISortableUIItem extends ng.IAugmentedJQuery { + interface UISortableUIItem extends Omit { sortable: UISortableProperties; } - interface UISortableUIParams extends SortableUIParams { + interface UISortableUIParams extends Omit { item: UISortableUIItem; } From 5ae6d3dd4f2763485f48683bf07dfabfbb5c2d9e Mon Sep 17 00:00:00 2001 From: Dan Manastireanu <498419+danmana@users.noreply.github.com> Date: Wed, 17 Oct 2018 18:46:32 +0300 Subject: [PATCH 009/184] Update amplitude-js to 4.4.0 (#29649) --- types/amplitude-js/amplitude-js-tests.ts | 143 +++++++++++++---------- types/amplitude-js/index.d.ts | 109 +++++++++++++++-- 2 files changed, 181 insertions(+), 71 deletions(-) diff --git a/types/amplitude-js/amplitude-js-tests.ts b/types/amplitude-js/amplitude-js-tests.ts index 4f3c2ea307..c5ffbe9898 100644 --- a/types/amplitude-js/amplitude-js-tests.ts +++ b/types/amplitude-js/amplitude-js-tests.ts @@ -1,85 +1,110 @@ // Tests for Amplitude SDK TypeScript definitions module Amplitude.Tests { + function all() { - amplitude.init('YOUR_API_KEY_HERE', null, { - // optional configuration options + var client: amplitude.AmplitudeClient = new amplitude.AmplitudeClient(); + var identify: amplitude.Identify = new amplitude.Identify(); + var revenue: amplitude.Revenue = new amplitude.Revenue(); + + client = amplitude.getInstance(); + client = amplitude.getInstance('some name'); + + amplitude.__VERSION__ === '1.2.3'; + amplitude.options.logLevel = 'WARN'; + + amplitude.init('API_KEY', 'USER_ID', { saveEvents: true, includeUtm: true, includeReferrer: true, batchEvents: true, eventUploadThreshold: 50 - }); - amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE', null, () => {}); + }, function () { }); + amplitude.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true }); + amplitude.init('API_KEY', 'USER_ID'); + amplitude.init('API_KEY'); - amplitude.logEvent('EVENT_IDENTIFIER_HERE'); - amplitude.setUserId('USER_ID_HERE'); - amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE'); - amplitude.setUserId(null); // not string 'null' - amplitude.setVersionName('VERSION_NAME_HERE'); - - amplitude.regenerateDeviceId(); - amplitude.setDeviceId('CUSTOM_DEVICE_ID'); - - amplitude.logEvent('EVENT_IDENTIFIER_HERE', { - 'color': 'blue', - 'age': 20, - 'key': 'value' - }); + amplitude.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 }); + amplitude.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' }); amplitude.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { }); + amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' }); + + amplitude.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0'); + amplitude.setDomain('.amplitude.com'); + amplitude.setGroup('orgId', '15'); + amplitude.setGroup('orgId', ['15', '16']); + amplitude.setUserId('joe@gmail.com'); + amplitude.setUserProperties({ 'gender': 'female', 'sign_up_complete': true }) + amplitude.setVersionName('1.12.3'); + amplitude.isNewSession(); + amplitude.getSessionId() === 123; - let identify = new amplitude.Identify().set('gender', 'female').set('age', 20); amplitude.identify(identify); + amplitude.logRevenue(3.99, 1, 'product_1234'); + amplitude.logRevenueV2(revenue); - identify = new amplitude.Identify().setOnce('sign_up_date', '08/24/2015'); - amplitude.identify(identify); - identify = new amplitude.Identify().setOnce('sign_up_date', '09/14/2015'); - amplitude.identify(identify); + client.init('API_KEY', 'USER_ID', { + saveEvents: true, + includeUtm: true, + includeReferrer: true, + batchEvents: true, + eventUploadThreshold: 50 + }, function () { }); + client.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true }); + client.init('API_KEY', 'USER_ID'); + client.init('API_KEY'); - identify = new amplitude.Identify().unset('gender').unset('age'); - amplitude.identify(identify); + client.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 }); + client.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' }); + client.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { }); + client.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' }); + client.logEventWithTimestamp('EVENT_IDENTIFIER_HERE', { 'key': 'value' }, 1505430378000, (httpCode, response) => { }); + + client.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0'); + client.setDomain('.amplitude.com'); + client.setUserId('joe@gmail.com'); + client.setOptOut(true); + client.setGroup('type', 'name'); + client.setGroup('type', ['name', 'name2']); + client.setUserProperties({ 'gender': 'female', 'sign_up_complete': true }); + client.setGlobalUserProperties({ 'gender': 'female', 'sign_up_complete': true }); + client.setVersionName('1.12.3'); + client.setSessionId(1505430378000); + + client.options.logLevel = 'WARN'; + client.getSessionId() === 123; + client.isNewSession() === true; + client.regenerateDeviceId(); + client.clearUserProperties(); + + client.identify(identify); + client.logRevenue(3.99, 1, 'product_1234'); + client.logRevenueV2(revenue); + + + identify = new amplitude.Identify().set('colors', ['rose', 'gold']).add('karma', 1).setOnce('sign_up_date', '2016-03-31'); identify = new amplitude.Identify().add('karma', 1).add('friends', 1); - amplitude.identify(identify); - - identify = new amplitude.Identify().append('ab-tests', 'new-user-test').append('some_list', [1, 2, 3, 4, 'values']); - amplitude.identify(identify); - - identify = new amplitude.Identify().prepend('ab-tests', 'new-user-test').prepend('some_list', [1, 2, 3, 4, 'values']); - amplitude.identify(identify); - - identify = new amplitude.Identify() - .set('karma', 10) - .add('karma', 1) - .unset('karma'); - amplitude.identify(identify); - + identify = new amplitude.Identify().set('karma', 10).add('karma', 1).unset('karma'); + identify = new amplitude.Identify().append('ab-tests', 'new-user-tests'); + identify.append('some_list', [1, 2, 3, 4, 'values']); + identify = new amplitude.Identify().prepend('ab-tests', 'new-user-tests'); + identify.prepend('some_list', [1, 2, 3, 4, 'values']); + identify = new amplitude.Identify().set('user_type', 'beta'); + identify.set('name', { 'first': 'John', 'last': 'Doe' }); + identify = new amplitude.Identify().setOnce('sign_up_date', '2016-04-01'); + identify = new amplitude.Identify().unset('user_type').unset('age'); identify = new amplitude.Identify() .set('colors', ['rose', 'gold']) .append('ab-tests', 'campaign_a') .append('existing_list', [4, 5]); - amplitude.identify(identify); - amplitude.setUserProperties({ - gender: 'female', - age: 20 - }); - amplitude.clearUserProperties(); - - amplitude.setOptOut(true); - amplitude.setOptOut(false); - - amplitude.setGroup('orgId', '15'); - amplitude.setGroup('sport', ['soccer', 'tennis']); - - // TODO: Implement those. - /* - var revenue = new amplitude.Revenue().setProductId('com.company.productId').setPrice(3.99).setQuantity(3); - amplitude.logRevenueV2(revenue); - - amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' }); - */ + revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99); + revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setEventProperties({ 'city': 'San Francisco' }); + revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setQuantity(5); + revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setRevenueType('purchase'); } + } diff --git a/types/amplitude-js/index.d.ts b/types/amplitude-js/index.d.ts index 613f5ad5d8..1cdb843589 100644 --- a/types/amplitude-js/index.d.ts +++ b/types/amplitude-js/index.d.ts @@ -1,61 +1,146 @@ -// Type definitions for Amplitude SDK 2.12.1 +// Type definitions for Amplitude SDK 4.4.0 // Project: https://github.com/amplitude/Amplitude-Javascript // Definitions by: Arvydas Sidorenko -// Definitions: https://github.com/Asido/DefinitelyTyped +// Dan Manastireanu +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped declare module amplitude { + + type Callback = (responseCode: number, responseBody: string, details?: { reason: string; }) => void; + type LogReturn = number | void; + interface Config { + apiEndpoint?: string; batchEvents?: boolean; cookieExpiration?: number; cookieName?: string; + userId?: string; deviceId?: string; + deviceIdFromUrlParam?: boolean; domain?: string; eventUploadPeriodMillis?: number; eventUploadThreshold?: number; + forceHttps?: boolean; + includeGclid?: boolean; includeReferrer?: boolean; includeUtm?: boolean; language?: string; + logLevel?: 'DISABLE' | 'ERROR' | 'WARN' | 'INFO'; optOut?: boolean; platform?: string; saveEvents?: boolean; savedMaxCount?: number; + saveParamsReferrerOncePerSession?: boolean; sessionTimeout?: number; + trackingOptions?: { + city?: boolean; + country?: boolean; + device_model?: boolean; + dma?: boolean; + ip_address?: boolean; + language?: boolean; + os_name?: boolean; + os_version?: boolean; + platform?: boolean; + region?: boolean; + version_name?: boolean; + }, + unsentKey?: string; + unsentIdentifyKey?: string; uploadBatchSize?: number; } export class Identify { set(key: string, value: any): Identify; setOnce(key: string, value: any): Identify; - add(key: string, value: number): Identify; + add(key: string, value: number | string): Identify; append(key: string, value: any): Identify; prepend(key: string, value: any): Identify; unset(key: string): Identify; } - export function init(apiKey: string): void; - export function init(apiKey: string, userId: string): void; - export function init(apiKey: string, userId: string, options: Config): void; - export function init(apiKey: string, userId: string, options: Config, callback: () => void): void; + export class Revenue { + + setProductId(productId: string): Revenue; + setQuantity(quantity: number): Revenue; + setPrice(price: number): Revenue; + setRevenueType(revenueType: string): Revenue; + setEventProperties(eventProperties: any): Revenue; + } + + export class AmplitudeClient { + + constructor(instanceName?: string); + + options: Config; + + init(apiKey: string, userId?: string, config?: Config, callback?: (client: AmplitudeClient) => void): void; + + setVersionName(versionName: string): void; + + isNewSession(): boolean; + setSessionId(sessionId: number): void; + getSessionId(): number; + + setDomain(domain: string): void; + setUserId(userId: string): void; + + setDeviceId(id: string): void; + regenerateDeviceId(): void; + + identify(identify_obj: Identify, opt_callback?: Callback): void; + + setUserProperties(properties: any): void; + setGlobalUserProperties(properties: any): void; + clearUserProperties(): void; + + setOptOut(enable: boolean): void; + + setGroup(groupType: string, groupName: string | string[]): void; + + logEvent(event: string, data?: any, callback?: Callback): LogReturn; + logEventWithGroups(event: string, data?: any, groups?: any, callback?: Callback): LogReturn; + logRevenueV2(revenue_obj: Revenue): LogReturn; + logRevenue(pric: number, quantity: number, product: string): LogReturn; + logEventWithTimestamp(event: string, data?: any, timestamp?: number, callback?: Callback): LogReturn; + } + + // Proxy methods that get executed on the default AmplitudeClient instance (not all client methods are proxied) + + export function init(apiKey: string, userId?: string, options?: Config, callback?: (client: AmplitudeClient) => void): void; export function setVersionName(version: string): void; + + export function isNewSession(): boolean; + export function getSessionId(): number; + + export function setDomain(domain: string): void; + export function setUserId(userId: string): void; export function setDeviceId(id: string): void; export function regenerateDeviceId(): void; - export function identify(identify: Identify): void; + export function identify(identify: Identify, callback?: Callback): void; - export function setUserProperties(properties: Object): void; + export function setUserProperties(properties: any): void; + export function setGlobalUserProperties(properties: any): void; export function clearUserProperties(): void; export function setOptOut(optOut: boolean): void; export function setGroup(groupType: string, groupName: string | string[]): void; - export function logEvent(event: string): void; - export function logEvent(event: string, data: Object): void; - export function logEvent(event: string, data: Object, callback: (httpCode: number, response: any) => void): void; + export function logEvent(event: string, data?: any, callback?: Callback): LogReturn; + export function logEventWithGroups(event: string, data?: any, groups?: any, callback?: Callback): LogReturn; + export function logRevenueV2(revenue_obj: Revenue): LogReturn; + export function logRevenue(pric: number, quantity: number, product: string): LogReturn; + export function logEventWithTimestamp(event: string, data?: any, timestamp?: number, callback?: Callback): LogReturn; + + + export function getInstance(instanceName?: string): AmplitudeClient; + export const __VERSION__: string; export var options: Config; } From 8a342681894fb74a6d25b4aae06a270c2dee85e6 Mon Sep 17 00:00:00 2001 From: Lenny Date: Wed, 17 Oct 2018 08:50:32 -0700 Subject: [PATCH 010/184] [@types/stripe] deleteExternalAccount should return IDeleteConfirmation (#29673) --- types/stripe/index.d.ts | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/types/stripe/index.d.ts b/types/stripe/index.d.ts index 9b0fe09059..732a58fc7d 100644 --- a/types/stripe/index.d.ts +++ b/types/stripe/index.d.ts @@ -5493,8 +5493,8 @@ declare namespace Stripe { * currency is not the Stripe account's default currency. Otherwise, you must set another external account to be the default for the currency * before deleting it. */ - deleteExternalAccount(accId: string, id: string, options: HeaderOptions, response?: IResponseFn): Promise; - deleteExternalAccount(accId: string, id: string, response?: IResponseFn): Promise; + deleteExternalAccount(accId: string, id: string, options: HeaderOptions, response?: IResponseFn): Promise; + deleteExternalAccount(accId: string, id: string, response?: IResponseFn): Promise; /** * You can see a list of the bank accounts belonging to a managed account. Note that the 10 most recent external accounts are always @@ -7365,7 +7365,11 @@ declare namespace Stripe { (err: IStripeError, value: R): void; } - interface IDeleteConfirmation { id: string; deleted: boolean; } + interface IDeleteConfirmation { + id: string; + object: string; + deleted: boolean; + } /** * A filter on the list based on this object field. The value can From 83b0f8edf05f6fd251dd0b307cd638811b735efe Mon Sep 17 00:00:00 2001 From: Ste Prescott Date: Wed, 17 Oct 2018 16:53:06 +0100 Subject: [PATCH 011/184] Expose properties of HttpProxyAgent (#29745) * Expose properties of HttpProxyAgent * Use 4 spaces over tabs * Remove options & timeout properties --- types/http-proxy-agent/http-proxy-agent-tests.ts | 3 +++ types/http-proxy-agent/index.d.ts | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/types/http-proxy-agent/http-proxy-agent-tests.ts b/types/http-proxy-agent/http-proxy-agent-tests.ts index f730cd1bde..2158a9129f 100644 --- a/types/http-proxy-agent/http-proxy-agent-tests.ts +++ b/types/http-proxy-agent/http-proxy-agent-tests.ts @@ -5,6 +5,9 @@ new Agent('url'); new Agent({}); new Agent({ host: 'url' }); +new Agent({}).proxy; +new Agent({}).secureProxy; + // $ExpectError new Agent(); diff --git a/types/http-proxy-agent/index.d.ts b/types/http-proxy-agent/index.d.ts index 015508b5d1..b518fddf0c 100644 --- a/types/http-proxy-agent/index.d.ts +++ b/types/http-proxy-agent/index.d.ts @@ -1,6 +1,7 @@ // Type definitions for http-proxy-agent 2.0 // Project: https://github.com/TooTallNate/node-http-proxy-agent // Definitions by: mrmlnc +// steprescott // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// @@ -10,6 +11,9 @@ import { Url } from 'url'; declare class HttpProxyAgent extends Agent { constructor(options: string | Url); + + proxy: Url; + secureProxy: boolean; } export = HttpProxyAgent; From 6a357014b9882e22d00602a06378c9d9e66c615c Mon Sep 17 00:00:00 2001 From: Tom Raviv Date: Wed, 17 Oct 2018 18:58:26 +0300 Subject: [PATCH 012/184] [murmurhash] fix optional seed argument (#29788) * fix murmurhash optional argument * improved readability of jsdocs --- types/murmurhash/index.d.ts | 22 ++++++++++++++-------- types/murmurhash/murmurhash-tests.ts | 5 +++++ 2 files changed, 19 insertions(+), 8 deletions(-) diff --git a/types/murmurhash/index.d.ts b/types/murmurhash/index.d.ts index 31c663fd33..eac6b500b7 100644 --- a/types/murmurhash/index.d.ts +++ b/types/murmurhash/index.d.ts @@ -9,21 +9,27 @@ export = murmurhash; * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011) * * @param key - ASCII only - * @param seed - Positive integer only - * @return - 32-bit positive integer hash + * @param seed - (optional) positive integer + * @returns 32-bit positive integer hash */ -declare function murmurhash(key: string, seed: number): number; +declare function murmurhash(key: string, seed?: number): number; declare namespace murmurhash { - // Circular reference from murmurhash - function v3(key: string, seed: number): number; + /** + * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011) + * + * @param key - ASCII only + * @param seed - (optional) positive integer + * @returns 32-bit positive integer hash + */ + function v3(key: string, seed?: number): number; /** * JS Implementation of MurmurHash2 * * @param str - ASCII only - * @param seed - Positive integer only - * @return - 32-bit positive integer hash + * @param seed - (optional) positive integer + * @returns 32-bit positive integer hash */ - function v2(str: string, seed: number): number; + function v2(str: string, seed?: number): number; } diff --git a/types/murmurhash/murmurhash-tests.ts b/types/murmurhash/murmurhash-tests.ts index ebbbf09cab..fe7fc9c501 100644 --- a/types/murmurhash/murmurhash-tests.ts +++ b/types/murmurhash/murmurhash-tests.ts @@ -3,6 +3,11 @@ import murmurhash = require('murmurhash'); const stringValue = "test"; let numberValue = 123; +numberValue = murmurhash(stringValue); numberValue = murmurhash(stringValue, numberValue); + +numberValue = murmurhash.v2(stringValue); numberValue = murmurhash.v2(stringValue, numberValue); + +numberValue = murmurhash.v3(stringValue); numberValue = murmurhash.v3(stringValue, numberValue); From 68765b81a894be967d05858bbaca69051c560c24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Jos=C3=A9=20Gonz=C3=A1lez=20Giraldo?= Date: Wed, 17 Oct 2018 11:01:19 -0500 Subject: [PATCH 013/184] Add critters webpack plugin (#29796) * Added critters-webpack-plugin definition * Modified to allow export default * Minor fixes * Added TypeScript version * Added missing strictFunctionTypes * Added version * Removed patch from version and removed unnecesary asterisks in jsdocs * Added new line at end of @deault statements on jsDocs * Empty the first line of every jsDoc --- .../critters-webpack-plugin-tests.ts | 10 +++ types/critters-webpack-plugin/index.d.ts | 65 +++++++++++++++++++ types/critters-webpack-plugin/tsconfig.json | 16 +++++ types/critters-webpack-plugin/tslint.json | 1 + 4 files changed, 92 insertions(+) create mode 100644 types/critters-webpack-plugin/critters-webpack-plugin-tests.ts create mode 100644 types/critters-webpack-plugin/index.d.ts create mode 100644 types/critters-webpack-plugin/tsconfig.json create mode 100644 types/critters-webpack-plugin/tslint.json diff --git a/types/critters-webpack-plugin/critters-webpack-plugin-tests.ts b/types/critters-webpack-plugin/critters-webpack-plugin-tests.ts new file mode 100644 index 0000000000..cb975b1cc0 --- /dev/null +++ b/types/critters-webpack-plugin/critters-webpack-plugin-tests.ts @@ -0,0 +1,10 @@ +import Critters from 'critters-webpack-plugin'; + +new Critters({ + compress: true, + external: true, + inlineFonts: false, + preloadFonts: true, + keyframes: 'critical', + noscriptFallback: true, +}); diff --git a/types/critters-webpack-plugin/index.d.ts b/types/critters-webpack-plugin/index.d.ts new file mode 100644 index 0000000000..df758a42e7 --- /dev/null +++ b/types/critters-webpack-plugin/index.d.ts @@ -0,0 +1,65 @@ +// Type definitions for critters-webpack-plugin 1.3 +// Project: https://github.com/GoogleChromeLabs/critters +// Definitions by: Juan José González Giraldo +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.3 + +import { Plugin } from 'webpack'; + +export default Critters; +declare class Critters extends Plugin { + constructor(options?: Critters.CrittersOptions); +} + +declare namespace Critters { + interface CrittersOptions { + /** + * Inline styles from external stylesheets. + * @default true + */ + external?: boolean; + /** + * The mechanism to use for lazy-loading stylesheets. [JS] indicates that a strategy requires JavaScript (falls back to