@dnb/eufemia/components/upload/UploadVerify.js

DNB Eufemia Design System UI Library

import _pushInstanceProperty from "core-js-pure/stable/instance/push.js";
import { format } from "../number-format/NumberUtils.js";
export const BYTES_IN_A_MEGA_BYTE = 1048576;
export function verifyFiles(files, context) {
  const {
    fileMaxSize,
    acceptedFileTypes,
    errorLargeFile,
    errorUnsupportedFile
  } = context;
  const getFileType = (file, listOfAcceptedFilesTypes) => {
    return hasPreferredMimeType(listOfAcceptedFilesTypes, file) ? file.type : getFileTypeFromExtension(file) || file.type;
  };
  const handleSize = file => {
    const validateFileSize = (fileSize, maxFileSize) => {
      if (maxFileSize && fileSize / BYTES_IN_A_MEGA_BYTE > maxFileSize) {
        return String(errorLargeFile).replace('%size', format(maxFileSize).toString());
      }
      return null;
    };
    if (isArrayOfStrings(acceptedFileTypes) || acceptedFileTypes.length === 0 || !acceptedFileTypes) {
      return validateFileSize(file.size, fileMaxSize);
    } else if (isArrayOfObjects(acceptedFileTypes)) {
      const fileType = getFileType(file, getAcceptedFileTypesAsListOfStrings(acceptedFileTypes));
      const acceptedFileTypeObj = acceptedFileTypes.find(item => {
        var _item$fileType;
        return (item === null || item === void 0 || (_item$fileType = item.fileType) === null || _item$fileType === void 0 ? void 0 : _item$fileType.toLowerCase()) === (fileType === null || fileType === void 0 ? void 0 : fileType.toLowerCase());
      });
      return validateFileSize(file.size, (acceptedFileTypeObj === null || acceptedFileTypeObj === void 0 ? void 0 : acceptedFileTypeObj.fileMaxSize) !== undefined ? acceptedFileTypeObj.fileMaxSize : fileMaxSize);
    }
    return null;
  };
  const handleType = file => {
    if (acceptedFileTypes.length === 0) {
      return false;
    }
    const listOfAcceptedFilesTypes = getAcceptedFileTypesAsListOfStrings(acceptedFileTypes);
    const fileType = getFileType(file, listOfAcceptedFilesTypes);
    const foundType = extendWithAbbreviation(listOfAcceptedFilesTypes).some(type => {
      var _fileType$toLowerCase;
      return fileType === null || fileType === void 0 || (_fileType$toLowerCase = fileType.toLowerCase()) === null || _fileType$toLowerCase === void 0 ? void 0 : _fileType$toLowerCase.includes(type.toLowerCase());
    });
    return !foundType ? errorUnsupportedFile : null;
  };
  const cleanedFiles = files.map(item => {
    const {
      file
    } = item;
    const errorMessage = handleSize(file) || handleType(file);
    if (errorMessage) {
      item.errorMessage = errorMessage;
    }
    return item;
  });
  return cleanedFiles;
}
export function getFileTypeFromExtension(file) {
  if (!file || !file.name) {
    return null;
  }
  return file.name.includes('.') && file.name.replace(/.*\.([^.]+)$/, '$1') || null;
}
export function getAcceptedFileTypes(acceptedFileTypes) {
  return extendWithAbbreviation(getAcceptedFileTypesAsListOfStrings(acceptedFileTypes)).map(type => type.includes('/') ? type : `.${type}`).join(',');
}
export function hasPreferredMimeType(acceptedFileTypes, file) {
  return file.type.split('/')[1] && (!(acceptedFileTypes !== null && acceptedFileTypes !== void 0 && acceptedFileTypes.length) || (acceptedFileTypes === null || acceptedFileTypes === void 0 ? void 0 : acceptedFileTypes.some(type => type.toLowerCase() === file.type.toLowerCase())));
}
function getAcceptedFileTypesAsListOfStrings(acceptedFileTypes) {
  return isArrayOfStrings(acceptedFileTypes) ? acceptedFileTypes : acceptedFileTypes.map(obj => obj.fileType);
}
export function isArrayOfStrings(arr) {
  return Array.isArray(arr) && arr.length > 0 && arr.every(i => typeof i === 'string');
}
export function isArrayOfObjects(arr) {
  return Array.isArray(arr) && arr.length > 0 && arr.every(i => typeof i === 'object');
}
export function extendWithAbbreviation(acceptedFileTypes, abbreviations = {
  jpg: 'jpeg'
}) {
  const list = [...acceptedFileTypes];
  const listSet = new Set(list);
  Object.entries(abbreviations).forEach(([type, abbr]) => {
    if (listSet.has(type) && !listSet.has(abbr)) {
      _pushInstanceProperty(list).call(list, abbr);
      listSet.add(abbr);
    }
  });
  return list;
}
//# sourceMappingURL=UploadVerify.js.map