ng2-file-upload 1.1.4-2 → 1.4.0

package/esm2015/file-upload/file-drop.directive.js

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Directive, EventEmitter, ElementRef, HostListener, Input, Output } from '@angular/core';
+import { FileUploader } from './file-uploader.class';
+export class FileDropDirective {
+    /**
+     * @param {?} element
+     */
+    constructor(element) {
+        this.fileOver = new EventEmitter();
+        this.onFileDrop = new EventEmitter();
+        this.element = element;
+    }
+    /**
+     * @return {?}
+     */
+    getOptions() {
+        return this.uploader.options;
+    }
+    /**
+     * @return {?}
+     */
+    getFilters() {
+        return {};
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onDrop(event) {
+        /** @type {?} */
+        let transfer = this._getTransfer(event);
+        if (!transfer) {
+            return;
+        }
+        /** @type {?} */
+        let options = this.getOptions();
+        /** @type {?} */
+        let filters = this.getFilters();
+        this._preventAndStop(event);
+        this.uploader.addToQueue(transfer.files, options, filters);
+        this.fileOver.emit(false);
+        this.onFileDrop.emit(transfer.files);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onDragOver(event) {
+        /** @type {?} */
+        let transfer = this._getTransfer(event);
+        if (!this._haveFiles(transfer.types)) {
+            return;
+        }
+        transfer.dropEffect = 'copy';
+        this._preventAndStop(event);
+        this.fileOver.emit(true);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onDragLeave(event) {
+        if (((/** @type {?} */ (this))).element) {
+            if (event.currentTarget === ((/** @type {?} */ (this))).element[0]) {
+                return;
+            }
+        }
+        this._preventAndStop(event);
+        this.fileOver.emit(false);
+    }
+    /**
+     * @protected
+     * @param {?} event
+     * @return {?}
+     */
+    _getTransfer(event) {
+        return event.dataTransfer ? event.dataTransfer : event.originalEvent.dataTransfer; // jQuery fix;
+    }
+    /**
+     * @protected
+     * @param {?} event
+     * @return {?}
+     */
+    _preventAndStop(event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    /**
+     * @protected
+     * @param {?} types
+     * @return {?}
+     */
+    _haveFiles(types) {
+        if (!types) {
+            return false;
+        }
+        if (types.indexOf) {
+            return types.indexOf('Files') !== -1;
+        }
+        else if (types.contains) {
+            return types.contains('Files');
+        }
+        else {
+            return false;
+        }
+    }
+}
+FileDropDirective.decorators = [
+    { type: Directive, args: [{ selector: '[ng2FileDrop]' },] }
+];
+/** @nocollapse */
+FileDropDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+FileDropDirective.propDecorators = {
+    uploader: [{ type: Input }],
+    fileOver: [{ type: Output }],
+    onFileDrop: [{ type: Output }],
+    onDrop: [{ type: HostListener, args: ['drop', ['$event'],] }],
+    onDragOver: [{ type: HostListener, args: ['dragover', ['$event'],] }],
+    onDragLeave: [{ type: HostListener, args: ['dragleave', ['$event'],] }]
+};
+if (false) {
+    /** @type {?} */
+    FileDropDirective.prototype.uploader;
+    /** @type {?} */
+    FileDropDirective.prototype.fileOver;
+    /** @type {?} */
+    FileDropDirective.prototype.onFileDrop;
+    /**
+     * @type {?}
+     * @protected
+     */
+    FileDropDirective.prototype.element;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1kcm9wLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25nMi1maWxlLXVwbG9hZC8iLCJzb3VyY2VzIjpbImZpbGUtdXBsb2FkL2ZpbGUtZHJvcC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVqRyxPQUFPLEVBQUUsWUFBWSxFQUF1QixNQUFNLHVCQUF1QixDQUFDO0FBRzFFLE1BQU0sT0FBTyxpQkFBaUI7Ozs7SUFPNUIsWUFBbUIsT0FBbUI7UUFMckIsYUFBUSxHQUFzQixJQUFJLFlBQVksRUFBRSxDQUFDO1FBQ2pELGVBQVUsR0FBeUIsSUFBSSxZQUFZLEVBQVUsQ0FBQztRQUs3RSxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztJQUN6QixDQUFDOzs7O0lBRU0sVUFBVTtRQUNmLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUM7SUFDL0IsQ0FBQzs7OztJQUVNLFVBQVU7UUFDZixPQUFPLEVBQUUsQ0FBQztJQUNaLENBQUM7Ozs7O0lBR00sTUFBTSxDQUFDLEtBQVU7O1lBQ2xCLFFBQVEsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQztRQUN2QyxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2IsT0FBTztTQUNSOztZQUVHLE9BQU8sR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFOztZQUMzQixPQUFPLEdBQUcsSUFBSSxDQUFDLFVBQVUsRUFBRTtRQUMvQixJQUFJLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzVCLElBQUksQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzNELElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQzFCLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN2QyxDQUFDOzs7OztJQUdNLFVBQVUsQ0FBQyxLQUFVOztZQUN0QixRQUFRLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUM7UUFDdkMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3BDLE9BQU87U0FDUjtRQUVELFFBQVEsQ0FBQyxVQUFVLEdBQUcsTUFBTSxDQUFDO1FBQzdCLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDNUIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDM0IsQ0FBQzs7Ozs7SUFHTSxXQUFXLENBQUMsS0FBVTtRQUMzQixJQUFJLENBQUMsbUJBQUEsSUFBSSxFQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUU7WUFDekIsSUFBSSxLQUFLLENBQUMsYUFBYSxLQUFLLENBQUMsbUJBQUEsSUFBSSxFQUFPLENBQUMsQ0FBQyxPQUFPLENBQUUsQ0FBQyxDQUFFLEVBQUU7Z0JBQ3RELE9BQU87YUFDUjtTQUNGO1FBRUQsSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM1QixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM1QixDQUFDOzs7Ozs7SUFFUyxZQUFZLENBQUMsS0FBVTtRQUMvQixPQUFPLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDLENBQUMsY0FBYztJQUNuRyxDQUFDOzs7Ozs7SUFFUyxlQUFlLENBQUMsS0FBVTtRQUNsQyxLQUFLLENBQUMsY0FBYyxFQUFFLENBQUM7UUFDdkIsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO0lBQzFCLENBQUM7Ozs7OztJQUVTLFVBQVUsQ0FBQyxLQUFVO1FBQzdCLElBQUksQ0FBQyxLQUFLLEVBQUU7WUFDVixPQUFPLEtBQUssQ0FBQztTQUNkO1FBRUQsSUFBSSxLQUFLLENBQUMsT0FBTyxFQUFFO1lBQ2pCLE9BQU8sS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztTQUN0QzthQUFNLElBQUksS0FBSyxDQUFDLFFBQVEsRUFBRTtZQUN6QixPQUFPLEtBQUssQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDaEM7YUFBTTtZQUNMLE9BQU8sS0FBSyxDQUFDO1NBQ2Q7SUFDSCxDQUFDOzs7WUFoRkYsU0FBUyxTQUFDLEVBQUUsUUFBUSxFQUFFLGVBQWUsRUFBRTs7OztZQUpOLFVBQVU7Ozt1QkFNekMsS0FBSzt1QkFDTCxNQUFNO3lCQUNOLE1BQU07cUJBZ0JOLFlBQVksU0FBQyxNQUFNLEVBQUUsQ0FBRSxRQUFRLENBQUU7eUJBZWpDLFlBQVksU0FBQyxVQUFVLEVBQUUsQ0FBRSxRQUFRLENBQUU7MEJBWXJDLFlBQVksU0FBQyxXQUFXLEVBQUUsQ0FBRSxRQUFRLENBQUU7Ozs7SUE3Q3ZDLHFDQUF1Qzs7SUFDdkMscUNBQWtFOztJQUNsRSx1Q0FBK0U7Ozs7O0lBRS9FLG9DQUE4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRXZlbnRFbWl0dGVyLCBFbGVtZW50UmVmLCBIb3N0TGlzdGVuZXIsIElucHV0LCBPdXRwdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgRmlsZVVwbG9hZGVyLCBGaWxlVXBsb2FkZXJPcHRpb25zIH0gZnJvbSAnLi9maWxlLXVwbG9hZGVyLmNsYXNzJztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnW25nMkZpbGVEcm9wXScgfSlcbmV4cG9ydCBjbGFzcyBGaWxlRHJvcERpcmVjdGl2ZSB7XG4gIEBJbnB1dCgpIHB1YmxpYyB1cGxvYWRlcjogRmlsZVVwbG9hZGVyO1xuICBAT3V0cHV0KCkgcHVibGljIGZpbGVPdmVyOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcbiAgQE91dHB1dCgpIHB1YmxpYyBvbkZpbGVEcm9wOiBFdmVudEVtaXR0ZXI8RmlsZVtdPiA9IG5ldyBFdmVudEVtaXR0ZXI8RmlsZVtdPigpO1xuXG4gIHByb3RlY3RlZCBlbGVtZW50OiBFbGVtZW50UmVmO1xuXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcihlbGVtZW50OiBFbGVtZW50UmVmKSB7XG4gICAgdGhpcy5lbGVtZW50ID0gZWxlbWVudDtcbiAgfVxuXG4gIHB1YmxpYyBnZXRPcHRpb25zKCk6IEZpbGVVcGxvYWRlck9wdGlvbnMge1xuICAgIHJldHVybiB0aGlzLnVwbG9hZGVyLm9wdGlvbnM7XG4gIH1cblxuICBwdWJsaWMgZ2V0RmlsdGVycygpOiBhbnkge1xuICAgIHJldHVybiB7fTtcbiAgfVxuXG4gIEBIb3N0TGlzdGVuZXIoJ2Ryb3AnLCBbICckZXZlbnQnIF0pXG4gIHB1YmxpYyBvbkRyb3AoZXZlbnQ6IGFueSk6IHZvaWQge1xuICAgIGxldCB0cmFuc2ZlciA9IHRoaXMuX2dldFRyYW5zZmVyKGV2ZW50KTtcbiAgICBpZiAoIXRyYW5zZmVyKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgbGV0IG9wdGlvbnMgPSB0aGlzLmdldE9wdGlvbnMoKTtcbiAgICBsZXQgZmlsdGVycyA9IHRoaXMuZ2V0RmlsdGVycygpO1xuICAgIHRoaXMuX3ByZXZlbnRBbmRTdG9wKGV2ZW50KTtcbiAgICB0aGlzLnVwbG9hZGVyLmFkZFRvUXVldWUodHJhbnNmZXIuZmlsZXMsIG9wdGlvbnMsIGZpbHRlcnMpO1xuICAgIHRoaXMuZmlsZU92ZXIuZW1pdChmYWxzZSk7XG4gICAgdGhpcy5vbkZpbGVEcm9wLmVtaXQodHJhbnNmZXIuZmlsZXMpO1xuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcignZHJhZ292ZXInLCBbICckZXZlbnQnIF0pXG4gIHB1YmxpYyBvbkRyYWdPdmVyKGV2ZW50OiBhbnkpOiB2b2lkIHtcbiAgICBsZXQgdHJhbnNmZXIgPSB0aGlzLl9nZXRUcmFuc2ZlcihldmVudCk7XG4gICAgaWYgKCF0aGlzLl9oYXZlRmlsZXModHJhbnNmZXIudHlwZXMpKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgdHJhbnNmZXIuZHJvcEVmZmVjdCA9ICdjb3B5JztcbiAgICB0aGlzLl9wcmV2ZW50QW5kU3RvcChldmVudCk7XG4gICAgdGhpcy5maWxlT3Zlci5lbWl0KHRydWUpO1xuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcignZHJhZ2xlYXZlJywgWyAnJGV2ZW50JyBdKVxuICBwdWJsaWMgb25EcmFnTGVhdmUoZXZlbnQ6IGFueSk6IGFueSB7XG4gICAgaWYgKCh0aGlzIGFzIGFueSkuZWxlbWVudCkge1xuICAgICAgaWYgKGV2ZW50LmN1cnJlbnRUYXJnZXQgPT09ICh0aGlzIGFzIGFueSkuZWxlbWVudFsgMCBdKSB7XG4gICAgICAgIHJldHVybjtcbiAgICAgIH1cbiAgICB9XG5cbiAgICB0aGlzLl9wcmV2ZW50QW5kU3RvcChldmVudCk7XG4gICAgdGhpcy5maWxlT3Zlci5lbWl0KGZhbHNlKTtcbiAgfVxuXG4gIHByb3RlY3RlZCBfZ2V0VHJhbnNmZXIoZXZlbnQ6IGFueSk6IGFueSB7XG4gICAgcmV0dXJuIGV2ZW50LmRhdGFUcmFuc2ZlciA/IGV2ZW50LmRhdGFUcmFuc2ZlciA6IGV2ZW50Lm9yaWdpbmFsRXZlbnQuZGF0YVRyYW5zZmVyOyAvLyBqUXVlcnkgZml4O1xuICB9XG5cbiAgcHJvdGVjdGVkIF9wcmV2ZW50QW5kU3RvcChldmVudDogYW55KTogYW55IHtcbiAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xuICAgIGV2ZW50LnN0b3BQcm9wYWdhdGlvbigpO1xuICB9XG5cbiAgcHJvdGVjdGVkIF9oYXZlRmlsZXModHlwZXM6IGFueSk6IGFueSB7XG4gICAgaWYgKCF0eXBlcykge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cblxuICAgIGlmICh0eXBlcy5pbmRleE9mKSB7XG4gICAgICByZXR1cm4gdHlwZXMuaW5kZXhPZignRmlsZXMnKSAhPT0gLTE7XG4gICAgfSBlbHNlIGlmICh0eXBlcy5jb250YWlucykge1xuICAgICAgcmV0dXJuIHR5cGVzLmNvbnRhaW5zKCdGaWxlcycpO1xuICAgIH0gZWxzZSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICB9XG59XG4iXX0=

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

@@ -0,0 +1,268 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { FileLikeObject } from './file-like-object.class';
+export class FileItem {
+    /**
+     * @param {?} uploader
+     * @param {?} some
+     * @param {?} options
+     */
+    constructor(uploader, some, options) {
+        this.url = '/';
+        this.headers = [];
+        this.withCredentials = true;
+        this.formData = [];
+        this.isReady = false;
+        this.isUploading = false;
+        this.isUploaded = false;
+        this.isSuccess = false;
+        this.isCancel = false;
+        this.isError = false;
+        this.progress = 0;
+        this.index = void 0;
+        this.uploader = uploader;
+        this.some = some;
+        this.options = options;
+        this.file = new FileLikeObject(some);
+        this._file = some;
+        if (uploader.options) {
+            this.method = uploader.options.method || 'POST';
+            this.alias = uploader.options.itemAlias || 'file';
+        }
+        this.url = uploader.options.url;
+    }
+    /**
+     * @return {?}
+     */
+    upload() {
+        try {
+            this.uploader.uploadItem(this);
+        }
+        catch (e) {
+            this.uploader._onCompleteItem(this, '', 0, {});
+            this.uploader._onErrorItem(this, '', 0, {});
+        }
+    }
+    /**
+     * @return {?}
+     */
+    cancel() {
+        this.uploader.cancelItem(this);
+    }
+    /**
+     * @return {?}
+     */
+    remove() {
+        this.uploader.removeFromQueue(this);
+    }
+    /**
+     * @return {?}
+     */
+    onBeforeUpload() {
+        return void 0;
+    }
+    /**
+     * @param {?} form
+     * @return {?}
+     */
+    onBuildForm(form) {
+        return { form };
+    }
+    /**
+     * @param {?} progress
+     * @return {?}
+     */
+    onProgress(progress) {
+        return { progress };
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onSuccess(response, status, headers) {
+        return { response, status, headers };
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onError(response, status, headers) {
+        return { response, status, headers };
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onCancel(response, status, headers) {
+        return { response, status, headers };
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    onComplete(response, status, headers) {
+        return { response, status, headers };
+    }
+    /**
+     * @return {?}
+     */
+    _onBeforeUpload() {
+        this.isReady = true;
+        this.isUploading = true;
+        this.isUploaded = false;
+        this.isSuccess = false;
+        this.isCancel = false;
+        this.isError = false;
+        this.progress = 0;
+        this.onBeforeUpload();
+    }
+    /**
+     * @param {?} form
+     * @return {?}
+     */
+    _onBuildForm(form) {
+        this.onBuildForm(form);
+    }
+    /**
+     * @param {?} progress
+     * @return {?}
+     */
+    _onProgress(progress) {
+        this.progress = progress;
+        this.onProgress(progress);
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    _onSuccess(response, status, headers) {
+        this.isReady = false;
+        this.isUploading = false;
+        this.isUploaded = true;
+        this.isSuccess = true;
+        this.isCancel = false;
+        this.isError = false;
+        this.progress = 100;
+        this.index = void 0;
+        this.onSuccess(response, status, headers);
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    _onError(response, status, headers) {
+        this.isReady = false;
+        this.isUploading = false;
+        this.isUploaded = true;
+        this.isSuccess = false;
+        this.isCancel = false;
+        this.isError = true;
+        this.progress = 0;
+        this.index = void 0;
+        this.onError(response, status, headers);
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    _onCancel(response, status, headers) {
+        this.isReady = false;
+        this.isUploading = false;
+        this.isUploaded = false;
+        this.isSuccess = false;
+        this.isCancel = true;
+        this.isError = false;
+        this.progress = 0;
+        this.index = void 0;
+        this.onCancel(response, status, headers);
+    }
+    /**
+     * @param {?} response
+     * @param {?} status
+     * @param {?} headers
+     * @return {?}
+     */
+    _onComplete(response, status, headers) {
+        this.onComplete(response, status, headers);
+        if (this.uploader.options.removeAfterUpload) {
+            this.remove();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    _prepareToUploading() {
+        this.index = this.index || ++this.uploader._nextIndex;
+        this.isReady = true;
+    }
+}
+if (false) {
+    /** @type {?} */
+    FileItem.prototype.file;
+    /** @type {?} */
+    FileItem.prototype._file;
+    /** @type {?} */
+    FileItem.prototype.alias;
+    /** @type {?} */
+    FileItem.prototype.url;
+    /** @type {?} */
+    FileItem.prototype.method;
+    /** @type {?} */
+    FileItem.prototype.headers;
+    /** @type {?} */
+    FileItem.prototype.withCredentials;
+    /** @type {?} */
+    FileItem.prototype.formData;
+    /** @type {?} */
+    FileItem.prototype.isReady;
+    /** @type {?} */
+    FileItem.prototype.isUploading;
+    /** @type {?} */
+    FileItem.prototype.isUploaded;
+    /** @type {?} */
+    FileItem.prototype.isSuccess;
+    /** @type {?} */
+    FileItem.prototype.isCancel;
+    /** @type {?} */
+    FileItem.prototype.isError;
+    /** @type {?} */
+    FileItem.prototype.progress;
+    /** @type {?} */
+    FileItem.prototype.index;
+    /** @type {?} */
+    FileItem.prototype._xhr;
+    /** @type {?} */
+    FileItem.prototype._form;
+    /**
+     * @type {?}
+     * @protected
+     */
+    FileItem.prototype.uploader;
+    /**
+     * @type {?}
+     * @protected
+     */
+    FileItem.prototype.some;
+    /**
+     * @type {?}
+     * @protected
+     */
+    FileItem.prototype.options;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-item.class.js","sourceRoot":"ng://ng2-file-upload/","sources":["file-upload/file-item.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { FileLikeObject } from './file-like-object.class';\nimport { FileUploader, ParsedResponseHeaders, FileUploaderOptions } from './file-uploader.class';\n\nexport class FileItem {\n  public file: FileLikeObject;\n  public _file: File;\n  public alias: string;\n  public url: string = '/';\n  public method: string;\n  public headers: any = [];\n  public withCredentials: boolean = true;\n  public formData: any = [];\n  public isReady: boolean = false;\n  public isUploading: boolean = false;\n  public isUploaded: boolean = false;\n  public isSuccess: boolean = false;\n  public isCancel: boolean = false;\n  public isError: boolean = false;\n  public progress: number = 0;\n  public index: number = void 0;\n  public _xhr: XMLHttpRequest;\n  public _form: any;\n\n  protected uploader: FileUploader;\n  protected some: File;\n  protected options: FileUploaderOptions;\n\n  public constructor(uploader: FileUploader, some: File, options: FileUploaderOptions) {\n    this.uploader = uploader;\n    this.some = some;\n    this.options = options;\n    this.file = new FileLikeObject(some);\n    this._file = some;\n    if (uploader.options) {\n      this.method = uploader.options.method || 'POST';\n      this.alias = uploader.options.itemAlias || 'file';\n    }\n    this.url = uploader.options.url;\n  }\n\n  public upload(): void {\n    try {\n      this.uploader.uploadItem(this);\n    } catch (e) {\n      this.uploader._onCompleteItem(this, '', 0, {});\n      this.uploader._onErrorItem(this, '', 0, {});\n    }\n  }\n\n  public cancel(): void {\n    this.uploader.cancelItem(this);\n  }\n\n  public remove(): void {\n    this.uploader.removeFromQueue(this);\n  }\n\n  public onBeforeUpload(): void {\n    return void 0;\n  }\n\n  public onBuildForm(form: any): any {\n    return { form };\n  }\n\n  public onProgress(progress: number): any {\n    return { progress };\n  }\n\n  public onSuccess(response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { response, status, headers };\n  }\n\n  public onError(response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { response, status, headers };\n  }\n\n  public onCancel(response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { response, status, headers };\n  }\n\n  public onComplete(response: string, status: number, headers: ParsedResponseHeaders): any {\n    return { response, status, headers };\n  }\n\n  public _onBeforeUpload(): void {\n    this.isReady = true;\n    this.isUploading = true;\n    this.isUploaded = false;\n    this.isSuccess = false;\n    this.isCancel = false;\n    this.isError = false;\n    this.progress = 0;\n    this.onBeforeUpload();\n  }\n\n  public _onBuildForm(form: any): void {\n    this.onBuildForm(form);\n  }\n\n  public _onProgress(progress: number): void {\n    this.progress = progress;\n    this.onProgress(progress);\n  }\n\n  public _onSuccess(response: string, status: number, headers: ParsedResponseHeaders): void {\n    this.isReady = false;\n    this.isUploading = false;\n    this.isUploaded = true;\n    this.isSuccess = true;\n    this.isCancel = false;\n    this.isError = false;\n    this.progress = 100;\n    this.index = void 0;\n    this.onSuccess(response, status, headers);\n  }\n\n  public _onError(response: string, status: number, headers: ParsedResponseHeaders): void {\n    this.isReady = false;\n    this.isUploading = false;\n    this.isUploaded = true;\n    this.isSuccess = false;\n    this.isCancel = false;\n    this.isError = true;\n    this.progress = 0;\n    this.index = void 0;\n    this.onError(response, status, headers);\n  }\n\n  public _onCancel(response: string, status: number, headers: ParsedResponseHeaders): void {\n    this.isReady = false;\n    this.isUploading = false;\n    this.isUploaded = false;\n    this.isSuccess = false;\n    this.isCancel = true;\n    this.isError = false;\n    this.progress = 0;\n    this.index = void 0;\n    this.onCancel(response, status, headers);\n  }\n\n  public _onComplete(response: string, status: number, headers: ParsedResponseHeaders): void {\n    this.onComplete(response, status, headers);\n\n    if (this.uploader.options.removeAfterUpload) {\n      this.remove();\n    }\n  }\n\n  public _prepareToUploading(): void {\n    this.index = this.index || ++this.uploader._nextIndex;\n    this.isReady = true;\n  }\n}\n"]}

package/esm2015/file-upload/file-like-object.class.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @param {?} node
+ * @return {?}
+ */
+function isElement(node) {
+    return !!(node && (node.nodeName || node.prop && node.attr && node.find));
+}
+export class FileLikeObject {
+    /**
+     * @param {?} fileOrInput
+     */
+    constructor(fileOrInput) {
+        this.rawFile = fileOrInput;
+        /** @type {?} */
+        let isInput = isElement(fileOrInput);
+        /** @type {?} */
+        let fakePathOrObject = isInput ? fileOrInput.value : fileOrInput;
+        /** @type {?} */
+        let postfix = typeof fakePathOrObject === 'string' ? 'FakePath' : 'Object';
+        /** @type {?} */
+        let method = '_createFrom' + postfix;
+        ((/** @type {?} */ (this)))[method](fakePathOrObject);
+    }
+    /**
+     * @param {?} path
+     * @return {?}
+     */
+    _createFromFakePath(path) {
+        this.lastModifiedDate = void 0;
+        this.size = void 0;
+        this.type = 'like/' + path.slice(path.lastIndexOf('.') + 1).toLowerCase();
+        this.name = path.slice(path.lastIndexOf('/') + path.lastIndexOf('\\') + 2);
+    }
+    /**
+     * @param {?} object
+     * @return {?}
+     */
+    _createFromObject(object) {
+        this.size = object.size;
+        this.type = object.type;
+        this.name = object.name;
+    }
+}
+if (false) {
+    /** @type {?} */
+    FileLikeObject.prototype.lastModifiedDate;
+    /** @type {?} */
+    FileLikeObject.prototype.size;
+    /** @type {?} */
+    FileLikeObject.prototype.type;
+    /** @type {?} */
+    FileLikeObject.prototype.name;
+    /** @type {?} */
+    FileLikeObject.prototype.rawFile;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/file-upload/file-select.directive.js

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Directive, EventEmitter, ElementRef, Input, HostListener, Output } from '@angular/core';
+import { FileUploader } from './file-uploader.class';
+export class FileSelectDirective {
+    /**
+     * @param {?} element
+     */
+    constructor(element) {
+        this.onFileSelected = new EventEmitter();
+        this.element = element;
+    }
+    /**
+     * @return {?}
+     */
+    getOptions() {
+        return this.uploader.options;
+    }
+    /**
+     * @return {?}
+     */
+    getFilters() {
+        return {};
+    }
+    /**
+     * @return {?}
+     */
+    isEmptyAfterSelection() {
+        return !!this.element.nativeElement.attributes.multiple;
+    }
+    /**
+     * @return {?}
+     */
+    onChange() {
+        /** @type {?} */
+        let files = this.element.nativeElement.files;
+        /** @type {?} */
+        let options = this.getOptions();
+        /** @type {?} */
+        let filters = this.getFilters();
+        this.uploader.addToQueue(files, options, filters);
+        this.onFileSelected.emit(files);
+        if (this.isEmptyAfterSelection()) {
+            this.element.nativeElement.value = '';
+        }
+    }
+}
+FileSelectDirective.decorators = [
+    { type: Directive, args: [{ selector: '[ng2FileSelect]' },] }
+];
+/** @nocollapse */
+FileSelectDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+FileSelectDirective.propDecorators = {
+    uploader: [{ type: Input }],
+    onFileSelected: [{ type: Output }],
+    onChange: [{ type: HostListener, args: ['change',] }]
+};
+if (false) {
+    /** @type {?} */
+    FileSelectDirective.prototype.uploader;
+    /** @type {?} */
+    FileSelectDirective.prototype.onFileSelected;
+    /**
+     * @type {?}
+     * @protected
+     */
+    FileSelectDirective.prototype.element;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1zZWxlY3QuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmcyLWZpbGUtdXBsb2FkLyIsInNvdXJjZXMiOlsiZmlsZS11cGxvYWQvZmlsZS1zZWxlY3QuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFakcsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBR3JELE1BQU0sT0FBTyxtQkFBbUI7Ozs7SUFNOUIsWUFBbUIsT0FBbUI7UUFKckIsbUJBQWMsR0FBeUIsSUFBSSxZQUFZLEVBQVUsQ0FBQztRQUtqRixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztJQUN6QixDQUFDOzs7O0lBRU0sVUFBVTtRQUNmLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUM7SUFDL0IsQ0FBQzs7OztJQUVNLFVBQVU7UUFDZixPQUFPLEVBQUUsQ0FBQztJQUNaLENBQUM7Ozs7SUFFTSxxQkFBcUI7UUFDMUIsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQztJQUMxRCxDQUFDOzs7O0lBR00sUUFBUTs7WUFDVCxLQUFLLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsS0FBSzs7WUFDeEMsT0FBTyxHQUFHLElBQUksQ0FBQyxVQUFVLEVBQUU7O1lBQzNCLE9BQU8sR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFO1FBRS9CLElBQUksQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDbEQsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFaEMsSUFBSSxJQUFJLENBQUMscUJBQXFCLEVBQUUsRUFBRTtZQUNoQyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxLQUFLLEdBQUcsRUFBRSxDQUFDO1NBQ3ZDO0lBQ0gsQ0FBQzs7O1lBbkNGLFNBQVMsU0FBQyxFQUFFLFFBQVEsRUFBRSxpQkFBaUIsRUFBRTs7OztZQUpSLFVBQVU7Ozt1QkFNekMsS0FBSzs2QkFDTCxNQUFNO3VCQW9CTixZQUFZLFNBQUMsUUFBUTs7OztJQXJCdEIsdUNBQXVDOztJQUN2Qyw2Q0FBbUY7Ozs7O0lBRW5GLHNDQUE4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRXZlbnRFbWl0dGVyLCBFbGVtZW50UmVmLCBJbnB1dCwgSG9zdExpc3RlbmVyLCBPdXRwdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgRmlsZVVwbG9hZGVyIH0gZnJvbSAnLi9maWxlLXVwbG9hZGVyLmNsYXNzJztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnW25nMkZpbGVTZWxlY3RdJyB9KVxuZXhwb3J0IGNsYXNzIEZpbGVTZWxlY3REaXJlY3RpdmUge1xuICBASW5wdXQoKSBwdWJsaWMgdXBsb2FkZXI6IEZpbGVVcGxvYWRlcjtcbiAgQE91dHB1dCgpIHB1YmxpYyBvbkZpbGVTZWxlY3RlZDogRXZlbnRFbWl0dGVyPEZpbGVbXT4gPSBuZXcgRXZlbnRFbWl0dGVyPEZpbGVbXT4oKTtcblxuICBwcm90ZWN0ZWQgZWxlbWVudDogRWxlbWVudFJlZjtcblxuICBwdWJsaWMgY29uc3RydWN0b3IoZWxlbWVudDogRWxlbWVudFJlZikge1xuICAgIHRoaXMuZWxlbWVudCA9IGVsZW1lbnQ7XG4gIH1cblxuICBwdWJsaWMgZ2V0T3B0aW9ucygpOiBhbnkge1xuICAgIHJldHVybiB0aGlzLnVwbG9hZGVyLm9wdGlvbnM7XG4gIH1cblxuICBwdWJsaWMgZ2V0RmlsdGVycygpOiBhbnkge1xuICAgIHJldHVybiB7fTtcbiAgfVxuXG4gIHB1YmxpYyBpc0VtcHR5QWZ0ZXJTZWxlY3Rpb24oKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuICEhdGhpcy5lbGVtZW50Lm5hdGl2ZUVsZW1lbnQuYXR0cmlidXRlcy5tdWx0aXBsZTtcbiAgfVxuXG4gIEBIb3N0TGlzdGVuZXIoJ2NoYW5nZScpXG4gIHB1YmxpYyBvbkNoYW5nZSgpOiBhbnkge1xuICAgIGxldCBmaWxlcyA9IHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LmZpbGVzO1xuICAgIGxldCBvcHRpb25zID0gdGhpcy5nZXRPcHRpb25zKCk7XG4gICAgbGV0IGZpbHRlcnMgPSB0aGlzLmdldEZpbHRlcnMoKTtcblxuICAgIHRoaXMudXBsb2FkZXIuYWRkVG9RdWV1ZShmaWxlcywgb3B0aW9ucywgZmlsdGVycyk7XG4gICAgdGhpcy5vbkZpbGVTZWxlY3RlZC5lbWl0KGZpbGVzKTtcblxuICAgIGlmICh0aGlzLmlzRW1wdHlBZnRlclNlbGVjdGlvbigpKSB7XG4gICAgICB0aGlzLmVsZW1lbnQubmF0aXZlRWxlbWVudC52YWx1ZSA9ICcnO1xuICAgIH1cbiAgfVxufVxuIl19