fix casing for a few files

src/scripts/deleteHelper.js

@@ -0,0 +1,54 @@
+import connectionManager from 'connectionManager';
+import confirm from 'confirm';
+import appRouter from 'appRouter';
+import globalize from 'globalize';
+
+function alertText(options) {
+
+    return new Promise(function (resolve, reject) {
+
+        require(['alert'], function (alert) {
+            alert(options).then(resolve, resolve);
+        });
+    });
+}
+
+export function deleteItem(options) {
+
+    const item = options.item;
+    const parentId = item.SeasonId || item.SeriesId || item.ParentId;
+
+    let apiClient = connectionManager.getApiClient(item.ServerId);
+
+    return confirm({
+
+        title: globalize.translate('HeaderDeleteItem'),
+        text: globalize.translate('ConfirmDeleteItem'),
+        confirmText: globalize.translate('Delete'),
+        primary: 'delete'
+
+    }).then(function () {
+
+        return apiClient.deleteItem(item.Id).then(function () {
+
+            if (options.navigate) {
+                if (parentId) {
+                    appRouter.showItem(parentId, item.ServerId);
+                } else {
+                    appRouter.goHome();
+                }
+            }
+        }, function (err) {
+
+            let result = function () {
+                return Promise.reject(err);
+            };
+
+            return alertText(globalize.translate('ErrorDeletingItem')).then(result, result);
+        });
+    });
+}
+
+export default {
+    deleteItem: deleteItem
+};

src/scripts/fileDownloader.js

@@ -0,0 +1,14 @@
+import multiDownload from 'multi-download';
+
+export function download(items) {
+
+    if (window.NativeShell) {
+        items.map(function (item) {
+            window.NativeShell.downloadFile(item);
+        });
+    } else {
+        multiDownload(items.map(function (item) {
+            return item.url;
+        }));
+    }
+}

src/scripts/multiDownload.js

@@ -0,0 +1,66 @@
+define(['browser'], function (browser) {
+    'use strict';
+
+    function fallback(urls) {
+        var i = 0;
+
+        (function createIframe() {
+            var frame = document.createElement('iframe');
+            frame.style.display = 'none';
+            frame.src = urls[i++];
+            document.documentElement.appendChild(frame);
+
+            // the download init has to be sequential otherwise IE only use the first
+            var interval = setInterval(function () {
+                if (frame.contentWindow.document.readyState === 'complete' || frame.contentWindow.document.readyState === 'interactive') {
+                    clearInterval(interval);
+
+                    // Safari needs a timeout
+                    setTimeout(function () {
+                        frame.parentNode.removeChild(frame);
+                    }, 1000);
+
+                    if (i < urls.length) {
+                        createIframe();
+                    }
+                }
+            }, 100);
+        })();
+    }
+
+    function sameDomain(url) {
+        var a = document.createElement('a');
+        a.href = url;
+
+        return location.hostname === a.hostname && location.protocol === a.protocol;
+    }
+
+    function download(url) {
+        var a = document.createElement('a');
+        a.download = '';
+        a.href = url;
+        // firefox doesn't support `a.click()`...
+        a.dispatchEvent(new MouseEvent('click'));
+    }
+
+    return function (urls) {
+        if (!urls) {
+            throw new Error('`urls` required');
+        }
+
+        if (typeof document.createElement('a').download === 'undefined') {
+            return fallback(urls);
+        }
+
+        var delay = 0;
+
+        urls.forEach(function (url) {
+            // the download init has to be sequential for firefox if the urls are not on the same domain
+            if (browser.firefox && !sameDomain(url)) {
+                return setTimeout(download.bind(null, url), 100 * ++delay);
+            }
+
+            download(url);
+        });
+    };
+});

src/scripts/scrollHelper.js

@@ -0,0 +1,137 @@
+define(['focusManager', 'dom', 'scrollStyles'], function (focusManager, dom) {
+    'use strict';
+
+    function getBoundingClientRect(elem) {
+
+        // Support: BlackBerry 5, iOS 3 (original iPhone)
+        // If we don't have gBCR, just use 0,0 rather than error
+        if (elem.getBoundingClientRect) {
+            return elem.getBoundingClientRect();
+        } else {
+            return { top: 0, left: 0 };
+        }
+    }
+
+    function getPosition(scrollContainer, item, horizontal) {
+
+        var slideeOffset = getBoundingClientRect(scrollContainer);
+        var itemOffset = getBoundingClientRect(item);
+
+        var offset = horizontal ? itemOffset.left - slideeOffset.left : itemOffset.top - slideeOffset.top;
+        var size = horizontal ? itemOffset.width : itemOffset.height;
+        if (!size && size !== 0) {
+            size = item[horizontal ? 'offsetWidth' : 'offsetHeight'];
+        }
+
+        var currentStart = horizontal ? scrollContainer.scrollLeft : scrollContainer.scrollTop;
+
+        offset += currentStart;
+
+        var frameSize = horizontal ? scrollContainer.offsetWidth : scrollContainer.offsetHeight;
+
+        var currentEnd = currentStart + frameSize;
+
+        var isVisible = offset >= currentStart && (offset + size) <= currentEnd;
+
+        return {
+            start: offset,
+            center: (offset - (frameSize / 2) + (size / 2)),
+            end: offset - frameSize + size,
+            size: size,
+            isVisible: isVisible
+        };
+    }
+
+    function toCenter(container, elem, horizontal, skipWhenVisible) {
+        var pos = getPosition(container, elem, horizontal);
+
+        if (skipWhenVisible && pos.isVisible) {
+            return;
+        }
+
+        if (container.scrollTo) {
+            if (horizontal) {
+                container.scrollTo(pos.center, 0);
+            } else {
+                container.scrollTo(0, pos.center);
+            }
+        } else {
+            if (horizontal) {
+                container.scrollLeft = Math.round(pos.center);
+            } else {
+                container.scrollTop = Math.round(pos.center);
+            }
+        }
+    }
+
+    function toStart(container, elem, horizontal, skipWhenVisible) {
+        var pos = getPosition(container, elem, horizontal);
+
+        if (skipWhenVisible && pos.isVisible) {
+            return;
+        }
+
+        if (container.scrollTo) {
+            if (horizontal) {
+                container.scrollTo(pos.start, 0);
+            } else {
+                container.scrollTo(0, pos.start);
+            }
+        } else {
+            if (horizontal) {
+                container.scrollLeft = Math.round(pos.start);
+            } else {
+                container.scrollTop = Math.round(pos.start);
+            }
+        }
+    }
+
+    function centerOnFocus(e, scrollSlider, horizontal) {
+        var focused = focusManager.focusableParent(e.target);
+
+        if (focused) {
+            toCenter(scrollSlider, focused, horizontal);
+        }
+    }
+
+    function centerOnFocusHorizontal(e) {
+        centerOnFocus(e, this, true);
+    }
+    function centerOnFocusVertical(e) {
+        centerOnFocus(e, this, false);
+    }
+
+    return {
+        getPosition: getPosition,
+        centerFocus: {
+            on: function (element, horizontal) {
+                if (horizontal) {
+                    dom.addEventListener(element, 'focus', centerOnFocusHorizontal, {
+                        capture: true,
+                        passive: true
+                    });
+                } else {
+                    dom.addEventListener(element, 'focus', centerOnFocusVertical, {
+                        capture: true,
+                        passive: true
+                    });
+                }
+            },
+            off: function (element, horizontal) {
+                if (horizontal) {
+                    dom.removeEventListener(element, 'focus', centerOnFocusHorizontal, {
+                        capture: true,
+                        passive: true
+                    });
+                } else {
+                    dom.removeEventListener(element, 'focus', centerOnFocusVertical, {
+                        capture: true,
+                        passive: true
+                    });
+                }
+            }
+        },
+        toCenter: toCenter,
+        toStart: toStart
+    };
+});

src/scripts/serverNotifications.js

@@ -0,0 +1,204 @@
+define(['connectionManager', 'playbackManager', 'events', 'inputManager', 'focusManager', 'appRouter'], function (connectionManager, playbackManager, events, inputManager, focusManager, appRouter) {
+    'use strict';
+
+    var serverNotifications = {};
+
+    function notifyApp() {
+        inputManager.notify();
+    }
+
+    function displayMessage(cmd) {
+        var args = cmd.Arguments;
+        if (args.TimeoutMs) {
+            require(['toast'], function (toast) {
+                toast({ title: args.Header, text: args.Text });
+            });
+        } else {
+            require(['alert'], function (alert) {
+                alert({ title: args.Header, text: args.Text });
+            });
+        }
+    }
+
+    function displayContent(cmd, apiClient) {
+        if (!playbackManager.isPlayingLocally(['Video', 'Book'])) {
+            appRouter.showItem(cmd.Arguments.ItemId, apiClient.serverId());
+        }
+    }
+
+    function playTrailers(apiClient, itemId) {
+        apiClient.getItem(apiClient.getCurrentUserId(), itemId).then(function (item) {
+            playbackManager.playTrailers(item);
+        });
+    }
+
+    function processGeneralCommand(cmd, apiClient) {
+        console.debug('Received command: ' + cmd.Name);
+        switch (cmd.Name) {
+            case 'Select':
+                inputManager.trigger('select');
+                return;
+            case 'Back':
+                inputManager.trigger('back');
+                return;
+            case 'MoveUp':
+                inputManager.trigger('up');
+                return;
+            case 'MoveDown':
+                inputManager.trigger('down');
+                return;
+            case 'MoveLeft':
+                inputManager.trigger('left');
+                return;
+            case 'MoveRight':
+                inputManager.trigger('right');
+                return;
+            case 'PageUp':
+                inputManager.trigger('pageup');
+                return;
+            case 'PageDown':
+                inputManager.trigger('pagedown');
+                return;
+            case 'PlayTrailers':
+                playTrailers(apiClient, cmd.Arguments.ItemId);
+                break;
+            case 'SetRepeatMode':
+                playbackManager.setRepeatMode(cmd.Arguments.RepeatMode);
+                break;
+            case 'VolumeUp':
+                inputManager.trigger('volumeup');
+                return;
+            case 'VolumeDown':
+                inputManager.trigger('volumedown');
+                return;
+            case 'ChannelUp':
+                inputManager.trigger('channelup');
+                return;
+            case 'ChannelDown':
+                inputManager.trigger('channeldown');
+                return;
+            case 'Mute':
+                inputManager.trigger('mute');
+                return;
+            case 'Unmute':
+                inputManager.trigger('unmute');
+                return;
+            case 'ToggleMute':
+                inputManager.trigger('togglemute');
+                return;
+            case 'SetVolume':
+                notifyApp();
+                playbackManager.setVolume(cmd.Arguments.Volume);
+                break;
+            case 'SetAudioStreamIndex':
+                notifyApp();
+                playbackManager.setAudioStreamIndex(parseInt(cmd.Arguments.Index));
+                break;
+            case 'SetSubtitleStreamIndex':
+                notifyApp();
+                playbackManager.setSubtitleStreamIndex(parseInt(cmd.Arguments.Index));
+                break;
+            case 'ToggleFullscreen':
+                inputManager.trigger('togglefullscreen');
+                return;
+            case 'GoHome':
+                inputManager.trigger('home');
+                return;
+            case 'GoToSettings':
+                inputManager.trigger('settings');
+                return;
+            case 'DisplayContent':
+                displayContent(cmd, apiClient);
+                break;
+            case 'GoToSearch':
+                inputManager.trigger('search');
+                return;
+            case 'DisplayMessage':
+                displayMessage(cmd);
+                break;
+            case 'ToggleOsd':
+                // todo
+                break;
+            case 'ToggleContextMenu':
+                // todo
+                break;
+            case 'TakeScreenShot':
+                // todo
+                break;
+            case 'SendKey':
+                // todo
+                break;
+            case 'SendString':
+                // todo
+                focusManager.sendText(cmd.Arguments.String);
+                break;
+            default:
+                console.debug('processGeneralCommand does not recognize: ' + cmd.Name);
+                break;
+        }
+
+        notifyApp();
+    }
+
+    function onMessageReceived(e, msg) {
+        var apiClient = this;
+        if (msg.MessageType === 'Play') {
+            notifyApp();
+            var serverId = apiClient.serverInfo().Id;
+            if (msg.Data.PlayCommand === 'PlayNext') {
+                playbackManager.queueNext({ ids: msg.Data.ItemIds, serverId: serverId });
+            } else if (msg.Data.PlayCommand === 'PlayLast') {
+                playbackManager.queue({ ids: msg.Data.ItemIds, serverId: serverId });
+            } else {
+                playbackManager.play({
+                    ids: msg.Data.ItemIds,
+                    startPositionTicks: msg.Data.StartPositionTicks,
+                    mediaSourceId: msg.Data.MediaSourceId,
+                    audioStreamIndex: msg.Data.AudioStreamIndex,
+                    subtitleStreamIndex: msg.Data.SubtitleStreamIndex,
+                    startIndex: msg.Data.StartIndex,
+                    serverId: serverId
+                });
+            }
+        } else if (msg.MessageType === 'Playstate') {
+            if (msg.Data.Command === 'Stop') {
+                inputManager.trigger('stop');
+            } else if (msg.Data.Command === 'Pause') {
+                inputManager.trigger('pause');
+            } else if (msg.Data.Command === 'Unpause') {
+                inputManager.trigger('play');
+            } else if (msg.Data.Command === 'PlayPause') {
+                inputManager.trigger('playpause');
+            } else if (msg.Data.Command === 'Seek') {
+                playbackManager.seek(msg.Data.SeekPositionTicks);
+            } else if (msg.Data.Command === 'NextTrack') {
+                inputManager.trigger('next');
+            } else if (msg.Data.Command === 'PreviousTrack') {
+                inputManager.trigger('previous');
+            } else {
+                notifyApp();
+            }
+        } else if (msg.MessageType === 'GeneralCommand') {
+            var cmd = msg.Data;
+            processGeneralCommand(cmd, apiClient);
+        } else if (msg.MessageType === 'UserDataChanged') {
+            if (msg.Data.UserId === apiClient.getCurrentUserId()) {
+                for (var i = 0, length = msg.Data.UserDataList.length; i < length; i++) {
+                    events.trigger(serverNotifications, 'UserDataChanged', [apiClient, msg.Data.UserDataList[i]]);
+                }
+            }
+        } else {
+            events.trigger(serverNotifications, msg.MessageType, [apiClient, msg.Data]);
+        }
+    }
+    function bindEvents(apiClient) {
+        events.off(apiClient, 'message', onMessageReceived);
+        events.on(apiClient, 'message', onMessageReceived);
+    }
+
+    connectionManager.getApiClients().forEach(bindEvents);
+    events.on(connectionManager, 'apiclientcreated', function (e, newApiClient) {
+        bindEvents(newApiClient);
+    });
+    return serverNotifications;
+});

src/scripts/shell.js

@@ -0,0 +1,24 @@
+define([], function () {
+    'use strict';
+
+    return {
+        openUrl: function (url, target) {
+            if (window.NativeShell) {
+                window.NativeShell.openUrl(url, target);
+            } else {
+                window.open(url, target || '_blank');
+            }
+
+        },
+        enableFullscreen: function () {
+            if (window.NativeShell) {
+                window.NativeShell.enableFullscreen();
+            }
+        },
+        disableFullscreen: function () {
+            if (window.NativeShell) {
+                window.NativeShell.disableFullscreen();
+            }
+        }
+    };
+});

src/scripts/site.js

@@ -376,7 +376,7 @@ var AppInfo = {};
         define('filesystem', [scriptsPath + '/filesystem'], returnFirstDependency);
 
         define('lazyLoader', [componentsPath + '/lazyloader/lazyloader-intersectionobserver'], returnFirstDependency);
-        define('shell', [componentsPath + '/shell'], returnFirstDependency);
+        define('shell', [scriptsPath + '/shell'], returnFirstDependency);
 
         if ('registerElement' in document) {
             define('registerElement', []);
@@ -397,8 +397,8 @@ var AppInfo = {};
         define('prompt', [componentsPath + '/prompt/prompt'], returnFirstDependency);
 
         define('loading', [componentsPath + '/loading/loading'], returnFirstDependency);
-        define('multi-download', [componentsPath + '/multidownload'], returnFirstDependency);
-        define('fileDownloader', [componentsPath + '/filedownloader'], returnFirstDependency);
+        define('multi-download', [scriptsPath + '/multiDownload'], returnFirstDependency);
+        define('fileDownloader', [scriptsPath + '/fileDownloader'], returnFirstDependency);
 
         define('castSenderApiLoader', [componentsPath + '/castSenderApi'], returnFirstDependency);
     }
@@ -490,7 +490,7 @@ var AppInfo = {};
         ];
 
         if (appHost.supports('remotecontrol')) {
-            list.push('components/sessionplayer');
+            list.push('components/sessionPlayer');
 
             if (browser.chrome || browser.opera) {
                 list.push('components/chromecast/chromecastplayer');
@@ -532,13 +532,13 @@ var AppInfo = {};
 
             window.Emby.Page = appRouter;
 
-            require(['emby-button', 'scripts/themeloader', 'libraryMenu', 'scripts/routes'], function () {
+            require(['emby-button', 'scripts/themeLoader', 'libraryMenu', 'scripts/routes'], function () {
                 Emby.Page.start({
                     click: false,
                     hashbang: true
                 });
 
-                require(['components/thememediaplayer', 'scripts/autobackdrops']);
+                require(['components/thememediaplayer', 'scripts/autoBackdrops']);
 
                 if (!browser.tv && !browser.xboxOne && !browser.ps4) {
                     require(['components/nowplayingbar/nowplayingbar']);
@@ -630,14 +630,14 @@ var AppInfo = {};
         var scriptsPath = getScriptsPath();
 
         var paths = {
-            browserdeviceprofile: 'scripts/browserdeviceprofile',
+            browserdeviceprofile: 'scripts/browserDeviceProfile',
             browser: 'scripts/browser',
-            libraryBrowser: 'scripts/librarybrowser',
+            libraryBrowser: 'scripts/libraryBrowser',
             inputManager: 'scripts/inputManager',
             datetime: 'scripts/datetime',
             globalize: 'scripts/globalize',
             dfnshelper: 'scripts/dfnshelper',
-            libraryMenu: 'scripts/librarymenu',
+            libraryMenu: 'scripts/libraryMenu',
             playlisteditor: componentsPath + '/playlisteditor/playlisteditor',
             medialibrarycreator: componentsPath + '/medialibrarycreator/medialibrarycreator',
             medialibraryeditor: componentsPath + '/medialibraryeditor/medialibraryeditor',
@@ -826,7 +826,7 @@ var AppInfo = {};
         define('cardBuilder', [componentsPath + '/cardbuilder/cardBuilder'], returnFirstDependency);
         define('peoplecardbuilder', [componentsPath + '/cardbuilder/peoplecardbuilder'], returnFirstDependency);
         define('chaptercardbuilder', [componentsPath + '/cardbuilder/chaptercardbuilder'], returnFirstDependency);
-        define('deleteHelper', [componentsPath + '/deletehelper'], returnFirstDependency);
+        define('deleteHelper', [componentsPath + '/deleteHelper'], returnFirstDependency);
         define('tvguide', [componentsPath + '/guide/guide'], returnFirstDependency);
         define('guide-settings-dialog', [componentsPath + '/guide/guide-settings'], returnFirstDependency);
         define('loadingDialog', [componentsPath + '/loadingdialog/loadingdialog'], returnFirstDependency);
@@ -843,18 +843,17 @@ var AppInfo = {};
         define('viewSettings', [componentsPath + '/viewsettings/viewsettings'], returnFirstDependency);
         define('filterMenu', [componentsPath + '/filtermenu/filtermenu'], returnFirstDependency);
         define('sortMenu', [componentsPath + '/sortmenu/sortmenu'], returnFirstDependency);
-        define('idb', [componentsPath + '/idb'], returnFirstDependency);
         define('sanitizefilename', [componentsPath + '/sanitizefilename'], returnFirstDependency);
         define('toast', [componentsPath + '/toast/toast'], returnFirstDependency);
-        define('scrollHelper', [componentsPath + '/scrollhelper'], returnFirstDependency);
-        define('touchHelper', [componentsPath + '/touchhelper'], returnFirstDependency);
+        define('scrollHelper', [componentsPath + '/scrollHelper'], returnFirstDependency);
+        define('touchHelper', [scriptsPath + '/touchHelper'], returnFirstDependency);
         define('imageUploader', [componentsPath + '/imageuploader/imageuploader'], returnFirstDependency);
         define('htmlMediaHelper', [componentsPath + '/htmlMediaHelper'], returnFirstDependency);
         define('viewContainer', [componentsPath + '/viewContainer'], returnFirstDependency);
         define('dialogHelper', [componentsPath + '/dialogHelper/dialogHelper'], returnFirstDependency);
-        define('serverNotifications', [componentsPath + '/serverNotifications'], returnFirstDependency);
+        define('serverNotifications', [scriptsPath + '/serverNotifications'], returnFirstDependency);
         define('skinManager', [componentsPath + '/skinManager'], returnFirstDependency);
-        define('keyboardnavigation', [scriptsPath + '/keyboardnavigation'], returnFirstDependency);
+        define('keyboardnavigation', [scriptsPath + '/keyboardNavigation'], returnFirstDependency);
         define('mouseManager', [scriptsPath + '/mouseManager'], returnFirstDependency);
         define('scrollManager', [componentsPath + '/scrollManager'], returnFirstDependency);
         define('autoFocuser', [componentsPath + '/autoFocuser'], returnFirstDependency);

src/scripts/touchHelper.js

@@ -0,0 +1,171 @@
+define(['dom', 'events'], function (dom, events) {
+    'use strict';
+
+    function getTouches(e) {
+
+        return e.changedTouches || e.targetTouches || e.touches;
+    }
+
+    function TouchHelper(elem, options) {
+
+        options = options || {};
+        var touchTarget;
+        var touchStartX;
+        var touchStartY;
+        var lastDeltaX;
+        var lastDeltaY;
+        var thresholdYMet;
+        var self = this;
+
+        var swipeXThreshold = options.swipeXThreshold || 50;
+        var swipeYThreshold = options.swipeYThreshold || 50;
+        var swipeXMaxY = 30;
+
+        var excludeTagNames = options.ignoreTagNames || [];
+
+        var touchStart = function (e) {
+
+            var touch = getTouches(e)[0];
+            touchTarget = null;
+            touchStartX = 0;
+            touchStartY = 0;
+            lastDeltaX = null;
+            lastDeltaY = null;
+            thresholdYMet = false;
+
+            if (touch) {
+
+                var currentTouchTarget = touch.target;
+
+                if (dom.parentWithTag(currentTouchTarget, excludeTagNames)) {
+                    return;
+                }
+
+                touchTarget = currentTouchTarget;
+                touchStartX = touch.clientX;
+                touchStartY = touch.clientY;
+            }
+        };
+
+        var touchEnd = function (e) {
+
+            var isTouchMove = e.type === 'touchmove';
+
+            if (touchTarget) {
+                var touch = getTouches(e)[0];
+
+                var deltaX;
+                var deltaY;
+
+                var clientX;
+                var clientY;
+
+                if (touch) {
+                    clientX = touch.clientX || 0;
+                    clientY = touch.clientY || 0;
+                    deltaX = clientX - (touchStartX || 0);
+                    deltaY = clientY - (touchStartY || 0);
+                } else {
+                    deltaX = 0;
+                    deltaY = 0;
+                }
+
+                var currentDeltaX = lastDeltaX == null ? deltaX : (deltaX - lastDeltaX);
+                var currentDeltaY = lastDeltaY == null ? deltaY : (deltaY - lastDeltaY);
+
+                lastDeltaX = deltaX;
+                lastDeltaY = deltaY;
+
+                if (deltaX > swipeXThreshold && Math.abs(deltaY) < swipeXMaxY) {
+                    events.trigger(self, 'swiperight', [touchTarget]);
+                } else if (deltaX < (0 - swipeXThreshold) && Math.abs(deltaY) < swipeXMaxY) {
+                    events.trigger(self, 'swipeleft', [touchTarget]);
+                } else if ((deltaY < (0 - swipeYThreshold) || thresholdYMet) && Math.abs(deltaX) < swipeXMaxY) {
+
+                    thresholdYMet = true;
+
+                    events.trigger(self, 'swipeup', [touchTarget, {
+                        deltaY: deltaY,
+                        deltaX: deltaX,
+                        clientX: clientX,
+                        clientY: clientY,
+                        currentDeltaX: currentDeltaX,
+                        currentDeltaY: currentDeltaY
+                    }]);
+                } else if ((deltaY > swipeYThreshold || thresholdYMet) && Math.abs(deltaX) < swipeXMaxY) {
+                    thresholdYMet = true;
+
+                    events.trigger(self, 'swipedown', [touchTarget, {
+                        deltaY: deltaY,
+                        deltaX: deltaX,
+                        clientX: clientX,
+                        clientY: clientY,
+                        currentDeltaX: currentDeltaX,
+                        currentDeltaY: currentDeltaY
+                    }]);
+                }
+
+                if (isTouchMove && options.preventDefaultOnMove) {
+                    e.preventDefault();
+                }
+            }
+
+            if (!isTouchMove) {
+                touchTarget = null;
+                touchStartX = 0;
+                touchStartY = 0;
+                lastDeltaX = null;
+                lastDeltaY = null;
+                thresholdYMet = false;
+            }
+        };
+
+        this.touchStart = touchStart;
+        this.touchEnd = touchEnd;
+
+        dom.addEventListener(elem, 'touchstart', touchStart, {
+            passive: true
+        });
+        if (options.triggerOnMove) {
+            dom.addEventListener(elem, 'touchmove', touchEnd, {
+                passive: !options.preventDefaultOnMove
+            });
+        }
+        dom.addEventListener(elem, 'touchend', touchEnd, {
+            passive: true
+        });
+        dom.addEventListener(elem, 'touchcancel', touchEnd, {
+            passive: true
+        });
+    }
+
+    TouchHelper.prototype.destroy = function () {
+
+        var elem = this.elem;
+
+        if (elem) {
+            var touchStart = this.touchStart;
+            var touchEnd = this.touchEnd;
+
+            dom.removeEventListener(elem, 'touchstart', touchStart, {
+                passive: true
+            });
+            dom.removeEventListener(elem, 'touchmove', touchEnd, {
+                passive: true
+            });
+            dom.removeEventListener(elem, 'touchend', touchEnd, {
+                passive: true
+            });
+            dom.removeEventListener(elem, 'touchcancel', touchEnd, {
+                passive: true
+            });
+        }
+
+        this.touchStart = null;
+        this.touchEnd = null;
+
+        this.elem = null;
+    };
+
+    return TouchHelper;
+});