Merge pull request #1779 from Camc314/migrate-to-ES6-67

Migration of experimentalWarnings and sessionPlayer to ES6 modules

package.json

@@ -172,6 +172,8 @@
           "src/components/remotecontrol/remotecontrol.js",
           "src/components/sanatizefilename.js",
           "src/components/scrollManager.js",
+          "src/plugins/experimentalWarnings/plugin.js",
+          "src/plugins/sessionPlayer/plugin.js",
           "src/plugins/htmlAudioPlayer/plugin.js",
           "src/plugins/chromecastPlayer/plugin.js",
           "src/components/slideshow/slideshow.js",

src/components/playback/playbackmanager.js

@@ -1416,8 +1416,8 @@ class PlaybackManager {
 
         self.toggleFullscreen = function (player) {
             player = player || self._currentPlayer;
-            if (!player.isLocalPlayer || player.toggleFulscreen) {
+            if (!player.isLocalPlayer || player.toggleFullscreen) {
-                return player.toggleFulscreen();
+                return player.toggleFullscreen();
             }
 
             if (screenfull.isEnabled) {

src/plugins/experimentalWarnings/plugin.js

@@ -1,15 +1,14 @@
-define(['connectionManager', 'globalize', 'userSettings', 'apphost'], function (connectionManager, globalize, userSettings, appHost) {
+import globalize from 'globalize';
-    'use strict';
+import * as userSettings from 'userSettings';
-
+import appHost from 'apphost';
-    appHost = appHost.default || appHost;
 
 // TODO: Replace with date-fns
 // https://stackoverflow.com/questions/6117814/get-week-of-year-in-javascript-like-in-php
 function getWeek(date) {
-        var d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
-        var dayNum = d.getUTCDay() || 7;
+    const dayNum = d.getUTCDay() || 7;
     d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-        var yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
     return Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
 }
 
@@ -18,7 +17,7 @@ define(['connectionManager', 'globalize', 'userSettings', 'apphost'], function (
         return Promise.resolve();
     }
 
-        var now = new Date();
+    const now = new Date();
 
     // TODO: Use date-fns
     userSettingsKey += now.getFullYear() + '-w' + getWeek(now);
@@ -30,7 +29,7 @@ define(['connectionManager', 'globalize', 'userSettings', 'apphost'], function (
     return new Promise(function (resolve, reject) {
         userSettings.set(userSettingsKey, '1', false);
 
-            require(['alert'], function (alert) {
+        import('alert').then(({default: alert}) => {
             return alert(text).then(resolve, resolve);
         });
     });
@@ -48,14 +47,15 @@ define(['connectionManager', 'globalize', 'userSettings', 'apphost'], function (
     return showMessage(globalize.translate('UnsupportedPlayback'), 'isoexpirementalinfo', 'nativeisoplayback');
 }
 
-    function ExpirementalPlaybackWarnings() {
+class ExpirementalPlaybackWarnings {
+    constructor() {
         this.name = 'Experimental playback warnings';
         this.type = 'preplayintercept';
         this.id = 'expirementalplaybackwarnings';
     }
 
-    ExpirementalPlaybackWarnings.prototype.intercept = function (options) {
+    intercept(options) {
-        var item = options.item;
+        const item = options.item;
         if (!item) {
             return Promise.resolve();
         }
@@ -73,7 +73,7 @@ define(['connectionManager', 'globalize', 'userSettings', 'apphost'], function (
         }
 
         return Promise.resolve();
-    };
+    }
+}
 
-    return ExpirementalPlaybackWarnings;
+export default ExpirementalPlaybackWarnings;
-});

src/plugins/sessionPlayer/plugin.js

@@ -1,22 +1,21 @@
-define(['playbackManager', 'events', 'serverNotifications', 'connectionManager'], function (playbackManager, events, serverNotifications, connectionManager) {
+import playbackManager from 'playbackManager';
-    'use strict';
+import events from 'events';
-
+import serverNotifications from 'serverNotifications';
-    serverNotifications = serverNotifications.default || serverNotifications;
+import connectionManager from 'connectionManager';
-    playbackManager = playbackManager.default || playbackManager;
 
 function getActivePlayerId() {
-        var info = playbackManager.getPlayerInfo();
+    const info = playbackManager.getPlayerInfo();
     return info ? info.id : null;
 }
 
 function sendPlayCommand(apiClient, options, playType) {
-        var sessionId = getActivePlayerId();
+    const sessionId = getActivePlayerId();
 
-        var ids = options.ids || options.items.map(function (i) {
+    const ids = options.ids || options.items.map(function (i) {
         return i.Id;
     });
 
-        var remoteOptions = {
+    const remoteOptions = {
         ItemIds: ids.join(','),
 
         PlayCommand: playType
@@ -46,13 +45,13 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 }
 
 function sendPlayStateCommand(apiClient, command, options) {
-        var sessionId = getActivePlayerId();
+    const sessionId = getActivePlayerId();
 
     apiClient.sendPlayStateCommand(sessionId, command, options);
 }
 
 function getCurrentApiClient(instance) {
-        var currentServerId = instance.currentServerId;
+    const currentServerId = instance.currentServerId;
 
     if (currentServerId) {
         return connectionManager.getApiClient(currentServerId);
@@ -62,7 +61,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 }
 
 function sendCommandByName(instance, name, options) {
-        var command = {
+    const command = {
         Name: name
     };
 
@@ -76,7 +75,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 function unsubscribeFromPlayerUpdates(instance) {
     instance.isUpdating = true;
 
-        var apiClient = getCurrentApiClient(instance);
+    const apiClient = getCurrentApiClient(instance);
     apiClient.sendMessage('SessionsStop');
     if (instance.pollInterval) {
         clearInterval(instance.pollInterval);
@@ -85,7 +84,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 }
 
 function processUpdatedSessions(instance, sessions, apiClient) {
-        var serverId = apiClient.serverId();
+    const serverId = apiClient.serverId();
 
     sessions.map(function (s) {
         if (s.NowPlayingItem) {
@@ -93,19 +92,19 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         }
     });
 
-        var currentTargetId = getActivePlayerId();
+    const currentTargetId = getActivePlayerId();
 
-        var session = sessions.filter(function (s) {
+    const session = sessions.filter(function (s) {
         return s.Id === currentTargetId;
     })[0];
 
     if (session) {
         normalizeImages(session, apiClient);
 
-            var eventNames = getChangedEvents(instance.lastPlayerData, session);
+        const eventNames = getChangedEvents(instance.lastPlayerData, session);
         instance.lastPlayerData = session;
 
-            for (var i = 0, length = eventNames.length; i < length; i++) {
+        for (let i = 0, length = eventNames.length; i < length; i++) {
             events.trigger(instance, eventNames[i], [session]);
         }
     } else {
@@ -116,7 +115,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 }
 
 function getChangedEvents(state1, state2) {
-        var names = [];
+    const names = [];
 
     if (!state1) {
         names.push('statechange');
@@ -135,8 +134,8 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 }
 
 function onPollIntervalFired() {
-        var instance = this;
+    const instance = this;
-        var apiClient = getCurrentApiClient(instance);
+    const apiClient = getCurrentApiClient(instance);
     if (!apiClient.isMessageChannelOpen()) {
         apiClient.getSessions().then(function (sessions) {
             processUpdatedSessions(instance, sessions, apiClient);
@@ -147,7 +146,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 function subscribeToPlayerUpdates(instance) {
     instance.isUpdating = true;
 
-        var apiClient = getCurrentApiClient(instance);
+    const apiClient = getCurrentApiClient(instance);
     apiClient.sendMessage('SessionsStart', '100,800');
     if (instance.pollInterval) {
         clearInterval(instance.pollInterval);
@@ -158,7 +157,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
 
 function normalizeImages(state, apiClient) {
     if (state && state.NowPlayingItem) {
-            var item = state.NowPlayingItem;
+        const item = state.NowPlayingItem;
 
         if (!item.ImageTags || !item.ImageTags.Primary) {
             if (item.PrimaryImageTag) {
@@ -179,8 +178,9 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
     }
 }
 
-    function SessionPlayer() {
+class SessionPlayer {
-        var self = this;
+    constructor() {
+        const self = this;
 
         this.name = 'Remote Control';
         this.type = 'mediaplayer';
@@ -192,7 +192,7 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         });
     }
 
-    SessionPlayer.prototype.beginPlayerUpdates = function () {
+    beginPlayerUpdates() {
         this.playerListenerCount = this.playerListenerCount || 0;
 
         if (this.playerListenerCount <= 0) {
@@ -202,9 +202,9 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         }
 
         this.playerListenerCount++;
-    };
+    }
 
-    SessionPlayer.prototype.endPlayerUpdates = function () {
+    endPlayerUpdates() {
         this.playerListenerCount = this.playerListenerCount || 0;
         this.playerListenerCount--;
 
@@ -212,21 +212,21 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
             unsubscribeFromPlayerUpdates(this);
             this.playerListenerCount = 0;
         }
-    };
+    }
 
-    SessionPlayer.prototype.getPlayerState = function () {
+    getPlayerState() {
         return this.lastPlayerData || {};
-    };
+    }
 
-    SessionPlayer.prototype.getTargets = function () {
+    getTargets() {
-        var apiClient = getCurrentApiClient(this);
+        const apiClient = getCurrentApiClient(this);
 
-        var sessionQuery = {
+        const sessionQuery = {
             ControllableByUserId: apiClient.getCurrentUserId()
         };
 
         if (apiClient) {
-            var name = this.name;
+            const name = this.name;
 
             return apiClient.getSessions(sessionQuery).then(function (sessions) {
                 return sessions.filter(function (s) {
@@ -243,11 +243,9 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
                         isLocalPlayer: false,
                         supportedCommands: s.Capabilities.SupportedCommands,
                         user: s.UserId ? {
-
                             Id: s.UserId,
                             Name: s.UserName,
                             PrimaryImageTag: s.UserPrimaryImageTag
-
                         } : null
                     };
                 });
@@ -255,16 +253,16 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         } else {
             return Promise.resolve([]);
         }
-    };
+    }
 
-    SessionPlayer.prototype.sendCommand = function (command) {
+    sendCommand(command) {
-        var sessionId = getActivePlayerId();
+        const sessionId = getActivePlayerId();
 
-        var apiClient = getCurrentApiClient(this);
+        const apiClient = getCurrentApiClient(this);
         apiClient.sendCommand(sessionId, command);
-    };
+    }
 
-    SessionPlayer.prototype.play = function (options) {
+    play(options) {
         options = Object.assign({}, options);
 
         if (options.items) {
@@ -276,251 +274,233 @@ define(['playbackManager', 'events', 'serverNotifications', 'connectionManager']
         }
 
         return sendPlayCommand(getCurrentApiClient(this), options, 'PlayNow');
-    };
+    }
 
-    SessionPlayer.prototype.shuffle = function (item) {
+    shuffle(item) {
         sendPlayCommand(getCurrentApiClient(this), { ids: [item.Id] }, 'PlayShuffle');
-    };
+    }
 
-    SessionPlayer.prototype.instantMix = function (item) {
+    instantMix(item) {
         sendPlayCommand(getCurrentApiClient(this), { ids: [item.Id] }, 'PlayInstantMix');
-    };
+    }
 
-    SessionPlayer.prototype.queue = function (options) {
+    queue(options) {
         sendPlayCommand(getCurrentApiClient(this), options, 'PlayNext');
-    };
+    }
 
-    SessionPlayer.prototype.queueNext = function (options) {
+    queueNext(options) {
         sendPlayCommand(getCurrentApiClient(this), options, 'PlayLast');
-    };
+    }
 
-    SessionPlayer.prototype.canPlayMediaType = function (mediaType) {
+    canPlayMediaType(mediaType) {
         mediaType = (mediaType || '').toLowerCase();
         return mediaType === 'audio' || mediaType === 'video';
-    };
+    }
 
-    SessionPlayer.prototype.canQueueMediaType = function (mediaType) {
+    canQueueMediaType(mediaType) {
         return this.canPlayMediaType(mediaType);
-    };
+    }
 
-    SessionPlayer.prototype.stop = function () {
+    stop() {
         sendPlayStateCommand(getCurrentApiClient(this), 'stop');
-    };
+    }
 
-    SessionPlayer.prototype.nextTrack = function () {
+    nextTrack() {
         sendPlayStateCommand(getCurrentApiClient(this), 'nextTrack');
-    };
+    }
 
-    SessionPlayer.prototype.previousTrack = function () {
+    previousTrack() {
         sendPlayStateCommand(getCurrentApiClient(this), 'previousTrack');
-    };
+    }
 
-    SessionPlayer.prototype.seek = function (positionTicks) {
+    seek(positionTicks) {
         sendPlayStateCommand(getCurrentApiClient(this), 'seek',
             {
                 SeekPositionTicks: positionTicks
             });
-    };
+    }
 
-    SessionPlayer.prototype.currentTime = function (val) {
+    currentTime(val) {
         if (val != null) {
             return this.seek(val);
         }
 
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.PositionTicks;
-    };
+    }
 
-    SessionPlayer.prototype.duration = function () {
+    duration() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
         return state.RunTimeTicks;
-    };
+    }
 
-    SessionPlayer.prototype.paused = function () {
+    paused() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.IsPaused;
-    };
+    }
 
-    SessionPlayer.prototype.getVolume = function () {
+    getVolume() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.VolumeLevel;
-    };
+    }
 
-    SessionPlayer.prototype.isMuted = function () {
+    isMuted() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.IsMuted;
-    };
+    }
 
-    SessionPlayer.prototype.pause = function () {
+    pause() {
         sendPlayStateCommand(getCurrentApiClient(this), 'Pause');
-    };
+    }
 
-    SessionPlayer.prototype.unpause = function () {
+    unpause() {
         sendPlayStateCommand(getCurrentApiClient(this), 'Unpause');
-    };
+    }
 
-    SessionPlayer.prototype.playPause = function () {
+    playPause() {
         sendPlayStateCommand(getCurrentApiClient(this), 'PlayPause');
-    };
+    }
 
-    SessionPlayer.prototype.setMute = function (isMuted) {
+    setMute(isMuted) {
         if (isMuted) {
             sendCommandByName(this, 'Mute');
         } else {
             sendCommandByName(this, 'Unmute');
         }
-    };
+    }
 
-    SessionPlayer.prototype.toggleMute = function () {
+    toggleMute() {
         sendCommandByName(this, 'ToggleMute');
-    };
+    }
 
-    SessionPlayer.prototype.setVolume = function (vol) {
+    setVolume(vol) {
         sendCommandByName(this, 'SetVolume', {
             Volume: vol
         });
-    };
+    }
 
-    SessionPlayer.prototype.volumeUp = function () {
+    volumeUp() {
         sendCommandByName(this, 'VolumeUp');
-    };
+    }
 
-    SessionPlayer.prototype.volumeDown = function () {
+    volumeDown() {
         sendCommandByName(this, 'VolumeDown');
-    };
+    }
 
-    SessionPlayer.prototype.toggleFullscreen = function () {
+    toggleFullscreen() {
         sendCommandByName(this, 'ToggleFullscreen');
-    };
+    }
 
-    SessionPlayer.prototype.audioTracks = function () {
+    audioTracks() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
-        var streams = state.MediaStreams || [];
+        const streams = state.MediaStreams || [];
         return streams.filter(function (s) {
             return s.Type === 'Audio';
         });
-    };
+    }
 
-    SessionPlayer.prototype.getAudioStreamIndex = function () {
+    getAudioStreamIndex() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.AudioStreamIndex;
-    };
+    }
 
-    SessionPlayer.prototype.playTrailers = function (item) {
+    playTrailers(item) {
         sendCommandByName(this, 'PlayTrailers', {
             ItemId: item.Id
         });
-    };
+    }
 
-    SessionPlayer.prototype.setAudioStreamIndex = function (index) {
+    setAudioStreamIndex(index) {
         sendCommandByName(this, 'SetAudioStreamIndex', {
             Index: index
         });
-    };
+    }
 
-    SessionPlayer.prototype.subtitleTracks = function () {
+    subtitleTracks() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
-        var streams = state.MediaStreams || [];
+        const streams = state.MediaStreams || [];
         return streams.filter(function (s) {
             return s.Type === 'Subtitle';
         });
-    };
+    }
 
-    SessionPlayer.prototype.getSubtitleStreamIndex = function () {
+    getSubtitleStreamIndex() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.PlayState || {};
         return state.SubtitleStreamIndex;
-    };
+    }
 
-    SessionPlayer.prototype.setSubtitleStreamIndex = function (index) {
+    setSubtitleStreamIndex(index) {
         sendCommandByName(this, 'SetSubtitleStreamIndex', {
             Index: index
         });
-    };
+    }
 
-    SessionPlayer.prototype.getMaxStreamingBitrate = function () {
+    setRepeatMode(mode) {
-
-    };
-
-    SessionPlayer.prototype.setMaxStreamingBitrate = function (options) {
-
-    };
-
-    SessionPlayer.prototype.isFullscreen = function () {
-
-    };
-
-    SessionPlayer.prototype.toggleFullscreen = function () {
-
-    };
-
-    SessionPlayer.prototype.getRepeatMode = function () {
-
-    };
-
-    SessionPlayer.prototype.setRepeatMode = function (mode) {
         sendCommandByName(this, 'SetRepeatMode', {
             RepeatMode: mode
         });
-    };
+    }
 
-    SessionPlayer.prototype.setQueueShuffleMode = function (mode) {
+    getRepeatMode() {
+    }
+
+    setQueueShuffleMode(mode) {
         sendCommandByName(this, 'SetShuffleQueue', {
             ShuffleMode: mode
         });
-    };
+    }
 
-    SessionPlayer.prototype.getQueueShuffleMode = function () {
+    getQueueShuffleMode() {
+    }
 
-    };
+    displayContent(options) {
-
-    SessionPlayer.prototype.displayContent = function (options) {
         sendCommandByName(this, 'DisplayContent', options);
-    };
+    }
 
-    SessionPlayer.prototype.isPlaying = function () {
+    isPlaying() {
-        var state = this.lastPlayerData || {};
+        const state = this.lastPlayerData || {};
         return state.NowPlayingItem != null;
-    };
+    }
 
-    SessionPlayer.prototype.isPlayingVideo = function () {
+    isPlayingVideo() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
         return state.MediaType === 'Video';
-    };
+    }
 
-    SessionPlayer.prototype.isPlayingAudio = function () {
+    isPlayingAudio() {
-        var state = this.lastPlayerData || {};
+        let state = this.lastPlayerData || {};
         state = state.NowPlayingItem || {};
         return state.MediaType === 'Audio';
-    };
+    }
 
-    SessionPlayer.prototype.getPlaylist = function () {
+    getPlaylist() {
         return Promise.resolve([]);
-    };
+    }
 
-    SessionPlayer.prototype.getCurrentPlaylistItemId = function () {
+    getCurrentPlaylistItemId() {
-    };
+    }
 
-    SessionPlayer.prototype.setCurrentPlaylistItem = function (playlistItemId) {
+    setCurrentPlaylistItem(playlistItemId) {
         return Promise.resolve();
-    };
+    }
 
-    SessionPlayer.prototype.removeFromPlaylist = function (playlistItemIds) {
+    removeFromPlaylist(playlistItemIds) {
         return Promise.resolve();
-    };
+    }
 
-    SessionPlayer.prototype.tryPair = function (target) {
+    tryPair(target) {
         return Promise.resolve();
-    };
+    }
+}
 
-    return SessionPlayer;
+export default SessionPlayer;
-});

src/scripts/site.js

@@ -340,7 +340,7 @@ function initClient() {
     function getPlaybackManager(playbackManager) {
         window.addEventListener('beforeunload', function () {
             try {
-                playbackManager.onAppClose();
+                playbackManager.default.onAppClose();
             } catch (err) {
                 console.error('error in onAppClose: ' + err);
             }