From fb3d5c7856b9fbed926091e91ec54de023859df8 Mon Sep 17 00:00:00 2001 From: Vincent Petry Date: Mon, 2 Nov 2015 13:19:30 +0100 Subject: [PATCH] Add evert's davclient.js + es6-promise + IE8 workaround - Add davclient.js lib - Add es6-promise required by that lib - Wrote IE8 workaround lib/shim for davclient.js --- bower.json | 4 +- core/js/core.json | 8 +- core/js/files/ie8davclient.js | 169 ++++ core/vendor/.gitignore | 11 + core/vendor/davclient.js/LICENSE | 27 + core/vendor/davclient.js/lib/client.js | 296 ++++++ core/vendor/es6-promise/.bower.json | 40 + core/vendor/es6-promise/.npmignore | 11 + core/vendor/es6-promise/.release.json | 17 + core/vendor/es6-promise/.spmignore | 11 + core/vendor/es6-promise/LICENSE | 19 + core/vendor/es6-promise/dist/es6-promise.js | 972 ++++++++++++++++++++ lib/private/template.php | 11 +- 13 files changed, 1591 insertions(+), 5 deletions(-) create mode 100644 core/js/files/ie8davclient.js create mode 100644 core/vendor/davclient.js/LICENSE create mode 100644 core/vendor/davclient.js/lib/client.js create mode 100644 core/vendor/es6-promise/.bower.json create mode 100644 core/vendor/es6-promise/.npmignore create mode 100644 core/vendor/es6-promise/.release.json create mode 100644 core/vendor/es6-promise/.spmignore create mode 100644 core/vendor/es6-promise/LICENSE create mode 100644 core/vendor/es6-promise/dist/es6-promise.js diff --git a/bower.json b/bower.json index e8bb9a35f3..77d7d75e85 100644 --- a/bower.json +++ b/bower.json @@ -27,6 +27,8 @@ "strengthify": "0.4.2", "underscore": "~1.8.0", "bootstrap": "~3.3.5", - "backbone": "~1.2.1" + "backbone": "~1.2.1", + "davclient.js": "https://github.com/evert/davclient.js.git", + "es6-promise": "https://github.com/jakearchibald/es6-promise.git#~2.3.0" } } diff --git a/core/js/core.json b/core/js/core.json index a80636e846..c7621a08d6 100644 --- a/core/js/core.json +++ b/core/js/core.json @@ -8,7 +8,9 @@ "handlebars/handlebars.js", "blueimp-md5/js/md5.js", "bootstrap/js/tooltip.js", - "backbone/backbone.js" + "backbone/backbone.js", + "es6-promise/dist/es6-promise.js", + "davclient.js/lib/client.js" ], "libraries": [ "jquery-showpassword.js", @@ -39,6 +41,8 @@ "setupchecks.js", "../search/js/search.js", "mimetype.js", - "mimetypelist.js" + "mimetypelist.js", + "files/fileinfo.js", + "files/client.js" ] } diff --git a/core/js/files/ie8davclient.js b/core/js/files/ie8davclient.js new file mode 100644 index 0000000000..9887d34e5b --- /dev/null +++ b/core/js/files/ie8davclient.js @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2015 + * + * This file is licensed under the Affero General Public License version 3 + * or later. + * + * See the COPYING-README file. + * + */ + +/* global dav */ +(function(dav) { + + /** + * Override davclient.js methods with IE8-compatible logic + */ + dav.Client.prototype = _.extend({}, dav.Client.prototype, { + + /** + * Generates a propFind request. + * + * @param {string} url Url to do the propfind request on + * @param {Array} properties List of properties to retrieve. + * @return {Promise} + */ + propFind : function(url, properties, depth) { + + if(typeof depth == "undefined") { + depth = 0; + } + + var headers = { + Depth : depth, + 'Content-Type' : 'application/xml; charset=utf-8' + }; + + var body = + '\n' + + '\n'; + + for(var ii in properties) { + var propText = properties[ii]; + if (typeof propText !== 'string') { + // can happen on IE8 + continue; + } + var property = this.parseClarkNotation(properties[ii]); + if (this.xmlNamespaces[property.namespace]) { + body+=' <' + this.xmlNamespaces[property.namespace] + ':' + property.name + ' />\n'; + } else { + body+=' \n'; + } + + } + body+=' \n'; + body+=''; + + return this.request('PROPFIND', url, headers, body).then( + function(result) { + var elements = this.parseMultiStatus(result.xhr.responseXML); + var response; + if (depth===0) { + response = { + status: result.status, + body: elements[0] + }; + } else { + response = { + status: result.status, + body: elements + }; + } + return response; + + }.bind(this) + ); + + }, + + + _getElementsByTagName: function(node, name, resolver) { + var parts = name.split(':'); + var tagName = parts[1]; + var namespace = resolver(parts[0]); + if (node.getElementsByTagNameNS) { + return node.getElementsByTagNameNS(namespace, tagName); + } + return node.getElementsByTagName(name); + }, + + /** + * Parses a multi-status response body. + * + * @param {string} xmlBody + * @param {Array} + */ + parseMultiStatus : function(doc) { + + var result = []; + var resolver = function(foo) { + var ii; + for(ii in this.xmlNamespaces) { + if (this.xmlNamespaces[ii] === foo) { + return ii; + } + } + }.bind(this); + + var responses = this._getElementsByTagName(doc, 'd:response', resolver); + var i; + for (i = 0; i < responses.length; i++) { + var responseNode = responses[i]; + var response = { + href : null, + propStat : [] + }; + + var hrefNode = this._getElementsByTagName(responseNode, 'd:href', resolver)[0]; + + response.href = hrefNode.textContent || hrefNode.text; + + var propStatNodes = this._getElementsByTagName(responseNode, 'd:propstat', resolver); + var j = 0; + + for (j = 0; j < propStatNodes.length; j++) { + var propStatNode = propStatNodes[j]; + var statusNode = this._getElementsByTagName(propStatNode, 'd:status', resolver)[0]; + + var propStat = { + status : statusNode.textContent || statusNode.text, + properties : [] + }; + + var propNode = this._getElementsByTagName(propStatNode, 'd:prop', resolver)[0]; + if (!propNode) { + continue; + } + var k = 0; + for (k = 0; k < propNode.childNodes.length; k++) { + var prop = propNode.childNodes[k]; + var value = prop.textContent || prop.text; + if (prop.childNodes && prop.childNodes.length > 0 && prop.childNodes[0].nodeType === 1) { + value = prop.childNodes; + } + propStat.properties['{' + prop.namespaceURI + '}' + (prop.localName || prop.baseName)] = value; + + } + response.propStat.push(propStat); + } + + result.push(response); + } + + return result; + + } + + + }); + +})(dav); + diff --git a/core/vendor/.gitignore b/core/vendor/.gitignore index bcbb59b6f2..09b6a47c72 100644 --- a/core/vendor/.gitignore +++ b/core/vendor/.gitignore @@ -122,3 +122,14 @@ bootstrap/js/* # backbone backbone/backbone-min* + +# davclient.js +davclient.js/** +!davclient.js/lib/* +!davclient.js/LICENSE + +# es6-promise +es6-promise/** +!es6-promise/LICENSE +!es6-promise/dist/es6-promise.js + diff --git a/core/vendor/davclient.js/LICENSE b/core/vendor/davclient.js/LICENSE new file mode 100644 index 0000000000..fd7293e8f3 --- /dev/null +++ b/core/vendor/davclient.js/LICENSE @@ -0,0 +1,27 @@ +Copyright (C) 2013-2014 fruux GmbH (https://fruux.com/) + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name Sabre nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. diff --git a/core/vendor/davclient.js/lib/client.js b/core/vendor/davclient.js/lib/client.js new file mode 100644 index 0000000000..93678f0924 --- /dev/null +++ b/core/vendor/davclient.js/lib/client.js @@ -0,0 +1,296 @@ +if (typeof dav == 'undefined') { dav = {}; }; + +dav.Client = function(options) { + var i; + for(i in options) { + this[i] = options[i]; + } + +}; + +dav.Client.prototype = { + + baseUrl : null, + + userName : null, + + password : null, + + + xmlNamespaces : { + 'DAV:' : 'd' + }, + + /** + * Generates a propFind request. + * + * @param {string} url Url to do the propfind request on + * @param {Array} properties List of properties to retrieve. + * @return {Promise} + */ + propFind : function(url, properties, depth) { + + if(typeof depth == "undefined") { + depth = 0; + } + + var headers = { + Depth : depth, + 'Content-Type' : 'application/xml; charset=utf-8' + }; + + var body = + '\n' + + '\n'; + + for(var ii in properties) { + + var property = this.parseClarkNotation(properties[ii]); + if (this.xmlNamespaces[property.namespace]) { + body+=' <' + this.xmlNamespaces[property.namespace] + ':' + property.name + ' />\n'; + } else { + body+=' \n'; + } + + } + body+=' \n'; + body+=''; + + return this.request('PROPFIND', url, headers, body).then( + function(result) { + + var resultBody = this.parseMultiStatus(result.body); + if (depth===0) { + return { + status: result.status, + body: resultBody[0], + xhr: result.xhr + }; + } else { + return { + status: result.status, + body: resultBody, + xhr: result.xhr + }; + } + + }.bind(this) + ); + + }, + + /** + * Performs a HTTP request, and returns a Promise + * + * @param {string} method HTTP method + * @param {string} url Relative or absolute url + * @param {Object} headers HTTP headers as an object. + * @param {string} body HTTP request body. + * @return {Promise} + */ + request : function(method, url, headers, body) { + + var xhr = this.xhrProvider(); + + if (this.userName) { + headers['Authorization'] = 'Basic ' + btoa(this.userName + ':' + this.password); + // xhr.open(method, this.resolveUrl(url), true, this.userName, this.password); + } + xhr.open(method, this.resolveUrl(url), true); + var ii; + for(ii in headers) { + xhr.setRequestHeader(ii, headers[ii]); + } + xhr.send(body); + + return new Promise(function(fulfill, reject) { + + xhr.onreadystatechange = function() { + + if (xhr.readyState !== 4) { + return; + } + + fulfill({ + body: xhr.response, + status: xhr.status, + xhr: xhr + }); + + }; + + xhr.ontimeout = function() { + + reject(new Error('Timeout exceeded')); + + }; + + }); + + }, + + /** + * Returns an XMLHttpRequest object. + * + * This is in its own method, so it can be easily overridden. + * + * @return {XMLHttpRequest} + */ + xhrProvider : function() { + + return new XMLHttpRequest(); + + }, + + + /** + * Parses a multi-status response body. + * + * @param {string} xmlBody + * @param {Array} + */ + parseMultiStatus : function(xmlBody) { + + var parser = new DOMParser(); + var doc = parser.parseFromString(xmlBody, "application/xml"); + + var resolver = function(foo) { + var ii; + for(ii in this.xmlNamespaces) { + if (this.xmlNamespaces[ii] === foo) { + return ii; + } + } + }.bind(this); + + var responseIterator = doc.evaluate('/d:multistatus/d:response', doc, resolver); + + var result = []; + var responseNode = responseIterator.iterateNext(); + + while(responseNode) { + + var response = { + href : null, + propStat : [] + }; + + response.href = doc.evaluate('string(d:href)', responseNode, resolver).stringValue; + + var propStatIterator = doc.evaluate('d:propstat', responseNode, resolver); + var propStatNode = propStatIterator.iterateNext(); + + while(propStatNode) { + + var propStat = { + status : doc.evaluate('string(d:status)', propStatNode, resolver).stringValue, + properties : [], + }; + + var propIterator = doc.evaluate('d:prop/*', propStatNode, resolver); + + var propNode = propIterator.iterateNext(); + while(propNode) { + var content = propNode.textContent; + if (!content && propNode.hasChildNodes()) { + content = propNode.childNodes; + } + + propStat.properties['{' + propNode.namespaceURI + '}' + propNode.localName] = content; + propNode = propIterator.iterateNext(); + + } + response.propStat.push(propStat); + propStatNode = propStatIterator.iterateNext(); + + + } + + result.push(response); + responseNode = responseIterator.iterateNext(); + + } + + return result; + + }, + + /** + * Takes a relative url, and maps it to an absolute url, using the baseUrl + * + * @param {string} url + * @return {string} + */ + resolveUrl : function(url) { + + // Note: this is rudamentary.. not sure yet if it handles every case. + if (/^https?:\/\//i.test(url)) { + // absolute + return url; + } + + var baseParts = this.parseUrl(this.baseUrl); + if (url.charAt('/')) { + // Url starts with a slash + return baseParts.root + url; + } + + // Url does not start with a slash, we need grab the base url right up until the last slash. + var newUrl = baseParts.root + '/'; + if (baseParts.path.lastIndexOf('/')!==-1) { + newUrl = newUrl = baseParts.path.subString(0, baseParts.path.lastIndexOf('/')) + '/'; + } + newUrl+=url; + return url; + + }, + + /** + * Parses a url and returns its individual components. + * + * @param {String} url + * @return {Object} + */ + parseUrl : function(url) { + + var parts = url.match(/^(?:([A-Za-z]+):)?(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/); + var result = { + url : parts[0], + scheme : parts[1], + host : parts[3], + port : parts[4], + path : parts[5], + query : parts[6], + fragment : parts[7], + }; + result.root = + result.scheme + '://' + + result.host + + (result.port ? ':' + result.port : ''); + + return result; + + }, + + parseClarkNotation : function(propertyName) { + + var result = propertyName.match(/^{([^}]+)}(.*)$/); + if (!result) { + return; + } + + return { + name : result[2], + namespace : result[1] + }; + + } + +}; + diff --git a/core/vendor/es6-promise/.bower.json b/core/vendor/es6-promise/.bower.json new file mode 100644 index 0000000000..f8c28b04e5 --- /dev/null +++ b/core/vendor/es6-promise/.bower.json @@ -0,0 +1,40 @@ +{ + "name": "es6-promise", + "namespace": "Promise", + "version": "2.3.0", + "description": "A polyfill for ES6-style Promises, tracking rsvp", + "authors": [ + "Stefan Penner " + ], + "main": "dist/es6-promise.js", + "keywords": [ + "promise" + ], + "repository": { + "type": "git", + "url": "git://github.com/jakearchibald/ES6-Promises.git" + }, + "bugs": { + "url": "https://github.com/jakearchibald/ES6-Promises/issues" + }, + "license": "MIT", + "ignore": [ + "node_modules", + "bower_components", + "test", + "tests", + "vendor", + "tasks" + ], + "homepage": "https://github.com/jakearchibald/es6-promise", + "_release": "2.3.0", + "_resolution": { + "type": "version", + "tag": "2.3.0", + "commit": "fcbab11a1a981eb2290bfff89017cb764335a2a5" + }, + "_source": "https://github.com/jakearchibald/es6-promise.git", + "_target": "~2.3.0", + "_originalSource": "https://github.com/jakearchibald/es6-promise.git", + "_direct": true +} \ No newline at end of file diff --git a/core/vendor/es6-promise/.npmignore b/core/vendor/es6-promise/.npmignore new file mode 100644 index 0000000000..7a758111e9 --- /dev/null +++ b/core/vendor/es6-promise/.npmignore @@ -0,0 +1,11 @@ +/node_modules/ +/tmp +/tasks +/test +/vendor +/.jshintrc +/.npmignore +/.travis.yml +/Gruntfile.js +/component.json +/index.html diff --git a/core/vendor/es6-promise/.release.json b/core/vendor/es6-promise/.release.json new file mode 100644 index 0000000000..dee8cbc5d9 --- /dev/null +++ b/core/vendor/es6-promise/.release.json @@ -0,0 +1,17 @@ +{ + "non-interactive": true, + "dry-run": false, + "verbose": false, + "force": false, + "pkgFiles": ["package.json", "bower.json"], + "increment": "patch", + "commitMessage": "Release %s", + "tagName": "%s", + "tagAnnotation": "Release %s", + "buildCommand": "npm run-script build-all", + "distRepo": "git@github.com:components/rsvp.js.git", + "distStageDir": "tmp/stage", + "distBase": "dist", + "distFiles": ["**/*", "../package.json", "../bower.json"], + "publish": false +} diff --git a/core/vendor/es6-promise/.spmignore b/core/vendor/es6-promise/.spmignore new file mode 100644 index 0000000000..7a758111e9 --- /dev/null +++ b/core/vendor/es6-promise/.spmignore @@ -0,0 +1,11 @@ +/node_modules/ +/tmp +/tasks +/test +/vendor +/.jshintrc +/.npmignore +/.travis.yml +/Gruntfile.js +/component.json +/index.html diff --git a/core/vendor/es6-promise/LICENSE b/core/vendor/es6-promise/LICENSE new file mode 100644 index 0000000000..954ec5992d --- /dev/null +++ b/core/vendor/es6-promise/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/core/vendor/es6-promise/dist/es6-promise.js b/core/vendor/es6-promise/dist/es6-promise.js new file mode 100644 index 0000000000..aff0482ee5 --- /dev/null +++ b/core/vendor/es6-promise/dist/es6-promise.js @@ -0,0 +1,972 @@ +/*! + * @overview es6-promise - a tiny implementation of Promises/A+. + * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald) + * @license Licensed under MIT license + * See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE + * @version 2.3.0 + */ + +(function() { + "use strict"; + function lib$es6$promise$utils$$objectOrFunction(x) { + return typeof x === 'function' || (typeof x === 'object' && x !== null); + } + + function lib$es6$promise$utils$$isFunction(x) { + return typeof x === 'function'; + } + + function lib$es6$promise$utils$$isMaybeThenable(x) { + return typeof x === 'object' && x !== null; + } + + var lib$es6$promise$utils$$_isArray; + if (!Array.isArray) { + lib$es6$promise$utils$$_isArray = function (x) { + return Object.prototype.toString.call(x) === '[object Array]'; + }; + } else { + lib$es6$promise$utils$$_isArray = Array.isArray; + } + + var lib$es6$promise$utils$$isArray = lib$es6$promise$utils$$_isArray; + var lib$es6$promise$asap$$len = 0; + var lib$es6$promise$asap$$toString = {}.toString; + var lib$es6$promise$asap$$vertxNext; + var lib$es6$promise$asap$$customSchedulerFn; + + var lib$es6$promise$asap$$asap = function asap(callback, arg) { + lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len] = callback; + lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len + 1] = arg; + lib$es6$promise$asap$$len += 2; + if (lib$es6$promise$asap$$len === 2) { + // If len is 2, that means that we need to schedule an async flush. + // If additional callbacks are queued before the queue is flushed, they + // will be processed by this flush that we are scheduling. + if (lib$es6$promise$asap$$customSchedulerFn) { + lib$es6$promise$asap$$customSchedulerFn(lib$es6$promise$asap$$flush); + } else { + lib$es6$promise$asap$$scheduleFlush(); + } + } + } + + function lib$es6$promise$asap$$setScheduler(scheduleFn) { + lib$es6$promise$asap$$customSchedulerFn = scheduleFn; + } + + function lib$es6$promise$asap$$setAsap(asapFn) { + lib$es6$promise$asap$$asap = asapFn; + } + + var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined; + var lib$es6$promise$asap$$browserGlobal = lib$es6$promise$asap$$browserWindow || {}; + var lib$es6$promise$asap$$BrowserMutationObserver = lib$es6$promise$asap$$browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver; + var lib$es6$promise$asap$$isNode = typeof process !== 'undefined' && {}.toString.call(process) === '[object process]'; + + // test for web worker but not in IE10 + var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' && + typeof importScripts !== 'undefined' && + typeof MessageChannel !== 'undefined'; + + // node + function lib$es6$promise$asap$$useNextTick() { + var nextTick = process.nextTick; + // node version 0.10.x displays a deprecation warning when nextTick is used recursively + // setImmediate should be used instead instead + var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/); + if (Array.isArray(version) && version[1] === '0' && version[2] === '10') { + nextTick = setImmediate; + } + return function() { + nextTick(lib$es6$promise$asap$$flush); + }; + } + + // vertx + function lib$es6$promise$asap$$useVertxTimer() { + return function() { + lib$es6$promise$asap$$vertxNext(lib$es6$promise$asap$$flush); + }; + } + + function lib$es6$promise$asap$$useMutationObserver() { + var iterations = 0; + var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush); + var node = document.createTextNode(''); + observer.observe(node, { characterData: true }); + + return function() { + node.data = (iterations = ++iterations % 2); + }; + } + + // web worker + function lib$es6$promise$asap$$useMessageChannel() { + var channel = new MessageChannel(); + channel.port1.onmessage = lib$es6$promise$asap$$flush; + return function () { + channel.port2.postMessage(0); + }; + } + + function lib$es6$promise$asap$$useSetTimeout() { + return function() { + setTimeout(lib$es6$promise$asap$$flush, 1); + }; + } + + var lib$es6$promise$asap$$queue = new Array(1000); + function lib$es6$promise$asap$$flush() { + for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) { + var callback = lib$es6$promise$asap$$queue[i]; + var arg = lib$es6$promise$asap$$queue[i+1]; + + callback(arg); + + lib$es6$promise$asap$$queue[i] = undefined; + lib$es6$promise$asap$$queue[i+1] = undefined; + } + + lib$es6$promise$asap$$len = 0; + } + + function lib$es6$promise$asap$$attemptVertex() { + try { + var r = require; + var vertx = r('vertx'); + lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext; + return lib$es6$promise$asap$$useVertxTimer(); + } catch(e) { + return lib$es6$promise$asap$$useSetTimeout(); + } + } + + var lib$es6$promise$asap$$scheduleFlush; + // Decide what async method to use to triggering processing of queued callbacks: + if (lib$es6$promise$asap$$isNode) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick(); + } else if (lib$es6$promise$asap$$BrowserMutationObserver) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver(); + } else if (lib$es6$promise$asap$$isWorker) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel(); + } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertex(); + } else { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout(); + } + + function lib$es6$promise$$internal$$noop() {} + + var lib$es6$promise$$internal$$PENDING = void 0; + var lib$es6$promise$$internal$$FULFILLED = 1; + var lib$es6$promise$$internal$$REJECTED = 2; + + var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject(); + + function lib$es6$promise$$internal$$selfFullfillment() { + return new TypeError("You cannot resolve a promise with itself"); + } + + function lib$es6$promise$$internal$$cannotReturnOwn() { + return new TypeError('A promises callback cannot return that same promise.'); + } + + function lib$es6$promise$$internal$$getThen(promise) { + try { + return promise.then; + } catch(error) { + lib$es6$promise$$internal$$GET_THEN_ERROR.error = error; + return lib$es6$promise$$internal$$GET_THEN_ERROR; + } + } + + function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) { + try { + then.call(value, fulfillmentHandler, rejectionHandler); + } catch(e) { + return e; + } + } + + function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) { + lib$es6$promise$asap$$asap(function(promise) { + var sealed = false; + var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) { + if (sealed) { return; } + sealed = true; + if (thenable !== value) { + lib$es6$promise$$internal$$resolve(promise, value); + } else { + lib$es6$promise$$internal$$fulfill(promise, value); + } + }, function(reason) { + if (sealed) { return; } + sealed = true; + + lib$es6$promise$$internal$$reject(promise, reason); + }, 'Settle: ' + (promise._label || ' unknown promise')); + + if (!sealed && error) { + sealed = true; + lib$es6$promise$$internal$$reject(promise, error); + } + }, promise); + } + + function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) { + if (thenable._state === lib$es6$promise$$internal$$FULFILLED) { + lib$es6$promise$$internal$$fulfill(promise, thenable._result); + } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, thenable._result); + } else { + lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) { + lib$es6$promise$$internal$$resolve(promise, value); + }, function(reason) { + lib$es6$promise$$internal$$reject(promise, reason); + }); + } + } + + function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable) { + if (maybeThenable.constructor === promise.constructor) { + lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable); + } else { + var then = lib$es6$promise$$internal$$getThen(maybeThenable); + + if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error); + } else if (then === undefined) { + lib$es6$promise$$internal$$fulfill(promise, maybeThenable); + } else if (lib$es6$promise$utils$$isFunction(then)) { + lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then); + } else { + lib$es6$promise$$internal$$fulfill(promise, maybeThenable); + } + } + } + + function lib$es6$promise$$internal$$resolve(promise, value) { + if (promise === value) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFullfillment()); + } else if (lib$es6$promise$utils$$objectOrFunction(value)) { + lib$es6$promise$$internal$$handleMaybeThenable(promise, value); + } else { + lib$es6$promise$$internal$$fulfill(promise, value); + } + } + + function lib$es6$promise$$internal$$publishRejection(promise) { + if (promise._onerror) { + promise._onerror(promise._result); + } + + lib$es6$promise$$internal$$publish(promise); + } + + function lib$es6$promise$$internal$$fulfill(promise, value) { + if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; } + + promise._result = value; + promise._state = lib$es6$promise$$internal$$FULFILLED; + + if (promise._subscribers.length !== 0) { + lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, promise); + } + } + + function lib$es6$promise$$internal$$reject(promise, reason) { + if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; } + promise._state = lib$es6$promise$$internal$$REJECTED; + promise._result = reason; + + lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publishRejection, promise); + } + + function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) { + var subscribers = parent._subscribers; + var length = subscribers.length; + + parent._onerror = null; + + subscribers[length] = child; + subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment; + subscribers[length + lib$es6$promise$$internal$$REJECTED] = onRejection; + + if (length === 0 && parent._state) { + lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, parent); + } + } + + function lib$es6$promise$$internal$$publish(promise) { + var subscribers = promise._subscribers; + var settled = promise._state; + + if (subscribers.length === 0) { return; } + + var child, callback, detail = promise._result; + + for (var i = 0; i < subscribers.length; i += 3) { + child = subscribers[i]; + callback = subscribers[i + settled]; + + if (child) { + lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail); + } else { + callback(detail); + } + } + + promise._subscribers.length = 0; + } + + function lib$es6$promise$$internal$$ErrorObject() { + this.error = null; + } + + var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject(); + + function lib$es6$promise$$internal$$tryCatch(callback, detail) { + try { + return callback(detail); + } catch(e) { + lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e; + return lib$es6$promise$$internal$$TRY_CATCH_ERROR; + } + } + + function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) { + var hasCallback = lib$es6$promise$utils$$isFunction(callback), + value, error, succeeded, failed; + + if (hasCallback) { + value = lib$es6$promise$$internal$$tryCatch(callback, detail); + + if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) { + failed = true; + error = value.error; + value = null; + } else { + succeeded = true; + } + + if (promise === value) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn()); + return; + } + + } else { + value = detail; + succeeded = true; + } + + if (promise._state !== lib$es6$promise$$internal$$PENDING) { + // noop + } else if (hasCallback && succeeded) { + lib$es6$promise$$internal$$resolve(promise, value); + } else if (failed) { + lib$es6$promise$$internal$$reject(promise, error); + } else if (settled === lib$es6$promise$$internal$$FULFILLED) { + lib$es6$promise$$internal$$fulfill(promise, value); + } else if (settled === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, value); + } + } + + function lib$es6$promise$$internal$$initializePromise(promise, resolver) { + try { + resolver(function resolvePromise(value){ + lib$es6$promise$$internal$$resolve(promise, value); + }, function rejectPromise(reason) { + lib$es6$promise$$internal$$reject(promise, reason); + }); + } catch(e) { + lib$es6$promise$$internal$$reject(promise, e); + } + } + + function lib$es6$promise$enumerator$$Enumerator(Constructor, input) { + var enumerator = this; + + enumerator._instanceConstructor = Constructor; + enumerator.promise = new Constructor(lib$es6$promise$$internal$$noop); + + if (enumerator._validateInput(input)) { + enumerator._input = input; + enumerator.length = input.length; + enumerator._remaining = input.length; + + enumerator._init(); + + if (enumerator.length === 0) { + lib$es6$promise$$internal$$fulfill(enumerator.promise, enumerator._result); + } else { + enumerator.length = enumerator.length || 0; + enumerator._enumerate(); + if (enumerator._remaining === 0) { + lib$es6$promise$$internal$$fulfill(enumerator.promise, enumerator._result); + } + } + } else { + lib$es6$promise$$internal$$reject(enumerator.promise, enumerator._validationError()); + } + } + + lib$es6$promise$enumerator$$Enumerator.prototype._validateInput = function(input) { + return lib$es6$promise$utils$$isArray(input); + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._validationError = function() { + return new Error('Array Methods must be provided an Array'); + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._init = function() { + this._result = new Array(this.length); + }; + + var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator; + + lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() { + var enumerator = this; + + var length = enumerator.length; + var promise = enumerator.promise; + var input = enumerator._input; + + for (var i = 0; promise._state === lib$es6$promise$$internal$$PENDING && i < length; i++) { + enumerator._eachEntry(input[i], i); + } + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) { + var enumerator = this; + var c = enumerator._instanceConstructor; + + if (lib$es6$promise$utils$$isMaybeThenable(entry)) { + if (entry.constructor === c && entry._state !== lib$es6$promise$$internal$$PENDING) { + entry._onerror = null; + enumerator._settledAt(entry._state, i, entry._result); + } else { + enumerator._willSettleAt(c.resolve(entry), i); + } + } else { + enumerator._remaining--; + enumerator._result[i] = entry; + } + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) { + var enumerator = this; + var promise = enumerator.promise; + + if (promise._state === lib$es6$promise$$internal$$PENDING) { + enumerator._remaining--; + + if (state === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, value); + } else { + enumerator._result[i] = value; + } + } + + if (enumerator._remaining === 0) { + lib$es6$promise$$internal$$fulfill(promise, enumerator._result); + } + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) { + var enumerator = this; + + lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) { + enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value); + }, function(reason) { + enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason); + }); + }; + function lib$es6$promise$promise$all$$all(entries) { + return new lib$es6$promise$enumerator$$default(this, entries).promise; + } + var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all; + function lib$es6$promise$promise$race$$race(entries) { + /*jshint validthis:true */ + var Constructor = this; + + var promise = new Constructor(lib$es6$promise$$internal$$noop); + + if (!lib$es6$promise$utils$$isArray(entries)) { + lib$es6$promise$$internal$$reject(promise, new TypeError('You must pass an array to race.')); + return promise; + } + + var length = entries.length; + + function onFulfillment(value) { + lib$es6$promise$$internal$$resolve(promise, value); + } + + function onRejection(reason) { + lib$es6$promise$$internal$$reject(promise, reason); + } + + for (var i = 0; promise._state === lib$es6$promise$$internal$$PENDING && i < length; i++) { + lib$es6$promise$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection); + } + + return promise; + } + var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race; + function lib$es6$promise$promise$resolve$$resolve(object) { + /*jshint validthis:true */ + var Constructor = this; + + if (object && typeof object === 'object' && object.constructor === Constructor) { + return object; + } + + var promise = new Constructor(lib$es6$promise$$internal$$noop); + lib$es6$promise$$internal$$resolve(promise, object); + return promise; + } + var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve; + function lib$es6$promise$promise$reject$$reject(reason) { + /*jshint validthis:true */ + var Constructor = this; + var promise = new Constructor(lib$es6$promise$$internal$$noop); + lib$es6$promise$$internal$$reject(promise, reason); + return promise; + } + var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject; + + var lib$es6$promise$promise$$counter = 0; + + function lib$es6$promise$promise$$needsResolver() { + throw new TypeError('You must pass a resolver function as the first argument to the promise constructor'); + } + + function lib$es6$promise$promise$$needsNew() { + throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."); + } + + var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise; + /** + Promise objects represent the eventual result of an asynchronous operation. The + primary way of interacting with a promise is through its `then` method, which + registers callbacks to receive either a promise's eventual value or the reason + why the promise cannot be fulfilled. + + Terminology + ----------- + + - `promise` is an object or function with a `then` method whose behavior conforms to this specification. + - `thenable` is an object or function that defines a `then` method. + - `value` is any legal JavaScript value (including undefined, a thenable, or a promise). + - `exception` is a value that is thrown using the throw statement. + - `reason` is a value that indicates why a promise was rejected. + - `settled` the final resting state of a promise, fulfilled or rejected. + + A promise can be in one of three states: pending, fulfilled, or rejected. + + Promises that are fulfilled have a fulfillment value and are in the fulfilled + state. Promises that are rejected have a rejection reason and are in the + rejected state. A fulfillment value is never a thenable. + + Promises can also be said to *resolve* a value. If this value is also a + promise, then the original promise's settled state will match the value's + settled state. So a promise that *resolves* a promise that rejects will + itself reject, and a promise that *resolves* a promise that fulfills will + itself fulfill. + + + Basic Usage: + ------------ + + ```js + var promise = new Promise(function(resolve, reject) { + // on success + resolve(value); + + // on failure + reject(reason); + }); + + promise.then(function(value) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Advanced Usage: + --------------- + + Promises shine when abstracting away asynchronous interactions such as + `XMLHttpRequest`s. + + ```js + function getJSON(url) { + return new Promise(function(resolve, reject){ + var xhr = new XMLHttpRequest(); + + xhr.open('GET', url); + xhr.onreadystatechange = handler; + xhr.responseType = 'json'; + xhr.setRequestHeader('Accept', 'application/json'); + xhr.send(); + + function handler() { + if (this.readyState === this.DONE) { + if (this.status === 200) { + resolve(this.response); + } else { + reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']')); + } + } + }; + }); + } + + getJSON('/posts.json').then(function(json) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Unlike callbacks, promises are great composable primitives. + + ```js + Promise.all([ + getJSON('/posts'), + getJSON('/comments') + ]).then(function(values){ + values[0] // => postsJSON + values[1] // => commentsJSON + + return values; + }); + ``` + + @class Promise + @param {function} resolver + Useful for tooling. + @constructor + */ + function lib$es6$promise$promise$$Promise(resolver) { + this._id = lib$es6$promise$promise$$counter++; + this._state = undefined; + this._result = undefined; + this._subscribers = []; + + if (lib$es6$promise$$internal$$noop !== resolver) { + if (!lib$es6$promise$utils$$isFunction(resolver)) { + lib$es6$promise$promise$$needsResolver(); + } + + if (!(this instanceof lib$es6$promise$promise$$Promise)) { + lib$es6$promise$promise$$needsNew(); + } + + lib$es6$promise$$internal$$initializePromise(this, resolver); + } + } + + lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default; + lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default; + lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default; + lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default; + lib$es6$promise$promise$$Promise._setScheduler = lib$es6$promise$asap$$setScheduler; + lib$es6$promise$promise$$Promise._setAsap = lib$es6$promise$asap$$setAsap; + lib$es6$promise$promise$$Promise._asap = lib$es6$promise$asap$$asap; + + lib$es6$promise$promise$$Promise.prototype = { + constructor: lib$es6$promise$promise$$Promise, + + /** + The primary way of interacting with a promise is through its `then` method, + which registers callbacks to receive either a promise's eventual value or the + reason why the promise cannot be fulfilled. + + ```js + findUser().then(function(user){ + // user is available + }, function(reason){ + // user is unavailable, and you are given the reason why + }); + ``` + + Chaining + -------- + + The return value of `then` is itself a promise. This second, 'downstream' + promise is resolved with the return value of the first promise's fulfillment + or rejection handler, or rejected if the handler throws an exception. + + ```js + findUser().then(function (user) { + return user.name; + }, function (reason) { + return 'default name'; + }).then(function (userName) { + // If `findUser` fulfilled, `userName` will be the user's name, otherwise it + // will be `'default name'` + }); + + findUser().then(function (user) { + throw new Error('Found user, but still unhappy'); + }, function (reason) { + throw new Error('`findUser` rejected and we're unhappy'); + }).then(function (value) { + // never reached + }, function (reason) { + // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'. + // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'. + }); + ``` + If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream. + + ```js + findUser().then(function (user) { + throw new PedagogicalException('Upstream error'); + }).then(function (value) { + // never reached + }).then(function (value) { + // never reached + }, function (reason) { + // The `PedgagocialException` is propagated all the way down to here + }); + ``` + + Assimilation + ------------ + + Sometimes the value you want to propagate to a downstream promise can only be + retrieved asynchronously. This can be achieved by returning a promise in the + fulfillment or rejection handler. The downstream promise will then be pending + until the returned promise is settled. This is called *assimilation*. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // The user's comments are now available + }); + ``` + + If the assimliated promise rejects, then the downstream promise will also reject. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // If `findCommentsByAuthor` fulfills, we'll have the value here + }, function (reason) { + // If `findCommentsByAuthor` rejects, we'll have the reason here + }); + ``` + + Simple Example + -------------- + + Synchronous Example + + ```javascript + var result; + + try { + result = findResult(); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + findResult(function(result, err){ + if (err) { + // failure + } else { + // success + } + }); + ``` + + Promise Example; + + ```javascript + findResult().then(function(result){ + // success + }, function(reason){ + // failure + }); + ``` + + Advanced Example + -------------- + + Synchronous Example + + ```javascript + var author, books; + + try { + author = findAuthor(); + books = findBooksByAuthor(author); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + + function foundBooks(books) { + + } + + function failure(reason) { + + } + + findAuthor(function(author, err){ + if (err) { + failure(err); + // failure + } else { + try { + findBoooksByAuthor(author, function(books, err) { + if (err) { + failure(err); + } else { + try { + foundBooks(books); + } catch(reason) { + failure(reason); + } + } + }); + } catch(error) { + failure(err); + } + // success + } + }); + ``` + + Promise Example; + + ```javascript + findAuthor(). + then(findBooksByAuthor). + then(function(books){ + // found books + }).catch(function(reason){ + // something went wrong + }); + ``` + + @method then + @param {Function} onFulfilled + @param {Function} onRejected + Useful for tooling. + @return {Promise} + */ + then: function(onFulfillment, onRejection) { + var parent = this; + var state = parent._state; + + if (state === lib$es6$promise$$internal$$FULFILLED && !onFulfillment || state === lib$es6$promise$$internal$$REJECTED && !onRejection) { + return this; + } + + var child = new this.constructor(lib$es6$promise$$internal$$noop); + var result = parent._result; + + if (state) { + var callback = arguments[state - 1]; + lib$es6$promise$asap$$asap(function(){ + lib$es6$promise$$internal$$invokeCallback(state, child, callback, result); + }); + } else { + lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection); + } + + return child; + }, + + /** + `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same + as the catch block of a try/catch statement. + + ```js + function findAuthor(){ + throw new Error('couldn't find that author'); + } + + // synchronous + try { + findAuthor(); + } catch(reason) { + // something went wrong + } + + // async with promises + findAuthor().catch(function(reason){ + // something went wrong + }); + ``` + + @method catch + @param {Function} onRejection + Useful for tooling. + @return {Promise} + */ + 'catch': function(onRejection) { + return this.then(null, onRejection); + } + }; + function lib$es6$promise$polyfill$$polyfill() { + var local; + + if (typeof global !== 'undefined') { + local = global; + } else if (typeof self !== 'undefined') { + local = self; + } else { + try { + local = Function('return this')(); + } catch (e) { + throw new Error('polyfill failed because global object is unavailable in this environment'); + } + } + + var P = local.Promise; + + if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) { + return; + } + + local.Promise = lib$es6$promise$promise$$default; + } + var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill; + + var lib$es6$promise$umd$$ES6Promise = { + 'Promise': lib$es6$promise$promise$$default, + 'polyfill': lib$es6$promise$polyfill$$default + }; + + /* global define:true module:true window: true */ + if (typeof define === 'function' && define['amd']) { + define(function() { return lib$es6$promise$umd$$ES6Promise; }); + } else if (typeof module !== 'undefined' && module['exports']) { + module['exports'] = lib$es6$promise$umd$$ES6Promise; + } else if (typeof this !== 'undefined') { + this['ES6Promise'] = lib$es6$promise$umd$$ES6Promise; + } + + lib$es6$promise$polyfill$$default(); +}).call(this); + diff --git a/lib/private/template.php b/lib/private/template.php index 97666f0b8d..2c9721dc96 100644 --- a/lib/private/template.php +++ b/lib/private/template.php @@ -143,7 +143,9 @@ class OC_Template extends \OC\Template\Base { OC_Util::addStyle("jquery.ocdialog"); OC_Util::addScript("compatibility", null, true); OC_Util::addScript("placeholders", null, true); - + OC_Util::addScript('files/fileinfo'); + OC_Util::addScript('files/client'); + // Add the stuff we need always // following logic will import all vendor libraries that are // specified in core/js/core.json @@ -158,7 +160,12 @@ class OC_Template extends \OC\Template\Base { } else { throw new \Exception('Cannot read core/js/core.json'); } - + + if (\OC::$server->getRequest()->isUserAgent([\OC\AppFramework\Http\Request::USER_AGENT_IE_8])) { + // shim for the davclient.js library + \OCP\Util::addScript('files/ie8davclient'); + } + self::$initTemplateEngineFirstRun = false; }