ng2-file-upload 1.1.4-2 → 1.4.0

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

@@ -0,0 +1,845 @@
+/**
+ * @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;
+}
+export class FileUploader {
+    /**
+     * @param {?} options
+     */
+    constructor(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 {?}
+             */
+            (item) => item._file),
+            formatDataFunctionIsAsync: false
+        };
+        this.setOptions(options);
+        this.response = new EventEmitter();
+    }
+    /**
+     * @param {?} options
+     * @return {?}
+     */
+    setOptions(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 (let i = 0; i < this.queue.length; i++) {
+            this.queue[i].url = this.options.url;
+        }
+    }
+    /**
+     * @param {?} files
+     * @param {?=} options
+     * @param {?=} filters
+     * @return {?}
+     */
+    addToQueue(files, options, filters) {
+        /** @type {?} */
+        let list = [];
+        for (let file of files) {
+            list.push(file);
+        }
+        /** @type {?} */
+        let arrayOfFilters = this._getFilters(filters);
+        /** @type {?} */
+        let count = this.queue.length;
+        /** @type {?} */
+        let addedFileItems = [];
+        list.map((/**
+         * @param {?} some
+         * @return {?}
+         */
+        (some) => {
+            if (!options) {
+                options = this.options;
+            }
+            /** @type {?} */
+            let temp = new FileLikeObject(some);
+            if (this._isValidFile(temp, arrayOfFilters, options)) {
+                /** @type {?} */
+                let fileItem = new FileItem(this, some, options);
+                addedFileItems.push(fileItem);
+                this.queue.push(fileItem);
+                this._onAfterAddingFile(fileItem);
+            }
+            else {
+                /** @type {?} */
+                let 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 {?}
+     */
+    removeFromQueue(value) {
+        /** @type {?} */
+        let index = this.getIndexOfItem(value);
+        /** @type {?} */
+        let item = this.queue[index];
+        if (item.isUploading) {
+            item.cancel();
+        }
+        this.queue.splice(index, 1);
+        this.progress = this._getTotalProgress();
+    }
+    /**
+     * @return {?}
+     */
+    clearQueue() {
+        while (this.queue.length) {
+            this.queue[0].remove();
+        }
+        this.progress = 0;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    uploadItem(value) {
+        /** @type {?} */
+        let index = this.getIndexOfItem(value);
+        /** @type {?} */
+        let item = this.queue[index];
+        /** @type {?} */
+        let transport = this.options.isHTML5 ? '_xhrTransport' : '_iframeTransport';
+        item._prepareToUploading();
+        if (this.isUploading) {
+            return;
+        }
+        this.isUploading = true;
+        ((/** @type {?} */ (this)))[transport](item);
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    cancelItem(value) {
+        /** @type {?} */
+        let index = this.getIndexOfItem(value);
+        /** @type {?} */
+        let item = this.queue[index];
+        /** @type {?} */
+        let prop = this.options.isHTML5 ? item._xhr : item._form;
+        if (item && item.isUploading) {
+            prop.abort();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    uploadAll() {
+        /** @type {?} */
+        let items = this.getNotUploadedItems().filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => !item.isUploading));
+        if (!items.length) {
+            return;
+        }
+        items.map((/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => item._prepareToUploading()));
+        items[0].upload();
+    }
+    /**
+     * @return {?}
+     */
+    cancelAll() {
+        /** @type {?} */
+        let items = this.getNotUploadedItems();
+        items.map((/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => item.cancel()));
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    isFile(value) {
+        return isFile(value);
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    isFileLikeObject(value) {
+        return value instanceof FileLikeObject;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    getIndexOfItem(value) {
+        return typeof value === 'number' ? value : this.queue.indexOf(value);
+    }
+    /**
+     * @return {?}
+     */
+    getNotUploadedItems() {
+        return this.queue.filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => !item.isUploaded));
+    }
+    /**
+     * @return {?}
+     */
+    getReadyItems() {
+        return this.queue
+            .filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => (item.isReady && !item.isUploading)))
+            .sort((/**
+         * @param {?} item1
+         * @param {?} item2
+         * @return {?}
+         */
+        (item1, item2) => item1.index - item2.index));
+    }
+    /**
+     * @return {?}
+     */
+    destroy() {
+        return void 0;
+    }
+    /**
+     * @param {?} fileItems
+     * @return {?}
+     */
+    onAfterAddingAll(fileItems) {
+        return { fileItems };
+    }
+    /**
+     * @param {?} fileItem
+     * @param {?} form
+     * @return {?}
+     */
+    onBuildItemForm(fileItem, form) {
+        return { fileItem, form };
+    }
+    /**
+     * @param {?} fileItem
+     * @return {?}
+     */
+    onAfterAddingFile(fileItem) {
+        return { fileItem };
+    }
+    /**
+     * @param {?} item
+     * @param {?} filter
+     * @param {?} options
+     * @return {?}
+     */
+    onWhenAddingFileFailed(item, filter, options) {
+        return { item, filter, options };
+    }
+    /**
+     * @param {?} fileItem
+     * @return {?}
+     */
+    onBeforeUploadItem(fileItem) {
+        return { fileItem };
+    }
+    /**
+     * @param {?} fileItem
+     * @param {?} progress
+     * @return {?}
+     */
+    onProgressItem(fileItem, progress) {
+        return { fileItem, progress };
+    }
+    /**
+     * @param {?} progress
+     * @return {?}
+     */
+    onProgressAll(progress) {
+        return { progress };
+    }
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onSuccessItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onErrorItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onCancelItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onCompleteItem(item, response, status, headers) {
+        return { item, response, status, headers };
+    }
+    /**
+     * @return {?}
+     */
+    onCompleteAll() {
+        return void 0;
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    _mimeTypeFilter(item) {
+        return !(this.options.allowedMimeType && this.options.allowedMimeType.indexOf(item.type) === -1);
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    _fileSizeFilter(item) {
+        return !(this.options.maxFileSize && item.size > this.options.maxFileSize);
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    _fileTypeFilter(item) {
+        return !(this.options.allowedFileType &&
+            this.options.allowedFileType.indexOf(FileType.getMimeClass(item)) === -1);
+    }
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    _onErrorItem(item, response, status, headers) {
+        item._onError(response, status, headers);
+        this.onErrorItem(item, response, status, headers);
+    }
+    /**
+     * @param {?} item
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    _onCompleteItem(item, response, status, headers) {
+        item._onComplete(response, status, headers);
+        this.onCompleteItem(item, response, status, headers);
+        /** @type {?} */
+        let nextItem = this.getReadyItems()[0];
+        this.isUploading = false;
+        if (nextItem) {
+            nextItem.upload();
+            return;
+        }
+        this.onCompleteAll();
+        this.progress = this._getTotalProgress();
+        this._render();
+    }
+    /**
+     * @protected
+     * @param {?} parsedHeaders
+     * @return {?}
+     */
+    _headersGetter(parsedHeaders) {
+        return (/**
+         * @param {?} name
+         * @return {?}
+         */
+        (name) => {
+            if (name) {
+                return parsedHeaders[name.toLowerCase()] || void 0;
+            }
+            return parsedHeaders;
+        });
+    }
+    /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    _xhrTransport(item) {
+        /** @type {?} */
+        let that = this;
+        /** @type {?} */
+        let xhr = item._xhr = new XMLHttpRequest();
+        /** @type {?} */
+        let 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 {?} */
+            const appendFile = (/**
+             * @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 {?}
+                 */
+                (key) => {
+                    /** @type {?} */
+                    let 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 {?}
+         */
+        (event) => {
+            /** @type {?} */
+            let progress = Math.round(event.lengthComputable ? event.loaded * 100 / event.total : 0);
+            this._onProgressItem(item, progress);
+        });
+        xhr.onload = (/**
+         * @return {?}
+         */
+        () => {
+            /** @type {?} */
+            let headers = this._parseHeaders(xhr.getAllResponseHeaders());
+            /** @type {?} */
+            let response = this._transformResponse(xhr.response, headers);
+            /** @type {?} */
+            let gist = this._isSuccessCode(xhr.status) ? 'Success' : 'Error';
+            /** @type {?} */
+            let method = '_on' + gist + 'Item';
+            ((/** @type {?} */ (this)))[method](item, response, xhr.status, headers);
+            this._onCompleteItem(item, response, xhr.status, headers);
+        });
+        xhr.onerror = (/**
+         * @return {?}
+         */
+        () => {
+            /** @type {?} */
+            let headers = this._parseHeaders(xhr.getAllResponseHeaders());
+            /** @type {?} */
+            let response = this._transformResponse(xhr.response, headers);
+            this._onErrorItem(item, response, xhr.status, headers);
+            this._onCompleteItem(item, response, xhr.status, headers);
+        });
+        xhr.onabort = (/**
+         * @return {?}
+         */
+        () => {
+            /** @type {?} */
+            let headers = this._parseHeaders(xhr.getAllResponseHeaders());
+            /** @type {?} */
+            let 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) {
+            for (let header of this.options.headers) {
+                xhr.setRequestHeader(header.name, header.value);
+            }
+        }
+        if (item.headers.length) {
+            for (let header of item.headers) {
+                xhr.setRequestHeader(header.name, header.value);
+            }
+        }
+        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 {?}
+             */
+            (result) => xhr.send(JSON.stringify(result))));
+        }
+        else {
+            xhr.send(sendable);
+        }
+        this._render();
+    }
+    /**
+     * @protected
+     * @param {?=} value
+     * @return {?}
+     */
+    _getTotalProgress(value = 0) {
+        if (this.options.removeAfterUpload) {
+            return value;
+        }
+        /** @type {?} */
+        let notUploaded = this.getNotUploadedItems().length;
+        /** @type {?} */
+        let uploaded = notUploaded ? this.queue.length - notUploaded : this.queue.length;
+        /** @type {?} */
+        let ratio = 100 / this.queue.length;
+        /** @type {?} */
+        let current = value * ratio / 100;
+        return Math.round(uploaded * ratio + current);
+    }
+    /**
+     * @protected
+     * @param {?} filters
+     * @return {?}
+     */
+    _getFilters(filters) {
+        if (!filters) {
+            return this.options.filters;
+        }
+        if (Array.isArray(filters)) {
+            return filters;
+        }
+        if (typeof filters === 'string') {
+            /** @type {?} */
+            let names = filters.match(/[^\s,]+/g);
+            return this.options.filters
+                .filter((/**
+             * @param {?} filter
+             * @return {?}
+             */
+            (filter) => names.indexOf(filter.name) !== -1));
+        }
+        return this.options.filters;
+    }
+    /**
+     * @protected
+     * @return {?}
+     */
+    _render() {
+        return void 0;
+    }
+    /**
+     * @protected
+     * @return {?}
+     */
+    _queueLimitFilter() {
+        return this.options.queueLimit === undefined || this.queue.length < this.options.queueLimit;
+    }
+    /**
+     * @protected
+     * @param {?} file
+     * @param {?} filters
+     * @param {?} options
+     * @return {?}
+     */
+    _isValidFile(file, filters, options) {
+        this._failFilterIndex = -1;
+        return !filters.length ? true : filters.every((/**
+         * @param {?} filter
+         * @return {?}
+         */
+        (filter) => {
+            this._failFilterIndex++;
+            return filter.fn.call(this, file, options);
+        }));
+    }
+    /**
+     * @protected
+     * @param {?} status
+     * @return {?}
+     */
+    _isSuccessCode(status) {
+        return (status >= 200 && status < 300) || status === 304;
+    }
+    /**
+     * @protected
+     * @param {?} response
+     * @param {?} headers
+     * @return {?}
+     */
+    _transformResponse(response, headers) {
+        return response;
+    }
+    /**
+     * @protected
+     * @param {?} headers
+     * @return {?}
+     */
+    _parseHeaders(headers) {
+        /** @type {?} */
+        let parsed = {};
+        /** @type {?} */
+        let key;
+        /** @type {?} */
+        let val;
+        /** @type {?} */
+        let i;
+        if (!headers) {
+            return parsed;
+        }
+        headers.split('\n').map((/**
+         * @param {?} line
+         * @return {?}
+         */
+        (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 {?}
+     */
+    _onWhenAddingFileFailed(item, filter, options) {
+        this.onWhenAddingFileFailed(item, filter, options);
+    }
+    /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    _onAfterAddingFile(item) {
+        this.onAfterAddingFile(item);
+    }
+    /**
+     * @protected
+     * @param {?} items
+     * @return {?}
+     */
+    _onAfterAddingAll(items) {
+        this.onAfterAddingAll(items);
+    }
+    /**
+     * @protected
+     * @param {?} item
+     * @return {?}
+     */
+    _onBeforeUploadItem(item) {
+        item._onBeforeUpload();
+        this.onBeforeUploadItem(item);
+    }
+    /**
+     * @protected
+     * @param {?} item
+     * @param {?} form
+     * @return {?}
+     */
+    _onBuildItemForm(item, form) {
+        item._onBuildForm(form);
+        this.onBuildItemForm(item, form);
+    }
+    /**
+     * @protected
+     * @param {?} item
+     * @param {?} progress
+     * @return {?}
+     */
+    _onProgressItem(item, progress) {
+        /** @type {?} */
+        let 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 {?}
+     */
+    _onSuccessItem(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 {?}
+     */
+    _onCancelItem(item, response, status, headers) {
+        item._onCancel(response, status, headers);
+        this.onCancelItem(item, response, status, headers);
+    }
+}
+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":"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","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"]}