@trendster-io/ng-uploader/bundles/trendster-io-ng-uploader.umd.js

A fully featured Angular file uploader that utilizes Angular's HttpClient internally, allows you to customize outgoing HTTP requests using the "Angular Way" (Interceptors), provides customizable concurrent queuing of uploads and a simple way to select fil

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('rxjs/operators'), require('@angular/common/http'), require('@angular/core')) :
    typeof define === 'function' && define.amd ? define('@trendster-io/ng-uploader', ['exports', 'rxjs', 'rxjs/operators', '@angular/common/http', '@angular/core'], factory) :
    (factory((global['trendster-io'] = global['trendster-io'] || {}, global['trendster-io']['ng-uploader'] = {}),global.rxjs,global.rxjs.operators,global.ng.common.http,global.ng.core));
}(this, (function (exports,rxjs,operators,i1,i0) { 'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m)
            return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
                ar.push(r.value);
        }
        catch (error) {
            e = { error: error };
        }
        finally {
            try {
                if (r && !r.done && (m = i["return"]))
                    m.call(i);
            }
            finally {
                if (e)
                    throw e.error;
            }
        }
        return ar;
    }

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var UploadItem = /** @class */ (function () {
        function UploadItem(listener, options) {
            this.listener = listener;
            this.onResponseSubject = new rxjs.Subject();
            this.onProgressSubject = new rxjs.Subject();
            this.onErrorSubject = new rxjs.Subject();
            this.onResponse = this.onResponseSubject.asObservable();
            this.onProgress = this.onProgressSubject.asObservable();
            this.onError = this.onErrorSubject.asObservable();
            this._progress = 0;
            this.url = options.url;
            this.method = options.method;
            this.file = options.file;
            this.fileAlias = options.fileAlias || 'file';
            this.additionalParams = options.additionalParams;
            this._req = this.buildRequest();
            /** @type {?} */
            var fileCategory = this.file.type.split('/')[0];
            if (fileCategory === 'image' || fileCategory === 'video') {
                this.preview = this.readMediaFile();
            }
        }
        Object.defineProperty(UploadItem.prototype, "req", {
            get: /**
             * @return {?}
             */ function () {
                return this._req;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(UploadItem.prototype, "progress", {
            get: /**
             * @return {?}
             */ function () {
                return this._progress;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(UploadItem.prototype, "fileName", {
            get: /**
             * @return {?}
             */ function () {
                return this.file.name;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(UploadItem.prototype, "isReady", {
            get: /**
             * @return {?}
             */ function () {
                return this.ready;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(UploadItem.prototype, "isUploading", {
            get: /**
             * @return {?}
             */ function () {
                return this.uploading;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(UploadItem.prototype, "isUploaded", {
            get: /**
             * @return {?}
             */ function () {
                return this.uploaded;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(UploadItem.prototype, "isCancelled", {
            get: /**
             * @return {?}
             */ function () {
                return this.cancelled;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(UploadItem.prototype, "isError", {
            get: /**
             * @return {?}
             */ function () {
                return this.error;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @private
         * @return {?}
         */
        UploadItem.prototype.buildFormData = /**
         * @private
         * @return {?}
         */
            function () {
                /** @type {?} */
                var formData = new FormData();
                if (this.additionalParams) {
                    Object.entries(this.additionalParams).forEach(( /**
                     * @param {?} __0
                     * @return {?}
                     */function (_a) {
                        var _b = __read(_a, 2), key = _b[0], value = _b[1];
                        return formData.set(key, value);
                    }));
                }
                formData.set(this.fileAlias, this.file, this.file.name);
                return formData;
            };
        /**
         * @private
         * @return {?}
         */
        UploadItem.prototype.buildRequest = /**
         * @private
         * @return {?}
         */
            function () {
                /** @type {?} */
                var body = this.buildFormData();
                return new i1.HttpRequest(this.method, this.url, body, {
                    reportProgress: true
                });
            };
        /**
         * @private
         * @return {?}
         */
        UploadItem.prototype.readMediaFile = /**
         * @private
         * @return {?}
         */
            function () {
                var _this = this;
                return new rxjs.Observable(( /**
                 * @param {?} observer
                 * @return {?}
                 */function (observer) {
                    /** @type {?} */
                    var reader = new FileReader();
                    reader.onload = ( /**
                     * @return {?}
                     */function () {
                        observer.next(( /** @type {?} */(reader.result)));
                        observer.complete();
                    });
                    reader.onerror = ( /**
                     * @return {?}
                     */function () {
                        reader.abort();
                        observer.error(reader.error);
                    });
                    reader.readAsDataURL(_this.file);
                }));
            };
        /**
         * @return {?}
         */
        UploadItem.prototype.cleanup = /**
         * @return {?}
         */
            function () {
                this.onResponseSubject.complete();
                this.onProgressSubject.complete();
                this.onErrorSubject.complete();
            };
        /**
         * @return {?}
         */
        UploadItem.prototype.onBeforeUpload = /**
         * @return {?}
         */
            function () {
                this.ready = true;
                this.uploading = false;
                this.uploaded = false;
                this.cancelled = false;
                this.error = false;
                this._progress = 0;
            };
        /**
         * @return {?}
         */
        UploadItem.prototype.onUploadStart = /**
         * @return {?}
         */
            function () {
                this.ready = true;
                this.uploading = true;
                this.uploaded = false;
                this.cancelled = false;
                this.error = false;
            };
        /**
         * @param {?} res
         * @return {?}
         */
        UploadItem.prototype.onUploadSuccess = /**
         * @param {?} res
         * @return {?}
         */
            function (res) {
                this.ready = false;
                this.uploading = false;
                this.uploaded = true;
                this.cancelled = false;
                this.error = false;
                this._progress = 100;
                this.onResponseSubject.next(res);
                this.cleanup();
            };
        /**
         * @param {?} progress
         * @return {?}
         */
        UploadItem.prototype.onUploadProgress = /**
         * @param {?} progress
         * @return {?}
         */
            function (progress) {
                this._progress = progress;
                this.onProgressSubject.next(this._progress);
            };
        /**
         * @return {?}
         */
        UploadItem.prototype.onUploadCancelled = /**
         * @return {?}
         */
            function () {
                this.ready = false;
                this.uploading = false;
                this.uploaded = false;
                this.cancelled = true;
                this.error = false;
                this._progress = 0;
            };
        /**
         * @param {?} err
         * @return {?}
         */
        UploadItem.prototype.onUploadError = /**
         * @param {?} err
         * @return {?}
         */
            function (err) {
                this.ready = false;
                this.uploading = false;
                this.uploaded = false;
                this.cancelled = false;
                this.error = true;
                this._progress = 0;
                this.onErrorSubject.next(err);
            };
        /**
         * @param {?=} additionalParams
         * @return {?}
         */
        UploadItem.prototype.upload = /**
         * @param {?=} additionalParams
         * @return {?}
         */
            function (additionalParams) {
                if (additionalParams) {
                    this.additionalParams = additionalParams;
                    this._req = this.buildRequest();
                }
                this.listener.uploadItem(this);
            };
        /**
         * @return {?}
         */
        UploadItem.prototype.cancel = /**
         * @return {?}
         */
            function () {
                this.listener.cancelItem(this);
            };
        /**
         * @return {?}
         */
        UploadItem.prototype.remove = /**
         * @return {?}
         */
            function () {
                this.listener.removeItem(this);
            };
        return UploadItem;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var Uploader = /** @class */ (function () {
        function Uploader(httpClient, options) {
            if (options === void 0) {
                options = {};
            }
            this.httpClient = httpClient;
            this.onItemSuccessSubject = new rxjs.Subject();
            this.onItemProgressSubject = new rxjs.Subject();
            this.onItemErrorSubject = new rxjs.Subject();
            this.onItemSuccess = this.onItemSuccessSubject.asObservable();
            this.onItemProgress = this.onItemProgressSubject.asObservable();
            this.onItemError = this.onItemErrorSubject.asObservable();
            this._totalProgress = 0;
            this.url = options.url;
            this.method = options.method;
            this.autoUpload = options.autoUpload;
            this.removeAfterUpload = options.removeAfterUpload;
            this.queueLimit = options.queueLimit;
            this.concurrency = options.concurrency || 1;
            this.maxFileSize = options.maxFileSize;
            this.allowedMimeTypes = options.allowedMimeTypes;
            this.setupQueue();
        }
        Object.defineProperty(Uploader.prototype, "itemsCount", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue.length;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "items", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue.map(( /**
                 * @param {?} queueItem
                 * @return {?}
                 */function (queueItem) { return queueItem.item; }));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "readyItemsCount", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isReady && !item.isUploading; })).length;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "readyItems", {
            get: /**
             * @private
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isReady && !item.isUploading; }));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "uploadingItemsCount", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isUploading; })).length;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "uploadingItems", {
            get: /**
             * @private
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isUploading; }));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "uploadedItemsCount", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isUploaded; })).length;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "uploadedItems", {
            get: /**
             * @private
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isUploaded; }));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "notUploadedItemsCount", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return !item.isUploaded; })).length;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "notUploadedItems", {
            get: /**
             * @private
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return !item.isUploaded; }));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "cancelledItemsCount", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isCancelled; })).length;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "cancelledItems", {
            get: /**
             * @private
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isCancelled; }));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "errorItemsCount", {
            get: /**
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isError; })).length;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "errorItems", {
            get: /**
             * @private
             * @return {?}
             */ function () {
                return this.queue
                    .map(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) { return queueItem.item; }))
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.isError; }));
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "totalProgress", {
            get: /**
             * @return {?}
             */ function () {
                return this._totalProgress;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(Uploader.prototype, "isUploading", {
            get: /**
             * @return {?}
             */ function () {
                return this.uploadingItemsCount > 0;
            },
            enumerable: true,
            configurable: true
        });
        /**
         * @private
         * @param {?} __0
         * @return {?}
         */
        Uploader.prototype.onQueueItemSuccess = /**
         * @private
         * @param {?} __0
         * @return {?}
         */
            function (_a) {
                var item = _a.item, res = _a.res;
                item.onUploadSuccess(res);
                this.onItemSuccessSubject.next({ item: item, res: res });
                if (this.removeAfterUpload) {
                    item.remove();
                }
            };
        /**
         * @private
         * @param {?} __0
         * @return {?}
         */
        Uploader.prototype.onQueueItemError = /**
         * @private
         * @param {?} __0
         * @return {?}
         */
            function (_a) {
                var item = _a.item, err = _a.err;
                item.onUploadError(err);
                this.onItemErrorSubject.next({ item: item, err: err });
            };
        /**
         * @private
         * @param {?} req
         * @return {?}
         */
        Uploader.prototype.request = /**
         * @private
         * @param {?} req
         * @return {?}
         */
            function (req) {
                return this.httpClient.request(req).pipe(operators.filter(( /**
                 * @param {?} event
                 * @return {?}
                 */function (event) {
                    return event.type === i1.HttpEventType.Sent ||
                        event.type === i1.HttpEventType.UploadProgress ||
                        event.type === i1.HttpEventType.Response;
                })), operators.map(( /**
                 * @param {?} event
                 * @return {?}
                 */function (event) {
                    switch (event.type) {
                        case i1.HttpEventType.Sent:
                            return { type: 'start', value: null };
                        case i1.HttpEventType.UploadProgress:
                            /** @type {?} */
                            var progress = Math.round((100 * event.loaded) / event.total);
                            return { type: 'progress', value: progress };
                        case i1.HttpEventType.Response:
                            return { type: 'response', value: event.body };
                    }
                })));
            };
        /**
         * @private
         * @return {?}
         */
        Uploader.prototype.calculateTotalProgress = /**
         * @private
         * @return {?}
         */
            function () {
                /** @type {?} */
                var value = this.uploadingItems.reduce(( /**
                 * @param {?} acc
                 * @param {?} item
                 * @return {?}
                 */function (acc, item) { return item.progress + acc; }), 0) /
                    (this.uploadingItemsCount || 1);
                if (this.removeAfterUpload) {
                    this._totalProgress = value;
                }
                else {
                    /** @type {?} */
                    var ratio = 100 / this.itemsCount;
                    /** @type {?} */
                    var current = (value * ratio) / 100;
                    this._totalProgress = Math.round(this.uploadedItemsCount * ratio + current);
                }
            };
        /**
         * @private
         * @param {?} queueItem
         * @return {?}
         */
        Uploader.prototype.prepareQueueItem = /**
         * @private
         * @param {?} queueItem
         * @return {?}
         */
            function (queueItem) {
                var _this = this;
                return new rxjs.Observable(( /**
                 * @param {?} observer
                 * @return {?}
                 */function (observer) {
                    queueItem.subscription = _this.request(queueItem.item.req)
                        .pipe(operators.finalize(( /**
                 * @return {?}
                 */function () {
                        if (!observer.closed) {
                            observer.complete();
                        }
                    })), operators.tap(( /**
                     * @param {?} event
                     * @return {?}
                     */function (event) {
                        switch (event.type) {
                            case 'start':
                                queueItem.item.onUploadStart();
                                break;
                            case 'progress':
                                /** @type {?} */
                                var progress = event.value;
                                /** @type {?} */
                                var item = queueItem.item;
                                item.onUploadProgress(progress);
                                _this.onItemProgressSubject.next({ item: item, progress: progress });
                                _this.calculateTotalProgress();
                                break;
                            default:
                                break;
                        }
                    })), operators.filter(( /**
                     * @param {?} event
                     * @return {?}
                     */function (event) { return event.type === 'response'; })), operators.map(( /**
                     * @param {?} event
                     * @return {?}
                     */function (event) { return event.value; })))
                        .subscribe({
                        next: ( /**
                         * @param {?} res
                         * @return {?}
                         */function (res) {
                            queueItem.subscription = null;
                            observer.next({ item: queueItem.item, res: res });
                            observer.complete();
                        }),
                        error: ( /**
                         * @param {?} err
                         * @return {?}
                         */function (err) {
                            queueItem.subscription = null;
                            observer.error({ item: queueItem.item, err: err });
                        }),
                        complete: ( /**
                         * @return {?}
                         */function () { return observer.complete(); })
                    });
                }));
            };
        /**
         * @private
         * @return {?}
         */
        Uploader.prototype.setupQueue = /**
         * @private
         * @return {?}
         */
            function () {
                var _this = this;
                this.queue = [];
                this.scheduler = new rxjs.Subject();
                this.scheduler
                    .pipe(operators.mergeMap(( /**
             * @param {?} queueItem
             * @return {?}
             */function (queueItem) {
                    return _this.prepareQueueItem(queueItem).pipe(operators.catchError(( /**
                     * @param {?} uploadEvent
                     * @return {?}
                     */function (uploadEvent) {
                        _this.onQueueItemError(uploadEvent);
                        return rxjs.of(null);
                    })));
                }), this.concurrency), operators.filter(( /**
                 * @param {?} uploadEvent
                 * @return {?}
                 */function (uploadEvent) { return Boolean(uploadEvent); })))
                    .subscribe(( /**
             * @param {?} uploadEvent
             * @return {?}
             */function (uploadEvent) { return _this.onQueueItemSuccess(uploadEvent); }));
            };
        /**
         * @private
         * @param {?} __0
         * @return {?}
         */
        Uploader.prototype.isValidRequestParams = /**
         * @private
         * @param {?} __0
         * @return {?}
         */
            function (_a) {
                var url = _a.url, method = _a.method;
                return Boolean(url || this.url) && Boolean(method || this.method);
            };
        /**
         * @private
         * @param {?} file
         * @return {?}
         */
        Uploader.prototype.isValidFileType = /**
         * @private
         * @param {?} file
         * @return {?}
         */
            function (file) {
                return this.allowedMimeTypes && this.allowedMimeTypes.length
                    ? this.allowedMimeTypes.includes(file.type)
                    : true;
            };
        /**
         * @private
         * @param {?} file
         * @return {?}
         */
        Uploader.prototype.isValidFileSize = /**
         * @private
         * @param {?} file
         * @return {?}
         */
            function (file) {
                return this.maxFileSize ? file.size <= this.maxFileSize : true;
            };
        /**
         * @private
         * @param {?} file
         * @return {?}
         */
        Uploader.prototype.isValidFile = /**
         * @private
         * @param {?} file
         * @return {?}
         */
            function (file) {
                return this.isValidFileType(file) && this.isValidFileSize(file);
            };
        /**
         * @private
         * @return {?}
         */
        Uploader.prototype.canAddToQueue = /**
         * @private
         * @return {?}
         */
            function () {
                return this.queueLimit ? this.itemsCount < this.queueLimit : true;
            };
        /**
         * @private
         * @param {?} options
         * @return {?}
         */
        Uploader.prototype.checkItem = /**
         * @private
         * @param {?} options
         * @return {?}
         */
            function (options) {
                if (!this.isValidRequestParams(options)) {
                    throw {
                        name: 'RequestParamsMissing',
                        message: 'You have not supplied a general url or method to the uploader and also didn\'t provide them in your item.'
                    };
                }
                if (!this.isValidFileType(options.file)) {
                    throw {
                        name: 'NotAllowedFileType',
                        message: 'The file type is not included in the allowedMimeTypes.'
                    };
                }
                if (!this.isValidFileSize(options.file)) {
                    throw {
                        name: 'FileSizeExceeded',
                        message: 'The file size exceeded the maximumFileSize.'
                    };
                }
                if (!this.canAddToQueue()) {
                    throw {
                        name: 'QueueLimitReached',
                        message: 'The specified queueLimit was reached, cannot add more items at the moment.'
                    };
                }
            };
        /**
         * @param {?} options
         * @return {?}
         */
        Uploader.prototype.addItem = /**
         * @param {?} options
         * @return {?}
         */
            function (options) {
                this.checkItem(options);
                Object.assign(options, {
                    url: options.url || this.url,
                    method: options.method || this.method
                });
                /** @type {?} */
                var item = new UploadItem(this, options);
                this.queue.push({ item: item, subscription: null });
                this.calculateTotalProgress();
                if (this.autoUpload) {
                    item.upload();
                }
                return item;
            };
        /**
         * @param {?} item
         * @return {?}
         */
        Uploader.prototype.uploadItem = /**
         * @param {?} item
         * @return {?}
         */
            function (item) {
                /** @type {?} */
                var queueItem = this.queue.find(( /**
                 * @param {?} current
                 * @return {?}
                 */function (current) {
                    return current.item === item &&
                        !(current.item.isReady ||
                            current.item.isUploading ||
                            current.item.isUploaded);
                }));
                if (queueItem) {
                    item.onBeforeUpload();
                    this.scheduler.next(queueItem);
                }
            };
        /**
         * @return {?}
         */
        Uploader.prototype.uploadAll = /**
         * @return {?}
         */
            function () {
                this.items
                    .filter(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return !(item.isReady || item.isUploading || item.isUploaded); }))
                    .forEach(( /**
             * @param {?} item
             * @return {?}
             */function (item) { return item.upload(); }));
            };
        /**
         * @param {?} item
         * @return {?}
         */
        Uploader.prototype.cancelItem = /**
         * @param {?} item
         * @return {?}
         */
            function (item) {
                /** @type {?} */
                var queueItem = this.queue.find(( /**
                 * @param {?} current
                 * @return {?}
                 */function (current) { return current.item === item && item.isReady; }));
                if (queueItem) {
                    if (queueItem.subscription) {
                        queueItem.subscription.unsubscribe();
                        queueItem.subscription = null;
                    }
                    queueItem.item.onUploadCancelled();
                    this.calculateTotalProgress();
                }
            };
        /**
         * @return {?}
         */
        Uploader.prototype.cancelAll = /**
         * @return {?}
         */
            function () {
                this.notUploadedItems.forEach(( /**
                 * @param {?} item
                 * @return {?}
                 */function (item) { return item.cancel(); }));
            };
        /**
         * @param {?} item
         * @return {?}
         */
        Uploader.prototype.removeItem = /**
         * @param {?} item
         * @return {?}
         */
            function (item) {
                if (item.isUploading) {
                    item.cancel();
                }
                item.cleanup();
                this.queue = this.queue.filter(( /**
                 * @param {?} current
                 * @return {?}
                 */function (current) { return current.item !== item; }));
                this.calculateTotalProgress();
            };
        /**
         * @return {?}
         */
        Uploader.prototype.clearQueue = /**
         * @return {?}
         */
            function () {
                while (this.itemsCount) {
                    this.queue[0].item.remove();
                }
                this._totalProgress = 0;
            };
        return Uploader;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var UploaderService = /** @class */ (function () {
        function UploaderService(httpClient) {
            this.httpClient = httpClient;
        }
        /**
         * @param {?} options
         * @return {?}
         */
        UploaderService.prototype.getUploader = /**
         * @param {?} options
         * @return {?}
         */
            function (options) {
                return new Uploader(this.httpClient, options);
            };
        UploaderService.decorators = [
            { type: i0.Injectable, args: [{
                        providedIn: 'root'
                    },] }
        ];
        /** @nocollapse */
        UploaderService.ctorParameters = function () {
            return [
                { type: i1.HttpClient }
            ];
        };
        /** @nocollapse */ UploaderService.ngInjectableDef = i0.defineInjectable({ factory: function UploaderService_Factory() { return new UploaderService(i0.inject(i1.HttpClient)); }, token: UploaderService, providedIn: "root" });
        return UploaderService;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var DropzoneDirective = /** @class */ (function () {
        function DropzoneDirective() {
            // Disable dropping on the body of the document.
            // This prevents the browser from loading the dropped files
            // using it's default behaviour if the user misses the drop zone.
            // Set this input to false if you want the browser default behaviour.
            this.preventBodyDrop = true;
            this.disabled = false;
            this.fileDrop = new i0.EventEmitter();
            // The `dropzone-active` class is applied to the host
            // element when a drag is currently over the target, to allow styling it
            this.active = false;
        }
        /**
         * @param {?} event
         * @return {?}
         */
        DropzoneDirective.prototype.onDrop = /**
         * @param {?} event
         * @return {?}
         */
            function (event) {
                event.preventDefault();
                if (!this.disabled) {
                    this.active = false;
                    var dataTransfer = event.dataTransfer;
                    if (dataTransfer.items) {
                        /** @type {?} */
                        var files = [];
                        for (var i = 0; i < dataTransfer.items.length; i++) {
                            // If dropped items aren't files, reject them
                            if (dataTransfer.items[i].kind === 'file') {
                                files.push(dataTransfer.items[i].getAsFile());
                            }
                        }
                        dataTransfer.items.clear();
                        this.fileDrop.emit(files);
                    }
                    else {
                        /** @type {?} */
                        var files = dataTransfer.files;
                        dataTransfer.clearData();
                        this.fileDrop.emit(Array.from(files));
                    }
                }
            };
        /**
         * @param {?} event
         * @return {?}
         */
        DropzoneDirective.prototype.onDragOver = /**
         * @param {?} event
         * @return {?}
         */
            function (event) {
                event.stopPropagation();
                event.preventDefault();
                if (!this.disabled) {
                    this.active = true;
                }
            };
        /**
         * @param {?} event
         * @return {?}
         */
        DropzoneDirective.prototype.onDragLeave = /**
         * @param {?} event
         * @return {?}
         */
            function (event) {
                if (!this.disabled) {
                    this.active = false;
                }
            };
        /**
         * @param {?} event
         * @return {?}
         */
        DropzoneDirective.prototype.onBodyDragOver = /**
         * @param {?} event
         * @return {?}
         */
            function (event) {
                if (this.preventBodyDrop) {
                    event.preventDefault();
                    event.stopPropagation();
                }
            };
        /**
         * @param {?} event
         * @return {?}
         */
        DropzoneDirective.prototype.onBodyDrop = /**
         * @param {?} event
         * @return {?}
         */
            function (event) {
                if (this.preventBodyDrop) {
                    event.preventDefault();
                }
            };
        DropzoneDirective.decorators = [
            { type: i0.Directive, args: [{
                        selector: '[dropzone]'
                    },] }
        ];
        DropzoneDirective.propDecorators = {
            preventBodyDrop: [{ type: i0.Input }],
            disabled: [{ type: i0.Input }],
            fileDrop: [{ type: i0.Output }],
            active: [{ type: i0.HostBinding, args: ['class.dropzone-active',] }],
            onDrop: [{ type: i0.HostListener, args: ['drop', ['$event'],] }],
            onDragOver: [{ type: i0.HostListener, args: ['dragover', ['$event'],] }],
            onDragLeave: [{ type: i0.HostListener, args: ['dragleave', ['$event'],] }],
            onBodyDragOver: [{ type: i0.HostListener, args: ['body:dragover', ['$event'],] }],
            onBodyDrop: [{ type: i0.HostListener, args: ['body:drop', ['$event'],] }]
        };
        return DropzoneDirective;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    var UploaderModule = /** @class */ (function () {
        function UploaderModule() {
        }
        UploaderModule.decorators = [
            { type: i0.NgModule, args: [{
                        declarations: [DropzoneDirective],
                        exports: [DropzoneDirective]
                    },] }
        ];
        return UploaderModule;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */

    exports.UploadItem = UploadItem;
    exports.Uploader = Uploader;
    exports.UploaderService = UploaderService;
    exports.DropzoneDirective = DropzoneDirective;
    exports.UploaderModule = UploaderModule;

    Object.defineProperty(exports, '__esModule', { value: true });

})));

//# sourceMappingURL=trendster-io-ng-uploader.umd.js.map