added type definitions for NPM package yt-player (#38094)

types/yt-player/index.d.ts

@@ -0,0 +1,67 @@
+// Type definitions for yt-player 3.3
+// Project: https://github.com/feross/yt-player
+// Definitions by: Thomas Röggla <https://github.com/troeggla>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { EventEmitter } from "events";
+
+interface YouTubePlayerOptions {
+    width?: number;
+    height?: number;
+    autoplay?: boolean;
+    captions?: false | string;
+    controls?: boolean;
+    keyboard?: boolean;
+    fullscreen?: boolean;
+    annotations?: boolean;
+    modestBranding?: boolean;
+    related?: boolean;
+    info?: boolean;
+    timeupdateFrequency?: number;
+    playsInline?: boolean;
+}
+
+type YoutubePlayerState = "unstarted" | "ended" | "playing" | "paused" | "buffering" | "cued";
+
+declare class YouTubePlayer extends EventEmitter {
+    videoId: string;
+    destroyed: boolean;
+
+    constructor(element: HTMLElement | string, options?: YouTubePlayerOptions);
+    load(videoId: string, autoplay?: boolean): void;
+
+    play(): void;
+    pause(): void;
+    stop(): void;
+    seek(seconds: number): void;
+
+    setVolume(volume: number): void;
+    getVolume(): number;
+    mute(): void;
+    unMute(): void;
+    isMuted(): boolean;
+
+    setSize(width: number, height: number): void;
+
+    setPlaybackRate(rate: number): void;
+    getPlaybackRate(): number;
+    getAvailablePlaybackRates(): number[];
+
+    getDuration(): number;
+    getProgress(): number;
+    getState(): YoutubePlayerState;
+    getCurrentTime(): number;
+
+    destroy(): void;
+
+    on(event: "timeupdate", callback: (seconds: number) => void): this;
+    on(event: "playbackQualityChange", callback: (quality: number) => void): this;
+    on(event: "playbackRateChange", callback: (playbackRate: number) => void): this;
+
+    on(event: YoutubePlayerState, callback: () => void): this;
+
+    on(event: "error", callback: (err: Error) => void): this;
+    on(event: "unplayable", callback: (videoId: string) => void): this;
+}
+
+export = YouTubePlayer;

types/yt-player/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6", "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "yt-player-tests.ts"
+    ]
+}

types/yt-player/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }

types/yt-player/yt-player-tests.ts

@@ -0,0 +1,62 @@
+import YoutubePlayer = require("yt-player");
+
+new YoutubePlayer("#player", {});
+
+new YoutubePlayer("#player", {
+    width: 640, height: 480, autoplay: true, fullscreen: true
+});
+
+new YoutubePlayer("#player", {
+    captions: "en_US"
+});
+
+new YoutubePlayer("#player", {
+    captions: false
+});
+
+const player = new YoutubePlayer("#player");
+
+player.load("abcdef");
+player.load("abcdef", true);
+
+player.play();
+player.pause();
+player.stop();
+player.seek(42);
+
+player.setVolume(67);
+player.getVolume();
+
+player.mute();
+player.unMute();
+player.isMuted();
+
+player.setSize(800, 600);
+
+player.getPlaybackRate();
+player.getAvailablePlaybackRates();
+player.setPlaybackRate(2);
+
+player.getDuration();
+player.getProgress();
+player.getState();
+player.getCurrentTime();
+
+player.destroy();
+
+player.destroyed;
+player.videoId;
+
+player.on("timeupdate", (sec: number) => {});
+player.on("playbackRateChange", (rate: number) => {});
+player.on("playbackQualityChange", (quality: number) => {});
+
+player.on("buffering", () => {});
+player.on("unstarted", () => {});
+player.on("ended", () => {});
+player.on("cued", () => {});
+player.on("playing", () => {});
+player.on("paused", () => {});
+
+player.on("error", (err: Error) => {});
+player.on("unplayable", (videoId: string) => {});