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

DNB Eufemia Design System UI Library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BYTES_IN_A_MEGA_BYTE = void 0;
exports.extendWithAbbreviation = extendWithAbbreviation;
exports.getAcceptedFileTypes = getAcceptedFileTypes;
exports.getFileTypeFromExtension = getFileTypeFromExtension;
exports.hasPreferredMimeType = hasPreferredMimeType;
exports.isArrayOfObjects = isArrayOfObjects;
exports.isArrayOfStrings = isArrayOfStrings;
exports.verifyFiles = verifyFiles;
var _includes = _interopRequireDefault(require("core-js-pure/stable/instance/includes.js"));
var _push = _interopRequireDefault(require("core-js-pure/stable/instance/push.js"));
var _NumberUtils = require("../number-format/NumberUtils.js");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const BYTES_IN_A_MEGA_BYTE = exports.BYTES_IN_A_MEGA_BYTE = 1048576;
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', (0, _NumberUtils.formatNumber)(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 => {
        return item?.fileType?.toLowerCase() === fileType?.toLowerCase();
      });
      return validateFileSize(file.size, 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 _context;
      return ((_context = fileType?.toLowerCase()) == null ? void 0 : Function.call.bind((0, _includes.default)(_context), _context))?.(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;
}
function getFileTypeFromExtension(file) {
  var _context2;
  if (!file || !file.name) {
    return null;
  }
  return (0, _includes.default)(_context2 = file.name).call(_context2, '.') && file.name.replace(/.*\.([^.]+)$/, '$1') || null;
}
function getAcceptedFileTypes(acceptedFileTypes) {
  return extendWithAbbreviation(getAcceptedFileTypesAsListOfStrings(acceptedFileTypes)).map(type => (0, _includes.default)(type).call(type, '/') ? type : `.${type}`).join(',');
}
function hasPreferredMimeType(acceptedFileTypes, file) {
  return file.type.split('/')[1] && (!acceptedFileTypes?.length || acceptedFileTypes?.some(type => type.toLowerCase() === file.type.toLowerCase()));
}
function getAcceptedFileTypesAsListOfStrings(acceptedFileTypes) {
  return isArrayOfStrings(acceptedFileTypes) ? acceptedFileTypes : acceptedFileTypes.map(obj => obj.fileType);
}
function isArrayOfStrings(arr) {
  return Array.isArray(arr) && arr.length > 0 && arr.every(i => typeof i === 'string');
}
function isArrayOfObjects(arr) {
  return Array.isArray(arr) && arr.length > 0 && arr.every(i => typeof i === 'object');
}
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)) {
      (0, _push.default)(list).call(list, abbr);
      listSet.add(abbr);
    }
  });
  return list;
}
//# sourceMappingURL=UploadVerify.js.map