ngx-uploader-directive
Version:
Angular File Uploader Directive which provides two directives, which are select and file drag and drop to upload files on server.
198 lines • 20.1 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: lib/directives/ngx-uploader-drop.directive.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* The MIT License (MIT)
* Copyright (c) 2015-2018 Jan Kuri jan@bleenco.com
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
// tslint:disable: max-line-length
// tslint:disable: no-console
import { Directive, Input, EventEmitter, Output, ElementRef, HostListener } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { NgxUploaderDirectiveService } from '../services/ngx-uploader-directive.service';
import { environment } from '../configs/config';
export class NgxUploaderDropDirective {
/**
* @param {?} elementRef
* @param {?} httpClient
*/
constructor(elementRef, httpClient) {
this.elementRef = elementRef;
this.httpClient = httpClient;
this.devEnv = !environment.production;
this.stopEvent = (/**
* @param {?} event
* @return {?}
*/
(event) => {
event.stopPropagation();
event.preventDefault();
});
this.uploadOutput = new EventEmitter();
}
// tslint:disable-next-line: use-life-cycle-interface
/**
* @return {?}
*/
ngOnInit() {
this.subscriptions = new Array();
/** @type {?} */
const concurrency = this.options.requestConcurrency;
/** @type {?} */
const allowedFileTypes = this.options.allowedFileTypes;
/** @type {?} */
const maxFileUploads = this.options.maxFileUploads;
/** @type {?} */
const maxFileSize = this.options.maxFileSize;
this.uploadService = new NgxUploaderDirectiveService(concurrency, this.options.maxFilesToAddInSingleRequest, allowedFileTypes, maxFileUploads, maxFileSize, this.httpClient, this.options.logs);
// file upload element
this.element = this.elementRef.nativeElement;
this.element.addEventListener('drop', this.stopEvent, false);
this.element.addEventListener('dragenter', this.stopEvent, false);
this.element.addEventListener('dragover', this.stopEvent, false);
// Adding events to subscriptions
this.subscriptions.push(this.uploadService.fileServiceEvents.subscribe((/**
* @param {?} event
* @return {?}
*/
(event) => {
if (event.fileSelectedEventType === 'DROP' || event.fileSelectedEventType === 'ALL') {
if (this.options.logs && this.devEnv) {
console.info('Output drop event', event);
}
if (event.type === 'error' || event.type === 'removedAll') {
this.element.files = null;
this.element.value = '';
}
else if (event.type === 'removed' || event.type === 'rejected') {
if (this.uploadService.queue.length === 0) {
this.element.files = null;
this.element.value = '';
}
}
this.uploadOutput.emit(event);
}
})));
if (this.uploadInput instanceof EventEmitter) {
if (this.options.logs && this.devEnv) {
console.info('Input drop Init');
}
this.subscriptions.push(this.uploadService.handleInputEvents(this.uploadInput));
}
}
// tslint:disable-next-line: use-life-cycle-interface
/**
* @return {?}
*/
ngOnDestroy() {
this.subscriptions.forEach((/**
* @param {?} sub
* @return {?}
*/
sub => sub.unsubscribe()));
}
/**
* @param {?} event
* @return {?}
*/
onDrop(event) {
event.stopPropagation();
event.preventDefault();
/** @type {?} */
const outputEvent = { type: 'drop', fileSelectedEventType: 'DROP' };
this.uploadOutput.emit(outputEvent);
this.uploadService.handleSelectedFiles(event.dataTransfer.files, 'DROP');
}
/**
* @param {?} event
* @return {?}
*/
onDragOver(event) {
if (!event) {
return;
}
/** @type {?} */
const outputEvent = { type: 'dragOver', fileSelectedEventType: 'DROP' };
this.uploadOutput.emit(outputEvent);
}
/**
* @param {?} event
* @return {?}
*/
onDragLeave(event) {
if (!event) {
return;
}
/** @type {?} */
const outputEvent = { type: 'dragOut', fileSelectedEventType: 'DROP' };
this.uploadOutput.emit(outputEvent);
}
}
NgxUploaderDropDirective.decorators = [
{ type: Directive, args: [{
// tslint:disable-next-line: directive-selector
selector: '[ngxFileDrop]'
},] }
];
/** @nocollapse */
NgxUploaderDropDirective.ctorParameters = () => [
{ type: ElementRef },
{ type: HttpClient }
];
NgxUploaderDropDirective.propDecorators = {
options: [{ type: Input }],
uploadInput: [{ type: Input }],
uploadOutput: [{ type: Output }],
onDrop: [{ type: HostListener, args: ['drop', ['$event'],] }],
onDragOver: [{ type: HostListener, args: ['dragover', ['$event'],] }],
onDragLeave: [{ type: HostListener, args: ['dragleave', ['$event'],] }]
};
if (false) {
/**
* @type {?}
* @private
*/
NgxUploaderDropDirective.prototype.devEnv;
/** @type {?} */
NgxUploaderDropDirective.prototype.options;
/** @type {?} */
NgxUploaderDropDirective.prototype.uploadInput;
/** @type {?} */
NgxUploaderDropDirective.prototype.uploadOutput;
/** @type {?} */
NgxUploaderDropDirective.prototype.uploadService;
/** @type {?} */
NgxUploaderDropDirective.prototype.element;
/** @type {?} */
NgxUploaderDropDirective.prototype.subscriptions;
/** @type {?} */
NgxUploaderDropDirective.prototype.stopEvent;
/** @type {?} */
NgxUploaderDropDirective.prototype.elementRef;
/**
* @type {?}
* @private
*/
NgxUploaderDropDirective.prototype.httpClient;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-uploader-drop.directive.js","sourceRoot":"../../../projects/ngx-uploader-directive/src/","sources":["lib/directives/ngx-uploader-drop.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * The MIT License (MIT)\r\n * Copyright (c) 2015-2018 Jan Kuri jan@bleenco.com\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n\r\n// tslint:disable: max-line-length\r\n// tslint:disable: no-console\r\nimport { Directive, Input, EventEmitter, Output, ElementRef, HostListener } from '@angular/core';\r\nimport { IUploadOptions, IUploadInput, IUploadOutput } from '../models/ngx-uploader-directive-models';\r\nimport { Subscription } from 'rxjs';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { NgxUploaderDirectiveService } from '../services/ngx-uploader-directive.service';\r\nimport { environment } from '../configs/config';\r\n\r\n@Directive({\r\n  // tslint:disable-next-line: directive-selector\r\n  selector: '[ngxFileDrop]'\r\n})\r\n\r\nexport class NgxUploaderDropDirective {\r\n\r\n  private devEnv = !environment.production;\r\n\r\n  @Input() options: IUploadOptions;\r\n  @Input() uploadInput: EventEmitter<IUploadInput>;\r\n  @Output() uploadOutput: EventEmitter<IUploadOutput>;\r\n\r\n  uploadService: NgxUploaderDirectiveService;\r\n  element: HTMLInputElement;\r\n\r\n  subscriptions: Array<Subscription>;\r\n\r\n  constructor(\r\n    public elementRef: ElementRef,\r\n    private httpClient: HttpClient,\r\n  ) {\r\n    this.uploadOutput = new EventEmitter<IUploadOutput>();\r\n  }\r\n\r\n  // tslint:disable-next-line: use-life-cycle-interface\r\n  ngOnInit() {\r\n    this.subscriptions = new Array<Subscription>();\r\n    const concurrency = this.options.requestConcurrency;\r\n    const allowedFileTypes = this.options.allowedFileTypes;\r\n    const maxFileUploads = this.options.maxFileUploads;\r\n    const maxFileSize = this.options.maxFileSize;\r\n    this.uploadService = new NgxUploaderDirectiveService(concurrency, this.options.maxFilesToAddInSingleRequest, allowedFileTypes, maxFileUploads, maxFileSize, this.httpClient, this.options.logs);\r\n\r\n    // file upload element\r\n    this.element = this.elementRef.nativeElement;\r\n\r\n    this.element.addEventListener('drop', this.stopEvent, false);\r\n    this.element.addEventListener('dragenter', this.stopEvent, false);\r\n    this.element.addEventListener('dragover', this.stopEvent, false);\r\n\r\n    // Adding events to subscriptions\r\n    this.subscriptions.push(\r\n      this.uploadService.fileServiceEvents.subscribe((event: IUploadOutput) => {\r\n        if (event.fileSelectedEventType === 'DROP' || event.fileSelectedEventType === 'ALL') {\r\n          if (this.options.logs && this.devEnv) {\r\n            console.info('Output drop event', event);\r\n          }\r\n          if (event.type === 'error' || event.type === 'removedAll') {\r\n            this.element.files = null;\r\n            this.element.value = '';\r\n          } else if (event.type === 'removed' || event.type === 'rejected') {\r\n            if (this.uploadService.queue.length === 0) {\r\n              this.element.files = null;\r\n              this.element.value = '';\r\n            }\r\n          }\r\n          this.uploadOutput.emit(event);\r\n        }\r\n      })\r\n    );\r\n\r\n    if (this.uploadInput instanceof EventEmitter) {\r\n      if (this.options.logs && this.devEnv) {\r\n        console.info('Input drop Init');\r\n      }\r\n      this.subscriptions.push(this.uploadService.handleInputEvents(this.uploadInput));\r\n    }\r\n  }\r\n\r\n  // tslint:disable-next-line: use-life-cycle-interface\r\n  ngOnDestroy() {\r\n    this.subscriptions.forEach(sub => sub.unsubscribe());\r\n  }\r\n\r\n  stopEvent = (event: Event) => {\r\n    event.stopPropagation();\r\n    event.preventDefault();\r\n  }\r\n\r\n  @HostListener('drop', ['$event'])\r\n  public onDrop(event: any) {\r\n    event.stopPropagation();\r\n    event.preventDefault();\r\n\r\n    const outputEvent: IUploadOutput = { type: 'drop', fileSelectedEventType: 'DROP' };\r\n    this.uploadOutput.emit(outputEvent);\r\n    this.uploadService.handleSelectedFiles(event.dataTransfer.files, 'DROP');\r\n  }\r\n\r\n  @HostListener('dragover', ['$event'])\r\n  public onDragOver(event: Event) {\r\n    if (!event) {\r\n      return;\r\n    }\r\n\r\n    const outputEvent: IUploadOutput = { type: 'dragOver', fileSelectedEventType: 'DROP' };\r\n    this.uploadOutput.emit(outputEvent);\r\n  }\r\n\r\n  @HostListener('dragleave', ['$event'])\r\n  public onDragLeave(event: Event) {\r\n    if (!event) {\r\n      return;\r\n    }\r\n\r\n    const outputEvent: IUploadOutput = { type: 'dragOut', fileSelectedEventType: 'DROP' };\r\n    this.uploadOutput.emit(outputEvent);\r\n  }\r\n\r\n}\r\n"]}