@trendster-io/ng-uploader
Version:
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
1,305 lines (1,290 loc) • 37 kB
JavaScript
import { __read } from 'tslib';
import { Observable, Subject, of } from 'rxjs';
import { mergeMap, tap, filter, map, catchError, finalize } from 'rxjs/operators';
import { HttpRequest, HttpEventType, HttpClient } from '@angular/common/http';
import { Injectable, NgModule, Directive, EventEmitter, HostBinding, HostListener, Input, Output, defineInjectable, inject } from '@angular/core';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @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 Subject();
this.onProgressSubject = new Subject();
this.onErrorSubject = new 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 HttpRequest(this.method, this.url, body, {
reportProgress: true
});
};
/**
* @private
* @return {?}
*/
UploadItem.prototype.readMediaFile = /**
* @private
* @return {?}
*/
function () {
var _this = this;
return new 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 Subject();
this.onItemProgressSubject = new Subject();
this.onItemErrorSubject = new 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(filter((/**
* @param {?} event
* @return {?}
*/
function (event) {
return event.type === HttpEventType.Sent ||
event.type === HttpEventType.UploadProgress ||
event.type === HttpEventType.Response;
})), map((/**
* @param {?} event
* @return {?}
*/
function (event) {
switch (event.type) {
case HttpEventType.Sent:
return { type: 'start', value: null };
case HttpEventType.UploadProgress:
/** @type {?} */
var progress = Math.round((100 * event.loaded) / event.total);
return { type: 'progress', value: progress };
case 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 Observable((/**
* @param {?} observer
* @return {?}
*/
function (observer) {
queueItem.subscription = _this.request(queueItem.item.req)
.pipe(finalize((/**
* @return {?}
*/
function () {
if (!observer.closed) {
observer.complete();
}
})), 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;
}
})), filter((/**
* @param {?} event
* @return {?}
*/
function (event) { return event.type === 'response'; })), 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 Subject();
this.scheduler
.pipe(mergeMap((/**
* @param {?} queueItem
* @return {?}
*/
function (queueItem) {
return _this.prepareQueueItem(queueItem).pipe(catchError((/**
* @param {?} uploadEvent
* @return {?}
*/
function (uploadEvent) {
_this.onQueueItemError(uploadEvent);
return of(null);
})));
}), this.concurrency), 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: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
UploaderService.ctorParameters = function () { return [
{ type: HttpClient }
]; };
/** @nocollapse */ UploaderService.ngInjectableDef = defineInjectable({ factory: function UploaderService_Factory() { return new UploaderService(inject(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 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: Directive, args: [{
selector: '[dropzone]'
},] }
];
DropzoneDirective.propDecorators = {
preventBodyDrop: [{ type: Input }],
disabled: [{ type: Input }],
fileDrop: [{ type: Output }],
active: [{ type: HostBinding, args: ['class.dropzone-active',] }],
onDrop: [{ type: HostListener, args: ['drop', ['$event'],] }],
onDragOver: [{ type: HostListener, args: ['dragover', ['$event'],] }],
onDragLeave: [{ type: HostListener, args: ['dragleave', ['$event'],] }],
onBodyDragOver: [{ type: HostListener, args: ['body:dragover', ['$event'],] }],
onBodyDrop: [{ type: 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: NgModule, args: [{
declarations: [DropzoneDirective],
exports: [DropzoneDirective]
},] }
];
return UploaderModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
export { UploadItem, Uploader, UploaderService, DropzoneDirective, UploaderModule };
//# sourceMappingURL=trendster-io-ng-uploader.js.map