@po-ui/ng-components 5.22.3 → 6.2.0

package/esm2020/lib/components/po-field/po-upload/po-upload-base.component.mjs

@@ -0,0 +1,634 @@
+import { __decorate } from "tslib";
+import { EventEmitter, Input, Output, Directive } from '@angular/core';
+import { convertToBoolean, isEquals, isIE, isMobile } from '../../../utils/util';
+import { requiredFailed } from '../validators';
+import { PoUploadFile } from './po-upload-file';
+import { PoUploadStatus } from './po-upload-status.enum';
+import { InputBoolean } from '../../../decorators';
+import { poLocaleDefault } from '../../../services/po-language/po-language.constant';
+import * as i0 from "@angular/core";
+import * as i1 from "./po-upload.service";
+import * as i2 from "../../../services/po-language/po-language.service";
+export const poUploadLiteralsDefault = {
+    en: {
+        files: 'files',
+        folders: 'folders',
+        selectFile: 'Select file',
+        selectFiles: 'Select files',
+        selectFolder: 'Select folder',
+        startSending: 'Start sending',
+        dragFilesHere: 'Drag files here',
+        dragFoldersHere: 'Drag folders here',
+        selectFilesOnComputer: 'or select files on your computer',
+        selectFolderOnComputer: 'or select folder on your computer',
+        dropFilesHere: 'Drop files here',
+        dropFoldersHere: 'Drop folders here',
+        invalidDropArea: '{0} were not dropped in the correct area',
+        invalidFileType: 'Failed to load {0} file(s) as it is not the allowed file type.',
+        invalidAmount: 'Failed to load {0} file(s), as it exceeds the limit amount of files.',
+        invalidFormat: 'Failed to load {0} file(s), as it does not match the format(s): {1}.',
+        invalidSize: 'Failed to load {0} files(s), as it is not the allowed size: from {1} to {2}.',
+        numberOfFilesAllowed: '{0} file(s) allowed',
+        allowedFormats: 'Accepted file formats: {0}.',
+        allowedFileSizeRange: 'Size limit per file: from {0} to {1}',
+        maxFileSizeAllowed: 'Size limit per file: {0} maximum',
+        minFileSizeAllowed: 'Size limit per file: {0} minimum',
+        errorOccurred: 'An error has occurred',
+        sentWithSuccess: 'Sent with success'
+    },
+    es: {
+        files: 'archivos',
+        folders: 'carpetas',
+        selectFile: 'Seleccionar archivo',
+        selectFiles: 'Seleccionar archivos',
+        selectFolder: 'Seleccionar carpeta',
+        startSending: 'Iniciar carga',
+        dragFilesHere: 'Arrastra los archivos aquí',
+        dragFoldersHere: 'Arrastra las carpetas aquí',
+        selectFilesOnComputer: 'o selecciona los archivos en tu computadora',
+        selectFolderOnComputer: 'o selecciona la carpeta en tu computadora',
+        dropFilesHere: 'Deja los archivos aquí',
+        dropFoldersHere: 'Deja las carpetas aquí',
+        invalidDropArea: 'Los {0} no se insertaron en la ubicación correcta',
+        invalidFileType: 'Error al cargar {0} archivo (s) ya que no es el tipo de archivo permitido',
+        invalidAmount: 'Error al cargar {0} archivo (s) ya que excede la cantidad limite de archivos.',
+        invalidFormat: 'Error al cargar {0} archivo (s) ya que no coincide con el formato (s): {1}.',
+        invalidSize: 'Error al cargar {0} archivo (s) ya que no cumple con el tamaño permitido: desde {1} hasta {2}.',
+        numberOfFilesAllowed: '{0} archivo(s) permitido(s)',
+        allowedFormats: 'Formatos aceptados: {0}.',
+        allowedFileSizeRange: 'Limite de tamaño de archivo: desde {0} hasta {1}',
+        maxFileSizeAllowed: 'Limite de tamaño de archivo: hasta {0}',
+        minFileSizeAllowed: 'Limite de tamaño de archivo: minimo {0}',
+        errorOccurred: 'Ocurrio un error',
+        sentWithSuccess: 'Enviado con éxito'
+    },
+    pt: {
+        files: 'arquivos',
+        folders: 'diretórios',
+        selectFile: 'Selecionar arquivo',
+        selectFiles: 'Selecionar arquivos',
+        selectFolder: 'Selecionar pasta',
+        startSending: 'Iniciar envio',
+        dragFilesHere: 'Arraste os arquivos aqui',
+        dragFoldersHere: 'Arraste as pastas aqui',
+        selectFilesOnComputer: 'ou selecione os arquivos no computador',
+        selectFolderOnComputer: 'ou selecione a pasta no computador',
+        dropFilesHere: 'Solte os arquivos aqui',
+        dropFoldersHere: 'Solte as pastas aqui',
+        invalidDropArea: 'Os {0} não foram inseridos no local correto',
+        invalidFileType: 'Falha ao carregar {0} arquivo (s), pois não é o tipo de arquivo permitido',
+        invalidAmount: 'Falha ao carregar {0} arquivo(s), pois excede(m) a quantidade limite de arquivos.',
+        invalidFormat: 'Falha ao carregar {0} arquivo(s), pois não corresponde(m) ao(s) formato(s): {1}.',
+        invalidSize: 'Falha ao carregar {0} arquivo(s), pois não atende ao tamanho permitido: {1} até {2}.',
+        numberOfFilesAllowed: 'Quantidade máxima: {0} arquivo(s)',
+        allowedFormats: 'Formatos adotados: {0}.',
+        allowedFileSizeRange: 'Limite de tamanho por arquivo: de {0} até {1}',
+        maxFileSizeAllowed: 'Limite de tamanho por arquivo: até {0}',
+        minFileSizeAllowed: 'Limite de tamanho por arquivo: no mínimo {0}',
+        errorOccurred: 'Ocorreu um erro',
+        sentWithSuccess: 'Enviado com sucesso'
+    },
+    ru: {
+        files: 'файлы',
+        folders: 'папки с файлами',
+        selectFile: 'Выберите файл',
+        selectFiles: 'Выберите файлы',
+        selectFolder: 'Выберите папку с файлами',
+        startSending: 'Начать загрузку',
+        dragFilesHere: 'Перетащите файлы сюда',
+        dragFoldersHere: 'Перетащите сюда папки',
+        selectFilesOnComputer: 'или выберите файлы на компьютере',
+        selectFolderOnComputer: 'или выберите папку на вашем компьютере',
+        dropFilesHere: 'Оставьте файлы здесь',
+        dropFoldersHere: 'Перетащите сюда папки',
+        invalidDropArea: '{0} не были вставлены в правильном месте.',
+        invalidFileType: 'Не удалось загрузить файлы {0}, так как это неверный тип файла',
+        invalidAmount: 'Não foi possível carregar os arquivos {0} porque eles excederam o limite de arquivos.',
+        invalidFormat: 'Не удалось загрузить файлы {0}, так как они не соответствуют формату (ам): {1}.',
+        invalidSize: 'Не удалось загрузить файлы {0}, поскольку они не соответствуют разрешенному размеру: от {1} до {2}.',
+        numberOfFilesAllowed: 'Максимальное количество: {0} файлов',
+        allowedFormats: 'Форматы приняты: {0}.',
+        allowedFileSizeRange: 'Ограничение размера файла: от {0} до {1}',
+        maxFileSizeAllowed: 'Ограничение размера файла: до {0}',
+        minFileSizeAllowed: 'Ограничение размера файла: не менее {0}',
+        errorOccurred: 'Произошла ошибка.',
+        sentWithSuccess: 'Успешно отправлено'
+    }
+};
+const poUploadFormFieldDefault = 'files';
+const poUploadMaxFileSize = 31457280; // 30MB
+const poUploadMinFileSize = 0;
+/**
+ * @description
+ *
+ * O componente `po-upload` permite que o usuário envie arquivo(s) ao servidor e acompanhe o progresso.
+ * Este componente também possibilita algumas configurações como:
+ *  – Envio de diretórios, onde ele acessa o diretório selecionado assim como seus sub-diretórios;
+ *  - Múltipla seleção, onde o usuário pode enviar mais de um arquivo ao servidor.
+ *  - Auto envio, onde o arquivo é enviado imediatamente após a seleção do usuário, não necessitando que o usuário
+ * clique em enviar.
+ *  - Restrições de formatos de arquivo e tamanho.
+ *  - Função de sucesso que será disparada quando os arquivos forem enviados com sucesso.
+ *  - Função de erro que será disparada quando houver erro no envio dos arquivos.
+ *  - Permite habilitar uma área onde os arquivos podem ser arrastados.
+ */
+export class PoUploadBaseComponent {
+    constructor(uploadService, languageService) {
+        this.uploadService = uploadService;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Aplica foco no elemento ao ser iniciado.
+         *
+         * > Caso mais de um elemento seja configurado com essa propriedade, apenas o último elemento declarado com ela terá o foco.
+         *
+         * @default `false`
+         */
+        this.autoFocus = false;
+        /** Define o valor do atributo `name` do componente. */
+        this.name = 'file';
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Define se o envio do arquivo será automático ao selecionar o mesmo.
+         *
+         * @default `false`
+         */
+        this.autoUpload = false;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Função que será executada no momento de realizar o envio do arquivo,
+         * onde será possível adicionar informações ao parâmetro que será enviado na requisição.
+         * É passado por parâmetro um objeto com o arquivo e a propiedade data nesta propriedade pode ser informado algum dado,
+         * que será enviado em conjunto com o arquivo na requisição, por exemplo:
+         *
+         * ```
+         *   event.data = {id: 'id do usuario'};
+         * ```
+         */
+        this.onUpload = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento será disparado quando ocorrer algum erro no envio do arquivo.
+         * > Por parâmetro será passado o objeto do retorno que é do tipo `HttpErrorResponse`.
+         */
+        this.onError = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento será disparado quando o envio do arquivo for realizado com sucesso.
+         * > Por parâmetro será passado o objeto do retorno que é do tipo `HttpResponse`.
+         */
+        this.onSuccess = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Função para atualizar o ngModel do componente, necessário quando não for utilizado dentro da *tag* `form`.
+         *
+         * Na versão 12.2.0 do Angular a verificação `strictTemplates` vem true como default. Portanto, para utilizar
+         * two-way binding no componente deve se utilizar da seguinte forma:
+         *
+         * ```
+         * <po-upload ... [ngModel]="UploadModel" (ngModelChange)="uploadModel = $event"> </po-upload>
+         * ```
+         *
+         */
+        this.ngModelChange = new EventEmitter();
+        this.extensionNotAllowed = 0;
+        this.quantityNotAllowed = 0;
+        this.sizeNotAllowed = 0;
+        this.onModelTouched = null;
+        this._dragDrop = false;
+        this.language = languageService.getShortLanguage();
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Permite a seleção de diretórios contendo um ou mais arquivos para envio.
+     *
+     * > A habilitação desta propriedade se restringe apenas à seleção de diretórios.
+     *
+     * > Definição não suportada pelo browser **Internet Explorer**, todavia será possível a seleção de arquivos padrão.
+     *
+     * @default `false`
+     */
+    set directory(value) {
+        this._directory = convertToBoolean(value);
+        this.canHandleDirectory = this._directory && !isIE() && !isMobile();
+        this.setDirectoryAttribute(this.canHandleDirectory);
+    }
+    get directory() {
+        return this._directory;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Exibe a área onde é possível arrastar e selecionar os arquivos. Quando estiver definida, omite o botão para seleção de arquivos
+     * automaticamente.
+     *
+     * > Recomendamos utilizar apenas um `po-upload` com esta funcionalidade por tela.
+     *
+     * @default `false`
+     */
+    set dragDrop(value) {
+        this._dragDrop = convertToBoolean(value);
+    }
+    get dragDrop() {
+        return this._dragDrop;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Oculta visualmente as informações de restrições para o upload.
+     *
+     * @default `false`
+     */
+    set hideRestrictionsInfo(value) {
+        this._hideRestrictionsInfo = convertToBoolean(value);
+    }
+    get hideRestrictionsInfo() {
+        return this._hideRestrictionsInfo;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Omite o botão de seleção de arquivos.
+     *
+     * > Caso o valor definido seja `true`, caberá ao desenvolvedor a responsabilidade
+     * pela chamada do método `selectFiles()` para seleção de arquivos.
+     *
+     * @default `false`
+     */
+    set hideSelectButton(value) {
+        this._hideSelectButton = convertToBoolean(value);
+    }
+    get hideSelectButton() {
+        return this._hideSelectButton;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Omite o botão de envio de arquivos.
+     *
+     * > Caso o valor definido seja `true`, caberá ao desenvolvedor a responsabilidade
+     * pela chamada do método `sendFiles()` para envio do(s) arquivo(s) selecionado(s).
+     *
+     * @default `false`
+     */
+    set hideSendButton(value) {
+        this._hideSendButton = convertToBoolean(value);
+    }
+    get hideSendButton() {
+        return this._hideSendButton;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Objeto com as literais usadas no `po-upload`.
+     *
+     * Existem duas maneiras de customizar o componente:
+     *
+     * - passando um objeto implementando a interface `PoUploadLiterals` com todas as literais disponíveis;
+     * - passando apenas as literais que deseja customizar:
+     * ```
+     *  const customLiterals: PoUploadLiterals = {
+     *    folders: 'Pastas',
+     *    selectFile: 'Buscar arquivo',
+     *    startSending: 'Enviar'
+     *  };
+     * ```
+     *
+     * E para carregar as literais customizadas, basta apenas passar o objeto para o componente:
+     *
+     * ```
+     * <po-upload
+     *   [p-literals]="customLiterals">
+     * </po-upload>
+     * ```
+     *
+     * > O objeto padrão de literais será traduzido de acordo com o idioma do *browser* (pt, en, es, ru).
+     */
+    set literals(value) {
+        if (value instanceof Object && !(value instanceof Array)) {
+            this._literals = {
+                ...poUploadLiteralsDefault[poLocaleDefault],
+                ...poUploadLiteralsDefault[this.language],
+                ...value
+            };
+        }
+        else {
+            this._literals = poUploadLiteralsDefault[this.language];
+        }
+    }
+    get literals() {
+        return this._literals || poUploadLiteralsDefault[this.language];
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Objeto que segue a definição da interface `PoUploadFileRestrictions`,
+     * que possibilita definir tamanho máximo/mínimo e extensão dos arquivos permitidos.
+     */
+    set fileRestrictions(restrictions) {
+        this._fileRestrictions = this.initRestrictions(restrictions);
+        this.setAllowedExtensions(restrictions);
+    }
+    get fileRestrictions() {
+        return this._fileRestrictions;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Nome do campo de formulário que será enviado para o serviço informado na propriedade `p-url`.
+     *
+     * @default `files`
+     */
+    set formField(value) {
+        this._formField = value && typeof value === 'string' ? value : poUploadFormFieldDefault;
+        this.getUploadService().formField = this.formField;
+    }
+    get formField() {
+        return this._formField;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Indica que o campo será desabilitado.
+     */
+    set disabled(value) {
+        this._disabled = convertToBoolean(value);
+        this.validateModel(this.currentFiles);
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define se pode selecionar mais de um arquivo.
+     *
+     * > Se utilizada a `p-directory`, habilita-se automaticamente esta propriedade.
+     */
+    set isMultiple(value) {
+        this._isMultiple = convertToBoolean(value);
+    }
+    get isMultiple() {
+        return this.canHandleDirectory ? true : this._isMultiple;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Indica que o campo será obrigatório.
+     *
+     * @default `false`
+     */
+    set required(required) {
+        this._required = convertToBoolean(required);
+        this.validateModel(this.currentFiles);
+    }
+    get required() {
+        return this._required;
+    }
+    // Função implementada do ControlValueAccessor
+    // Usada para interceptar os estados de habilitado via forms api
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    registerOnChange(fn) {
+        this.onModelChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onModelTouched = fn;
+    }
+    registerOnValidatorChange(fn) {
+        this.validatorChange = fn;
+    }
+    validate(abstractControl) {
+        if (requiredFailed(this.required, this.disabled, abstractControl.value)) {
+            return {
+                required: {
+                    valid: false
+                }
+            };
+        }
+    }
+    writeValue(model) {
+        if (model) {
+            if (!isEquals(this.currentFiles, model)) {
+                this.currentFiles = this.parseFiles(model);
+            }
+        }
+        else {
+            this.currentFiles = undefined;
+        }
+    }
+    isExceededFileLimit(currentFilesLength) {
+        return (this.isMultiple &&
+            this.fileRestrictions &&
+            this.fileRestrictions.maxFiles > 0 &&
+            this.fileRestrictions.maxFiles <= currentFilesLength);
+    }
+    // Faz o parse dos arquivos selecionados para arquivos do formato PoUploadFile e atualiza os arquivos correntes.
+    parseFiles(files) {
+        let poUploadFiles = this.currentFiles || [];
+        const filesLength = files.length;
+        for (let i = 0; i < filesLength; i++) {
+            if (this.isExceededFileLimit(poUploadFiles.length)) {
+                this.quantityNotAllowed = filesLength - this.fileRestrictions.maxFiles;
+                break;
+            }
+            const file = new PoUploadFile(files[i]);
+            if (this.checkRestrictions(file)) {
+                poUploadFiles = this.insertFileInFiles(file, poUploadFiles);
+            }
+        }
+        this.sendFeedback();
+        return poUploadFiles;
+    }
+    validateModel(model) {
+        if (this.validatorChange) {
+            this.validatorChange(model);
+        }
+    }
+    // Verifica se o arquivo está de acordo com as restrições.
+    checkRestrictions(file) {
+        const restrictions = this.fileRestrictions;
+        if (restrictions) {
+            const allowedExtensions = restrictions.allowedExtensions;
+            const minFileSize = restrictions.minFileSize;
+            const maxFileSize = restrictions.maxFileSize;
+            const isAccept = allowedExtensions ? this.isAllowedExtension(file.extension, allowedExtensions) : true;
+            const isAcceptSize = file.size >= minFileSize && file.size <= maxFileSize;
+            if (!isAcceptSize) {
+                this.sizeNotAllowed = this.sizeNotAllowed + 1;
+            }
+            return isAccept && isAcceptSize;
+        }
+        return true;
+    }
+    existsFileSameName(file, files) {
+        return files.some(currentFile => file.name === currentFile.name);
+    }
+    getUploadService() {
+        return this.uploadService;
+    }
+    insertFileInFiles(newFile, files) {
+        if (this.existsFileSameName(newFile, files)) {
+            return this.updateExistsFileInFiles(newFile, files);
+        }
+        if (this.isMultiple) {
+            files.push(newFile);
+        }
+        else {
+            files.splice(0, files.length, newFile);
+        }
+        return files;
+    }
+    isAllowedExtension(extension, allowedExtensions = []) {
+        const isAllowed = allowedExtensions.some(ext => ext.toLowerCase() === extension);
+        if (!isAllowed) {
+            this.extensionNotAllowed = this.extensionNotAllowed + 1;
+        }
+        return isAllowed;
+    }
+    setAllowedExtensions(restrictions = {}) {
+        const _allowedExtensions = restrictions.allowedExtensions || [];
+        this.allowedExtensions = _allowedExtensions.join(',');
+    }
+    initRestrictions(restrictions) {
+        if (!restrictions) {
+            return;
+        }
+        const minFileSize = restrictions.minFileSize || poUploadMinFileSize;
+        const maxFileSize = restrictions.maxFileSize || poUploadMaxFileSize;
+        return {
+            ...restrictions,
+            maxFileSize: maxFileSize,
+            minFileSize: minFileSize
+        };
+    }
+    updateExistsFileInFiles(newFile, files) {
+        const fileIndex = files.findIndex(currentFile => newFile.name === currentFile.name && currentFile.status !== PoUploadStatus.Uploaded);
+        if (fileIndex !== -1) {
+            files.splice(fileIndex, 1, newFile);
+        }
+        return files;
+    }
+}
+PoUploadBaseComponent.ɵfac = function PoUploadBaseComponent_Factory(t) { return new (t || PoUploadBaseComponent)(i0.ɵɵdirectiveInject(i1.PoUploadService), i0.ɵɵdirectiveInject(i2.PoLanguageService)); };
+PoUploadBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoUploadBaseComponent, inputs: { autoFocus: ["p-auto-focus", "autoFocus"], dragDropHeight: ["p-drag-drop-height", "dragDropHeight"], label: ["p-label", "label"], help: ["p-help", "help"], url: ["p-url", "url"], name: "name", autoUpload: ["p-auto-upload", "autoUpload"], optional: ["p-optional", "optional"], headers: ["p-headers", "headers"], directory: ["p-directory", "directory"], dragDrop: ["p-drag-drop", "dragDrop"], hideRestrictionsInfo: ["p-hide-restrictions-info", "hideRestrictionsInfo"], hideSelectButton: ["p-hide-select-button", "hideSelectButton"], hideSendButton: ["p-hide-send-button", "hideSendButton"], literals: ["p-literals", "literals"], fileRestrictions: ["p-restrictions", "fileRestrictions"], formField: ["p-form-field", "formField"], disabled: ["p-disabled", "disabled"], isMultiple: ["p-multiple", "isMultiple"], required: ["p-required", "required"] }, outputs: { onUpload: "p-upload", onError: "p-error", onSuccess: "p-success", ngModelChange: "ngModelChange" } });
+__decorate([
+    InputBoolean()
+], PoUploadBaseComponent.prototype, "autoFocus", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoUploadBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.PoUploadService }, { type: i2.PoLanguageService }]; }, { autoFocus: [{
+            type: Input,
+            args: ['p-auto-focus']
+        }], dragDropHeight: [{
+            type: Input,
+            args: ['p-drag-drop-height']
+        }], label: [{
+            type: Input,
+            args: ['p-label']
+        }], help: [{
+            type: Input,
+            args: ['p-help']
+        }], url: [{
+            type: Input,
+            args: ['p-url']
+        }], name: [{
+            type: Input,
+            args: ['name']
+        }], autoUpload: [{
+            type: Input,
+            args: ['p-auto-upload']
+        }], optional: [{
+            type: Input,
+            args: ['p-optional']
+        }], headers: [{
+            type: Input,
+            args: ['p-headers']
+        }], onUpload: [{
+            type: Output,
+            args: ['p-upload']
+        }], onError: [{
+            type: Output,
+            args: ['p-error']
+        }], onSuccess: [{
+            type: Output,
+            args: ['p-success']
+        }], ngModelChange: [{
+            type: Output,
+            args: ['ngModelChange']
+        }], directory: [{
+            type: Input,
+            args: ['p-directory']
+        }], dragDrop: [{
+            type: Input,
+            args: ['p-drag-drop']
+        }], hideRestrictionsInfo: [{
+            type: Input,
+            args: ['p-hide-restrictions-info']
+        }], hideSelectButton: [{
+            type: Input,
+            args: ['p-hide-select-button']
+        }], hideSendButton: [{
+            type: Input,
+            args: ['p-hide-send-button']
+        }], literals: [{
+            type: Input,
+            args: ['p-literals']
+        }], fileRestrictions: [{
+            type: Input,
+            args: ['p-restrictions']
+        }], formField: [{
+            type: Input,
+            args: ['p-form-field']
+        }], disabled: [{
+            type: Input,
+            args: ['p-disabled']
+        }], isMultiple: [{
+            type: Input,
+            args: ['p-multiple']
+        }], required: [{
+            type: Input,
+            args: ['p-required']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-upload-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-field/po-upload/po-upload-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl, ControlValueAccessor, Validator } from '@angular/forms';\nimport { EventEmitter, Input, Output, Directive } from '@angular/core';\n\nimport { convertToBoolean, isEquals, isIE, isMobile } from '../../../utils/util';\nimport { requiredFailed } from '../validators';\n\nimport { PoUploadFile } from './po-upload-file';\nimport { PoUploadFileRestrictions } from './interfaces/po-upload-file-restriction.interface';\nimport { PoUploadLiterals } from './interfaces/po-upload-literals.interface';\nimport { PoUploadService } from './po-upload.service';\nimport { PoUploadStatus } from './po-upload-status.enum';\nimport { InputBoolean } from '../../../decorators';\nimport { PoLanguageService } from '../../../services/po-language/po-language.service';\nimport { poLocaleDefault } from '../../../services/po-language/po-language.constant';\n\nexport const poUploadLiteralsDefault = {\n  en: <PoUploadLiterals>{\n    files: 'files',\n    folders: 'folders',\n    selectFile: 'Select file',\n    selectFiles: 'Select files',\n    selectFolder: 'Select folder',\n    startSending: 'Start sending',\n    dragFilesHere: 'Drag files here',\n    dragFoldersHere: 'Drag folders here',\n    selectFilesOnComputer: 'or select files on your computer',\n    selectFolderOnComputer: 'or select folder on your computer',\n    dropFilesHere: 'Drop files here',\n    dropFoldersHere: 'Drop folders here',\n    invalidDropArea: '{0} were not dropped in the correct area',\n    invalidFileType: 'Failed to load {0} file(s) as it is not the allowed file type.',\n    invalidAmount: 'Failed to load {0} file(s), as it exceeds the limit amount of files.',\n    invalidFormat: 'Failed to load {0} file(s), as it does not match the format(s): {1}.',\n    invalidSize: 'Failed to load {0} files(s), as it is not the allowed size: from {1} to {2}.',\n    numberOfFilesAllowed: '{0} file(s) allowed',\n    allowedFormats: 'Accepted file formats: {0}.',\n    allowedFileSizeRange: 'Size limit per file: from {0} to {1}',\n    maxFileSizeAllowed: 'Size limit per file: {0} maximum',\n    minFileSizeAllowed: 'Size limit per file: {0} minimum',\n    errorOccurred: 'An error has occurred',\n    sentWithSuccess: 'Sent with success'\n  },\n  es: <PoUploadLiterals>{\n    files: 'archivos',\n    folders: 'carpetas',\n    selectFile: 'Seleccionar archivo',\n    selectFiles: 'Seleccionar archivos',\n    selectFolder: 'Seleccionar carpeta',\n    startSending: 'Iniciar carga',\n    dragFilesHere: 'Arrastra los archivos aquí',\n    dragFoldersHere: 'Arrastra las carpetas aquí',\n    selectFilesOnComputer: 'o selecciona los archivos en tu computadora',\n    selectFolderOnComputer: 'o selecciona la carpeta en tu computadora',\n    dropFilesHere: 'Deja los archivos aquí',\n    dropFoldersHere: 'Deja las carpetas aquí',\n    invalidDropArea: 'Los {0} no se insertaron en la ubicación correcta',\n    invalidFileType: 'Error al cargar {0} archivo (s) ya que no es el tipo de archivo permitido',\n    invalidAmount: 'Error al cargar {0} archivo (s) ya que excede la cantidad limite de archivos.',\n    invalidFormat: 'Error al cargar {0} archivo (s) ya que no coincide con el formato (s): {1}.',\n    invalidSize: 'Error al cargar {0} archivo (s) ya que no cumple con el tamaño permitido: desde {1} hasta {2}.',\n    numberOfFilesAllowed: '{0} archivo(s) permitido(s)',\n    allowedFormats: 'Formatos aceptados: {0}.',\n    allowedFileSizeRange: 'Limite de tamaño de archivo: desde {0} hasta {1}',\n    maxFileSizeAllowed: 'Limite de tamaño de archivo: hasta {0}',\n    minFileSizeAllowed: 'Limite de tamaño de archivo: minimo {0}',\n    errorOccurred: 'Ocurrio un error',\n    sentWithSuccess: 'Enviado con éxito'\n  },\n  pt: <PoUploadLiterals>{\n    files: 'arquivos',\n    folders: 'diretórios',\n    selectFile: 'Selecionar arquivo',\n    selectFiles: 'Selecionar arquivos',\n    selectFolder: 'Selecionar pasta',\n    startSending: 'Iniciar envio',\n    dragFilesHere: 'Arraste os arquivos aqui',\n    dragFoldersHere: 'Arraste as pastas aqui',\n    selectFilesOnComputer: 'ou selecione os arquivos no computador',\n    selectFolderOnComputer: 'ou selecione a pasta no computador',\n    dropFilesHere: 'Solte os arquivos aqui',\n    dropFoldersHere: 'Solte as pastas aqui',\n    invalidDropArea: 'Os {0} não foram inseridos no local correto',\n    invalidFileType: 'Falha ao carregar {0} arquivo (s), pois não é o tipo de arquivo permitido',\n    invalidAmount: 'Falha ao carregar {0} arquivo(s), pois excede(m) a quantidade limite de arquivos.',\n    invalidFormat: 'Falha ao carregar {0} arquivo(s), pois não corresponde(m) ao(s) formato(s): {1}.',\n    invalidSize: 'Falha ao carregar {0} arquivo(s), pois não atende ao tamanho permitido: {1} até {2}.',\n    numberOfFilesAllowed: 'Quantidade máxima: {0} arquivo(s)',\n    allowedFormats: 'Formatos adotados: {0}.',\n    allowedFileSizeRange: 'Limite de tamanho por arquivo: de {0} até {1}',\n    maxFileSizeAllowed: 'Limite de tamanho por arquivo: até {0}',\n    minFileSizeAllowed: 'Limite de tamanho por arquivo: no mínimo {0}',\n    errorOccurred: 'Ocorreu um erro',\n    sentWithSuccess: 'Enviado com sucesso'\n  },\n  ru: <PoUploadLiterals>{\n    files: 'файлы',\n    folders: 'папки с файлами',\n    selectFile: 'Выберите файл',\n    selectFiles: 'Выберите файлы',\n    selectFolder: 'Выберите папку с файлами',\n    startSending: 'Начать загрузку',\n    dragFilesHere: 'Перетащите файлы сюда',\n    dragFoldersHere: 'Перетащите сюда папки',\n    selectFilesOnComputer: 'или выберите файлы на компьютере',\n    selectFolderOnComputer: 'или выберите папку на вашем компьютере',\n    dropFilesHere: 'Оставьте файлы здесь',\n    dropFoldersHere: 'Перетащите сюда папки',\n    invalidDropArea: '{0} не были вставлены в правильном месте.',\n    invalidFileType: 'Не удалось загрузить файлы {0}, так как это неверный тип файла',\n    invalidAmount: 'Não foi possível carregar os arquivos {0} porque eles excederam o limite de arquivos.',\n    invalidFormat: 'Не удалось загрузить файлы {0}, так как они не соответствуют формату (ам): {1}.',\n    invalidSize: 'Не удалось загрузить файлы {0}, поскольку они не соответствуют разрешенному размеру: от {1} до {2}.',\n    numberOfFilesAllowed: 'Максимальное количество: {0} файлов',\n    allowedFormats: 'Форматы приняты: {0}.',\n    allowedFileSizeRange: 'Ограничение размера файла: от {0} до {1}',\n    maxFileSizeAllowed: 'Ограничение размера файла: до {0}',\n    minFileSizeAllowed: 'Ограничение размера файла: не менее {0}',\n    errorOccurred: 'Произошла ошибка.',\n    sentWithSuccess: 'Успешно отправлено'\n  }\n};\n\nconst poUploadFormFieldDefault = 'files';\n\nconst poUploadMaxFileSize = 31457280; // 30MB\nconst poUploadMinFileSize = 0;\n\n/**\n * @description\n *\n * O componente `po-upload` permite que o usuário envie arquivo(s) ao servidor e acompanhe o progresso.\n * Este componente também possibilita algumas configurações como:\n *  – Envio de diretórios, onde ele acessa o diretório selecionado assim como seus sub-diretórios;\n *  - Múltipla seleção, onde o usuário pode enviar mais de um arquivo ao servidor.\n *  - Auto envio, onde o arquivo é enviado imediatamente após a seleção do usuário, não necessitando que o usuário\n * clique em enviar.\n *  - Restrições de formatos de arquivo e tamanho.\n *  - Função de sucesso que será disparada quando os arquivos forem enviados com sucesso.\n *  - Função de erro que será disparada quando houver erro no envio dos arquivos.\n *  - Permite habilitar uma área onde os arquivos podem ser arrastados.\n */\n@Directive()\nexport abstract class PoUploadBaseComponent implements ControlValueAccessor, Validator {\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Aplica foco no elemento ao ser iniciado.\n   *\n   * > Caso mais de um elemento seja configurado com essa propriedade, apenas o último elemento declarado com ela terá o foco.\n   *\n   * @default `false`\n   */\n  @Input('p-auto-focus') @InputBoolean() autoFocus: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define em *pixels* a altura da área onde podem ser arrastados os arquivos. A altura mínima aceita é `160px`.\n   *\n   * > Esta propriedade funciona somente se a propriedade `p-drag-drop` estiver habilitada.\n   *\n   * @default `320`\n   */\n  @Input('p-drag-drop-height') dragDropHeight: number;\n\n  /** Rótulo do campo. */\n  @Input('p-label') label?: string;\n\n  /** Texto de apoio para o campo. */\n  @Input('p-help') help?: string;\n\n  /** URL que deve ser feita a requisição com os arquivos selecionados. */\n  @Input('p-url') url: string;\n\n  /** Define o valor do atributo `name` do componente. */\n  @Input('name') name: string = 'file';\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define se o envio do arquivo será automático ao selecionar o mesmo.\n   *\n   * @default `false`\n   */\n  @Input('p-auto-upload') autoUpload?: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define se a indicação de campo opcional será exibida.\n   *\n   * > Não será exibida a indicação se:\n   *  - O campo conter `p-required`;\n   *  - Não possuir `p-help` e/ou `p-label`.\n   *\n   * @default `false`\n   */\n  @Input('p-optional') optional: boolean;\n\n  /** Objeto que contém os cabeçalhos que será enviado na requisição dos arquvios. */\n  @Input('p-headers') headers: { [name: string]: string | Array<string> };\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Função que será executada no momento de realizar o envio do arquivo,\n   * onde será possível adicionar informações ao parâmetro que será enviado na requisição.\n   * É passado por parâmetro um objeto com o arquivo e a propiedade data nesta propriedade pode ser informado algum dado,\n   * que será enviado em conjunto com o arquivo na requisição, por exemplo:\n   *\n   * ```\n   *   event.data = {id: 'id do usuario'};\n   * ```\n   */\n  @Output('p-upload') onUpload: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento será disparado quando ocorrer algum erro no envio do arquivo.\n   * > Por parâmetro será passado o objeto do retorno que é do tipo `HttpErrorResponse`.\n   */\n  @Output('p-error') onError: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento será disparado quando o envio do arquivo for realizado com sucesso.\n   * > Por parâmetro será passado o objeto do retorno que é do tipo `HttpResponse`.\n   */\n  @Output('p-success') onSuccess: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Função para atualizar o ngModel do componente, necessário quando não for utilizado dentro da *tag* `form`.\n   *\n   * Na versão 12.2.0 do Angular a verificação `strictTemplates` vem true como default. Portanto, para utilizar\n   * two-way binding no componente deve se utilizar da seguinte forma:\n   *\n   * ```\n   * <po-upload ... [ngModel]=\"UploadModel\" (ngModelChange)=\"uploadModel = $event\"> </po-upload>\n   * ```\n   *\n   */\n  @Output('ngModelChange') ngModelChange: EventEmitter<any> = new EventEmitter<any>();\n\n  allowedExtensions: string;\n  currentFiles: Array<PoUploadFile>;\n\n  canHandleDirectory: boolean;\n  onModelChange: any;\n\n  protected extensionNotAllowed = 0;\n  protected quantityNotAllowed = 0;\n  protected sizeNotAllowed = 0;\n  protected onModelTouched: any = null;\n\n  private _directory?: boolean;\n  private _disabled?: boolean;\n  private _dragDrop?: boolean = false;\n  private _fileRestrictions?: PoUploadFileRestrictions;\n  private _formField?: string;\n  private _hideRestrictionsInfo?: boolean;\n  private _hideSelectButton?: boolean;\n  private _hideSendButton?: boolean;\n  private _isMultiple?: boolean;\n  private _literals?: any;\n  private _required?: boolean;\n  private language: string;\n  private validatorChange: any;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Permite a seleção de diretórios contendo um ou mais arquivos para envio.\n   *\n   * > A habilitação desta propriedade se restringe apenas à seleção de diretórios.\n   *\n   * > Definição não suportada pelo browser **Internet Explorer**, todavia será possível a seleção de arquivos padrão.\n   *\n   * @default `false`\n   */\n  @Input('p-directory') set directory(value: boolean) {\n    this._directory = convertToBoolean(value);\n\n    this.canHandleDirectory = this._directory && !isIE() && !isMobile();\n    this.setDirectoryAttribute(this.canHandleDirectory);\n  }\n\n  get directory() {\n    return this._directory;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Exibe a área onde é possível arrastar e selecionar os arquivos. Quando estiver definida, omite o botão para seleção de arquivos\n   * automaticamente.\n   *\n   * > Recomendamos utilizar apenas um `po-upload` com esta funcionalidade por tela.\n   *\n   * @default `false`\n   */\n  @Input('p-drag-drop') set dragDrop(value: boolean) {\n    this._dragDrop = convertToBoolean(value);\n  }\n\n  get dragDrop() {\n    return this._dragDrop;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Oculta visualmente as informações de restrições para o upload.\n   *\n   * @default `false`\n   */\n  @Input('p-hide-restrictions-info') set hideRestrictionsInfo(value: boolean) {\n    this._hideRestrictionsInfo = convertToBoolean(value);\n  }\n\n  get hideRestrictionsInfo() {\n    return this._hideRestrictionsInfo;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Omite o botão de seleção de arquivos.\n   *\n   * > Caso o valor definido seja `true`, caberá ao desenvolvedor a responsabilidade\n   * pela chamada do método `selectFiles()` para seleção de arquivos.\n   *\n   * @default `false`\n   */\n  @Input('p-hide-select-button') set hideSelectButton(value: boolean) {\n    this._hideSelectButton = convertToBoolean(value);\n  }\n  get hideSelectButton(): boolean {\n    return this._hideSelectButton;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Omite o botão de envio de arquivos.\n   *\n   * > Caso o valor definido seja `true`, caberá ao desenvolvedor a responsabilidade\n   * pela chamada do método `sendFiles()` para envio do(s) arquivo(s) selecionado(s).\n   *\n   * @default `false`\n   */\n  @Input('p-hide-send-button') set hideSendButton(value: boolean) {\n    this._hideSendButton = convertToBoolean(value);\n  }\n  get hideSendButton(): boolean {\n    return this._hideSendButton;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Objeto com as literais usadas no `po-upload`.\n   *\n   * Existem duas maneiras de customizar o componente:\n   *\n   * - passando um objeto implementando a interface `PoUploadLiterals` com todas as literais disponíveis;\n   * - passando apenas as literais que deseja customizar:\n   * ```\n   *  const customLiterals: PoUploadLiterals = {\n   *    folders: 'Pastas',\n   *    selectFile: 'Buscar arquivo',\n   *    startSending: 'Enviar'\n   *  };\n   * ```\n   *\n   * E para carregar as literais customizadas, basta apenas passar o objeto para o componente:\n   *\n   * ```\n   * <po-upload\n   *   [p-literals]=\"customLiterals\">\n   * </po-upload>\n   * ```\n   *\n   * > O objeto padrão de literais será traduzido de acordo com o idioma do *browser* (pt, en, es, ru).\n   */\n  @Input('p-literals') set literals(value: PoUploadLiterals) {\n    if (value instanceof Object && !(value instanceof Array)) {\n      this._literals = {\n        ...poUploadLiteralsDefault[poLocaleDefault],\n        ...poUploadLiteralsDefault[this.language],\n        ...value\n      };\n    } else {\n      this._literals = poUploadLiteralsDefault[this.language];\n    }\n  }\n  get literals() {\n    return this._literals || poUploadLiteralsDefault[this.language];\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Objeto que segue a definição da interface `PoUploadFileRestrictions`,\n   * que possibilita definir tamanho máximo/mínimo e extensão dos arquivos permitidos.\n   */\n  @Input('p-restrictions') set fileRestrictions(restrictions: PoUploadFileRestrictions) {\n    this._fileRestrictions = this.initRestrictions(restrictions);\n\n    this.setAllowedExtensions(restrictions);\n  }\n\n  get fileRestrictions(): PoUploadFileRestrictions {\n    return this._fileRestrictions;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Nome do campo de formulário que será enviado para o serviço informado na propriedade `p-url`.\n   *\n   * @default `files`\n   */\n  @Input('p-form-field') set formField(value: string) {\n    this._formField = value && typeof value === 'string' ? value : poUploadFormFieldDefault;\n\n    this.getUploadService().formField = this.formField;\n  }\n\n  get formField(): string {\n    return this._formField;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Indica que o campo será desabilitado.\n   */\n  @Input('p-disabled') set disabled(value: boolean) {\n    this._disabled = convertToBoolean(value);\n\n    this.validateModel(this.currentFiles);\n  }\n\n  get disabled() {\n    return this._disabled;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define se pode selecionar mais de um arquivo.\n   *\n   * > Se utilizada a `p-directory`, habilita-se automaticamente esta propriedade.\n   */\n  @Input('p-multiple') set isMultiple(value: boolean) {\n    this._isMultiple = convertToBoolean(value);\n  }\n\n  get isMultiple() {\n    return this.canHandleDirectory ? true : this._isMultiple;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Indica que o campo será obrigatório.\n   *\n   * @default `false`\n   */\n  @Input('p-required') set required(required: boolean) {\n    this._required = convertToBoolean(required);\n\n    this.validateModel(this.currentFiles);\n  }\n\n  get required() {\n    return this._required;\n  }\n\n  constructor(protected uploadService: PoUploadService, languageService: PoLanguageService) {\n    this.language = languageService.getShortLanguage();\n  }\n\n  // Função implementada do ControlValueAccessor\n  // Usada para interceptar os estados de habilitado via forms api\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n  }\n\n  registerOnChange(fn: any): void {\n    this.onModelChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onModelTouched = fn;\n  }\n\n  registerOnValidatorChange(fn: () => void) {\n    this.validatorChange = fn;\n  }\n\n  validate(abstractControl: AbstractControl): { [key: string]: any } {\n    if (requiredFailed(this.required, this.disabled, abstractControl.value)) {\n      return {\n        required: {\n          valid: false\n        }\n      };\n    }\n  }\n\n  writeValue(model: any): void {\n    if (model) {\n      if (!isEquals(this.currentFiles, model)) {\n        this.currentFiles = this.parseFiles(model);\n      }\n    } else {\n      this.currentFiles = undefined;\n    }\n  }\n\n  protected isExceededFileLimit(currentFilesLength: number): boolean {\n    return (\n      this.isMultiple &&\n      this.fileRestrictions &&\n      this.fileRestrictions.maxFiles > 0 &&\n      this.fileRestrictions.maxFiles <= currentFilesLength\n    );\n  }\n\n  // Faz o parse dos arquivos selecionados para arquivos do formato PoUploadFile e atualiza os arquivos correntes.\n  protected parseFiles(files: Array<File>): Array<PoUploadFile> {\n    let poUploadFiles: Array<PoUploadFile> = this.currentFiles || [];\n    const filesLength = files.length;\n\n    for (let i = 0; i < filesLength; i++) {\n      if (this.isExceededFileLimit(poUploadFiles.length)) {\n        this.quantityNotAllowed = filesLength - this.fileRestrictions.maxFiles;\n        break;\n      }\n      const file = new PoUploadFile(files[i]);\n\n      if (this.checkRestrictions(file)) {\n        poUploadFiles = this.insertFileInFiles(file, poUploadFiles);\n      }\n    }\n    this.sendFeedback();\n    return poUploadFiles;\n  }\n\n  protected validateModel(model: any) {\n    if (this.validatorChange) {\n      this.validatorChange(model);\n    }\n  }\n\n  // Verifica se o arquivo está de acordo com as restrições.\n  private checkRestrictions(file: PoUploadFile): boolean {\n    const restrictions = this.fileRestrictions;\n\n    if (restrictions) {\n      const allowedExtensions = restrictions.allowedExtensions;\n      const minFileSize = restrictions.minFileSize;\n      const maxFileSize = restrictions.maxFileSize;\n\n      const isAccept = allowedExtensions ? this.isAllowedExtension(file.extension, allowedExtensions) : true;\n      const isAcceptSize = file.size >= minFileSize && file.size <= maxFileSize;\n\n      if (!isAcceptSize) {\n        this.sizeNotAllowed = this.sizeNotAllowed + 1;\n      }\n\n      return isAccept && isAcceptSize;\n    }\n\n    return true;\n  }\n\n  private existsFileSameName(file: PoUploadFile, files: Array<PoUploadFile>): boolean {\n    return files.some(currentFile => file.name === currentFile.name);\n  }\n\n  private getUploadService(): PoUploadService {\n    return this.uploadService;\n  }\n\n  private insertFileInFiles(newFile: PoUploadFile, files: Array<PoUploadFile>) {\n    if (this.existsFileSameName(newFile, files)) {\n      return this.updateExistsFileInFiles(newFile, files);\n    }\n\n    if (this.isMultiple) {\n      files.push(newFile);\n    } else {\n      files.splice(0, files.length, newFile);\n    }\n\n    return files;\n  }\n\n  private isAllowedExtension(extension: string, allowedExtensions: Array<string> = []): boolean {\n    const isAllowed = allowedExtensions.some(ext => ext.toLowerCase() === extension);\n    if (!isAllowed) {\n      this.extensionNotAllowed = this.extensionNotAllowed + 1;\n    }\n    return isAllowed;\n  }\n\n  private setAllowedExtensions(restrictions: PoUploadFileRestrictions = {}) {\n    const _allowedExtensions = restrictions.allowedExtensions || [];\n\n    this.allowedExtensions = _allowedExtensions.join(',');\n  }\n\n  private initRestrictions(restrictions: PoUploadFileRestrictions): PoUploadFileRestrictions {\n    if (!restrictions) {\n      return;\n    }\n\n    const minFileSize = restrictions.minFileSize || poUploadMinFileSize;\n    const maxFileSize = restrictions.maxFileSize || poUploadMaxFileSize;\n\n    return {\n      ...restrictions,\n      maxFileSize: maxFileSize,\n      minFileSize: minFileSize\n    };\n  }\n\n  private updateExistsFileInFiles(newFile: PoUploadFile, files: Array<PoUploadFile>) {\n    const fileIndex = files.findIndex(\n      currentFile => newFile.name === currentFile.name && currentFile.status !== PoUploadStatus.Uploaded\n    );\n\n    if (fileIndex !== -1) {\n      files.splice(fileIndex, 1, newFile);\n    }\n\n    return files;\n  }\n\n  abstract sendFeedback(): void;\n\n  abstract setDirectoryAttribute(value: boolean);\n}\n"]}