@gcorevideo/player 0.0.1

package/lib/plugins/audio-selector/AudioSelector.js

@@ -0,0 +1,282 @@
+import assert from 'assert';
+import { Events, UICorePlugin, template } from '@clappr/core';
+import { HlsEvents, } from 'hls.js';
+import pluginHtml from '../../../assets/plugins/audio-selector/track-selector.ejs';
+import '../../../assets/plugins/audio-selector/style.scss';
+import audioArrow from '../../../assets/icons/old/quality-arrow.svg';
+assert(process.env.CLAPPR_VERSION, 'CLAPPR_VERSION is required');
+const CLAPPR_VERSION = process.env.CLAPPR_VERSION;
+assert(process.env.VERSION, 'VERSION is required');
+const VERSION = process.env.VERSION;
+// const T = 'plugins.audio_selector';
+const AUTO = 0;
+export default class AudioSelector extends UICorePlugin {
+    selectedTrackId;
+    currentTrack = null;
+    tracks = [];
+    get name() {
+        return 'audio_selector';
+    }
+    get supportedVersion() {
+        return { min: CLAPPR_VERSION };
+    }
+    static get version() {
+        return VERSION;
+    }
+    get template() {
+        return template(pluginHtml);
+    }
+    get attributes() {
+        return {
+            'class': this.name,
+            'data-track-selector': ''
+        };
+    }
+    //   constructor(core) {
+    //     super(core);
+    //   }
+    get events() {
+        return {
+            'click [data-track-selector-select]': 'onTrackSelect',
+            'click [data-track-selector-button]': 'onShowLevelSelectMenu'
+        };
+    }
+    bindEvents() {
+        this.listenTo(this.core, Events.CORE_READY, this.bindPlaybackEvents);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_CONTAINERCHANGED, this.reload);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_RENDERED, this.render);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_HIDE, this.hideSelectTrackMenu);
+    }
+    unBindEvents() {
+        // @ts-ignore
+        this.stopListening(this.core, Events.CORE_READY);
+        // @ts-ignore
+        this.stopListening(this.core.mediaControl, Events.MEDIACONTROL_CONTAINERCHANGED);
+        // @ts-ignore
+        this.stopListening(this.core.mediaControl, Events.MEDIACONTROL_RENDERED);
+        // @ts-ignore
+        this.stopListening(this.core.mediaControl, Events.MEDIACONTROL_HIDE);
+    }
+    bindPlaybackEvents() {
+        // this.currentTrack = {};
+        // this.removeAuto = false;
+        this.selectedTrackId = undefined;
+        const currentPlayback = this.core.activePlayback;
+        this.listenTo(currentPlayback, Events.PLAYBACK_STOP, this.onStop);
+        this.setupAudioTrackListeners();
+    }
+    setupAudioTrackListeners() {
+        const currentPlayback = this.core.activePlayback;
+        // TODO no-crutch:currentPlayback._hls
+        if (currentPlayback._hls) {
+            // TODO AUDIO_TRACKS_UPDATED
+            // currentPlayback._hls.on('hlsAudioTracksUpdated', (e, data) => {
+            currentPlayback._hls.on(HlsEvents.AUDIO_TRACKS_UPDATED, (e, data) => {
+                // let id = -1;
+                // for (const audioTrack of data.audioTracks) {
+                //   if (audioTrack.default) {
+                //     id = audioTrack.id;
+                //     this.currentTrack = audioTrack;
+                //   }
+                // }
+                const defaultTrack = data.audioTracks.find((track) => track.default);
+                if (defaultTrack) {
+                    this.currentTrack = {
+                        id: defaultTrack.id,
+                        label: defaultTrack.name
+                    };
+                }
+                this.fillTracks(data.audioTracks.map(p => ({
+                    id: p.id,
+                    label: p.name
+                })), defaultTrack?.id);
+            });
+            currentPlayback._hls.on(HlsEvents.AUDIO_TRACK_SWITCHING, this.startTrackSwitch.bind(this));
+            currentPlayback._hls.on(HlsEvents.AUDIO_TRACK_SWITCHED, this.updateCurrentTrack.bind(this));
+            currentPlayback._hls.on(HlsEvents.AUDIO_TRACK_LOADED, this.updateCurrentTrack.bind(this));
+        }
+        else {
+            this.listenToOnce(currentPlayback, Events.PLAYBACK_PLAY, () => {
+                const mediaElement = currentPlayback.$el.get(0);
+                // const { audioTracks } = currentPlayback.$el.get(0);
+                const audioTracks = mediaElement.audioTracks;
+                if (audioTracks && audioTracks.length) {
+                    let index = 0;
+                    const trackItems = [];
+                    for (const audioTrack of audioTracks) {
+                        if (audioTrack.enabled) {
+                            const t = {
+                                id: index,
+                                label: audioTrack.label,
+                            };
+                            this.currentTrack = t;
+                            trackItems.push(t);
+                            index++;
+                        }
+                    }
+                    audioTracks.addEventListener('change', () => this.updateCurrentTrackW3C());
+                    this.fillTracks(trackItems, trackItems[0].id);
+                }
+            });
+        }
+    }
+    onStop() { }
+    reload() {
+        this.unBindEvents();
+        this.bindEvents();
+        this.bindPlaybackEvents();
+    }
+    shouldRender() {
+        if (!this.core.activeContainer) {
+            return false;
+        }
+        const currentPlayback = this.core.activePlayback;
+        if (!currentPlayback) {
+            return false;
+        }
+        const { audioTracks } = (currentPlayback.activePlayback._hls || currentPlayback.$el.get(0));
+        this.tracks = audioTracks;
+        // Only care if we have at least 2 to choose from
+        return this.tracks && this.tracks.length > 1;
+    }
+    render() {
+        if (this.shouldRender()) {
+            this.$el.html(this.template({ 'tracks': this.tracks, 'title': this.getTitle() }));
+            if (Object.prototype.hasOwnProperty.call(this.core.mediaControl, '$audioTracksSelector') &&
+                this.core.mediaControl.$audioTracksSelector.length > 0) {
+                this.core.mediaControl.$audioTracksSelector.append(this.el);
+            }
+            this.highlightCurrentTrack();
+        }
+        if (Object.prototype.hasOwnProperty.call(this.core.mediaControl, '$audioTracksSelector') &&
+            this.core.mediaControl.$audioTracksSelector.find('span.audio-arrow').length > 0) {
+            this.core.mediaControl.$audioTracksSelector.find('span.audio-arrow').append(audioArrow);
+        }
+        return this;
+    }
+    fillTracks(tracks, selected = AUTO) {
+        if (this.selectedTrackId === undefined) {
+            this.selectedTrackId = selected;
+        }
+        // this.tracks = levels.audioTracks;
+        // for (let i = 0; i < this.tracks.length; i++) {
+        //   if (this.tracks[i].name && !this.tracks[i].label) {
+        //     this.tracks[i].label = this.tracks[i].name;
+        //   }
+        // }
+        this.tracks = tracks;
+        // Player.player.trigger('tracks', this.tracks);
+        // this.core.trigger('tracks', this.tracks);
+        this.render();
+    }
+    findTrackBy(id) {
+        return this.tracks.find((track) => track.id === id);
+    }
+    onTrackSelect(event) {
+        // this.selectedTrackId = parseInt(event.target.dataset.levelSelectorSelect, 10)
+        const id = event.target?.dataset?.trackSelectorSelect;
+        if (id) {
+            this.setIndexTrack(Number(id));
+        }
+        this.toggleContextMenu();
+        event.stopPropagation();
+        return false;
+    }
+    setIndexTrack(index) {
+        this.selectedTrackId = index;
+        if (this.core.activePlayback._hls) {
+            if (this.core.activePlayback._hls.audioTrack.id === this.selectedTrackId) {
+                return;
+            }
+            this.core.activePlayback._hls.audioTrack = this.selectedTrackId;
+        }
+        else {
+            const { audioTracks } = this.core.activePlayback.$el.get(0);
+            for (const track of audioTracks) {
+                track.enabled = track.id === this.selectedTrackId;
+            }
+        }
+        this.updateText(this.selectedTrackId);
+    }
+    onShowLevelSelectMenu() {
+        this.toggleContextMenu();
+    }
+    hideSelectTrackMenu() {
+        this.$('.audio_selector ul').hide();
+    }
+    toggleContextMenu() {
+        this.$('.audio_selector ul').toggle();
+    }
+    buttonElement() {
+        return this.$('.audio_selector button');
+    }
+    buttonElementText() {
+        return this.$('.audio_selector button .audio-text');
+    }
+    trackElement(id) {
+        return this.$('.audio_selector ul a' + (id !== undefined ? '[data-track-selector-select="' + id + '"]' : '')).parent();
+    }
+    getTitle() {
+        if (!this.tracks) {
+            return '';
+        }
+        const selectedTrackId = this.selectedTrackId || 0;
+        const selectedTrack = this.tracks[selectedTrackId];
+        return selectedTrack?.label || '';
+    }
+    startTrackSwitch() {
+        this.buttonElement().addClass('changing');
+    }
+    updateText(trackId) {
+        if (trackId === undefined) {
+            return;
+        }
+        const track = this.findTrackBy(trackId);
+        if (track) {
+            this.buttonElementText().text(track.label);
+        }
+    }
+    updateCurrentTrack(e, info) {
+        // if (!info) {
+        //   const { audioTracks } = this.core.activePlayback.$el.get(0);
+        //   for (const track of audioTracks) {
+        //     if (track.enabled) {
+        //       info = track;
+        //     }
+        //   }
+        // }
+        // if (!info) {
+        //   return;
+        // }
+        // const track = this.findTrackBy(info.id);
+        // this.currentTrack = track ? track : null;
+        // this.selectedTrackId = track?.id;
+        // this.highlightCurrentTrack();
+        // this.buttonElement().removeClass('changing');
+        this.setCurrentTrack(info.id);
+    }
+    updateCurrentTrackW3C() {
+        const { audioTracks } = this.core.activePlayback.$el.get(0);
+        const index = audioTracks.findIndex((track) => track.enabled);
+        if (index >= 0) {
+            this.setCurrentTrack(index);
+        }
+    }
+    setCurrentTrack(index) {
+        const track = this.findTrackBy(index);
+        this.currentTrack = track ?? null;
+        this.selectedTrackId = index;
+        this.highlightCurrentTrack();
+        this.buttonElement().removeClass('changing');
+    }
+    highlightCurrentTrack() {
+        this.trackElement().removeClass('current');
+        this.trackElement().find('a').removeClass('gcore-skin-active');
+        if (this.currentTrack) {
+            const currentTrackElement = this.trackElement(this.currentTrack.id);
+            currentTrackElement.addClass('current');
+            currentTrackElement.find('a').addClass('gcore-skin-active');
+        }
+        this.updateText(this.selectedTrackId);
+    }
+}

package/lib/plugins/big-mute-button/BigMuteButton.d.ts

@@ -0,0 +1,33 @@
+import { UICorePlugin } from '@clappr/core';
+import '../../../assets/plugins/big-mute-button/big-mute-button.scss';
+export default class BigMuteButton extends UICorePlugin {
+    private isBigMuteButtonHidden;
+    private _adIsPlaying;
+    private $bigMuteBtnContainer;
+    private $bigMuteButton;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get events(): {
+        'click .big-mute-icon': string;
+        'click .big-mute-icon-wrapper': string;
+    };
+    bindEvents(): void;
+    unBindEvents(): void;
+    private onCoreReady;
+    private onContainerVolume;
+    private onContainerStart;
+    private onPlaybackEnded;
+    private mediaControlRendered;
+    private onStartAd;
+    private onFinishAd;
+    private shouldRender;
+    render(): this;
+    private hideBigMuteBtn;
+    private showBigMuteBtn;
+    private destroyBigMuteBtn;
+    private handleBigMuteBtnClick;
+}
+//# sourceMappingURL=BigMuteButton.d.ts.map

package/lib/plugins/big-mute-button/BigMuteButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BigMuteButton.d.ts","sourceRoot":"","sources":["../../../src/plugins/big-mute-button/BigMuteButton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,YAAY,EAAS,MAAM,cAAc,CAAC;AAMrE,OAAO,8DAA8D,CAAC;AAStE,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,YAAY;IACrD,OAAO,CAAC,qBAAqB,CAAS;IAEtC,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,oBAAoB,CAA4B;IAExD,OAAO,CAAC,cAAc,CAA4B;IAElD,IAAI,IAAI,WAEP;IAED,IAAI,gBAAgB;;MAEnB;IAMD,IAAI,QAAQ,QAEX;IAED,IAAI,MAAM;;;MAKT;IAED,UAAU;IAWV,YAAY;IAcZ,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,oBAAoB;IAe5B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,YAAY;IAmBpB,MAAM;IAqBN,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,qBAAqB;CAQ9B"}

package/lib/plugins/big-mute-button/BigMuteButton.js

@@ -0,0 +1,148 @@
+import { Events, template, UICorePlugin, Utils } from '@clappr/core';
+import assert from 'assert';
+import { trace } from "../../trace/index.js";
+import volumeMuteIcon from '../../../assets/icons/new/volume-off.svg';
+import pluginHtml from '../../../assets/plugins/big-mute-button/big-mute-button.ejs';
+import '../../../assets/plugins/big-mute-button/big-mute-button.scss';
+assert(process.env.CLAPPR_VERSION, 'CLAPPR_VERSION is required');
+const CLAPPR_VERSION = process.env.CLAPPR_VERSION;
+const T = "plugins.big-mute-button";
+export default class BigMuteButton extends UICorePlugin {
+    isBigMuteButtonHidden = false;
+    _adIsPlaying = false;
+    $bigMuteBtnContainer = null;
+    $bigMuteButton = null;
+    get name() {
+        return 'big-mute-button';
+    }
+    get supportedVersion() {
+        return { min: CLAPPR_VERSION };
+    }
+    // constructor(core) {
+    //   super(core);
+    // }
+    get template() {
+        return template(pluginHtml);
+    }
+    get events() {
+        return {
+            'click .big-mute-icon': 'handleBigMuteBtnClick',
+            'click .big-mute-icon-wrapper': 'destroyBigMuteBtn',
+        };
+    }
+    bindEvents() {
+        super.bindEvents();
+        this.listenTo(this.core, Events.CORE_READY, this.onCoreReady);
+        this.listenTo(this.core, 'core:advertisement:start', this.onStartAd);
+        this.listenTo(this.core, 'core:advertisement:finish', this.onFinishAd);
+        trace(`${T} bindEvents`, {
+            mediacontrol: !!this.core.mediaControl,
+        });
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_RENDERED, this.mediaControlRendered);
+    }
+    unBindEvents() {
+        // @ts-ignore
+        this.stopListening(this.core, Events.CORE_READY);
+        this.stopListening(this.core, 'core:advertisement:start', this.onStartAd);
+        this.stopListening(this.core, 'core:advertisement:finish', this.onFinishAd);
+        this.stopListening(this.core.mediaControl, Events.MEDIACONTROL_RENDERED, this.mediaControlRendered);
+        const container = this.core.activeContainer;
+        if (container) {
+            this.stopListening(container.playback, Events.PLAYBACK_PLAY, this.render);
+        }
+    }
+    onCoreReady() {
+        this.listenTo(this.core.activeContainer, Events.CONTAINER_VOLUME, this.onContainerVolume);
+        this.listenTo(this.core.activeContainer, Events.CONTAINER_READY, this.onContainerStart);
+        this.listenTo(this.core.activePlayback, Events.PLAYBACK_ENDED, this.onPlaybackEnded);
+    }
+    onContainerVolume(value) {
+        if (value !== 0) {
+            this.destroyBigMuteBtn();
+        }
+    }
+    onContainerStart() {
+        if (this.isBigMuteButtonHidden) {
+            this.showBigMuteBtn();
+        }
+    }
+    onPlaybackEnded() {
+        this.hideBigMuteBtn();
+    }
+    mediaControlRendered() {
+        const container = this.core.activeContainer;
+        trace(`${T} mediaControlRendered`, {
+            container: !!container,
+        });
+        if (container) {
+            this.listenTo(container.playback, Events.PLAYBACK_PLAY, () => {
+                trace(`${T} PLAYBACK_PLAY`);
+                this.render();
+            });
+        }
+    }
+    onStartAd() {
+        this._adIsPlaying = true;
+        if (this.$bigMuteBtnContainer) {
+            this.$bigMuteBtnContainer.addClass('hide');
+        }
+    }
+    onFinishAd() {
+        this._adIsPlaying = false;
+        if (this.$bigMuteBtnContainer) {
+            this.$bigMuteBtnContainer.removeClass('hide');
+        }
+    }
+    shouldRender() {
+        const container = this.core.activeContainer;
+        if (!container) {
+            return false;
+        }
+        const { autoPlay, wasMuted } = this.options;
+        const volume = container.volume;
+        trace(`${T} shouldRender`, {
+            autoPlay,
+            wasMuted,
+            volume,
+        });
+        return autoPlay && !wasMuted && volume === 0;
+    }
+    render() {
+        if (this.shouldRender()) {
+            trace(`${T} render`, {
+                el: !!this.$el,
+            });
+            this.$el.html(this.template());
+            this.$bigMuteBtnContainer = this.$el.find('.big-mute-icon-wrapper[data-big-mute]');
+            this._adIsPlaying && this.$bigMuteBtnContainer.addClass('hide');
+            this.$bigMuteButton = this.$bigMuteBtnContainer.find('.big-mute-icon');
+            this.$bigMuteButton.append(volumeMuteIcon);
+            const container = this.core.activeContainer;
+            container.$el.append(this.$el.get(0));
+        }
+        return this;
+    }
+    hideBigMuteBtn() {
+        this.isBigMuteButtonHidden = true;
+        this.$bigMuteBtnContainer?.addClass('hide');
+    }
+    showBigMuteBtn() {
+        this.isBigMuteButtonHidden = false;
+        if (this.$bigMuteBtnContainer) {
+            this.$bigMuteBtnContainer.removeClass('hide');
+        }
+    }
+    destroyBigMuteBtn(e) {
+        this.hideBigMuteBtn();
+        if (e && e.stopPropagation) {
+            e.stopPropagation();
+        }
+        this.destroy();
+    }
+    handleBigMuteBtnClick(e) {
+        const localVolume = Utils.Config.restore('volume');
+        const volume = !isNaN(localVolume) ? localVolume : 100;
+        this.core.mediaControl.setVolume(volume === 0 ? 100 : volume);
+        this.destroyBigMuteBtn(e);
+    }
+}

package/lib/plugins/bottom-gear/BottomGear.d.ts

@@ -0,0 +1,30 @@
+import { UICorePlugin } from '@clappr/core';
+import '../../../assets/plugins/bottom-gear/gear.scss';
+import '../../../assets/plugins/bottom-gear/gear-sub-menu.scss';
+export default class BottomGear extends UICorePlugin {
+    private isHd;
+    get name(): string;
+    get supportedVersion(): {
+        min: string;
+    };
+    get template(): any;
+    get attributes(): {
+        class: string;
+        'data-track-selector': string;
+    };
+    get events(): {
+        'click .button-gear': string;
+    };
+    get container(): any;
+    bindEvents(): void;
+    unBindEvents(): void;
+    private onActiveContainerChanged;
+    private bindContainerEvents;
+    reload(): void;
+    private highDefinitionUpdate;
+    render(): this;
+    refresh(): void;
+    toggleGearMenu(): void;
+    hide(): void;
+}
+//# sourceMappingURL=BottomGear.d.ts.map

package/lib/plugins/bottom-gear/BottomGear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BottomGear.d.ts","sourceRoot":"","sources":["../../../src/plugins/bottom-gear/BottomGear.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAoB,MAAM,cAAc,CAAC;AAI9D,OAAO,+CAA+C,CAAC;AACvD,OAAO,wDAAwD,CAAC;AAShE,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,YAAY;IAClD,OAAO,CAAC,IAAI,CAAS;IAErB,IAAI,IAAI,WAEP;IAED,IAAI,gBAAgB;;MAEnB;IAMD,IAAI,QAAQ,QAEX;IAED,IAAI,UAAU;;;MAKb;IAED,IAAI,MAAM;;MAIT;IAED,IAAI,SAAS,QAEZ;IAOD,UAAU;IASV,YAAY;IAOZ,OAAO,CAAC,wBAAwB;IAKhC,OAAO,CAAC,mBAAmB;IAO3B,MAAM;IAKN,OAAO,CAAC,oBAAoB;IAS5B,MAAM;IAmBN,OAAO;IAKP,cAAc;IAId,IAAI;CAGL"}

package/lib/plugins/bottom-gear/BottomGear.js

@@ -0,0 +1,103 @@
+import { UICorePlugin, template, Events } from '@clappr/core';
+import assert from 'assert';
+import pluginHtml from '../../../assets/plugins/bottom-gear/bottomgear.ejs';
+import '../../../assets/plugins/bottom-gear/gear.scss';
+import '../../../assets/plugins/bottom-gear/gear-sub-menu.scss';
+import gearIcon from '../../../assets/icons/new/gear.svg';
+import gearHdIcon from '../../../assets/icons/new/gear-hd.svg';
+import { trace } from '../../trace/index.js';
+assert(process.env.CLAPPR_VERSION, 'CLAPPR_VERSION is required');
+const CLAPPR_VERSION = process.env.CLAPPR_VERSION;
+export default class BottomGear extends UICorePlugin {
+    isHd = false;
+    get name() {
+        return 'gear';
+    }
+    get supportedVersion() {
+        return { min: CLAPPR_VERSION };
+    }
+    // static get version() {
+    //   return process.env.VERSION;
+    // }
+    get template() {
+        return template(pluginHtml);
+    }
+    get attributes() {
+        return {
+            'class': this.name,
+            'data-track-selector': ''
+        };
+    }
+    get events() {
+        return {
+            'click .button-gear': 'toggleGearMenu',
+        };
+    }
+    get container() {
+        return this.core && this.core.activeContainer;
+    }
+    // constructor(core) {
+    //   super(core);
+    //   this.isHd = false;
+    // }
+    bindEvents() {
+        this.listenTo(this.core, Events.CORE_ACTIVE_CONTAINER_CHANGED, this.onActiveContainerChanged);
+        this.listenTo(this.core, 'gear:refresh', this.refresh);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_CONTAINERCHANGED, this.reload);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_RENDERED, this.render);
+        this.listenTo(this.core.mediaControl, Events.MEDIACONTROL_HIDE, this.hide);
+        this.bindContainerEvents();
+    }
+    unBindEvents() {
+        this.stopListening(this.core, Events.CORE_ACTIVE_CONTAINER_CHANGED, this.onActiveContainerChanged);
+        this.stopListening(this.core.mediaControl, Events.MEDIACONTROL_CONTAINERCHANGED, this.reload);
+        this.stopListening(this.core.mediaControl, Events.MEDIACONTROL_RENDERED, this.render);
+        this.stopListening(this.core.mediaControl, Events.MEDIACONTROL_HIDE, this.hide);
+    }
+    onActiveContainerChanged() {
+        this.bindEvents();
+        this.bindContainerEvents();
+    }
+    bindContainerEvents() {
+        if (!this.container) {
+            return;
+        }
+        this.listenTo(this.container, Events.CONTAINER_HIGHDEFINITIONUPDATE, this.highDefinitionUpdate);
+    }
+    reload() {
+        this.unBindEvents();
+        this.bindEvents();
+    }
+    highDefinitionUpdate(isHd) {
+        this.isHd = isHd;
+        if (isHd) {
+            this.$el.find('.gear-icon').html(gearHdIcon);
+        }
+        else {
+            this.$el.find('.gear-icon').html(gearIcon);
+        }
+    }
+    render() {
+        const items = [
+            'quality',
+            'rate',
+            'nerd',
+        ];
+        const icon = this.isHd ? gearHdIcon : gearIcon;
+        trace(`plugins.BottomGear render`, { items, isHd: this.isHd, mediaControl: !!this.core.mediaControl });
+        this.$el.html(this.template({ icon, items }));
+        this.core.mediaControl.$bottomGear?.html(this.el);
+        this.core.trigger('gear:rendered');
+        return this;
+    }
+    refresh() {
+        this.render();
+        this.$el.find('.gear-wrapper').show();
+    }
+    toggleGearMenu() {
+        this.$el.find('.gear-wrapper').toggle();
+    }
+    hide() {
+        this.$el.find('.gear-wrapper').hide();
+    }
+}

package/lib/plugins/click-to-pause/ClickToPause.d.ts

@@ -0,0 +1,16 @@
+import { ContainerPlugin } from '@clappr/core';
+export default class ClickToPause extends ContainerPlugin {
+    private pointerEnabled;
+    private timer;
+    get name(): string;
+    get supportedVersion(): {
+        min: string | undefined;
+    };
+    get config(): any;
+    bindEvents(): void;
+    private click;
+    private settingsUpdate;
+    private togglePlay;
+    private clearTimer;
+}
+//# sourceMappingURL=ClickToPause.d.ts.map

package/lib/plugins/click-to-pause/ClickToPause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClickToPause.d.ts","sourceRoot":"","sources":["../../../src/plugins/click-to-pause/ClickToPause.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAoB,MAAM,cAAc,CAAC;AAOjE,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,eAAe;IACvD,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,KAAK,CAAsB;IAEnC,IAAI,IAAI,WAEP;IAED,IAAI,gBAAgB;;MAEnB;IAED,IAAI,MAAM,QAET;IAMD,UAAU;IAKV,OAAO,CAAC,KAAK;IAoBb,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,UAAU;CAMnB"}