ng2-file-upload 1.1.4-2 → 1.4.0

package/esm5/file-upload/file-uploader.class.js

@@ -0,0 +1,1132 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { EventEmitter } from '@angular/core';
+import { FileLikeObject } from './file-like-object.class';
+import { FileItem } from './file-item.class';
+import { FileType } from './file-type.class';
+/**
+ * @param {?} value
+ * @return {?}
+ */
+function isFile(value) {
+    return (File && value instanceof File);
+}
+/**
+ * @record
+ */
+export function Headers() { }
+if (false) {
+    /** @type {?} */
+    Headers.prototype.name;
+    /** @type {?} */
+    Headers.prototype.value;
+}
+/**
+ * @record
+ */
+export function FileUploaderOptions() { }
+if (false) {
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.allowedMimeType;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.allowedFileType;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.autoUpload;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.isHTML5;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.filters;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.headers;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.method;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.authToken;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.maxFileSize;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.queueLimit;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.removeAfterUpload;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.url;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.disableMultipart;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.itemAlias;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.authTokenHeader;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.additionalParameter;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.parametersBeforeFiles;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.formatDataFunction;
+    /** @type {?|undefined} */
+    FileUploaderOptions.prototype.formatDataFunctionIsAsync;
+}
+var FileUploader = /** @class */ (function () {
+    function FileUploader(options) {
+        this.isUploading = false;
+        this.queue = [];
+        this.progress = 0;
+        this._nextIndex = 0;
+        this.options = {
+            autoUpload: false,
+            isHTML5: true,
+            filters: [],
+            removeAfterUpload: false,
+            disableMultipart: false,
+            formatDataFunction: (/**
+             * @param {?} item
+             * @return {?}
+             */
+            function (item) { return item._file; }),
+            formatDataFunctionIsAsync: false
+        };
+        this.setOptions(options);
+        this.response = new EventEmitter();
+    }
+    /**
+     * @param {?} options
+     * @return {?}
+     */
+    FileUploader.prototype.setOptions = /**
+     * @param {?} options
+     * @return {?}
+     */
+    function (options) {
+        this.options = Object.assign(this.options, options);
+        this.authToken = this.options.authToken;
+        this.authTokenHeader = this.options.authTokenHeader || 'Authorization';
+        this.autoUpload = this.options.autoUpload;
+        this.options.filters.unshift({ name: 'queueLimit', fn: this._queueLimitFilter });
+        if (this.options.maxFileSize) {
+            this.options.filters.unshift({ name: 'fileSize', fn: this._fileSizeFilter });
+        }
+        if (this.options.allowedFileType) {
+            this.options.filters.unshift({ name: 'fileType', fn: this._fileTypeFilter });
+        }
+        if (this.options.allowedMimeType) {
+            this.options.filters.unshift({ name: 'mimeType', fn: this._mimeTypeFilter });
+        }
+        for (var i = 0; i < this.queue.length; i++) {
+            this.queue[i].url = this.options.url;
+        }
+    };
+    /**
+     * @param {?} files
+     * @param {?=} options
+     * @param {?=} filters
+     * @return {?}
+     */
+    FileUploader.prototype.addToQueue = /**
+     * @param {?} files
+     * @param {?=} options
+     * @param {?=} filters
+     * @return {?}
+     */
+    function (files, options, filters) {
+        var e_1, _a;
+        var _this = this;
+        /** @type {?} */
+        var list = [];
+        try {
+            for (var files_1 = __values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+                var file = files_1_1.value;
+                list.push(file);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (files_1_1 && !files_1_1.done && (_a = files_1.return)) _a.call(files_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        /** @type {?} */
+        var arrayOfFilters = this._getFilters(filters);
+        /** @type {?} */
+        var count = this.queue.length;
+        /** @type {?} */
+        var addedFileItems = [];
+        list.map((/**
+         * @param {?} some
+         * @return {?}
+         */
+        function (some) {
+            if (!options) {
+                options = _this.options;
+            }
+            /** @type {?} */
+            var temp = new FileLikeObject(some);
+            if (_this._isValidFile(temp, arrayOfFilters, options)) {
+                /** @type {?} */
+                var fileItem = new FileItem(_this, some, options);
+                addedFileItems.push(fileItem);
+                _this.queue.push(fileItem);
+                _this._onAfterAddingFile(fileItem);
+            }
+            else {
+                /** @type {?} */
+                var filter = arrayOfFilters[_this._failFilterIndex];
+                _this._onWhenAddingFileFailed(temp, filter, options);
+            }
+        }));
+        if (this.queue.length !== count) {
+            this._onAfterAddingAll(addedFileItems);
+            this.progress = this._getTotalProgress();
+        }
+        this._render();
+        if (this.options.autoUpload) {
+            this.uploadAll();
+        }
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    FileUploader.prototype.removeFromQueue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        /** @type {?} */
+        var index = this.getIndexOfItem(value);
+        /** @type {?} */
+        var item = this.queue[index];
+        if (item.isUploading) {
+            item.cancel();
+        }
+        this.queue.splice(index, 1);
+        this.progress = this._getTotalProgress();
+    };
+    /**
+     * @return {?}
+     */
+    FileUploader.prototype.clearQueue = /**
+     * @return {?}
+     */
+    function () {
+        while (this.queue.length) {
+            this.queue[0].remove();
+        }
+        this.progress = 0;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    FileUploader.prototype.uploadItem = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        /** @type {?} */
+        var index = this.getIndexOfItem(value);
+        /** @type {?} */
+        var item = this.queue[index];
+        /** @type {?} */
+        var transport = this.options.isHTML5 ? '_xhrTransport' : '_iframeTransport';
+        item._prepareToUploading();
+        if (this.isUploading) {
+            return;
+        }
+        this.isUploading = true;
+        ((/** @type {?} */ (this)))[transport](item);
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    FileUploader.prototype.cancelItem = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        /** @type {?} */
+        var index = this.getIndexOfItem(value);
+        /** @type {?} */
+        var item = this.queue[index];
+        /** @type {?} */
+        var prop = this.options.isHTML5 ? item._xhr : item._form;
+        if (item && item.isUploading) {
+            prop.abort();
+        }
+    };
+    /**
+     * @return {?}
+     */
+    FileUploader.prototype.uploadAll = /**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var items = this.getNotUploadedItems().filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return !item.isUploading; }));
+        if (!items.length) {
+            return;
+        }
+        items.map((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return item._prepareToUploading(); }));
+        items[0].upload();
+    };
+    /**
+     * @return {?}
+     */
+    FileUploader.prototype.cancelAll = /**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var items = this.getNotUploadedItems();
+        items.map((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return item.cancel(); }));
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    FileUploader.prototype.isFile = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return isFile(value);
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    FileUploader.prototype.isFileLikeObject = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return value instanceof FileLikeObject;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    FileUploader.prototype.getIndexOfItem = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return typeof value === 'number' ? value : this.queue.indexOf(value);
+    };
+    /**
+     * @return {?}
+     */
+    FileUploader.prototype.getNotUploadedItems = /**
+     * @return {?}
+     */
+    function () {
+        return this.queue.filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return !item.isUploaded; }));
+    };
+    /**
+     * @return {?}
+     */
+    FileUploader.prototype.getReadyItems = /**
+     * @return {?}
+     */
+    function () {
+        return this.queue
+            .filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) { return (item.isReady && !item.isUploading); }))
+            .sort((/**
+         * @param {?} item1
+         * @param {?} item2
+         * @return {?}
+         */
+        function (item1, item2) { return item1.index - item2.index; }));
+    };
+    /**
+     * @return {?}
+     */
+    FileUploader.prototype.destroy = /**
+     * @return {?}
+     */
+    function () {
+        return void 0;
+    };
+    /**
+     * @param {?} fileItems
+     * @return {?}
+     */
+    FileUploader.prototype.onAfterAddingAll = /**
+     * @param {?} fileItems
+     * @return {?}
+     */
+    function (fileItems) {
+        return { fileItems: fileItems };
+    };
+    /**
+     * @param {?} fileItem
+     * @param {?} form
+     * @return {?}
+     */
+    FileUploader.prototype.onBuildItemForm = /**
+     * @param {?} fileItem
+     * @param {?} form
+     * @return {?}
+     */
+    function (fileItem, form) {
+        return { fileItem: fileItem, form: form };
+    };
+    /**
+     * @param {?} fileItem
+     * @return {?}
+     */
+    FileUploader.prototype.onAfterAddingFile = /**
+     * @param {?} fileItem
+     * @return {?}
+     */
+    function (fileItem) {
+        return { fileItem: fileItem };
+    };
+    /**
+     * @param {?} item
+     * @param {?} filter
+     * @param {?} options
+     * @return {?}
+     */
+    FileUploader.prototype.onWhenAddingFileFailed = /**
+     * @param {?} item
+     * @param {?} filter
+     * @param {?} options
+     * @return {?}
+     */
+    function (item, filter, options) {
+        return { item: item, filter: filter, options: options };
+    };
+    /**
+     * @param {?} fileItem
+     * @return {?}
+     */
+    FileUploader.prototype.onBeforeUploadItem = /**
+     * @param {?} fileItem
+     * @return {?}
+     */
+    function (fileItem) {
+        return { fileItem: fileItem };
+    };
+    /**
+     * @param {?} fileItem
+     * @param {?} progress
+     * @return {?}
+     */
+    FileUploader.prototype.onProgressItem = /**
+     * @param {?} fileItem
+     * @param {?} progress
+     * @return {?}
+     */
+    function (fileItem, progress) {
+        return { fileItem: fileItem, progress: progress };
+    };
+    /**
+     * @param {?} progress
+     * @return {?}
+     */
+    FileUploader.prototype.onProgressAll = /**
+     * @param {?} progress
+     * @return {?}
+     */
+    function (progress) {
+        return { progress: progress };
+    };
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype.onSuccessItem = /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        return { item: item, response: response, status: status, headers: headers };
+    };
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype.onErrorItem = /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        return { item: item, response: response, status: status, headers: headers };
+    };
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype.onCancelItem = /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        return { item: item, response: response, status: status, headers: headers };
+    };
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype.onCompleteItem = /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        return { item: item, response: response, status: status, headers: headers };
+    };
+    /**
+     * @return {?}
+     */
+    FileUploader.prototype.onCompleteAll = /**
+     * @return {?}
+     */
+    function () {
+        return void 0;
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    FileUploader.prototype._mimeTypeFilter = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return !(this.options.allowedMimeType && this.options.allowedMimeType.indexOf(item.type) === -1);
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    FileUploader.prototype._fileSizeFilter = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return !(this.options.maxFileSize && item.size > this.options.maxFileSize);
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    FileUploader.prototype._fileTypeFilter = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        return !(this.options.allowedFileType &&
+            this.options.allowedFileType.indexOf(FileType.getMimeClass(item)) === -1);
+    };
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype._onErrorItem = /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        item._onError(response, status, headers);
+        this.onErrorItem(item, response, status, headers);
+    };
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype._onCompleteItem = /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        item._onComplete(response, status, headers);
+        this.onCompleteItem(item, response, status, headers);
+        /** @type {?} */
+        var nextItem = this.getReadyItems()[0];
+        this.isUploading = false;
+        if (nextItem) {
+            nextItem.upload();
+            return;
+        }
+        this.onCompleteAll();
+        this.progress = this._getTotalProgress();
+        this._render();
+    };
+    /**
+     * @protected
+     * @param {?} parsedHeaders
+     * @return {?}
+     */
+    FileUploader.prototype._headersGetter = /**
+     * @protected
+     * @param {?} parsedHeaders
+     * @return {?}
+     */
+    function (parsedHeaders) {
+        return (/**
+         * @param {?} name
+         * @return {?}
+         */
+        function (name) {
+            if (name) {
+                return parsedHeaders[name.toLowerCase()] || void 0;
+            }
+            return parsedHeaders;
+        });
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    FileUploader.prototype._xhrTransport = /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        var e_2, _a, e_3, _b;
+        var _this = this;
+        /** @type {?} */
+        var that = this;
+        /** @type {?} */
+        var xhr = item._xhr = new XMLHttpRequest();
+        /** @type {?} */
+        var sendable;
+        this._onBeforeUploadItem(item);
+        if (typeof item._file.size !== 'number') {
+            throw new TypeError('The file specified is no longer valid');
+        }
+        if (!this.options.disableMultipart) {
+            sendable = new FormData();
+            this._onBuildItemForm(item, sendable);
+            /** @type {?} */
+            var appendFile = (/**
+             * @return {?}
+             */
+            function () { return sendable.append(item.alias, item._file, item.file.name); });
+            if (!this.options.parametersBeforeFiles) {
+                appendFile();
+            }
+            // For AWS, Additional Parameters must come BEFORE Files
+            if (this.options.additionalParameter !== undefined) {
+                Object.keys(this.options.additionalParameter).forEach((/**
+                 * @param {?} key
+                 * @return {?}
+                 */
+                function (key) {
+                    /** @type {?} */
+                    var paramVal = _this.options.additionalParameter[key];
+                    // Allow an additional parameter to include the filename
+                    if (typeof paramVal === 'string' && paramVal.indexOf('{{file_name}}') >= 0) {
+                        paramVal = paramVal.replace('{{file_name}}', item.file.name);
+                    }
+                    sendable.append(key, paramVal);
+                }));
+            }
+            if (this.options.parametersBeforeFiles) {
+                appendFile();
+            }
+        }
+        else {
+            sendable = this.options.formatDataFunction(item);
+        }
+        xhr.upload.onprogress = (/**
+         * @param {?} event
+         * @return {?}
+         */
+        function (event) {
+            /** @type {?} */
+            var progress = Math.round(event.lengthComputable ? event.loaded * 100 / event.total : 0);
+            _this._onProgressItem(item, progress);
+        });
+        xhr.onload = (/**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var headers = _this._parseHeaders(xhr.getAllResponseHeaders());
+            /** @type {?} */
+            var response = _this._transformResponse(xhr.response, headers);
+            /** @type {?} */
+            var gist = _this._isSuccessCode(xhr.status) ? 'Success' : 'Error';
+            /** @type {?} */
+            var method = '_on' + gist + 'Item';
+            ((/** @type {?} */ (_this)))[method](item, response, xhr.status, headers);
+            _this._onCompleteItem(item, response, xhr.status, headers);
+        });
+        xhr.onerror = (/**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var headers = _this._parseHeaders(xhr.getAllResponseHeaders());
+            /** @type {?} */
+            var response = _this._transformResponse(xhr.response, headers);
+            _this._onErrorItem(item, response, xhr.status, headers);
+            _this._onCompleteItem(item, response, xhr.status, headers);
+        });
+        xhr.onabort = (/**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var headers = _this._parseHeaders(xhr.getAllResponseHeaders());
+            /** @type {?} */
+            var response = _this._transformResponse(xhr.response, headers);
+            _this._onCancelItem(item, response, xhr.status, headers);
+            _this._onCompleteItem(item, response, xhr.status, headers);
+        });
+        xhr.open(item.method, item.url, true);
+        xhr.withCredentials = item.withCredentials;
+        if (this.options.headers) {
+            try {
+                for (var _c = __values(this.options.headers), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var header = _d.value;
+                    xhr.setRequestHeader(header.name, header.value);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        if (item.headers.length) {
+            try {
+                for (var _e = __values(item.headers), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var header = _f.value;
+                    xhr.setRequestHeader(header.name, header.value);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+        if (this.authToken) {
+            xhr.setRequestHeader(this.authTokenHeader, this.authToken);
+        }
+        xhr.onreadystatechange = (/**
+         * @return {?}
+         */
+        function () {
+            if (xhr.readyState == XMLHttpRequest.DONE) {
+                that.response.emit(xhr.responseText);
+            }
+        });
+        if (this.options.formatDataFunctionIsAsync) {
+            sendable.then((/**
+             * @param {?} result
+             * @return {?}
+             */
+            function (result) { return xhr.send(JSON.stringify(result)); }));
+        }
+        else {
+            xhr.send(sendable);
+        }
+        this._render();
+    };
+    /**
+     * @protected
+     * @param {?=} value
+     * @return {?}
+     */
+    FileUploader.prototype._getTotalProgress = /**
+     * @protected
+     * @param {?=} value
+     * @return {?}
+     */
+    function (value) {
+        if (value === void 0) { value = 0; }
+        if (this.options.removeAfterUpload) {
+            return value;
+        }
+        /** @type {?} */
+        var notUploaded = this.getNotUploadedItems().length;
+        /** @type {?} */
+        var uploaded = notUploaded ? this.queue.length - notUploaded : this.queue.length;
+        /** @type {?} */
+        var ratio = 100 / this.queue.length;
+        /** @type {?} */
+        var current = value * ratio / 100;
+        return Math.round(uploaded * ratio + current);
+    };
+    /**
+     * @protected
+     * @param {?} filters
+     * @return {?}
+     */
+    FileUploader.prototype._getFilters = /**
+     * @protected
+     * @param {?} filters
+     * @return {?}
+     */
+    function (filters) {
+        if (!filters) {
+            return this.options.filters;
+        }
+        if (Array.isArray(filters)) {
+            return filters;
+        }
+        if (typeof filters === 'string') {
+            /** @type {?} */
+            var names_1 = filters.match(/[^\s,]+/g);
+            return this.options.filters
+                .filter((/**
+             * @param {?} filter
+             * @return {?}
+             */
+            function (filter) { return names_1.indexOf(filter.name) !== -1; }));
+        }
+        return this.options.filters;
+    };
+    /**
+     * @protected
+     * @return {?}
+     */
+    FileUploader.prototype._render = /**
+     * @protected
+     * @return {?}
+     */
+    function () {
+        return void 0;
+    };
+    /**
+     * @protected
+     * @return {?}
+     */
+    FileUploader.prototype._queueLimitFilter = /**
+     * @protected
+     * @return {?}
+     */
+    function () {
+        return this.options.queueLimit === undefined || this.queue.length < this.options.queueLimit;
+    };
+    /**
+     * @protected
+     * @param {?} file
+     * @param {?} filters
+     * @param {?} options
+     * @return {?}
+     */
+    FileUploader.prototype._isValidFile = /**
+     * @protected
+     * @param {?} file
+     * @param {?} filters
+     * @param {?} options
+     * @return {?}
+     */
+    function (file, filters, options) {
+        var _this = this;
+        this._failFilterIndex = -1;
+        return !filters.length ? true : filters.every((/**
+         * @param {?} filter
+         * @return {?}
+         */
+        function (filter) {
+            _this._failFilterIndex++;
+            return filter.fn.call(_this, file, options);
+        }));
+    };
+    /**
+     * @protected
+     * @param {?} status
+     * @return {?}
+     */
+    FileUploader.prototype._isSuccessCode = /**
+     * @protected
+     * @param {?} status
+     * @return {?}
+     */
+    function (status) {
+        return (status >= 200 && status < 300) || status === 304;
+    };
+    /**
+     * @protected
+     * @param {?} response
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype._transformResponse = /**
+     * @protected
+     * @param {?} response
+     * @param {?} headers
+     * @return {?}
+     */
+    function (response, headers) {
+        return response;
+    };
+    /**
+     * @protected
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype._parseHeaders = /**
+     * @protected
+     * @param {?} headers
+     * @return {?}
+     */
+    function (headers) {
+        /** @type {?} */
+        var parsed = {};
+        /** @type {?} */
+        var key;
+        /** @type {?} */
+        var val;
+        /** @type {?} */
+        var i;
+        if (!headers) {
+            return parsed;
+        }
+        headers.split('\n').map((/**
+         * @param {?} line
+         * @return {?}
+         */
+        function (line) {
+            i = line.indexOf(':');
+            key = line.slice(0, i).trim().toLowerCase();
+            val = line.slice(i + 1).trim();
+            if (key) {
+                parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+            }
+        }));
+        return parsed;
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @param {?} filter
+     * @param {?} options
+     * @return {?}
+     */
+    FileUploader.prototype._onWhenAddingFileFailed = /**
+     * @protected
+     * @param {?} item
+     * @param {?} filter
+     * @param {?} options
+     * @return {?}
+     */
+    function (item, filter, options) {
+        this.onWhenAddingFileFailed(item, filter, options);
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    FileUploader.prototype._onAfterAddingFile = /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        this.onAfterAddingFile(item);
+    };
+    /**
+     * @protected
+     * @param {?} items
+     * @return {?}
+     */
+    FileUploader.prototype._onAfterAddingAll = /**
+     * @protected
+     * @param {?} items
+     * @return {?}
+     */
+    function (items) {
+        this.onAfterAddingAll(items);
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    FileUploader.prototype._onBeforeUploadItem = /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        item._onBeforeUpload();
+        this.onBeforeUploadItem(item);
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @param {?} form
+     * @return {?}
+     */
+    FileUploader.prototype._onBuildItemForm = /**
+     * @protected
+     * @param {?} item
+     * @param {?} form
+     * @return {?}
+     */
+    function (item, form) {
+        item._onBuildForm(form);
+        this.onBuildItemForm(item, form);
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @param {?} progress
+     * @return {?}
+     */
+    FileUploader.prototype._onProgressItem = /**
+     * @protected
+     * @param {?} item
+     * @param {?} progress
+     * @return {?}
+     */
+    function (item, progress) {
+        /** @type {?} */
+        var total = this._getTotalProgress(progress);
+        this.progress = total;
+        item._onProgress(progress);
+        this.onProgressItem(item, progress);
+        this.onProgressAll(total);
+        this._render();
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype._onSuccessItem = /**
+     * @protected
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        item._onSuccess(response, status, headers);
+        this.onSuccessItem(item, response, status, headers);
+    };
+    /**
+     * @protected
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    FileUploader.prototype._onCancelItem = /**
+     * @protected
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    function (item, response, status, headers) {
+        item._onCancel(response, status, headers);
+        this.onCancelItem(item, response, status, headers);
+    };
+    return FileUploader;
+}());
+export { FileUploader };
+if (false) {
+    /** @type {?} */
+    FileUploader.prototype.authToken;
+    /** @type {?} */
+    FileUploader.prototype.isUploading;
+    /** @type {?} */
+    FileUploader.prototype.queue;
+    /** @type {?} */
+    FileUploader.prototype.progress;
+    /** @type {?} */
+    FileUploader.prototype._nextIndex;
+    /** @type {?} */
+    FileUploader.prototype.autoUpload;
+    /** @type {?} */
+    FileUploader.prototype.authTokenHeader;
+    /** @type {?} */
+    FileUploader.prototype.response;
+    /** @type {?} */
+    FileUploader.prototype.options;
+    /**
+     * @type {?}
+     * @protected
+     */
+    FileUploader.prototype._failFilterIndex;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-uploader.class.js","sourceRoot":"ng://ng2-file-upload/","sources":["file-upload/file-uploader.class.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;;;;;AAE7C,SAAS,MAAM,CAAC,KAAU;IACxB,OAAO,CAAC,IAAI,IAAI,KAAK,YAAY,IAAI,CAAC,CAAC;AACzC,CAAC;;;;AAED,6BAGC;;;IAFC,uBAAa;;IACb,wBAAc;;;;;AAUhB,yCAoBC;;;IAnBC,8CAA2B;;IAC3B,8CAA2B;;IAC3B,yCAAqB;;IACrB,sCAAkB;;IAClB,sCAA2B;;IAC3B,sCAAoB;;IACpB,qCAAgB;;IAChB,wCAAmB;;IACnB,0CAAqB;;IACrB,yCAAoB;;IACpB,gDAA4B;;IAC5B,kCAAa;;IACb,+CAA2B;;IAC3B,wCAAmB;;IACnB,8CAAyB;;IACzB,kDAA+C;;IAC/C,oDAAgC;;IAChC,iDAA8B;;IAC9B,wDAAoC;;AAGtC;IAuBE,sBAAmB,OAA4B;QApBxC,gBAAW,GAAY,KAAK,CAAC;QAC7B,UAAK,GAAe,EAAE,CAAC;QACvB,aAAQ,GAAW,CAAC,CAAC;QACrB,eAAU,GAAW,CAAC,CAAC;QAKvB,YAAO,GAAwB;YACpC,UAAU,EAAE,KAAK;YACjB,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,EAAE;YACX,iBAAiB,EAAE,KAAK;YACxB,gBAAgB,EAAE,KAAK;YACvB,kBAAkB;;;;YAAE,UAAC,IAAc,IAAK,OAAA,IAAI,CAAC,KAAK,EAAV,CAAU,CAAA;YAClD,yBAAyB,EAAE,KAAK;SACjC,CAAC;QAKA,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,IAAI,YAAY,EAAO,CAAC;IAC1C,CAAC;;;;;IAEM,iCAAU;;;;IAAjB,UAAkB,OAA4B;QAC5C,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAEpD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;QACxC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,eAAe,CAAC;QACvE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;QAC1C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAEjF,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;YAC5B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;SAC9E;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE;YAChC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;SAC9E;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE;YAChC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;SAC9E;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC1C,IAAI,CAAC,KAAK,CAAE,CAAC,CAAE,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC;SACxC;IACH,CAAC;;;;;;;IAEM,iCAAU;;;;;;IAAjB,UAAkB,KAAa,EAAE,OAA6B,EAAE,OAAmC;;QAAnG,iBAgCC;;YA/BK,IAAI,GAAW,EAAE;;YACrB,KAAiB,IAAA,UAAA,SAAA,KAAK,CAAA,4BAAA,+CAAE;gBAAnB,IAAI,IAAI,kBAAA;gBACX,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACjB;;;;;;;;;;YACG,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;;YAC1C,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;;YACzB,cAAc,GAAe,EAAE;QACnC,IAAI,CAAC,GAAG;;;;QAAC,UAAC,IAAU;YAClB,IAAI,CAAC,OAAO,EAAE;gBACZ,OAAO,GAAG,KAAI,CAAC,OAAO,CAAC;aACxB;;gBAEG,IAAI,GAAG,IAAI,cAAc,CAAC,IAAI,CAAC;YACnC,IAAI,KAAI,CAAC,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE;;oBAChD,QAAQ,GAAG,IAAI,QAAQ,CAAC,KAAI,EAAE,IAAI,EAAE,OAAO,CAAC;gBAChD,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC9B,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAC1B,KAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;aACnC;iBAAM;;oBACD,MAAM,GAAG,cAAc,CAAE,KAAI,CAAC,gBAAgB,CAAE;gBACpD,KAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;aACrD;QACH,CAAC,EAAC,CAAC;QACH,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE;YAC/B,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;YACvC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;SAC1C;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAC3B,IAAI,CAAC,SAAS,EAAE,CAAC;SAClB;IACH,CAAC;;;;;IAEM,sCAAe;;;;IAAtB,UAAuB,KAAe;;YAChC,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;;YAClC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAE,KAAK,CAAE;QAC9B,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,IAAI,CAAC,MAAM,EAAE,CAAC;SACf;QACD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3C,CAAC;;;;IAEM,iCAAU;;;IAAjB;QACE,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACxB,IAAI,CAAC,KAAK,CAAE,CAAC,CAAE,CAAC,MAAM,EAAE,CAAC;SAC1B;QACD,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IACpB,CAAC;;;;;IAEM,iCAAU;;;;IAAjB,UAAkB,KAAe;;YAC3B,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;;YAClC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAE,KAAK,CAAE;;YAC1B,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,kBAAkB;QAC3E,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO;SACR;QACD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,CAAC,mBAAA,IAAI,EAAO,CAAC,CAAE,SAAS,CAAE,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;;;;;IAEM,iCAAU;;;;IAAjB,UAAkB,KAAe;;YAC3B,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;;YAClC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAE,KAAK,CAAE;;YAC1B,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK;QACxD,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,EAAE;YAC5B,IAAI,CAAC,KAAK,EAAE,CAAC;SACd;IACH,CAAC;;;;IAEM,gCAAS;;;IAAhB;;YACM,KAAK,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC,MAAM;;;;QAAC,UAAC,IAAc,IAAK,OAAA,CAAC,IAAI,CAAC,WAAW,EAAjB,CAAiB,EAAC;QACpF,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;YACjB,OAAO;SACR;QACD,KAAK,CAAC,GAAG;;;;QAAC,UAAC,IAAc,IAAK,OAAA,IAAI,CAAC,mBAAmB,EAAE,EAA1B,CAA0B,EAAC,CAAC;QAC1D,KAAK,CAAE,CAAC,CAAE,CAAC,MAAM,EAAE,CAAC;IACtB,CAAC;;;;IAEM,gCAAS;;;IAAhB;;YACM,KAAK,GAAG,IAAI,CAAC,mBAAmB,EAAE;QACtC,KAAK,CAAC,GAAG;;;;QAAC,UAAC,IAAc,IAAK,OAAA,IAAI,CAAC,MAAM,EAAE,EAAb,CAAa,EAAC,CAAC;IAC/C,CAAC;;;;;IAEM,6BAAM;;;;IAAb,UAAc,KAAU;QACtB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;;;;;IAEM,uCAAgB;;;;IAAvB,UAAwB,KAAU;QAChC,OAAO,KAAK,YAAY,cAAc,CAAC;IACzC,CAAC;;;;;IAEM,qCAAc;;;;IAArB,UAAsB,KAAU;QAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACvE,CAAC;;;;IAEM,0CAAmB;;;IAA1B;QACE,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM;;;;QAAC,UAAC,IAAc,IAAK,OAAA,CAAC,IAAI,CAAC,UAAU,EAAhB,CAAgB,EAAC,CAAC;IACjE,CAAC;;;;IAEM,oCAAa;;;IAApB;QACE,OAAO,IAAI,CAAC,KAAK;aACd,MAAM;;;;QAAC,UAAC,IAAc,IAAK,OAAA,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAnC,CAAmC,EAAC;aAC/D,IAAI;;;;;QAAC,UAAC,KAAU,EAAE,KAAU,IAAK,OAAA,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,EAAzB,CAAyB,EAAC,CAAC;IACjE,CAAC;;;;IAEM,8BAAO;;;IAAd;QACE,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;;;;;IAEM,uCAAgB;;;;IAAvB,UAAwB,SAAc;QACpC,OAAO,EAAE,SAAS,WAAA,EAAE,CAAC;IACvB,CAAC;;;;;;IAEM,sCAAe;;;;;IAAtB,UAAuB,QAAkB,EAAE,IAAS;QAClD,OAAO,EAAE,QAAQ,UAAA,EAAE,IAAI,MAAA,EAAE,CAAC;IAC5B,CAAC;;;;;IAEM,wCAAiB;;;;IAAxB,UAAyB,QAAkB;QACzC,OAAO,EAAE,QAAQ,UAAA,EAAE,CAAC;IACtB,CAAC;;;;;;;IAEM,6CAAsB;;;;;;IAA7B,UAA8B,IAAoB,EAAE,MAAW,EAAE,OAAY;QAC3E,OAAO,EAAE,IAAI,MAAA,EAAE,MAAM,QAAA,EAAE,OAAO,SAAA,EAAE,CAAC;IACnC,CAAC;;;;;IAEM,yCAAkB;;;;IAAzB,UAA0B,QAAkB;QAC1C,OAAO,EAAE,QAAQ,UAAA,EAAE,CAAC;IACtB,CAAC;;;;;;IAEM,qCAAc;;;;;IAArB,UAAsB,QAAkB,EAAE,QAAa;QACrD,OAAO,EAAE,QAAQ,UAAA,EAAE,QAAQ,UAAA,EAAE,CAAC;IAChC,CAAC;;;;;IAEM,oCAAa;;;;IAApB,UAAqB,QAAa;QAChC,OAAO,EAAE,QAAQ,UAAA,EAAE,CAAC;IACtB,CAAC;;;;;;;;IAEM,oCAAa;;;;;;;IAApB,UAAqB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACnG,OAAO,EAAE,IAAI,MAAA,EAAE,QAAQ,UAAA,EAAE,MAAM,QAAA,EAAE,OAAO,SAAA,EAAE,CAAC;IAC7C,CAAC;;;;;;;;IAEM,kCAAW;;;;;;;IAAlB,UAAmB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACjG,OAAO,EAAE,IAAI,MAAA,EAAE,QAAQ,UAAA,EAAE,MAAM,QAAA,EAAE,OAAO,SAAA,EAAE,CAAC;IAC7C,CAAC;;;;;;;;IAEM,mCAAY;;;;;;;IAAnB,UAAoB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAClG,OAAO,EAAE,IAAI,MAAA,EAAE,QAAQ,UAAA,EAAE,MAAM,QAAA,EAAE,OAAO,SAAA,EAAE,CAAC;IAC7C,CAAC;;;;;;;;IAEM,qCAAc;;;;;;;IAArB,UAAsB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACpG,OAAO,EAAE,IAAI,MAAA,EAAE,QAAQ,UAAA,EAAE,MAAM,QAAA,EAAE,OAAO,SAAA,EAAE,CAAC;IAC7C,CAAC;;;;IAEM,oCAAa;;;IAApB;QACE,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;;;;;IAEM,sCAAe;;;;IAAtB,UAAuB,IAAoB;QACzC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnG,CAAC;;;;;IAEM,sCAAe;;;;IAAtB,UAAuB,IAAoB;QACzC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7E,CAAC;;;;;IAEM,sCAAe;;;;IAAtB,UAAuB,IAAoB;QACzC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe;YACnC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC9E,CAAC;;;;;;;;IAEM,mCAAY;;;;;;;IAAnB,UAAoB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QAClG,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACpD,CAAC;;;;;;;;IAEM,sCAAe;;;;;;;IAAtB,UAAuB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACrG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;;YACjD,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAE,CAAC,CAAE;QACxC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,QAAQ,EAAE;YACZ,QAAQ,CAAC,MAAM,EAAE,CAAC;YAClB,OAAO;SACR;QACD,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzC,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;;;;;;IAES,qCAAc;;;;;IAAxB,UAAyB,aAAoC;QAC3D;;;;QAAO,UAAC,IAAS;YACf,IAAI,IAAI,EAAE;gBACR,OAAO,aAAa,CAAE,IAAI,CAAC,WAAW,EAAE,CAAE,IAAI,KAAK,CAAC,CAAC;aACtD;YACD,OAAO,aAAa,CAAC;QACvB,CAAC,EAAC;IACJ,CAAC;;;;;;IAES,oCAAa;;;;;IAAvB,UAAwB,IAAc;;QAAtC,iBAyFC;;YAxFK,IAAI,GAAG,IAAI;;YACX,GAAG,GAAG,IAAI,CAAC,IAAI,GAAG,IAAI,cAAc,EAAE;;YACtC,QAAa;QACjB,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAE/B,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE;YACvC,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC,CAAC;SAC9D;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE;YAClC,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;;gBAEhC,UAAU;;;YAAG,cAAM,OAAA,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAvD,CAAuD,CAAA;YAChF,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE;gBACvC,UAAU,EAAE,CAAC;aACd;YAED,wDAAwD;YACxD,IAAI,IAAI,CAAC,OAAO,CAAC,mBAAmB,KAAK,SAAS,EAAE;gBAClD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,OAAO;;;;gBAAC,UAAC,GAAW;;wBAC5D,QAAQ,GAAG,KAAI,CAAC,OAAO,CAAC,mBAAmB,CAAE,GAAG,CAAE;oBACtD,wDAAwD;oBACxD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE;wBAC1E,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBAC9D;oBACD,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;gBACjC,CAAC,EAAC,CAAC;aACJ;YAED,IAAI,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE;gBACtC,UAAU,EAAE,CAAC;aACd;SACF;aAAM;YACL,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;SAClD;QAED,GAAG,CAAC,MAAM,CAAC,UAAU;;;;QAAG,UAAC,KAAU;;gBAC7B,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACxF,KAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAA,CAAC;QACF,GAAG,CAAC,MAAM;;;QAAG;;gBACP,OAAO,GAAG,KAAI,CAAC,aAAa,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC;;gBACzD,QAAQ,GAAG,KAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC;;gBACzD,IAAI,GAAG,KAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO;;gBAC5D,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,MAAM;YAClC,CAAC,mBAAA,KAAI,EAAO,CAAC,CAAE,MAAM,CAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC7D,KAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC,CAAA,CAAC;QACF,GAAG,CAAC,OAAO;;;QAAG;;gBACR,OAAO,GAAG,KAAI,CAAC,aAAa,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC;;gBACzD,QAAQ,GAAG,KAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC;YAC7D,KAAI,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACvD,KAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC,CAAA,CAAC;QACF,GAAG,CAAC,OAAO;;;QAAG;;gBACR,OAAO,GAAG,KAAI,CAAC,aAAa,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC;;gBACzD,QAAQ,GAAG,KAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC;YAC7D,KAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACxD,KAAI,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC5D,CAAC,CAAA,CAAC;QACF,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACtC,GAAG,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;QAC3C,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;;gBACxB,KAAmB,IAAA,KAAA,SAAA,IAAI,CAAC,OAAO,CAAC,OAAO,CAAA,gBAAA,4BAAE;oBAApC,IAAI,MAAM,WAAA;oBACb,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;iBACjD;;;;;;;;;SACF;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;;gBACvB,KAAmB,IAAA,KAAA,SAAA,IAAI,CAAC,OAAO,CAAA,gBAAA,4BAAE;oBAA5B,IAAI,MAAM,WAAA;oBACb,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;iBACjD;;;;;;;;;SACF;QACD,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,GAAG,CAAC,gBAAgB,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;SAC5D;QACD,GAAG,CAAC,kBAAkB;;;QAAG;YACvB,IAAI,GAAG,CAAC,UAAU,IAAI,cAAc,CAAC,IAAI,EAAE;gBACzC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;aACrC;QACH,CAAC,CAAA,CAAA;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE;YAC1C,QAAQ,CAAC,IAAI;;;;YACX,UAAC,MAAW,IAAK,OAAA,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAhC,CAAgC,EAClD,CAAC;SACH;aAAM;YACL,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACpB;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;;;;;;IAES,wCAAiB;;;;;IAA3B,UAA4B,KAAiB;QAAjB,sBAAA,EAAA,SAAiB;QAC3C,IAAI,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE;YAClC,OAAO,KAAK,CAAC;SACd;;YACG,WAAW,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC,MAAM;;YAC/C,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;;YAC5E,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;;YAC/B,OAAO,GAAG,KAAK,GAAG,KAAK,GAAG,GAAG;QACjC,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC,CAAC;IAChD,CAAC;;;;;;IAES,kCAAW;;;;;IAArB,UAAsB,OAAkC;QACtD,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;SAC7B;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC1B,OAAO,OAAO,CAAC;SAChB;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;;gBAC3B,OAAK,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC;YACrC,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO;iBACxB,MAAM;;;;YAAC,UAAC,MAAW,IAAK,OAAA,OAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAjC,CAAiC,EAAC,CAAC;SAC/D;QACD,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;IAC9B,CAAC;;;;;IAES,8BAAO;;;;IAAjB;QACE,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;;;;;IAES,wCAAiB;;;;IAA3B;QACE,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;IAC9F,CAAC;;;;;;;;IAES,mCAAY;;;;;;;IAAtB,UAAuB,IAAoB,EAAE,OAAyB,EAAE,OAA4B;QAApG,iBAMC;QALC,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC;QAC3B,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK;;;;QAAC,UAAC,MAAsB;YACnE,KAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,OAAO,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,KAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;IAES,qCAAc;;;;;IAAxB,UAAyB,MAAc;QACrC,OAAO,CAAC,MAAM,IAAI,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC,IAAI,MAAM,KAAK,GAAG,CAAC;IAC3D,CAAC;;;;;;;IAES,yCAAkB;;;;;;IAA5B,UAA6B,QAAgB,EAAE,OAA8B;QAC3E,OAAO,QAAQ,CAAC;IAClB,CAAC;;;;;;IAES,oCAAa;;;;;IAAvB,UAAwB,OAAe;;YACjC,MAAM,GAAQ,EAAE;;YAChB,GAAQ;;YACR,GAAQ;;YACR,CAAM;QACV,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,MAAM,CAAC;SACf;QACD,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG;;;;QAAC,UAAC,IAAS;YAChC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACtB,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC5C,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAC/B,IAAI,GAAG,EAAE;gBACP,MAAM,CAAE,GAAG,CAAE,GAAG,MAAM,CAAE,GAAG,CAAE,CAAC,CAAC,CAAC,MAAM,CAAE,GAAG,CAAE,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;aAClE;QACH,CAAC,EAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAChB,CAAC;;;;;;;;IAES,8CAAuB;;;;;;;IAAjC,UAAkC,IAAoB,EAAE,MAAW,EAAE,OAAY;QAC/E,IAAI,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;;;;;;IAES,yCAAkB;;;;;IAA5B,UAA6B,IAAc;QACzC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;;;;;;IAES,wCAAiB;;;;;IAA3B,UAA4B,KAAU;QACpC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;;;;;;IAES,0CAAmB;;;;;IAA7B,UAA8B,IAAc;QAC1C,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;;;;;;;IAES,uCAAgB;;;;;;IAA1B,UAA2B,IAAc,EAAE,IAAS;QAClD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;;;;;;;IAES,sCAAe;;;;;;IAAzB,UAA0B,IAAc,EAAE,QAAa;;YACjD,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC;QAC5C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC3B,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACpC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;;;;;;;;;IAES,qCAAc;;;;;;;;IAAxB,UAAyB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACvG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAC3C,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;;;;;;;;;IAES,oCAAa;;;;;;;;IAAvB,UAAwB,IAAc,EAAE,QAAgB,EAAE,MAAc,EAAE,OAA8B;QACtG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAC1C,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IACH,mBAAC;AAAD,CAAC,AAtcD,IAscC;;;;IApcC,iCAAyB;;IACzB,mCAAoC;;IACpC,6BAA8B;;IAC9B,gCAA4B;;IAC5B,kCAA8B;;IAC9B,kCAAuB;;IACvB,uCAA+B;;IAC/B,gCAAmC;;IAEnC,+BAQE;;;;;IAEF,wCAAmC","sourcesContent":["import { EventEmitter } from '@angular/core';\nimport { FileLikeObject } from './file-like-object.class';\nimport { FileItem } from './file-item.class';\nimport { FileType } from './file-type.class';\n\nfunction isFile(value: any): boolean {\n  return (File && value instanceof File);\n}\n\nexport interface Headers {\n  name: string;\n  value: string;\n}\n\nexport type ParsedResponseHeaders = { [ headerFieldName: string ]: string };\n\nexport type FilterFunction = {\n  name: string,\n  fn: (item?: FileLikeObject, options?: FileUploaderOptions) => boolean\n};\n\nexport interface FileUploaderOptions {\n  allowedMimeType?: string[];\n  allowedFileType?: string[];\n  autoUpload?: boolean;\n  isHTML5?: boolean;\n  filters?: FilterFunction[];\n  headers?: Headers[];\n  method?: string;\n  authToken?: string;\n  maxFileSize?: number;\n  queueLimit?: number;\n  removeAfterUpload?: boolean;\n  url?: string;\n  disableMultipart?: boolean;\n  itemAlias?: string;\n  authTokenHeader?: string;\n  additionalParameter?: { [ key: string ]: any };\n  parametersBeforeFiles?: boolean;\n  formatDataFunction?: Function;\n  formatDataFunctionIsAsync?: boolean;\n}\n\nexport class FileUploader {\n\n  public authToken: string;\n  public isUploading: boolean = false;\n  public queue: FileItem[] = [];\n  public progress: number = 0;\n  public _nextIndex: number = 0;\n  public autoUpload: any;\n  public authTokenHeader: string;\n  public response: EventEmitter<any>;\n\n  public options: FileUploaderOptions = {\n    autoUpload: false,\n    isHTML5: true,\n    filters: [],\n    removeAfterUpload: false,\n    disableMultipart: false,\n    formatDataFunction: (item: FileItem) => item._file,\n    formatDataFunctionIsAsync: false\n  };\n\n  protected _failFilterIndex: number;\n\n  public constructor(options: FileUploaderOptions) {\n    this.setOptions(options);\n    this.response = new EventEmitter<any>();\n  }\n\n  public setOptions(options: FileUploaderOptions): void {\n    this.options = Object.assign(this.options, options);\n\n    this.authToken = this.options.authToken;\n    this.authTokenHeader = this.options.authTokenHeader || 'Authorization';\n    this.autoUpload = this.options.autoUpload;\n    this.options.filters.unshift({ name: 'queueLimit', fn: this._queueLimitFilter });\n\n    if (this.options.maxFileSize) {\n      this.options.filters.unshift({ name: 'fileSize', fn: this._fileSizeFilter });\n    }\n\n    if (this.options.allowedFileType) {\n      this.options.filters.unshift({ name: 'fileType', fn: this._fileTypeFilter });\n    }\n\n    if (this.options.allowedMimeType) {\n      this.options.filters.unshift({ name: 'mimeType', fn: this._mimeTypeFilter });\n    }\n\n    for (let i = 0; i < this.queue.length; i++) {\n      this.queue[ i ].url = this.options.url;\n    }\n  }\n\n  public addToQueue(files: File[], options?: FileUploaderOptions, filters?: FilterFunction[] | string): void {\n    let list: File[] = [];\n    for (let file of files) {\n      list.push(file);\n    }\n    let arrayOfFilters = this._getFilters(filters);\n    let count = this.queue.length;\n    let addedFileItems: FileItem[] = [];\n    list.map((some: File) => {\n      if (!options) {\n        options = this.options;\n      }\n\n      let temp = new FileLikeObject(some);\n      if (this._isValidFile(temp, arrayOfFilters, options)) {\n        let fileItem = new FileItem(this, some, options);\n        addedFileItems.push(fileItem);\n        this.queue.push(fileItem);\n        this._onAfterAddingFile(fileItem);\n      } else {\n        let filter = arrayOfFilters[ this._failFilterIndex ];\n        this._onWhenAddingFileFailed(temp, filter, options);\n      }\n    });\n    if (this.queue.length !== count) {\n      this._onAfterAddingAll(addedFileItems);\n      this.progress = this._getTotalProgress();\n    }\n    this._render();\n    if (this.options.autoUpload) {\n      this.uploadAll();\n    }\n  }\n\n  public removeFromQueue(value: FileItem): void {\n    let index = this.getIndexOfItem(value);\n    let item = this.queue[ index ];\n    if (item.isUploading) {\n      item.cancel();\n    }\n    this.queue.splice(index, 1);\n    this.progress = this._getTotalProgress();\n  }\n\n  public clearQueue(): void {\n    while (this.queue.length) {\n      this.queue[ 0 ].remove();\n    }\n    this.progress = 0;\n  }\n\n  public uploadItem(value: FileItem): void {\n    let index = this.getIndexOfItem(value);\n    let item = this.queue[ index ];\n    let transport = this.options.isHTML5 ? '_xhrTransport' : '_iframeTransport';\n    item._prepareToUploading();\n    if (this.isUploading) {\n      return;\n    }\n    this.isUploading = true;\n    (this as any)[ transport ](item);\n  }\n\n  public cancelItem(value: FileItem): void {\n    let index = this.getIndexOfItem(value);\n    let item = this.queue[ index ];\n    let prop = this.options.isHTML5 ? item._xhr : item._form;\n    if (item && item.isUploading) {\n      prop.abort();\n    }\n  }\n\n  public uploadAll(): void {\n    let items = this.getNotUploadedItems().filter((item: FileItem) => !item.isUploading);\n    if (!items.length) {\n      return;\n    }\n    items.map((item: FileItem) => item._prepareToUploading());\n    items[ 0 ].upload();\n  }\n\n  public cancelAll(): void {\n    let items = this.getNotUploadedItems();\n    items.map((item: FileItem) => item.cancel());\n  }\n\n  public isFile(value: any): boolean {\n    return isFile(value);\n  }\n\n  public isFileLikeObject(value: any): boolean {\n    return value instanceof FileLikeObject;\n  }\n\n  public getIndexOfItem(value: any): number {\n    return typeof value === 'number' ? value : this.queue.indexOf(value);\n  }\n\n  public getNotUploadedItems(): any[] {\n    return this.queue.filter((item: FileItem) => !item.isUploaded);\n  }\n\n  public getReadyItems(): any[] {\n    return this.queue\n      .filter((item: FileItem) => (item.isReady && !item.isUploading))\n      .sort((item1: any, item2: any) => item1.index - item2.index);\n  }\n\n  public destroy(): void {\n    return void 0;\n  }\n\n  public onAfterAddingAll(fileItems: any): any {\n    return { fileItems };\n  }\n\n  public onBuildItemForm(fileItem: FileItem, form: any): any {\n    return { fileItem, form };\n  }\n\n  public onAfterAddingFile(fileItem: FileItem): any {\n    return { fileItem };\n  }\n\n  public onWhenAddingFileFailed(item: FileLikeObject, filter: any, options: any): any {\n    return { item, filter, options };\n  }\n\n  public onBeforeUploadItem(fileItem: FileItem): any {\n    return { fileItem };\n  }\n\n  public onProgressItem(fileItem: FileItem, progress: any): any {\n    return { fileItem, progress };\n  }\n\n  public onProgressAll(progress: any): any {\n    return { progress };\n  }\n\n  public onSuccessItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  public onErrorItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  public onCancelItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  public onCompleteItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { item, response, status, headers };\n  }\n\n  public onCompleteAll(): any {\n    return void 0;\n  }\n\n  public _mimeTypeFilter(item: FileLikeObject): boolean {\n    return !(this.options.allowedMimeType && this.options.allowedMimeType.indexOf(item.type) === -1);\n  }\n\n  public _fileSizeFilter(item: FileLikeObject): boolean {\n    return !(this.options.maxFileSize && item.size > this.options.maxFileSize);\n  }\n\n  public _fileTypeFilter(item: FileLikeObject): boolean {\n    return !(this.options.allowedFileType &&\n      this.options.allowedFileType.indexOf(FileType.getMimeClass(item)) === -1);\n  }\n\n  public _onErrorItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onError(response, status, headers);\n    this.onErrorItem(item, response, status, headers);\n  }\n\n  public _onCompleteItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onComplete(response, status, headers);\n    this.onCompleteItem(item, response, status, headers);\n    let nextItem = this.getReadyItems()[ 0 ];\n    this.isUploading = false;\n    if (nextItem) {\n      nextItem.upload();\n      return;\n    }\n    this.onCompleteAll();\n    this.progress = this._getTotalProgress();\n    this._render();\n  }\n\n  protected _headersGetter(parsedHeaders: ParsedResponseHeaders): any {\n    return (name: any): any => {\n      if (name) {\n        return parsedHeaders[ name.toLowerCase() ] || void 0;\n      }\n      return parsedHeaders;\n    };\n  }\n\n  protected _xhrTransport(item: FileItem): any {\n    let that = this;\n    let xhr = item._xhr = new XMLHttpRequest();\n    let sendable: any;\n    this._onBeforeUploadItem(item);\n\n    if (typeof item._file.size !== 'number') {\n      throw new TypeError('The file specified is no longer valid');\n    }\n    if (!this.options.disableMultipart) {\n      sendable = new FormData();\n      this._onBuildItemForm(item, sendable);\n\n      const appendFile = () => sendable.append(item.alias, item._file, item.file.name);\n      if (!this.options.parametersBeforeFiles) {\n        appendFile();\n      }\n\n      // For AWS, Additional Parameters must come BEFORE Files\n      if (this.options.additionalParameter !== undefined) {\n        Object.keys(this.options.additionalParameter).forEach((key: string) => {\n          let paramVal = this.options.additionalParameter[ key ];\n          // Allow an additional parameter to include the filename\n          if (typeof paramVal === 'string' && paramVal.indexOf('{{file_name}}') >= 0) {\n            paramVal = paramVal.replace('{{file_name}}', item.file.name);\n          }\n          sendable.append(key, paramVal);\n        });\n      }\n\n      if (this.options.parametersBeforeFiles) {\n        appendFile();\n      }\n    } else {\n      sendable = this.options.formatDataFunction(item);\n    }\n\n    xhr.upload.onprogress = (event: any) => {\n      let progress = Math.round(event.lengthComputable ? event.loaded * 100 / event.total : 0);\n      this._onProgressItem(item, progress);\n    };\n    xhr.onload = () => {\n      let headers = this._parseHeaders(xhr.getAllResponseHeaders());\n      let response = this._transformResponse(xhr.response, headers);\n      let gist = this._isSuccessCode(xhr.status) ? 'Success' : 'Error';\n      let method = '_on' + gist + 'Item';\n      (this as any)[ method ](item, response, xhr.status, headers);\n      this._onCompleteItem(item, response, xhr.status, headers);\n    };\n    xhr.onerror = () => {\n      let headers = this._parseHeaders(xhr.getAllResponseHeaders());\n      let response = this._transformResponse(xhr.response, headers);\n      this._onErrorItem(item, response, xhr.status, headers);\n      this._onCompleteItem(item, response, xhr.status, headers);\n    };\n    xhr.onabort = () => {\n      let headers = this._parseHeaders(xhr.getAllResponseHeaders());\n      let response = this._transformResponse(xhr.response, headers);\n      this._onCancelItem(item, response, xhr.status, headers);\n      this._onCompleteItem(item, response, xhr.status, headers);\n    };\n    xhr.open(item.method, item.url, true);\n    xhr.withCredentials = item.withCredentials;\n    if (this.options.headers) {\n      for (let header of this.options.headers) {\n        xhr.setRequestHeader(header.name, header.value);\n      }\n    }\n    if (item.headers.length) {\n      for (let header of item.headers) {\n        xhr.setRequestHeader(header.name, header.value);\n      }\n    }\n    if (this.authToken) {\n      xhr.setRequestHeader(this.authTokenHeader, this.authToken);\n    }\n    xhr.onreadystatechange = function () {\n      if (xhr.readyState == XMLHttpRequest.DONE) {\n        that.response.emit(xhr.responseText)\n      }\n    }\n    if (this.options.formatDataFunctionIsAsync) {\n      sendable.then(\n        (result: any) => xhr.send(JSON.stringify(result))\n      );\n    } else {\n      xhr.send(sendable);\n    }\n    this._render();\n  }\n\n  protected _getTotalProgress(value: number = 0): number {\n    if (this.options.removeAfterUpload) {\n      return value;\n    }\n    let notUploaded = this.getNotUploadedItems().length;\n    let uploaded = notUploaded ? this.queue.length - notUploaded : this.queue.length;\n    let ratio = 100 / this.queue.length;\n    let current = value * ratio / 100;\n    return Math.round(uploaded * ratio + current);\n  }\n\n  protected _getFilters(filters: FilterFunction[] | string): FilterFunction[] {\n    if (!filters) {\n      return this.options.filters;\n    }\n    if (Array.isArray(filters)) {\n      return filters;\n    }\n    if (typeof filters === 'string') {\n      let names = filters.match(/[^\\s,]+/g);\n      return this.options.filters\n        .filter((filter: any) => names.indexOf(filter.name) !== -1);\n    }\n    return this.options.filters;\n  }\n\n  protected _render(): any {\n    return void 0;\n  }\n\n  protected _queueLimitFilter(): boolean {\n    return this.options.queueLimit === undefined || this.queue.length < this.options.queueLimit;\n  }\n\n  protected _isValidFile(file: FileLikeObject, filters: FilterFunction[], options: FileUploaderOptions): boolean {\n    this._failFilterIndex = -1;\n    return !filters.length ? true : filters.every((filter: FilterFunction) => {\n      this._failFilterIndex++;\n      return filter.fn.call(this, file, options);\n    });\n  }\n\n  protected _isSuccessCode(status: number): boolean {\n    return (status >= 200 && status < 300) || status === 304;\n  }\n\n  protected _transformResponse(response: string, headers: ParsedResponseHeaders): string {\n    return response;\n  }\n\n  protected _parseHeaders(headers: string): ParsedResponseHeaders {\n    let parsed: any = {};\n    let key: any;\n    let val: any;\n    let i: any;\n    if (!headers) {\n      return parsed;\n    }\n    headers.split('\\n').map((line: any) => {\n      i = line.indexOf(':');\n      key = line.slice(0, i).trim().toLowerCase();\n      val = line.slice(i + 1).trim();\n      if (key) {\n        parsed[ key ] = parsed[ key ] ? parsed[ key ] + ', ' + val : val;\n      }\n    });\n    return parsed;\n  }\n\n  protected _onWhenAddingFileFailed(item: FileLikeObject, filter: any, options: any): void {\n    this.onWhenAddingFileFailed(item, filter, options);\n  }\n\n  protected _onAfterAddingFile(item: FileItem): void {\n    this.onAfterAddingFile(item);\n  }\n\n  protected _onAfterAddingAll(items: any): void {\n    this.onAfterAddingAll(items);\n  }\n\n  protected _onBeforeUploadItem(item: FileItem): void {\n    item._onBeforeUpload();\n    this.onBeforeUploadItem(item);\n  }\n\n  protected _onBuildItemForm(item: FileItem, form: any): void {\n    item._onBuildForm(form);\n    this.onBuildItemForm(item, form);\n  }\n\n  protected _onProgressItem(item: FileItem, progress: any): void {\n    let total = this._getTotalProgress(progress);\n    this.progress = total;\n    item._onProgress(progress);\n    this.onProgressItem(item, progress);\n    this.onProgressAll(total);\n    this._render();\n  }\n\n  protected _onSuccessItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onSuccess(response, status, headers);\n    this.onSuccessItem(item, response, status, headers);\n  }\n\n  protected _onCancelItem(item: FileItem, response: string, status: number, headers: ParsedResponseHeaders): void {\n    item._onCancel(response, status, headers);\n    this.onCancelItem(item, response, status, headers);\n  }\n}\n"]}