@capgo/capacitor-youtube-player 8.2.0 → 8.2.1

package/dist/esm/web.d.ts

@@ -1,6 +1,6 @@
 import { WebPlugin } from '@capacitor/core';
-import type { YoutubePlayerPlugin } from './definitions';
-import type { IPlayerSize, IPlayerState, IPlayerOptions, RequiredKeys, IPlaylistOptions, IPlaybackQuality, IVideoOptionsById, IVideoOptionsByUrl, Events, PlayerEvent } from './web/models/models';
+import type { PlayerEventListenerOptions, PlayerIdOptions, PlayVideoAtOptions, PlaylistMethodOptions, SeekToOptions, SetLoopOptions, SetPlaybackQualityOptions, SetPlaybackRateOptions, SetShuffleOptions, SetSizeOptions, SetVolumeOptions, ToggleFullScreenOptions, VideoByIdMethodOptions, VideoByUrlMethodOptions, YoutubePlayerPlugin } from './definitions';
+import type { IPlayerSize, IPlayerState, IPlayerOptions, RequiredKeys, IPlaybackQuality, IVideoOptionsById, IVideoOptionsByUrl, PlayerEvent } from './web/models/models';
 export declare function YT(): any;
 export declare function Player(): any;
 export declare function PlayerState(): any;
@@ -23,32 +23,32 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
         playerReady: boolean;
         player: string;
     } | undefined>;
-    destroy(playerId: string): Promise<{
+    destroy({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
     /*********/
-    stopVideo(playerId: string): Promise<{
+    stopVideo({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    playVideo(playerId: string): Promise<{
+    playVideo({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    pauseVideo(playerId: string): Promise<{
+    pauseVideo({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    seekTo(playerId: string, seconds: number, allowSeekAhead: boolean): Promise<{
+    seekTo({ playerId, seconds, allowSeekAhead, }: SeekToOptions): Promise<{
         result: {
             method: string;
             value: boolean;
@@ -56,28 +56,28 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
             allowSeekAhead: boolean;
         };
     }>;
-    loadVideoById(playerId: string, options: IVideoOptionsById): Promise<{
+    loadVideoById({ playerId, options, }: VideoByIdMethodOptions): Promise<{
         result: {
             method: string;
             value: boolean;
             options: IVideoOptionsById;
         };
     }>;
-    cueVideoById(playerId: string, options: IVideoOptionsById): Promise<{
+    cueVideoById({ playerId, options, }: VideoByIdMethodOptions): Promise<{
         result: {
             method: string;
             value: boolean;
             options: IVideoOptionsById;
         };
     }>;
-    loadVideoByUrl(playerId: string, options: IVideoOptionsByUrl): Promise<{
+    loadVideoByUrl({ playerId, options, }: VideoByUrlMethodOptions): Promise<{
         result: {
             method: string;
             value: boolean;
             options: IVideoOptionsByUrl;
         };
     }>;
-    cueVideoByUrl(playerId: string, options: IVideoOptionsByUrl): Promise<{
+    cueVideoByUrl({ playerId, options, }: VideoByUrlMethodOptions): Promise<{
         result: {
             method: string;
             value: boolean;
@@ -86,13 +86,13 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    cuePlaylist(playerId: string, playlistOptions: IPlaylistOptions): Promise<{
+    cuePlaylist({ playerId, playlistOptions, }: PlaylistMethodOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    loadPlaylist(playerId: string, playlistOptions: IPlaylistOptions): Promise<{
+    loadPlaylist({ playerId, playlistOptions, }: PlaylistMethodOptions): Promise<{
         result: {
             method: string;
             value: boolean;
@@ -100,38 +100,38 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    nextVideo(playerId: string): Promise<{
+    nextVideo({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    previousVideo(playerId: string): Promise<{
+    previousVideo({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    playVideoAt(playerId: string, index: number): Promise<{
+    playVideoAt({ playerId, index }: PlayVideoAtOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
     /*********/
-    getPlaybackRate(playerId: string): Promise<{
+    getPlaybackRate({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number;
         };
     }>;
-    setPlaybackRate(playerId: string, rate: number): Promise<{
+    setPlaybackRate({ playerId, suggestedRate, }: SetPlaybackRateOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    getAvailablePlaybackRates(playerId: string): Promise<{
+    getAvailablePlaybackRates({ playerId, }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number[];
@@ -140,13 +140,13 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     /*********/
     /*********/
     /*********/
-    setLoop(playerId: string, loop: boolean): Promise<{
+    setLoop({ playerId, loopPlaylists }: SetLoopOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    setShuffle(playerId: string, shuffle: boolean): Promise<{
+    setShuffle({ playerId, shufflePlaylist, }: SetShuffleOptions): Promise<{
         result: {
             method: string;
             value: boolean;
@@ -154,31 +154,31 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    mute(playerId: string): Promise<{
+    mute({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    unMute(playerId: string): Promise<{
+    unMute({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    isMuted(playerId: string): Promise<{
+    isMuted({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    setVolume(playerId: string, volume: number): Promise<{
+    setVolume({ playerId, volume }: SetVolumeOptions): Promise<{
         result: {
             method: string;
             value: number;
         };
     }>;
-    getVolume(playerId: string): Promise<{
+    getVolume({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number;
@@ -186,7 +186,7 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    setSize(playerId: string, width: number, height: number): Promise<{
+    setSize({ playerId, width, height, }: SetSizeOptions): Promise<{
         result: {
             method: string;
             value: IPlayerSize;
@@ -194,13 +194,13 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    getVideoLoadedFraction(playerId: string): Promise<{
+    getVideoLoadedFraction({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number;
         };
     }>;
-    getPlayerState(playerId: string): Promise<{
+    getPlayerState({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number;
@@ -212,13 +212,13 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
             value: Map<string, IPlayerState>;
         };
     }>;
-    getCurrentTime(playerId: string): Promise<{
+    getCurrentTime({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number;
         };
     }>;
-    toggleFullScreen(playerId: string, isFullScreen: boolean | null | undefined): Promise<{
+    toggleFullScreen({ playerId, isFullScreen, }: ToggleFullScreenOptions): Promise<{
         result: {
             method: string;
             value: boolean | null | undefined;
@@ -226,19 +226,19 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    getPlaybackQuality(playerId: string): Promise<{
+    getPlaybackQuality({ playerId, }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: IPlaybackQuality;
         };
     }>;
-    setPlaybackQuality(playerId: string, playbackQuality: IPlaybackQuality): Promise<{
+    setPlaybackQuality({ playerId, suggestedQuality, }: SetPlaybackQualityOptions): Promise<{
         result: {
             method: string;
             value: boolean;
         };
     }>;
-    getAvailableQualityLevels(playerId: string): Promise<{
+    getAvailableQualityLevels({ playerId, }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: IPlaybackQuality[];
@@ -246,19 +246,19 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    getDuration(playerId: string): Promise<{
+    getDuration({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number;
         };
     }>;
-    getVideoUrl(playerId: string): Promise<{
+    getVideoUrl({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: string;
         };
     }>;
-    getVideoEmbedCode(playerId: string): Promise<{
+    getVideoEmbedCode({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: string;
@@ -266,13 +266,13 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    getPlaylist(playerId: string): Promise<{
+    getPlaylist({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: string[];
         };
     }>;
-    getPlaylistIndex(playerId: string): Promise<{
+    getPlaylistIndex({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: number;
@@ -280,15 +280,15 @@ export declare class YoutubePlayerPluginWeb extends WebPlugin implements Youtube
     }>;
     /*********/
     /*********/
-    getIframe(playerId: string): Promise<{
+    getIframe({ playerId }: PlayerIdOptions): Promise<{
         result: {
             method: string;
             value: HTMLIFrameElement;
         };
     }>;
     /*********/
-    addEventListener<TEvent extends PlayerEvent>(playerId: string, eventName: keyof Events, listener: (event: TEvent) => void): void;
-    removeEventListener<TEvent extends PlayerEvent>(playerId: string, eventName: keyof Events, listener: (event: TEvent) => void): void;
+    addEventListener<TEvent extends PlayerEvent>({ playerId, eventName, listener, }: PlayerEventListenerOptions<TEvent>): void;
+    removeEventListener<TEvent extends PlayerEvent>({ playerId, eventName, listener, }: PlayerEventListenerOptions<TEvent>): void;
     /*********/
     getPluginVersion(): Promise<{
         version: string;

package/dist/esm/web.js

@@ -168,7 +168,7 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
             return Promise.resolve(playerReady);
         }
     }
-    async destroy(playerId) {
+    async destroy({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> destroy`);
         this.players[playerId].destroy();
         return Promise.resolve({ result: { method: 'destroy', value: true } });
@@ -178,27 +178,27 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     // Stops and cancels loading of the current video. This function should be reserved for rare situations when you know that the user will not be watching
     // additional video in the player. If your intent is to pause the video, you should just call the pauseVideo function. If you want to change the video
     // that the player is playing, you can call one of the queueing functions without calling stopVideo first.
-    async stopVideo(playerId) {
+    async stopVideo({ playerId }) {
         this.playerLogger.log(`player "${playerId}" ->  stopVideo`);
         this.players[playerId].stopVideo();
         return Promise.resolve({ result: { method: 'stopVideo', value: true } });
     }
     // Plays the currently cued/loaded video. The final player state after this function executes will be playing (1).
-    async playVideo(playerId) {
+    async playVideo({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> playVideo`);
         this.players[playerId].playVideo();
         return Promise.resolve({ result: { method: 'playVideo', value: true } });
     }
     // Pauses the currently playing video. The final player state after this function executes will be paused (2) unless the player is in the ended (0)
     // state when the function is called, in which case the player state will not change.
-    async pauseVideo(playerId) {
+    async pauseVideo({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> pauseVideo`);
         this.players[playerId].pauseVideo();
         return Promise.resolve({ result: { method: 'pauseVideo', value: true } });
     }
     // Seeks to a specified time in the video. If the player is paused when the function is called, it will remain paused. If the function is called from
     // another state (playing, video cued, etc.), the player will play the video.
-    async seekTo(playerId, seconds, allowSeekAhead) {
+    async seekTo({ playerId, seconds, allowSeekAhead, }) {
         this.playerLogger.log(`player "${playerId}" -> seekTo ${seconds} seconds`);
         this.players[playerId].seekTo(seconds, allowSeekAhead);
         return Promise.resolve({
@@ -206,23 +206,23 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
         });
     }
     // Loads and plays the specified video.
-    async loadVideoById(playerId, options) {
+    async loadVideoById({ playerId, options, }) {
         this.playerLogger.log(`player "${playerId}" -> loadVideoById with options ${options}`);
         this.players[playerId].loadVideoById(options);
         return Promise.resolve({ result: { method: 'loadVideoById', value: true, options: options } });
     }
     // Loads the specified video's thumbnail and prepares the player to play the video. The player does not request the FLV until playVideo() or seekTo() is called.
-    async cueVideoById(playerId, options) {
+    async cueVideoById({ playerId, options, }) {
         this.playerLogger.log(`player "${playerId}" -> cueVideoById with options ${options}`);
         this.players[playerId].cueVideoById(options);
         return Promise.resolve({ result: { method: 'cueVideoById', value: true, options: options } });
     }
-    async loadVideoByUrl(playerId, options) {
+    async loadVideoByUrl({ playerId, options, }) {
         this.playerLogger.log(`player "${playerId}" -> loadVideoByUrl with options ${options}`);
         this.players[playerId].loadVideoByUrl(options);
         return Promise.resolve({ result: { method: 'loadVideoByUrl', value: true, options: options } });
     }
-    async cueVideoByUrl(playerId, options) {
+    async cueVideoByUrl({ playerId, options, }) {
         this.playerLogger.log(`player "${playerId}" -> cueVideoByUrl with options ${options}`);
         this.players[playerId].cueVideoByUrl(options);
         return Promise.resolve({ result: { method: 'cueVideoByUrl', value: true, options: options } });
@@ -230,12 +230,12 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Methods for playing playlist.
     /*********/
-    async cuePlaylist(playerId, playlistOptions) {
+    async cuePlaylist({ playerId, playlistOptions, }) {
         this.playerLogger.log(`player "${playerId}" -> cuePlaylist with options ${JSON.stringify(playlistOptions)}`);
         this.players[playerId].cuePlaylist(playlistOptions);
         return Promise.resolve({ result: { method: 'cuePlaylist', value: true } });
     }
-    async loadPlaylist(playerId, playlistOptions) {
+    async loadPlaylist({ playerId, playlistOptions, }) {
         this.playerLogger.log(`player "${playerId}" -> loadPlaylist with options ${playlistOptions}`);
         this.players[playerId].loadPlaylist(playlistOptions);
         return Promise.resolve({ result: { method: 'loadPlaylist', value: true } });
@@ -243,33 +243,33 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Methods for playing video in playlist.
     /*********/
-    async nextVideo(playerId) {
+    async nextVideo({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> nextVideo`);
         this.players[playerId].nextVideo();
         return Promise.resolve({ result: { method: 'nextVideo', value: true } });
     }
-    async previousVideo(playerId) {
+    async previousVideo({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> previousVideo`);
         this.players[playerId].previousVideo();
         return Promise.resolve({ result: { method: 'previousVideo', value: true } });
     }
-    async playVideoAt(playerId, index) {
+    async playVideoAt({ playerId, index }) {
         this.playerLogger.log(`player "${playerId}" -> playVideoAt`);
         this.players[playerId].playVideoAt(index);
         return Promise.resolve({ result: { method: 'playVideoAt', value: true } });
     }
     /*********/
     // Methods for adjusting the playback speed.
-    async getPlaybackRate(playerId) {
+    async getPlaybackRate({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getPlaybackRate`);
         return Promise.resolve({ result: { method: 'getPlaybackRate', value: this.players[playerId].getPlaybackRate() } });
     }
-    async setPlaybackRate(playerId, rate) {
+    async setPlaybackRate({ playerId, suggestedRate, }) {
         this.playerLogger.log(`player "${playerId}" -> setPlaybackRate`);
-        this.players[playerId].setPlaybackRate(rate);
+        this.players[playerId].setPlaybackRate(suggestedRate);
         return Promise.resolve({ result: { method: 'setPlaybackRate', value: true } });
     }
-    async getAvailablePlaybackRates(playerId) {
+    async getAvailablePlaybackRates({ playerId, }) {
         this.playerLogger.log(`player -> getAvailablePlaybackRates`);
         return Promise.resolve({
             result: { method: 'getAvailablePlaybackRates', value: this.players[playerId].getAvailablePlaybackRates() },
@@ -279,44 +279,44 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Methods for playlist playback settings
     /*********/
-    async setLoop(playerId, loop) {
+    async setLoop({ playerId, loopPlaylists }) {
         this.playerLogger.log(`player "${playerId}" -> setLoop`);
-        this.players[playerId].setLoop(loop);
+        this.players[playerId].setLoop(loopPlaylists);
         return Promise.resolve({ result: { method: 'setLoop', value: true } });
     }
-    async setShuffle(playerId, shuffle) {
+    async setShuffle({ playerId, shufflePlaylist, }) {
         this.playerLogger.log(`player "${playerId}" -> setShuffle`);
-        this.players[playerId].setShuffle(shuffle);
+        this.players[playerId].setShuffle(shufflePlaylist);
         return Promise.resolve({ result: { method: 'setShuffle', value: true } });
     }
     /*********/
     // Methods changing the player volume.
     /*********/
     // Mutes the player.
-    async mute(playerId) {
+    async mute({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> mute`);
         this.players[playerId].mute();
         return Promise.resolve({ result: { method: 'mute', value: true } });
     }
     // Unmutes the player.
-    async unMute(playerId) {
+    async unMute({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> unMute`);
         this.players[playerId].unMute();
         return Promise.resolve({ result: { method: 'unMute', value: true } });
     }
     // Returns true if the player is muted, false if not.
-    async isMuted(playerId) {
+    async isMuted({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> isMuted`);
         return Promise.resolve({ result: { method: 'isMuted', value: this.players[playerId].isMuted() } });
     }
     // Sets the volume. Accepts an integer between 0 and 100.
-    async setVolume(playerId, volume) {
+    async setVolume({ playerId, volume }) {
         this.playerLogger.log(`player "${playerId}" -> setVolume ${volume}`);
         this.players[playerId].setVolume(volume);
         return Promise.resolve({ result: { method: 'setVolume', value: volume } });
     }
     // Returns the player's current volume, an integer between 0 and 100. Note that getVolume() will return the volume even if the player is muted.
-    async getVolume(playerId) {
+    async getVolume({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getVolume`);
         return Promise.resolve({ result: { method: 'getVolume', value: this.players[playerId].getVolume() } });
     }
@@ -324,7 +324,7 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     // Methods setting the player size.
     /*********/
     // Sets the size in pixels of the <iframe> that contains the player.
-    async setSize(playerId, width, height) {
+    async setSize({ playerId, width, height, }) {
         this.playerLogger.log(`player "${playerId}" -> setSize width: ${width} height: ${height}`);
         this.players[playerId].setSize(width, height);
         return Promise.resolve({ result: { method: 'setSize', value: { width: width, height: height } } });
@@ -334,7 +334,7 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Returns a number between 0 and 1 that specifies the percentage of the video that the player shows as buffered.
     // This method returns a more reliable number than the now-deprecated getVideoBytesLoaded and getVideoBytesTotal methods.
-    async getVideoLoadedFraction(playerId) {
+    async getVideoLoadedFraction({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getVideoLoadedFraction`);
         return Promise.resolve({
             result: { method: 'getVideoLoadedFraction', value: this.players[playerId].getVideoLoadedFraction() },
@@ -347,7 +347,7 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     // 2 – paused
     // 3 – buffering
     // 5 – video cued
-    async getPlayerState(playerId) {
+    async getPlayerState({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getPlayerState`);
         return Promise.resolve({ result: { method: 'getPlayerState', value: this.players[playerId].getPlayerState() } });
     }
@@ -356,11 +356,11 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
         return Promise.resolve({ result: { method: 'getAllPlayersEventsState', value: this.playersEventsState } });
     }
     // Returns the elapsed time in seconds since the video started playing.
-    async getCurrentTime(playerId) {
+    async getCurrentTime({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getCurrentTime`);
         return Promise.resolve({ result: { method: 'getCurrentTime', value: this.players[playerId].getCurrentTime() } });
     }
-    async toggleFullScreen(playerId, isFullScreen) {
+    async toggleFullScreen({ playerId, isFullScreen, }) {
         this.playerLogger.log(`player "${playerId}" -> toggleFullScreen`);
         let { height, width } = this.defaultSizes;
         if (!isFullScreen) {
@@ -373,18 +373,18 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Methods playback quality.
     /*********/
-    async getPlaybackQuality(playerId) {
+    async getPlaybackQuality({ playerId, }) {
         this.playerLogger.log(`player "${playerId}" -> getPlaybackQuality`);
         return Promise.resolve({
             result: { method: 'getPlaybackQuality', value: this.players[playerId].getPlaybackQuality() },
         });
     }
-    async setPlaybackQuality(playerId, playbackQuality) {
+    async setPlaybackQuality({ playerId, suggestedQuality, }) {
         this.playerLogger.log(`player "${playerId}" -> setPlaybackQuality`);
-        this.players[playerId].setPlaybackQuality(playbackQuality);
+        this.players[playerId].setPlaybackQuality(suggestedQuality);
         return Promise.resolve({ result: { method: 'setPlaybackQuality', value: true } });
     }
-    async getAvailableQualityLevels(playerId) {
+    async getAvailableQualityLevels({ playerId, }) {
         this.playerLogger.log(`player "${playerId}" -> getAvailableQualityLevels`);
         return Promise.resolve({
             result: { method: 'getAvailableQualityLevels', value: this.players[playerId].getAvailableQualityLevels() },
@@ -393,15 +393,15 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Methods for retrieving video information.
     /*********/
-    async getDuration(playerId) {
+    async getDuration({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getDuration`);
         return Promise.resolve({ result: { method: 'getDuration', value: this.players[playerId].getDuration() } });
     }
-    async getVideoUrl(playerId) {
+    async getVideoUrl({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getVideoUrl`);
         return Promise.resolve({ result: { method: 'getVideoUrl', value: this.players[playerId].getVideoUrl() } });
     }
-    async getVideoEmbedCode(playerId) {
+    async getVideoEmbedCode({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getVideoEmbedCode`);
         return Promise.resolve({
             result: { method: 'getVideoEmbedCode', value: this.players[playerId].getVideoEmbedCode() },
@@ -410,11 +410,11 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Methods for retrieving playlist information.
     /*********/
-    async getPlaylist(playerId) {
+    async getPlaylist({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getPlaylist`);
         return Promise.resolve({ result: { method: 'getPlaylist', value: this.players[playerId].getPlaylist() } });
     }
-    async getPlaylistIndex(playerId) {
+    async getPlaylistIndex({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getPlaylistIndex`);
         return Promise.resolve({
             result: { method: 'getPlaylistIndex', value: this.players[playerId].getPlaylistIndex() },
@@ -423,17 +423,17 @@ export class YoutubePlayerPluginWeb extends WebPlugin {
     /*********/
     // Methods accessing and modifying DOM nodes.
     /*********/
-    async getIframe(playerId) {
+    async getIframe({ playerId }) {
         this.playerLogger.log(`player "${playerId}" -> getIframe`);
         return Promise.resolve({ result: { method: 'getIframe', value: this.players[playerId].getIframe() } });
     }
     /*********/
     // Player event listeners.
-    addEventListener(playerId, eventName, listener) {
+    addEventListener({ playerId, eventName, listener, }) {
         this.playerLogger.log(`player "${playerId}" -> addEventListener "${eventName}"`);
         this.players[playerId].addEventListener(eventName, listener);
     }
-    removeEventListener(playerId, eventName, listener) {
+    removeEventListener({ playerId, eventName, listener, }) {
         this.playerLogger.log(`player "${playerId}" -> removeEventListener "${eventName}"`);
         this.players[playerId].removeEventListener(eventName, listener);
     }