fix merge conflicts

dashboard-ui/bower_components/emby-webcomponents/images/basicimageloader.js

@@ -0,0 +1,25 @@
+define([], function () {
+
+    function loadImage(elem, url) {
+
+        if (elem.tagName !== "IMG") {
+
+            var tmp = new Image();
+
+            tmp.onload = function () {
+                elem.style.backgroundImage = "url('" + url + "')";
+            };
+            tmp.src = url;
+
+        } else {
+            elem.setAttribute("src", url);
+        }
+
+        return Promise.resolve(elem);
+    }
+
+    return {
+        loadImage: loadImage
+    };
+
+});

dashboard-ui/bower_components/emby-webcomponents/images/imagehelper.js

@@ -0,0 +1,175 @@
+define(['visibleinviewport', 'imageloader'], function (visibleinviewport, imageLoader) {
+
+    var thresholdX = screen.availWidth;
+    var thresholdY = screen.availHeight;
+
+    var wheelEvent = (document.implementation.hasFeature('Event.wheel', '3.0') ? 'wheel' : 'mousewheel');
+
+    function isVisible(elem) {
+        return visibleinviewport(elem, true, thresholdX, thresholdY);
+    }
+
+    function fillImage(elem) {
+        var source = elem.getAttribute('data-src');
+        if (source) {
+            imageLoader.loadImage(elem, source);
+            elem.setAttribute("data-src", '');
+        }
+    }
+
+    function cancelAll(tokens) {
+        for (var i = 0, length = tokens.length; i < length; i++) {
+
+            tokens[i] = true;
+        }
+    }
+
+    function unveilElements(images) {
+
+        if (!images.length) {
+            return;
+        }
+
+        var cancellationTokens = [];
+        function unveilInternal(tokenIndex) {
+
+            var remaining = [];
+            var anyFound = false;
+            var out = false;
+
+            // TODO: This out construct assumes left to right, top to bottom
+
+            for (var i = 0, length = images.length; i < length; i++) {
+
+                if (cancellationTokens[tokenIndex]) {
+                    return;
+                }
+                var img = images[i];
+                if (!out && isVisible(img)) {
+                    anyFound = true;
+                    fillImage(img);
+                } else {
+
+                    if (anyFound) {
+                        out = true;
+                    }
+                    remaining.push(img);
+                }
+            }
+
+            images = remaining;
+
+            if (!images.length) {
+                document.removeEventListener('focus', unveil, true);
+                document.removeEventListener('scroll', unveil, true);
+                document.removeEventListener(wheelEvent, unveil, true);
+                window.removeEventListener('resize', unveil, true);
+            }
+        }
+
+        function unveil() {
+
+            cancelAll(cancellationTokens);
+
+            var index = cancellationTokens.length;
+            cancellationTokens.length++;
+
+            setTimeout(function () {
+                unveilInternal(index);
+            }, 1);
+        }
+
+        document.addEventListener('scroll', unveil, true);
+        document.addEventListener('focus', unveil, true);
+        document.addEventListener(wheelEvent, unveil, true);
+        window.addEventListener('resize', unveil, true);
+
+        unveil();
+    }
+
+    function fillImages(elems) {
+
+        for (var i = 0, length = elems.length; i < length; i++) {
+            var elem = elems[0];
+            var source = elem.getAttribute('data-src');
+            if (source) {
+                ImageStore.setImageInto(elem, source);
+                elem.setAttribute("data-src", '');
+            }
+        }
+    }
+
+    function lazyChildren(elem) {
+
+        unveilElements(elem.getElementsByClassName('lazy'));
+    }
+
+    function lazyImage(elem, url) {
+
+        elem.setAttribute('data-src', url);
+        fillImages([elem]);
+    }
+
+    function getPrimaryImageAspectRatio(items) {
+
+        var values = [];
+
+        for (var i = 0, length = items.length; i < length; i++) {
+
+            var ratio = items[i].PrimaryImageAspectRatio || 0;
+
+            if (!ratio) {
+                continue;
+            }
+
+            values[values.length] = ratio;
+        }
+
+        if (!values.length) {
+            return null;
+        }
+
+        // Use the median
+        values.sort(function (a, b) { return a - b; });
+
+        var half = Math.floor(values.length / 2);
+
+        var result;
+
+        if (values.length % 2)
+            result = values[half];
+        else
+            result = (values[half - 1] + values[half]) / 2.0;
+
+        // If really close to 2:3 (poster image), just return 2:3
+        var aspect2x3 = 2 / 3;
+        if (Math.abs(aspect2x3 - result) <= .15) {
+            return aspect2x3;
+        }
+
+        // If really close to 16:9 (episode image), just return 16:9
+        var aspect16x9 = 16 / 9;
+        if (Math.abs(aspect16x9 - result) <= .2) {
+            return aspect16x9;
+        }
+
+        // If really close to 1 (square image), just return 1
+        if (Math.abs(1 - result) <= .15) {
+            return 1;
+        }
+
+        // If really close to 4:3 (poster image), just return 2:3
+        var aspect4x3 = 4 / 3;
+        if (Math.abs(aspect4x3 - result) <= .15) {
+            return aspect4x3;
+        }
+
+        return result;
+    }
+
+    return {
+        lazyChildren: lazyChildren,
+        getPrimaryImageAspectRatio: getPrimaryImageAspectRatio
+    };
+
+});

dashboard-ui/bower_components/emby-webcomponents/images/persistentimageloader.js

@@ -0,0 +1,164 @@
+define(['cryptojs-md5'], function () {
+
+    function setImageIntoElement(elem, url) {
+
+        if (elem.tagName !== "IMG") {
+
+            elem.style.backgroundImage = "url('" + url + "')";
+
+        } else {
+            elem.setAttribute("src", url);
+        }
+    }
+
+    // Request Quota (only for File System API)  
+    var requestedBytes = 1024 * 1024 * 1500;
+    var imageCacheDirectoryEntry;
+    var imageCacheFolder = 'images';
+
+    function createDir(rootDirEntry, folders, callback, errorCallback) {
+        // Throw out './' or '/' and move on to prevent something like '/foo/.//bar'.
+        if (folders[0] == '.' || folders[0] == '') {
+            folders = folders.slice(1);
+        }
+        rootDirEntry.getDirectory(folders[0], { create: true }, function (dirEntry) {
+            // Recursively add the new subfolder (if we still have another to create).
+            if (folders.length > 1) {
+                createDir(dirEntry, folders.slice(1), callback, errorCallback);
+            } else {
+                callback(dirEntry);
+            }
+        }, errorCallback);
+    }
+
+    navigator.webkitPersistentStorage.requestQuota(
+        requestedBytes, function (grantedBytes) {
+
+            var requestMethod = window.webkitRequestFileSystem || window.requestFileSystem;
+
+            requestMethod(PERSISTENT, grantedBytes, function (fs) {
+
+                fileSystem = fs;
+
+                createDir(fileSystem.root, imageCacheFolder.split('/'), function (dirEntry) {
+
+                    imageCacheDirectoryEntry = dirEntry;
+
+                });
+
+            });
+
+        });
+
+    function getCacheKey(url) {
+
+        // Try to strip off the domain to share the cache between local and remote connections
+        var index = url.indexOf('://');
+
+        if (index != -1) {
+            url = url.substring(index + 3);
+
+            index = url.indexOf('/');
+
+            if (index != -1) {
+                url = url.substring(index + 1);
+            }
+
+        }
+
+        return CryptoJS.MD5(url).toString();
+    }
+
+    function downloadToFile(url, dir, filename, callback, errorCallback) {
+
+        console.log('Downloading ' + url);
+
+        var xhr = new XMLHttpRequest();
+        xhr.open('GET', url, true);
+        xhr.responseType = "arraybuffer";
+
+        xhr.onload = function (e) {
+            if (this.status == 200) {
+                writeData(dir, filename, this.getResponseHeader('Content-Type'), this.response, callback, errorCallback);
+            } else {
+                errorCallback();
+            }
+        }
+
+        xhr.send();
+    }
+
+    function writeData(dir, filename, fileType, data, callback, errorCallback) {
+
+        dir.getFile(filename, { create: true }, function (fileEntry) {
+
+            // Create a FileWriter object for our FileEntry (log.txt).
+            fileEntry.createWriter(function (fileWriter) {
+
+                fileWriter.onwriteend = function (e) {
+                    callback(fileEntry);
+                };
+
+                fileWriter.onerror = errorCallback;
+
+                // Create a new Blob and write it to log.txt.
+                var blob = new Blob([data], { type: fileType });
+
+                fileWriter.write(blob);
+
+            }, errorCallback);
+
+        }, errorCallback);
+    }
+
+    function getImageUrl(originalUrl) {
+
+        return new Promise(function (resolve, reject) {
+
+            if (originalUrl.indexOf('tag=') != -1) {
+                originalUrl += "&accept=webp";
+            }
+
+            var key = getCacheKey(originalUrl);
+
+            var fileEntryCallback = function (fileEntry) {
+                resolve(fileEntry.toURL());
+            };
+
+            var errorCallback = function (e) {
+                console.log('Imagestore error: ' + e.name);
+                reject();
+            };
+
+            if (!fileSystem || !imageCacheDirectoryEntry) {
+                errorCallback('');
+                return;
+            }
+
+            var path = '/' + imageCacheFolder + "/" + key;
+
+            fileSystem.root.getFile(path, { create: false }, fileEntryCallback, function () {
+
+                downloadToFile(originalUrl, imageCacheDirectoryEntry, key, fileEntryCallback, errorCallback);
+            });
+        });
+    }
+
+    var fileSystem;
+
+    return {
+        loadImage: function (elem, url) {
+
+            return getImageUrl(url).then(function (localUrl) {
+
+                setImageIntoElement(elem, localUrl);
+                return elem;
+
+            }, function () {
+                setImageIntoElement(elem, url);
+                return elem;
+            });
+        }
+    };
+
+});