@apia/uploader-controller 4.0.44

package/dist/index.js

@@ -0,0 +1,1502 @@
+import { getLabel, toBoolean, EventEmitter, arrayOrArray, downloadUrl, addBoundary, formatMessage, parseAsSize } from '@apia/util';
+import { makeObservable, observable } from 'mobx';
+import QueryString from 'qs';
+import { ApiaApi } from '@apia/api2';
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, key + "" , value);
+  return value;
+};
+function getFileExtension(fileName) {
+  const parts = fileName.split(".");
+  return parts.length > 1 ? parts.pop().toLowerCase() : "";
+}
+const getInitialState = (execution) => Object.freeze({
+  metadata: {
+    metadataArray: [],
+    freeMetadataArray: [],
+    isFreeMetadata: false
+  },
+  fromDirectoryFile: null,
+  docFolder: void 0,
+  docPath: void 0,
+  docExpDate: void 0,
+  description: "",
+  isReadonly: false,
+  permissions: {
+    pools: [],
+    users: execution.ownerCanUpdate ? [
+      {
+        canUpdate: true,
+        userId: execution.currentUserLogin,
+        userLogin: execution.currentUserLogin
+      }
+    ] : [],
+    allowAllType: execution.everyoneCanUpdate !== false ? "M" : ""
+  },
+  fileReqError: false
+});
+class UploaderModalController {
+  constructor(api, modalConfig, conf) {
+    this.api = api;
+    this.modalConfig = modalConfig;
+    this.conf = conf;
+    __publicField$1(this, "state");
+    makeObservable(this, {
+      state: observable
+    });
+    this.state = getInitialState(api.props.context);
+  }
+  get allMetadata() {
+    return [
+      ...this.state.metadata.metadataArray,
+      ...this.state.metadata.freeMetadataArray
+    ];
+  }
+  get allowAllType() {
+    return this.state.permissions.allowAllType;
+  }
+  get description() {
+    return this.state.description;
+  }
+  get docFolder() {
+    return this.state.docFolder;
+  }
+  get docExpDate() {
+    return this.state.docExpDate;
+  }
+  get docTypes() {
+    return this.api.getDocTypes();
+  }
+  get freeMetadata() {
+    return this.state.metadata.freeMetadataArray;
+  }
+  get exitingFiles() {
+    return this.api.getExistingFiles();
+  }
+  get inProgressFiles() {
+    return this.api.getInProgressFiles();
+  }
+  get hiddenFiles() {
+    return this.api.getHiddenFiles();
+  }
+  get progress() {
+    return this.api.getProgress();
+  }
+  get metadata() {
+    return this.state.metadata.metadataArray;
+  }
+  get selectedDocTypeId() {
+    return this.api.getCurrentDocTypeId();
+  }
+  get selectedDocType() {
+    return this.api.getCurrentDocType();
+  }
+  addMetadata() {
+    this.state.metadata.freeMetadataArray.push({
+      free: "Y",
+      id: String(Math.random()),
+      name: "",
+      required: "Y",
+      title: "",
+      type: "S",
+      value: "",
+      errorMessage: "",
+      labelErrorMessage: ""
+    });
+  }
+  addFiles(files) {
+    this.state.fileReqError = false;
+    this.state.isReadonly = false;
+    this.api.saveDroppedFiles(files, this.conf);
+  }
+  addDirectoryFile(file) {
+    this.state.fileReqError = false;
+    this.api.state.inProgressFiles = [];
+    this.state.fromDirectoryFile = file;
+  }
+  async changeDocType(docTypeId) {
+    this.resetMetadata();
+    this.api.setCurrentDocTypeId(docTypeId);
+    this.onChangeExtension();
+    this.api.reloadMetadata({ docTypeId });
+  }
+  clearDirectoryFile() {
+    this.state.fromDirectoryFile = null;
+    this.state.isReadonly = false;
+  }
+  clearFile(name) {
+    this.api.clearFile(name);
+  }
+  clearFiles() {
+    this.api.clearFiles();
+  }
+  clearState() {
+    this.state = getInitialState(this.api.props.context);
+    this.api.clearState();
+  }
+  clearPartialState() {
+    if (this.api.state.inProgressFiles.length === 0) {
+      this.state = getInitialState(this.api.props.context);
+    }
+  }
+  onCloseModal() {
+    this.clearState();
+  }
+  async confirm() {
+    let isValid = this.validate();
+    if (isValid)
+      isValid = await this.api.confirmDropModal(this.conf);
+    return isValid;
+  }
+  deleteMetadata(indices) {
+    const deleteSet = new Set(indices);
+    const offset = this.state.metadata.metadataArray.length;
+    this.state.metadata.freeMetadataArray = this.state.metadata.freeMetadataArray.filter(
+      (_, localIndex) => (
+        // conservamos sólo los que NO estén en deleteSet
+        !deleteSet.has(localIndex + offset)
+      )
+    );
+  }
+  deletePermission(item) {
+    if (item && "userId" in item) {
+      this.state.permissions.users = this.state.permissions.users.filter(
+        (c) => c.userId !== item.userId
+      );
+    } else {
+      this.state.permissions.pools = this.state.permissions.pools.filter(
+        (c) => c.poolId !== item.poolId
+      );
+    }
+  }
+  onChangeExtension() {
+    const rawDocExts = this.api.getCurrentDocType()?.docExts || "";
+    let hideFileNames = "";
+    const allowedExtensions = rawDocExts.split(";").map((ext) => ext.trim()).filter((ext) => ext !== "");
+    if (rawDocExts === "") {
+      const allFiles = [...this.inProgressFiles, ...this.hiddenFiles];
+      const dedupedFiles = Array.from(
+        new Map(allFiles.map((file) => [file.name, file])).values()
+      );
+      this.api.state.inProgressFiles = dedupedFiles;
+      this.api.state.hiddenFiles = [];
+      return;
+    }
+    const allowedInProgress = [];
+    const toHide = [];
+    this.inProgressFiles.forEach((file) => {
+      const ext = getFileExtension(file.name);
+      if (allowedExtensions.includes(ext)) {
+        allowedInProgress.push(file);
+      } else {
+        toHide.push(file);
+        hideFileNames += ` ${file.name} `;
+      }
+    });
+    const allowedHidden = [];
+    const stillHidden = [];
+    this.api.state.hiddenFiles.forEach((file) => {
+      const ext = getFileExtension(file.name);
+      if (allowedExtensions.includes(ext)) {
+        allowedHidden.push(file);
+      } else {
+        stillHidden.push(file);
+      }
+    });
+    const combinedInProgress = [...allowedInProgress, ...allowedHidden];
+    const dedupedInProgress = Array.from(
+      new Map(
+        combinedInProgress.map((file) => [file.name, file])
+      ).values()
+    );
+    const combinedHidden = [...toHide, ...stillHidden];
+    const dedupedHidden = Array.from(
+      new Map(combinedHidden.map((file) => [file.name, file])).values()
+    );
+    this.api.state.inProgressFiles = dedupedInProgress;
+    this.api.state.hiddenFiles = dedupedHidden;
+    if (hideFileNames)
+      this.api.notify({
+        title: getLabel("msgFileWrngExt").text,
+        message: hideFileNames,
+        type: "warning"
+      });
+  }
+  async openModal() {
+    const a = "openUploaderModal";
+    import(
+      /* webpackInclude: /\.tsx?$/ */
+      `/src/static/files/${a}`
+    ).then((r) => {
+      r.default(this);
+    });
+  }
+  setDescription(desc) {
+    this.state.description = desc;
+  }
+  async resetMetadata() {
+    this.state.metadata = {
+      freeMetadataArray: [],
+      metadataArray: [],
+      isFreeMetadata: false
+    };
+  }
+  validate() {
+    let isValid = true;
+    this.state.fileReqError = false;
+    if (this.api.getInProgressFiles().length === 0 && !this.state.fromDirectoryFile) {
+      this.state.fileReqError = true;
+      isValid = false;
+    }
+    this.allMetadata.forEach((c) => {
+      if (c.required === "Y") {
+        if (c.name.trim() === "" && c.free === "Y") {
+          c.labelErrorMessage = getLabel("msgReqField").text;
+          isValid = false;
+        }
+        if (c.value.trim() === "") {
+          if (!c.errorMessage)
+            c.errorMessage = getLabel("msgReqField").text;
+          isValid = false;
+        }
+      }
+    });
+    return isValid;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function returnExactlyTheSame(defaultParameters) {
+  return defaultParameters;
+}
+const parseFileDefinition = (context, fileDefinition, isSignRequired) => {
+  const { lock, isLocked, lockedBy, userLocking, ...file } = fileDefinition;
+  return {
+    ...file,
+    isLocked: isLocked === "true" || isLocked === true || toBoolean(lock) || file.locked === true,
+    isLockedByMe: (lockedBy || userLocking) === context.currentUserLogin,
+    isMarkedToSign: file.markedToSign || toBoolean(file.sign) || isSignRequired,
+    isVirtual: file.virtualDoc ?? false,
+    lockingUser: lockedBy || userLocking
+  };
+};
+class UploaderApi extends EventEmitter {
+  constructor(props) {
+    super();
+    this.props = props;
+    __publicField(this, "maxFiles", Infinity);
+    __publicField(this, "modalController", null);
+    __publicField(this, "allowTranslations", false);
+    __publicField(this, "langs");
+    __publicField(this, "currentConfiguration");
+    __publicField(this, "state", {
+      progress: 0,
+      allowedTypes: [],
+      selectedDocTypeId: "1",
+      versioningFile: null,
+      inProgressFiles: [],
+      files: {},
+      selectedFiles: [],
+      hiddenFiles: [],
+      translatedFiles: /* @__PURE__ */ new Map(),
+      hasAllDocTypes: false
+    });
+    __publicField(this, "getCheckSignatureParameters", returnExactlyTheSame);
+    __publicField(this, "getAjaxUploadFileStatusParameters", returnExactlyTheSame);
+    __publicField(this, "getAjaxUploadStartParameters", returnExactlyTheSame);
+    __publicField(this, "getConfirmDropModalParameters", returnExactlyTheSame);
+    __publicField(this, "getCheckLockDocumentParameters", returnExactlyTheSame);
+    __publicField(this, "getCheckWebDavLockParameters", returnExactlyTheSame);
+    __publicField(this, "getConfirmDropModalPostdata", returnExactlyTheSame);
+    __publicField(this, "getConfirmDropModalMetadataString", ({
+      metadata
+    }) => {
+      return metadata?.filter?.((current) => !!current.value).map((current) => `${current.id}~${current.type}~${current.value}`).join(";") ?? [];
+    });
+    __publicField(this, "getConfirmDropModalPermissionsString", ({
+      poolsPermissions,
+      usersPermissions
+    }) => {
+      let returnString = "";
+      poolsPermissions.forEach(
+        (current) => returnString = `${returnString}${returnString.length > 0 ? "&" : ""}docPoolId=${current.poolId}&docPoolName=${current.poolName}&docPermType${current.poolId}=${String(current.canUpdate)}`
+      );
+      usersPermissions.forEach(
+        (current) => returnString = `${returnString}${returnString.length > 0 ? "&" : ""}docUserId=${current.userId}&docUsrLogin=${current.userLogin}&docPermType${current.userId}=${String(current.canUpdate)}`
+      );
+      return returnString;
+    });
+    __publicField(this, "getConfirmDropModalAdditionalMetadataString", (additionalMetadata) => {
+      return Object.values(additionalMetadata).filter((current) => !!current?.value).map((current) => `${current.name}~${current.value}`).join(";");
+    });
+    __publicField(this, "getDeleteDocumentParameters", returnExactlyTheSame);
+    __publicField(this, "getClearTempFilesParameters", returnExactlyTheSame);
+    __publicField(this, "getDocumentInfoParameters", returnExactlyTheSame);
+    __publicField(this, "getDownloadMultipleDocumentsParameters", returnExactlyTheSame);
+    __publicField(this, "getEditDocumentParameters", returnExactlyTheSame);
+    __publicField(this, "getLockDocumentParameters", returnExactlyTheSame);
+    __publicField(this, "getMarkFileToSignParameters", returnExactlyTheSame);
+    __publicField(this, "getProcessDroppedFilesParameters", returnExactlyTheSame);
+    __publicField(this, "getProcessDroppedFilesPostdata", returnExactlyTheSame);
+    __publicField(this, "getReloadMetadataParameters", returnExactlyTheSame);
+    __publicField(this, "getSaveDroppedFilesParameters", returnExactlyTheSame);
+    __publicField(this, "parseFileDefinition", (file) => {
+      return {
+        ...parseFileDefinition(this.props.context, file, false),
+        canEdit: file.canEdit || file.canWrite,
+        canRead: file.canRead
+      };
+    });
+    makeObservable(this, {
+      state: observable
+    });
+    this.allowTranslations = props.type === "E" && !!this.props.context.docLangs;
+    this.langs = this.props.context.docLangs;
+  }
+  get filesArray() {
+    return Object.values(this.state.files);
+  }
+  get context() {
+    return this.props.context;
+  }
+  async init() {
+    await this.ajaxUploadStart();
+    await this.reloadMetadata({
+      docTypeId: this.state.selectedDocTypeId
+    });
+    await this.loadCurrentDocuments();
+  }
+  buildModalController(conf) {
+    return new UploaderModalController(this, this.props.modalConfig, conf);
+  }
+  async onStartUpload(files) {
+    if (this.props.modalConfig.oneClickUpload) {
+      await this.saveDroppedFiles(files ?? []);
+    } else {
+      if (files) {
+        const result = await this.saveDroppedFiles(files ?? []);
+        if (!result)
+          return;
+      }
+      this.modalController = this.buildModalController();
+      this.modalController.openModal();
+    }
+  }
+  async onTranslateUpload(conf, files) {
+    if (this.props.modalConfig.oneClickUpload) {
+      await this.saveDroppedFiles(files ?? [], conf);
+    } else {
+      await this.init();
+      let mustOpen = true;
+      if (files) {
+        const res = await this.saveDroppedFiles(files ?? [], conf);
+        if (!res) {
+          mustOpen = false;
+        }
+      }
+      if (mustOpen) {
+        this.modalController = this.buildModalController(conf);
+        this.modalController.openModal();
+      }
+    }
+  }
+  async onVersionUpload(file, conf = { newFiles: [] }) {
+    this.version(file, conf);
+  }
+  async autoLock() {
+    return new Promise((resolve) => {
+      resolve(false);
+    });
+  }
+  notify(notification) {
+    this.props.context.notify(notification);
+  }
+  getAjaxUrl() {
+    return this.props.context.URL_REQUEST_AJAX;
+  }
+  getDocTypes() {
+    return this.state.allowedTypes;
+  }
+  getCurrentDocTypeId() {
+    return this.state.selectedDocTypeId;
+  }
+  getCurrentDocType() {
+    return this.state.allowedTypes.find(
+      (c) => c.id === this.state.selectedDocTypeId
+    );
+  }
+  getInProgressFiles() {
+    return this.state.inProgressFiles;
+  }
+  getHiddenFiles() {
+    return this.state.hiddenFiles;
+  }
+  getExistingFiles() {
+    return this.state.files;
+  }
+  getProgress() {
+    return this.state.progress;
+  }
+  getHasAllDocTypes() {
+    return this.state.hasAllDocTypes;
+  }
+  async getDocumentInfo({
+    docId: apiId,
+    downloadDocId: docId
+  }, newElem) {
+    const id = apiId ? this.getDocument(apiId).docId : docId;
+    const result = await ApiaApi.post(
+      this.context,
+      this.getDocumentInfoParameters({
+        action: "getDocumentInfo",
+        isAjax: true,
+        docId: id,
+        newElem,
+        prefix: this.props.type,
+        ajaxUrl: this.getAjaxUrl()
+      })
+    );
+    if (result?.data) {
+      return result.data;
+    }
+    return null;
+  }
+  /**
+   * This method searches for the provided id in several places:
+   *
+   * If it's found in the current files, returns it.
+   * If not, it searches the provided docId in the translations map of each uploaded file.
+   */
+  getDocument(docId) {
+    if (this.state.files[docId]) {
+      return this.state.files[docId];
+    } else {
+      for (const map of this.state.translatedFiles.values()) {
+        for (const file of map.values()) {
+          if (file.docId === docId) {
+            return file;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  updateDocument(docId, newValue) {
+    if (this.state.files[docId]) {
+      this.state.files[docId] = { ...this.getDocument(docId), ...newValue };
+    } else {
+      this.state.translatedFiles.forEach((innerMap) => {
+        innerMap.forEach((doc, langKey) => {
+          if (doc.docId === docId) {
+            innerMap.set(langKey, { ...doc, ...newValue });
+          }
+        });
+      });
+    }
+  }
+  deleteDocument(docId) {
+    if (this.state.files[docId]) {
+      delete this.state.files[docId];
+    } else {
+      this.state.translatedFiles.forEach((innerMap) => {
+        innerMap.forEach((doc, langKey) => {
+          if (doc.docId === docId) {
+            innerMap.delete(langKey);
+          }
+        });
+      });
+    }
+  }
+  clearFile(name) {
+    if (this.modalController) {
+      this.modalController.state.isReadonly = false;
+    }
+    this.state.inProgressFiles = this.state.inProgressFiles.filter(
+      (c) => c.name !== name
+    );
+  }
+  clearFiles() {
+    if (this.modalController) {
+      this.modalController.state.isReadonly = false;
+    }
+    this.state.inProgressFiles = [];
+    this.state.versioningFile = null;
+    this.state.hiddenFiles = [];
+  }
+  clearState() {
+    if (this.modalController) {
+      this.modalController.state.isReadonly = false;
+    }
+    this.state.selectedDocTypeId = this.getDocTypes().find(
+      (c) => String(c.id) === "1"
+    ) ? "1" : this.getDocTypes()[0]?.id;
+    this.state.inProgressFiles = [];
+    this.state.versioningFile = null;
+  }
+  async checkLockDocument(id, shouldNotifyUnlocked = true) {
+    if (this.props.context.IN_MONITOR) {
+      return false;
+    }
+    const file = this.getDocument(id);
+    if (Number(file.docId) < 0)
+      return true;
+    const result = await ApiaApi.post(
+      this.context,
+      this.getCheckLockDocumentParameters({
+        action: "checkLockDocument",
+        docId: file.docId,
+        ajaxUrl: this.getAjaxUrl(),
+        prefix: this.props.type
+      })
+    );
+    const isLocked = result?.data?.success === "ok";
+    if (!isLocked && result?.data?.usr && result.data.usr !== this.props.context.currentUserLogin) {
+      this.notify({
+        message: `${getLabel("msgDocLockedByUsr", {}, this.props.context).text.split(".")[0]}: ${result.data.usr}.`,
+        type: "warning"
+      });
+      return result.data.usr;
+    }
+    if (!isLocked && shouldNotifyUnlocked && !await this.autoLock())
+      this.notify({
+        message: getLabel("msgDocMustBeLocked", {}, this.props.context).text,
+        type: "warning"
+      });
+    return isLocked;
+  }
+  setCurrentDocTypeId(docTypeId) {
+    this.state.selectedDocTypeId = docTypeId;
+  }
+  async ajaxUploadStart(newFiles = []) {
+    if (this.props.context.IN_MONITOR) {
+      return;
+    }
+    const versioningFile = this.state.versioningFile;
+    const res = await ApiaApi.post(
+      this.context,
+      this.getAjaxUploadStartParameters({
+        action: "ajaxUploadStart",
+        isAjax: true,
+        docId: versioningFile?.docId,
+        prefix: this.props.type,
+        docTypeId: newFiles.length === 1 ? versioningFile?.docTypeId || "1" : "1",
+        newDoc: !versioningFile,
+        useDocTypePermitted: true,
+        docTypePermittedObjType: this.props.type,
+        // docTypePermittedObjId: this.docTypePermittedObjId,  // How do I find this?
+        ajaxUrl: this.getAjaxUrl()
+      })
+    );
+    if (res?.data) {
+      const docTypes = arrayOrArray(res?.data?.function?.docTypes?.docType);
+      const hasGeneric = !!docTypes.find((c) => String(c.id) === "1");
+      this.state.allowedTypes = docTypes;
+      this.state.selectedDocTypeId = hasGeneric ? "1" : docTypes[0].id;
+      if (newFiles.length > 0) {
+        await this.saveDroppedFiles(newFiles);
+      }
+      return res?.data?.function.name === "fncDocumentLoadInformation" ? true : false;
+    } else {
+      throw new Error("No files data");
+    }
+  }
+  async reloadMetadata(props, additionalProps) {
+    if (!this.modalController)
+      return;
+    const res = await ApiaApi.post(
+      this.context,
+      this.getReloadMetadataParameters({
+        ajaxUrl: this.getAjaxUrl(),
+        action: "reloadMetadata",
+        isAjax: true,
+        docId: props?.docId,
+        docTypeId: props?.docTypeId,
+        metadata: this.getConfirmDropModalMetadataString({
+          metadata: this.modalController?.allMetadata
+        }),
+        prefix: this.props.type,
+        ...additionalProps
+      })
+    );
+    if (res?.data && props?.docTypeId) {
+      const isFreeMetadata = this.state.allowedTypes.find(
+        (current) => current.id === props.docTypeId
+      )?.free ?? false;
+      this.modalController.state.metadata.metadataArray = arrayOrArray(
+        res.data.metadata
+      );
+      this.modalController.state.metadata.isFreeMetadata = isFreeMetadata;
+    }
+  }
+  async saveDroppedFiles(unprocessedFiles, conf) {
+    if (this.props.context.IN_MONITOR) {
+      return false;
+    }
+    const {
+      langId,
+      strictMode: isConfStrictMode = false,
+      translatingFile
+    } = conf ?? {};
+    const isStrictMode = isConfStrictMode || !!this.state.versioningFile || !!this.modalController?.state.fromDirectoryFile;
+    const docType = this.getCurrentDocTypeId();
+    if (!isStrictMode && !docType) {
+      this.notify({
+        message: `${getLabel("lblDropFileDeleted", {}, this.props.context).text}: ${unprocessedFiles.map((current) => current.name).join(", ")}.`,
+        type: "warning"
+      });
+      return false;
+    }
+    const allowedFiles = this.filterAlreadyUploadedFiles(
+      this.filterByFilesAmountLimit(
+        this.filterAcceptedFiles(
+          this.filterExistingFiles(
+            this.filterVersioningFiles(unprocessedFiles, conf),
+            conf
+          ),
+          true,
+          docType
+        )
+      ),
+      conf
+    );
+    if (allowedFiles.length > 0) {
+      const formData = new FormData();
+      allowedFiles.forEach(
+        (file) => formData.append("fileRepository", file, file.name)
+      );
+      await ApiaApi.post(
+        this.context,
+        this.getSaveDroppedFilesParameters({
+          action: "saveDroppedFiles",
+          docId: this.state.versioningFile?.docId,
+          ajaxUrl: this.getAjaxUrl(),
+          elemType: this.props.type,
+          elemId: `prmDocumentContainter${this.props.type}`,
+          frmOut: !this.modalController,
+          docTypeId: this.state.selectedDocTypeId,
+          langId
+        }),
+        {
+          postData: formData,
+          axiosConfig: {
+            onUploadProgress: (ev) => this.state.progress = ev.loaded * 100 / ((ev.total ?? ev.loaded) * 2)
+          }
+        }
+      );
+      const ajaxUploadFileStatusParameters = this.getAjaxUploadFileStatusParameters({
+        action: "ajaxUploadFileStatus",
+        ajaxUrl: this.getAjaxUrl(),
+        delayForDrop: true,
+        isAjax: true,
+        prefix: this.props.type
+      });
+      let tries = 0;
+      const checkUploadResult = async () => {
+        return new Promise(async (resolve) => {
+          tries += 1;
+          if (tries === 10) {
+            this.notify({
+              message: "Error while checking for uploadFileStatus, too many tries",
+              type: "error"
+            });
+            resolve(false);
+            return;
+          }
+          const response = await ApiaApi.post(
+            this.context,
+            ajaxUploadFileStatusParameters
+          );
+          if (response && response.data) {
+            const hasMessages = arrayOrArray(
+              response.data?.sysMessages?.message ?? response.data?.sysExceptions?.exception ?? response.data?.exceptions?.exception ?? response.data.function.messages?.message
+            ).length > 0 || !!response.data.function.dropLastMessage;
+            const uploadMessage = arrayOrArray(
+              response.data.function.messages?.message
+            ).find((current) => current.name === "message");
+            if (uploadMessage)
+              this.notify({ message: uploadMessage.label, type: "warning" });
+            const method = response.data?.function.name;
+            this.state.progress = 44;
+            if (hasMessages) {
+              resolve(false);
+              return;
+            }
+            if (method === "fncProceedDocumentProcessing") {
+              resolve(true);
+              return;
+            }
+            if (tries === 10) {
+              resolve(method === "fncProceedDocumentProcessing");
+            }
+            setTimeout(() => {
+              checkUploadResult().then(resolve).catch(() => resolve(false));
+            }, 100);
+          } else {
+            resolve(false);
+          }
+        });
+      };
+      const hasUploadedCorrectly = await checkUploadResult();
+      this.state.progress = 66;
+      if (hasUploadedCorrectly) {
+        const shown = (this.state.inProgressFiles ?? []).map(
+          (file) => file.name
+        );
+        const postData = QueryString.stringify(
+          this.getProcessDroppedFilesPostdata({
+            useDocTypePermitted: true,
+            // docTypePermittedObjId: this.docTypePermittedObjId?.toString(), // How do I get this?
+            docTypePermittedObjType: this.props.type,
+            dropped: allowedFiles.map((file) => file.name).concat(shown),
+            shown
+          }),
+          { arrayFormat: "repeat" }
+        );
+        const secondResult = await ApiaApi.post(
+          this.context,
+          this.getProcessDroppedFilesParameters({
+            action: "processDroppedFiles",
+            elemType: this.props.type,
+            docId: this.state.versioningFile?.docId,
+            frmOut: !this.modalController,
+            ajaxUrl: this.getAjaxUrl()
+          }),
+          {
+            postData: postData.toString()
+          }
+        );
+        this.state.progress = 83;
+        if (secondResult?.data?.function?.principal?.docInfo) {
+          const acceptedByServerFiles = arrayOrArray(
+            secondResult.data.function?.principal?.docInfo
+          );
+          this.state.inProgressFiles = [
+            ...this.state.inProgressFiles ?? [],
+            ...acceptedByServerFiles.map(
+              (current) => [...this.state.inProgressFiles, ...unprocessedFiles].find(
+                (search) => search.name === current.docInfoName
+              )
+            ).filter((current) => !!current)
+          ];
+          this.state.progress = 100;
+          if (this.modalController)
+            this.modalController.state.fromDirectoryFile = null;
+          this.notify({
+            type: "success",
+            message: getLabel(
+              "lblFileUploadedSuccessfully",
+              {},
+              this.props.context
+            ).text
+          });
+          if (this.props.modalConfig.oneClickUpload) {
+            if (langId && translatingFile)
+              void this.confirmDropModal({ langId, translatingFile });
+            else
+              void this.confirmDropModal();
+          }
+        }
+      }
+      this.state.progress = 100;
+      return true;
+    } else {
+      return false;
+    }
+  }
+  async checkWebDavLock(docId) {
+    if (this.props.context.IN_MONITOR) {
+      return false;
+    }
+    return new Promise((resolve) => {
+      let tries = 10;
+      const checkLockAction = async () => {
+        const isLocked = await ApiaApi.post(
+          this.context,
+          this.getCheckWebDavLockParameters({
+            action: "isWebDavDocumentLocked",
+            docId,
+            ajaxUrl: this.props.context.URL_REQUEST_AJAX
+          })
+        );
+        if (isLocked?.data?.locked === true || isLocked?.data?.locked === void 0) {
+          if (--tries > 0) {
+            setTimeout(() => void checkLockAction(), 1e3);
+          } else {
+            this.notify({
+              message: getLabel("msgFailSyncDocument", {}, this.props.context).text
+            });
+            resolve(false);
+          }
+        } else {
+          resolve(true);
+        }
+      };
+      void checkLockAction();
+    });
+  }
+  async checkSignature(file) {
+    let res = null;
+    if (Number(file.docId) >= 0)
+      res = await ApiaApi.get(
+        this.context,
+        this.getCheckSignatureParameters({
+          action: "viewDocSigns",
+          docId: file.docId,
+          lock: false,
+          isAjax: true,
+          prefix: this.props.type,
+          react: true
+        })
+      );
+    return res;
+  }
+  async editDocument(id) {
+    if (this.props.context.IN_MONITOR) {
+      return;
+    }
+    const file = this.getDocument(id);
+    if (await this.checkLockDocument(file.docId) === true) {
+      const result = await ApiaApi.post(
+        this.context,
+        this.getEditDocumentParameters({
+          action: "updateWebDavDocument",
+          docId: file.docId,
+          prefix: this.props.type,
+          isAjax: true
+        })
+      );
+      if (result?.data?.folderId) {
+        const sDocumentUrl = `${this.props.context.WEBDAV_SERVER}${result?.data?.folderId}/${file.docId}/${file.name || file.docName || ""}`;
+        const ProtocolInstallMessage = () => {
+          this.notify({
+            type: "warning",
+            message: getLabel("msgNoDocEditProtocol", {}, this.props.context).text,
+            title: getLabel("lblEdit", {}, this.props.context).text
+          });
+        };
+        this.props.context.ITHit.WebDAV.Client.DavConstants.ProtocolTimeoutMs = 1e4;
+        await this.props.context.ITHit.WebDAV.Client.DocManager.DavProtocolEditDocument(
+          sDocumentUrl,
+          this.props.context.WEBDAV_SERVER,
+          ProtocolInstallMessage,
+          null,
+          "Current",
+          "ApiaWebDavCookie",
+          // Cookie(s) to copy.
+          "",
+          // URL to navigate to if any cookie from the list is not found.
+          "Edit"
+        );
+      }
+    }
+  }
+  async downloadVersion(fileId, version) {
+    const file = this.getDocument(fileId);
+    if (!file)
+      return;
+    if (this.props.context.IN_MONITOR || await this.checkWebDavLock(file.docId))
+      await downloadUrl(
+        ApiaApi.makeUrl(this.context, {
+          action: "downloadDocument",
+          docId: file.downloadDocId,
+          version
+        })
+      );
+  }
+  async downloadDocument(id, version) {
+    const file = this.getDocument(id);
+    if (this.props.context.IN_MONITOR || await this.checkWebDavLock(file.docId)) {
+      await downloadUrl(
+        ApiaApi.makeUrl(this.context, {
+          action: "downloadDocument",
+          prefix: this.props.type,
+          docId: file.downloadDocId,
+          ajaxUrl: this.getAjaxUrl(),
+          version
+        })
+      );
+    }
+  }
+  async ajaxDeleteDocument(id, langId) {
+    const file = this.getDocument(id);
+    const isLocked = await this.checkLockDocument(file.docId);
+    if (isLocked === true) {
+      const result = await ApiaApi.post(
+        this.context,
+        this.getDeleteDocumentParameters({
+          action: "ajaxRemoveDocument",
+          docId: file.docId,
+          isAjax: true,
+          prefix: this.props.type,
+          ajaxUrl: this.getAjaxUrl(),
+          langId
+        })
+      );
+      if (this.evaluateDeleteDocumentResult(result?.data))
+        this.deleteDocument(id);
+    }
+  }
+  async version(file, conf = { newFiles: [] }) {
+    const checkLock = await this.checkLockDocument(file.docId, true);
+    const isLocked = await this.checkWebDavLock(file.docId);
+    if (!(checkLock === true && isLocked))
+      return;
+    this.state.versioningFile = file;
+    const openVersionModal = () => {
+      if (!this.props.modalConfig.oneClickUpload) {
+        this.modalController = this.buildModalController({
+          versionFile: file
+        });
+        this.modalController.openModal();
+      }
+    };
+    if (!conf.newFiles || conf.newFiles.length === 0) {
+      openVersionModal();
+    }
+    await this.ajaxUploadStart();
+    if (file.docTypeId)
+      this.state.selectedDocTypeId = file.docTypeId;
+    await this.versionFileInfo(file);
+    const hasNewFiles = !!(conf.newFiles && conf.newFiles.length > 0);
+    if (hasNewFiles) {
+      const res = await this.saveDroppedFiles(conf.newFiles, {
+        langId: conf.langId,
+        translatingFile: conf.translatingFile,
+        shouldReset: false,
+        strictMode: true
+      });
+      if (res) {
+        openVersionModal();
+      }
+    } else {
+      await this.reloadMetadata({
+        docId: file.docId,
+        docTypeId: file.docTypeId
+      });
+    }
+  }
+  async versionFileInfo(file) {
+    const documentInfo = await this.getDocumentInfo({ docId: file.docId });
+    if (documentInfo?.function) {
+      const {
+        data: { general },
+        metadatas
+      } = documentInfo.function;
+      const isFreeMetadata = this.state.allowedTypes.find((current) => current.id === file.docTypeId)?.free ?? false;
+      if (this.modalController) {
+        this.modalController.state = {
+          description: general.docDesc,
+          docFolder: general.docFolder === "" ? void 0 : Number(general.docFolder),
+          docPath: general.docFolderPath,
+          permissions: {
+            allowAllType: general.docAllPoolPerm,
+            users: arrayOrArray(
+              documentInfo.function.data.permissions?.user
+            ).map((current) => {
+              const returnObject = {
+                canUpdate: current.permType === "M",
+                userId: current.id,
+                userLogin: current.name
+              };
+              return returnObject;
+            }),
+            pools: arrayOrArray(
+              documentInfo.function.data.permissions?.pool
+            ).map((current) => {
+              const returnObject = {
+                canUpdate: current.permType === "M",
+                poolId: current.id,
+                poolName: current.name
+              };
+              return returnObject;
+            })
+          },
+          docExpDate: general.docExpDate,
+          fileReqError: false,
+          fromDirectoryFile: null,
+          metadata: {
+            metadataArray: arrayOrArray(metadatas?.metadata),
+            freeMetadataArray: [],
+            isFreeMetadata
+          }
+        };
+      }
+    }
+  }
+  async pickFileById(id) {
+    const documentInfo = await this.getDocumentInfo(
+      { downloadDocId: id },
+      true
+    );
+    if (documentInfo) {
+      const document = documentInfo.function.data.general;
+      const { permissions } = documentInfo.function.data;
+      if (this.modalController) {
+        this.setCurrentDocTypeId(document.docTypeId);
+        this.modalController.addDirectoryFile(document);
+        this.modalController.state.description = document.docDesc;
+        this.modalController.state.docExpDate = document.docExpDate;
+        this.modalController.state.permissions = {
+          pools: arrayOrArray(permissions?.pool).map((c) => {
+            return {
+              poolId: c.id,
+              poolName: c.name,
+              canUpdate: c.permType === "M"
+            };
+          }),
+          users: [
+            ...arrayOrArray(permissions?.user).map((c) => {
+              return {
+                userId: c.id,
+                userLogin: c.name,
+                canUpdate: c.permType === "M"
+              };
+            })
+          ],
+          allowAllType: document.docAllPoolPerm
+        };
+        this.modalController.changeDocType(document.docTypeId);
+        this.modalController.state.isReadonly = !documentInfo.function.currentUsrPems.usrCanModify;
+      }
+      void this.reloadMetadata(
+        { docId: document.docId, docTypeId: document.docTypeId },
+        {
+          docReuse: true
+        }
+      );
+    }
+  }
+  async markFileToSign(id, langId) {
+    if (this.props.context.IN_MONITOR) {
+      return;
+    }
+    const file = this.getDocument(id);
+    if (await this.checkLockDocument(file.docId) === true) {
+      const marked = await ApiaApi.post(
+        this.context,
+        this.getMarkFileToSignParameters({
+          action: "markDocTosign",
+          docId: file.docId,
+          isAjax: true,
+          prefix: this.props.type,
+          ajaxUrl: this.getAjaxUrl(),
+          langId
+        })
+      );
+      if (marked?.data?.markedToSign !== void 0) {
+        if (this.state.files[id]) {
+          this.state.files[id].markedToSign = marked.data.markedToSign;
+        } else {
+          this.state.translatedFiles.forEach((innerMap) => {
+            innerMap.forEach((doc, langKey) => {
+              if (doc.docId === id) {
+                innerMap.set(langKey, {
+                  ...doc,
+                  markedToSign: marked?.data?.markedToSign ?? false
+                });
+              }
+            });
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Por el momento realiza la descarga de todos los archivos
+   * que estén subidos.
+   */
+  downloadMultipleDocuments() {
+    const files = this.filesArray;
+    if (files.length === 0)
+      return;
+    const docIds = this.state.selectedFiles;
+    const selectedFiles = files.filter(
+      (current) => docIds.find((search) => search === current.docId)
+    );
+    const ids = (selectedFiles.length > 0 ? selectedFiles : files).map((current) => current.downloadDocId).join("-");
+    void downloadUrl(
+      ApiaApi.makeUrl(
+        this.context,
+        this.getDownloadMultipleDocumentsParameters({
+          action: "multipleDownload",
+          docId: ids,
+          prefix: this.props.type
+        })
+      ),
+      "documents.zip"
+    );
+  }
+  async confirmDropModal(conf) {
+    if (this.props.context.IN_MONITOR) {
+      return false;
+    }
+    const { langId, translatingFile } = conf ?? {};
+    const cmbDocType = this.state.selectedDocTypeId;
+    const fromDirectoryFile = this.modalController?.state.fromDirectoryFile;
+    const docDesc = this.modalController?.description ?? "";
+    const docAllowAllType = this.props.modalConfig.oneClickUpload ? "M" : this.modalController?.allowAllType ?? "";
+    const docFolder = this.modalController?.docFolder;
+    const docExpDate = this.modalController?.docExpDate;
+    const metadata = this.modalController?.metadata ?? [];
+    const freeMetadata = this.modalController?.freeMetadata ?? [];
+    const poolsPermissions = this.modalController?.state.permissions.pools ?? [];
+    const usersPermissions = this.modalController?.state.permissions.users ?? [];
+    let postData = QueryString.stringify(
+      this.getConfirmDropModalPostdata({
+        cmbDocType,
+        docDesc,
+        docAllowAllType,
+        // pe: this.docTypePermittedObjId?.toString(), // How do I get this?
+        dropped: this.state.inProgressFiles.map((file) => file.name),
+        txtLangId: langId,
+        txtLangGroup: translatingFile?.docLangGroup,
+        docFolder
+      }),
+      { arrayFormat: "repeat" }
+    );
+    postData = `${postData}${postData.length > 0 ? "&" : ""}${this.getConfirmDropModalPermissionsString({
+      poolsPermissions,
+      usersPermissions
+    })}&txtFreeMetadata=${this.getConfirmDropModalAdditionalMetadataString(
+      freeMetadata
+    )}&txtMetadata=${this.getConfirmDropModalMetadataString({
+      metadata: Object.values(metadata || {})
+    })}&docExpDate=${docExpDate ?? ""}`;
+    const result = await ApiaApi.post(
+      this.context,
+      this.getConfirmDropModalParameters({
+        ajaxUrl: this.getAjaxUrl(),
+        docId: fromDirectoryFile ? fromDirectoryFile.docId : this.state.versioningFile?.docId,
+        action: fromDirectoryFile ? "associateExistingFile" : "confirmDropModal",
+        elemType: this.props.type,
+        fromForm: true,
+        ...fromDirectoryFile ? {
+          docId: fromDirectoryFile.docId,
+          fromReuse: true,
+          uploadDocument: false
+        } : null
+      }),
+      {
+        postData: postData.toString()
+      }
+    );
+    if (result?.data?.function) {
+      const currentFiles = { ...this.state.files };
+      const versioningFile = this.state.versioningFile;
+      if (versioningFile && versioningFile.name) {
+        delete currentFiles[versioningFile.name];
+      }
+      const newFiles = arrayOrArray(
+        result.data.function.general
+      ).map(
+        (current) => this.parseFileDefinition({
+          ...current,
+          canWrite: true,
+          canRead: true,
+          canEdit: true
+        })
+      ).filter((current) => !currentFiles[current.docId]).reduce((acc, current) => ({ ...acc, [current.docId]: current }), {});
+      if (langId && translatingFile) {
+        const firstFile = Object.values(newFiles)[0];
+        this.setTranslationFile(firstFile, translatingFile.docId, langId);
+      } else {
+        this.state.files = { ...currentFiles, ...newFiles };
+      }
+      this.clearFiles();
+      this.emit("fileUploaded", null);
+      return true;
+    }
+    return false;
+  }
+  async loadCurrentDocuments() {
+    const result = await ApiaApi.post(
+      this.context,
+      {
+        ajaxUrl: this.getAjaxUrl(),
+        action: "ajaxLoadCurrent",
+        isAjax: true,
+        readOnly: this.props.context.readonly,
+        allowLock: true,
+        allowSign: true,
+        allowMultiple: true,
+        prefix: this.props.type
+      },
+      {}
+    );
+    if (result && result.data) {
+      const currentConfiguration = arrayOrArray(result.data.function.messages.message).reduce(
+        (prev, { name, label }) => ({ ...prev, [name]: Boolean(label) }),
+        {}
+      );
+      const currentFiles = result.data.function.general ? arrayOrArray(result.data.function.general).map(
+        this.parseFileDefinition
+      ) : [];
+      this.currentConfiguration = currentConfiguration;
+      const nonTranslationFiles = [];
+      const translationFiles = [];
+      currentFiles.forEach((current) => {
+        if (current.docLang === void 0)
+          nonTranslationFiles.push(current);
+        else
+          translationFiles.push(current);
+      });
+      nonTranslationFiles.forEach((c) => {
+        this.state.files[c.docId] = c;
+      });
+      translationFiles.forEach((current) => {
+        const originalFile = nonTranslationFiles.find(
+          (search) => search.docLangGroup === current.docLangGroup
+        );
+        if (originalFile && current.docLang !== void 0) {
+          this.setTranslationFile(
+            current,
+            originalFile.docId,
+            Number(current.docLang)
+          );
+        } else
+          console.warn(
+            `The following file is translated but has no orignal file`,
+            current,
+            nonTranslationFiles
+          );
+      });
+    }
+  }
+  async lockDocument(id) {
+    if (this.props.context.IN_MONITOR) {
+      return;
+    }
+    const file = this.getDocument(id);
+    if (file.markedToSign) {
+      this.notify({
+        message: getLabel("lblCantUnlockMarkedToSign", {}, this.props.context).text,
+        type: "warning"
+      });
+      return;
+    }
+    if (!file.isLocked || !file.isLockedByMe) {
+      const isLocked = await this.checkLockDocument(file.docId, false);
+      this.updateDocument(
+        id,
+        typeof isLocked === "string" ? this.parseFileDefinition({
+          ...file,
+          userLocking: isLocked,
+          lock: true,
+          isLocked: true,
+          lockedBy: isLocked
+        }) : { ...file, isLocked }
+      );
+    }
+    const result = await ApiaApi.post(
+      this.context,
+      this.getLockDocumentParameters({
+        action: "lockDocument",
+        ajaxUrl: this.getAjaxUrl(),
+        docId: file.docId,
+        lock: file.isLocked || file.locked,
+        isAjax: true,
+        prefix: this.props.type
+      })
+    );
+    if (result?.data) {
+      const resultFile = result.data.function?.data?.general;
+      if (resultFile)
+        this.updateDocument(
+          resultFile.docId,
+          this.parseFileDefinition({
+            ...file,
+            ...resultFile,
+            isLocked: resultFile.locked
+          })
+        );
+    }
+  }
+  evaluateDeleteDocumentResult(result) {
+    return result?.function?.name === "fncDocumentRemove";
+  }
+  setTranslationFile(file, docId, langId) {
+    if (!this.state.translatedFiles.has(docId)) {
+      this.state.translatedFiles.set(docId, /* @__PURE__ */ new Map());
+    }
+    this.state.translatedFiles.get(docId)?.set(langId, file);
+  }
+  filterAlreadyUploadedFiles(files, conf) {
+    const versioningFile = this.state.versioningFile;
+    if (versioningFile)
+      return files;
+    const uploadedFiles = Object.values(this.state.files).filter(
+      (file) => Number(file.docId) > 0
+    );
+    const existingFiles = [];
+    const nonExistingFiles = [];
+    if (conf?.langId) {
+      const docId = conf.translatingFile?.docId ?? Infinity;
+      const translationsMap = this.state.translatedFiles.get(String(docId));
+      const alreadyUploadedToTranslationsFile = translationsMap ? Array.from(translationsMap.values()).find(
+        (current) => (current.docName || current.name) === files[0]?.name
+      ) : void 0;
+      if (alreadyUploadedToTranslationsFile)
+        existingFiles.push(files[0]);
+    } else
+      files.forEach((file) => {
+        if (uploadedFiles.find((search) => search.docName === file.name)) {
+          existingFiles.push(file);
+        } else
+          nonExistingFiles.push(file);
+      });
+    if (existingFiles.length > 0) {
+      void this.notify({
+        message: `${getLabel("lblDropFileRepeated", {}, this.props.context).text}: ${existingFiles.map((current) => current.name).join(", ")}`,
+        type: "warning"
+      });
+      return nonExistingFiles;
+    }
+    return files;
+  }
+  filterByFilesAmountLimit(files) {
+    return files.slice(
+      0,
+      addBoundary(this.maxFiles - (this.state.inProgressFiles?.length ?? 0), 0)
+    );
+  }
+  filterAcceptedFiles(files, shouldNotify = true, docTypeId) {
+    const docTypes = docTypeId !== void 0 ? this.state.allowedTypes.filter((c) => {
+      return typeof docTypeId === "string" ? c.id === docTypeId : c.id === docTypeId.id;
+    }) : this.state.allowedTypes;
+    if (!docTypes.find((c) => c.docExts === "")) {
+      const notAllowedFilesBecauseOfExtension = [];
+      const notAllowedFilesBecauseOfSize = [];
+      let maxSize = Infinity;
+      const allowedFiles = files.filter((currentFile) => {
+        const extension = (currentFile.name.match(/\.(\w+)$/) ?? [])[1];
+        let isAllowed = true;
+        if (!docTypes.find((currentDocType) => {
+          if (!currentDocType.docExts.split(";").map((current) => current.toLowerCase()).includes(extension.toLowerCase())) {
+            return false;
+          }
+          return true;
+        })) {
+          isAllowed = false;
+          notAllowedFilesBecauseOfExtension.push(currentFile);
+        }
+        if (isAllowed && !docTypes.find((currentDocType) => {
+          if (Number(currentDocType.maxSize) < currentFile.size) {
+            maxSize = Number(currentDocType.maxSize);
+            return false;
+          }
+          return true;
+        })) {
+          notAllowedFilesBecauseOfSize.push(currentFile);
+          isAllowed = false;
+        }
+        if (!isAllowed)
+          return false;
+        return true;
+      });
+      if (shouldNotify) {
+        let errorMessage = "";
+        if (notAllowedFilesBecauseOfExtension.length > 0) {
+          const filesNames = notAllowedFilesBecauseOfExtension.reduce(
+            (accumulated, current) => {
+              if (accumulated.length === 0)
+                return current.name;
+              return `${accumulated}, ${current.name}`;
+            },
+            ""
+          );
+          errorMessage = `<strong>${getLabel("lblFilesWrongExt", {}, this.props.context).text}</strong><br />${filesNames}`;
+        }
+        if (notAllowedFilesBecauseOfSize.length > 0) {
+          const filesNames = notAllowedFilesBecauseOfSize.reduce(
+            (accumulated, current) => {
+              if (accumulated.length === 0)
+                return current.name;
+              return `${accumulated}, ${current.name}`;
+            },
+            ""
+          );
+          if (errorMessage.length > 0)
+            errorMessage = `${errorMessage} <br /><br />`;
+          errorMessage = `${errorMessage}${formatMessage(
+            getLabel("lblFilesTooBig", {}, this.props.context).text,
+            {
+              TOK1: `<br />${filesNames}`,
+              TOK2: `${parseAsSize(maxSize)}`
+            }
+          )}`;
+        }
+        if (errorMessage.length > 0)
+          this.notify({
+            message: errorMessage,
+            type: "warning"
+          });
+      }
+      return allowedFiles;
+    }
+    return files;
+  }
+  filterExistingFiles(files, conf) {
+    if (conf?.langId)
+      return files;
+    const currentFiles = this.state.inProgressFiles;
+    const alreadyUploadedFiles = Object.values(this.state.files).filter(
+      (current) => Number(current.docId) < 0
+    );
+    let alreadyIncludedFileNames = "";
+    const filteredFiles = files.filter((current) => {
+      const isIncluded = currentFiles.findIndex((search) => search.name === current.name) !== -1 || alreadyUploadedFiles.findIndex(
+        (search) => search.docName === current.name
+      ) !== -1;
+      if (isIncluded)
+        alreadyIncludedFileNames = `${alreadyIncludedFileNames}${alreadyIncludedFileNames.length > 0 ? ", " : ""}${current.name}`;
+      return !isIncluded;
+    });
+    if (alreadyIncludedFileNames.length > 0)
+      this.notify({
+        message: `${getLabel("lblDropFileRepeated", {}, this.props.context).text}: ${alreadyIncludedFileNames}`,
+        type: "warning"
+      });
+    return filteredFiles;
+  }
+  filterVersioningFiles(files, conf) {
+    const versioningFile = this.state.versioningFile;
+    if (versioningFile) {
+      const newFiles = files.filter(
+        (current) => current.name === versioningFile.docName || current.name === versioningFile.name
+      );
+      if (newFiles.length === 0) {
+        this.notify({
+          type: "warning",
+          message: getLabel("lblDropFileNamesNotMatch", {}, this.props.context).text
+        });
+      }
+      return newFiles;
+    }
+    return files;
+  }
+  getLoadFileSystemStructureTree() {
+    return {
+      useDocTypePermitted: true,
+      // docTypePermittedObjId: this.docTypePermittedObjId, // Get by inheritance
+      docTypePermittedObjType: this.props.type
+    };
+  }
+  getLoadFilesForFolderParameters() {
+    return {
+      useDocTypePermitted: true,
+      // docTypePermittedObjId: this.docTypePermittedObjId, // Get by inheritance
+      docTypePermittedObjType: this.props.type
+    };
+  }
+}
+
+export { UploaderApi, UploaderModalController, parseFileDefinition, returnExactlyTheSame };
+//# sourceMappingURL=index.js.map