@adyen/kyc-components 4.0.0-compact.0 → 4.0.0

package/dist/validate-CvtamBXH.js

@@ -1,605 +0,0 @@
-;
-{
-  try {
-    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f5f09dbf-2bc2-4298-82ce-e58841d36af0", e._sentryDebugIdIdentifier = "sentry-dbid-f5f09dbf-2bc2-4298-82ce-e58841d36af0");
-  } catch (e) {
-  }
-}
-;
-import { e as TrustedFieldsProviders } from "./fieldConfigurations-B8bDFQ53.js";
-import { N as createLogger, bu as businessDetailsApiKeyMapping, a$ as individualApiKeyMapping, aE as remediationHasFileUploadField, bv as dataMissingRemediationsToFieldsMap, aD as keysOf, k as httpPost, aB as httpDelete, o as httpGet, bw as StateContext, a as useTranslation, U as useAnalyticsContext, V as Icon, x as Typography, P as IconButton } from "./StoreProvider-BlaJzXSZ.js";
-import { g as getLocalizedIdDocumentTypeOptions } from "./utils-CXtNbmpA.js";
-import { jsx, jsxs } from "preact/jsx-runtime";
-import cx from "classnames";
-import { useEffect } from "preact/hooks";
-const linkedFieldsMap = {
-  "additionalInformation.vatNumber": "additionalInformation.exemptedFromVat",
-  "additionalInformation.exemptedFromVat": "additionalInformation.vatNumber",
-  "additionalInformation.vatAbsenceReason": "additionalInformation.vatNumber"
-};
-function calculateLinkedRequiredFields(field, formId, customRules) {
-  const tldsField = makeTLDSFieldName(formId, field);
-  const linkedField = linkedFieldsMap[tldsField];
-  if (!linkedField)
-    return {
-      isRequiredFromLinkedField: false,
-      isOptionalFromLinkedField: false
-    };
-  switch (field) {
-    case "vatNumber": {
-      const processedRule = customRules.countryUsesVat();
-      return {
-        isRequiredFromLinkedField: processedRule === "REQUIRED",
-        isOptionalFromLinkedField: processedRule === "OPTIONAL"
-      };
-    }
-    case "exemptedFromVat": {
-      const processedRule = customRules.isVatExempt();
-      return {
-        isRequiredFromLinkedField: processedRule === "REQUIRED",
-        isOptionalFromLinkedField: processedRule === "OPTIONAL"
-      };
-    }
-    case "vatAbsenceReason": {
-      const processedRule = customRules.isVatExempt();
-      return {
-        isRequiredFromLinkedField: processedRule === "REQUIRED",
-        isOptionalFromLinkedField: processedRule === "OPTIONAL"
-      };
-    }
-    default:
-      return {
-        isRequiredFromLinkedField: false,
-        isOptionalFromLinkedField: false
-      };
-  }
-}
-const logger$1 = createLogger();
-const composePerScenarioFormConfigurations = (scenarios = [], configurations) => scenarios.reduce(
-  (composedConfiguration, scenarioName) => ({
-    ...composedConfiguration,
-    ...configurations[scenarioName]
-  }),
-  {}
-);
-const augmentWithCountryConfigs = (countrySpecificConfig, baseFormConfig) => {
-  if (!countrySpecificConfig) return baseFormConfig;
-  return keysOf(countrySpecificConfig).reduce(
-    (mergedConfig, field) => ({
-      ...mergedConfig,
-      [field]: {
-        ...baseFormConfig[field],
-        ...countrySpecificConfig[field]
-      }
-    }),
-    baseFormConfig
-  );
-};
-const evaluateRules = (fieldSettings, customRules) => {
-  const ruleNames = [fieldSettings.rule, ...fieldSettings.rules ?? []].filter(
-    Boolean
-  );
-  const rules = ruleNames.map((ruleName) => {
-    switch (ruleName) {
-      case "REQUIRED":
-        return () => "REQUIRED";
-      case "OPTIONAL":
-        return () => "OPTIONAL";
-      default: {
-        const ruleFn = customRules[ruleName];
-        if (!ruleFn) {
-          logger$1.error(`Rule with name '${ruleName}' is not defined`);
-          return () => void 0;
-        }
-        return ruleFn;
-      }
-    }
-  });
-  return rules.map((rule) => rule());
-};
-const isFieldRequired = (fieldSettings, customRules) => {
-  return evaluateRules(fieldSettings, customRules).every((result) => result === "REQUIRED");
-};
-const isFieldOptional = (fieldSettings, customRules) => {
-  return evaluateRules(fieldSettings, customRules).every((result) => result === "OPTIONAL");
-};
-function getPropsFromConfigurations({
-  scenarioConfiguration,
-  forms,
-  remediationActions,
-  dataMissingErrors,
-  fieldsWithExistingData,
-  // TODO can type more strictly as `MappingKey<FormSchema>`
-  customRules,
-  legalEntityType,
-  legalEntityTrustedFields,
-  remediationFieldAsOptional = false
-}) {
-  const requiredFields = {};
-  const optionalFields = {};
-  const allFields = {};
-  const obscuredFields = {};
-  const trustedFields = {};
-  if (!scenarioConfiguration) {
-    return;
-  }
-  const readonly = ["legalFormDescription"];
-  const trustedFieldMappings = legalEntityTrustedFields?.reduce((acc, trusted) => {
-    switch (trusted.provider) {
-      case TrustedFieldsProviders.KOMPANY: {
-        if (legalEntityType === "organization") {
-          return [
-            ...acc,
-            ...trusted.fields.map(
-              (tf) => businessDetailsApiKeyMapping[tf]
-            )
-          ];
-        }
-        return acc;
-      }
-      case TrustedFieldsProviders.SINGPASS: {
-        if (legalEntityType === "organization") {
-          const orgFields = trusted.fields.filter(
-            (field) => field.split(".")[0] === "organization"
-          );
-          return [
-            ...acc,
-            ...orgFields.map(
-              (tf) => businessDetailsApiKeyMapping[tf]
-            )
-          ];
-        }
-        if (legalEntityType === "individual") {
-          const individualFields = trusted.fields.filter(
-            (field) => field.split(".")[0] === "individual"
-          );
-          return [
-            ...acc,
-            ...individualFields.map(
-              (tf) => individualApiKeyMapping[tf]
-            )
-          ];
-        }
-        return acc;
-      }
-      default:
-        return acc;
-    }
-  }, []);
-  Object.entries(forms).forEach(([_formId, formDetails]) => {
-    const formId = _formId;
-    const formFieldsWithExistingData = fieldsWithExistingData.filter((field) => field.startsWith(formId)).map((field) => field.slice(field.lastIndexOf(".") + 1));
-    if (trustedFieldMappings) {
-      trustedFields[formId] = getFormTrustedFields(formId, trustedFieldMappings);
-    }
-    formDetails.fields?.forEach((_field) => {
-      const field = _field;
-      const fieldSettings = scenarioConfiguration[field];
-      const isRequiredFromFieldConfig = fieldSettings && isFieldRequired(fieldSettings, customRules);
-      const isOptionalFromFieldConfig = fieldSettings && isFieldOptional(fieldSettings, customRules);
-      const isFieldRequiredByRemediationAction = showRemediationField(field, remediationActions);
-      const isFieldNeededToRemediateDataMissingError = isFieldRequiredToRemediateDataMissingError(
-        formId,
-        field,
-        dataMissingErrors
-      );
-      const isRequiredByRemediationAction = !remediationFieldAsOptional && isFieldRequiredByRemediationAction;
-      const isOptionalByRemediationAction = remediationFieldAsOptional && isFieldRequiredByRemediationAction;
-      const isRequiredFieldPopulated = !isOptionalFromFieldConfig && formFieldsWithExistingData.includes(field);
-      const { isRequiredFromLinkedField, isOptionalFromLinkedField } = calculateLinkedRequiredFields(field, formId, customRules);
-      const isRequired = (isRequiredFromFieldConfig || isRequiredByRemediationAction || isFieldNeededToRemediateDataMissingError || isRequiredFieldPopulated || isRequiredFromLinkedField) && !isOptionalFromLinkedField;
-      if (isRequired && !readonly.includes(field)) {
-        requiredFields[formId] = requiredFields[formId] ? [...requiredFields[formId], field] : [field];
-        allFields[formId] = allFields[formId] ? [...allFields[formId], field] : [field];
-      }
-      const isOptional = !isRequired && (isOptionalFromFieldConfig || isOptionalByRemediationAction || isOptionalFromLinkedField);
-      if (isOptional) {
-        optionalFields[formId] = optionalFields[formId] ? [...optionalFields[formId], field] : [field];
-        allFields[formId] = allFields[formId] ? [...allFields[formId], field] : [field];
-      }
-      if (fieldSettings?.obscured) {
-        obscuredFields[formId] = obscuredFields[formId] ? [...obscuredFields[formId], field] : [field];
-      }
-    });
-  });
-  return {
-    requiredFields,
-    optionalFields,
-    allFields,
-    obscuredFields,
-    trustedFields
-  };
-}
-const showRemediationField = (field, remediationActions) => remediationActions.some(
-  (rem) => rem.fields?.includes(field) && remediationHasFileUploadField(rem)
-);
-const makeTLDSFieldName = (formId, fieldName) => {
-  if (fieldName === "proofOfOrganizationTaxInfo") {
-    return `${formId}.taxDocument`;
-  }
-  return `${formId}.${fieldName}`;
-};
-const isFieldRequiredToRemediateDataMissingError = (formId, field, dataMissingErrors) => {
-  const dataMissingRemediations = dataMissingErrors.flatMap((error) => error.remediatingActions).filter(
-    (remediatingAction) => !!remediatingAction && remediatingAction.code in dataMissingRemediationsToFieldsMap
-  );
-  const missingFields = dataMissingRemediations.flatMap((remediatingAction) => dataMissingRemediationsToFieldsMap[remediatingAction.code]).filter((missingField) => Boolean(missingField)).map((missingField) => makeTLDSFieldName(formId, missingField));
-  return missingFields.includes(makeTLDSFieldName(formId, field));
-};
-const getFormTrustedFields = (formId, trustedFields) => trustedFields.filter((field) => field.split(".")[0] === formId).map(
-  (field) => field.split(".").filter((item) => formId !== item).join(".")
-);
-const createDocument = async (context, document, ownerId) => {
-  const { baseUrl, rootLegalEntityId } = context;
-  return httpPost(
-    {
-      baseUrl,
-      path: `legalEntities/${rootLegalEntityId}/documents/${ownerId}`
-    },
-    document
-  );
-};
-const deleteDocument$1 = async (context, documentId) => {
-  const { baseUrl, rootLegalEntityId } = context;
-  return httpDelete({
-    baseUrl,
-    path: `legalEntities/${rootLegalEntityId}/documents/${documentId}/`
-  });
-};
-const getDocument$1 = async (context, documentId) => {
-  const { baseUrl, rootLegalEntityId } = context;
-  return httpGet({
-    baseUrl,
-    path: `legalEntities/${rootLegalEntityId}/documents/${documentId}`
-  });
-};
-const updateDocument = async (context, document, documentId, ownerId) => {
-  const { baseUrl, rootLegalEntityId } = context;
-  return httpPost(
-    {
-      baseUrl,
-      path: `legalEntities/${rootLegalEntityId}/documents/${documentId}/${ownerId}`
-    },
-    document
-  );
-};
-const isExistingFile = (file) => "existing" in file && file.existing;
-const isNewlyUploadedFile = (file) => !isExistingFile(file);
-const logger = createLogger();
-const documentStore = {};
-const idDocumentTypeOptions = getLocalizedIdDocumentTypeOptions();
-const idTypes = idDocumentTypeOptions.map((types) => types.id);
-let getDocumentService;
-let updateDocumentService;
-let createDocumentService;
-let deleteDocumentService;
-const documentApiUtils = (context) => {
-  if (!getDocumentService || !updateDocumentService || !createDocumentService || !deleteDocumentService) {
-    getDocumentService = (documentId) => getDocument$1(context, documentId);
-    updateDocumentService = (document, documentId, ownerId) => updateDocument(context, document, documentId, ownerId);
-    createDocumentService = (document, ownerId) => createDocument(context, document, ownerId);
-    if (deleteDocument$1) {
-      deleteDocumentService = (documentId) => deleteDocument$1(context, documentId);
-    }
-  }
-  return {
-    fetchDocuments,
-    fetchDocument,
-    uploadDocuments,
-    deleteDocument
-  };
-};
-const fetchDocuments = async (documentDetails, entityId) => {
-  if (documentDetails.length === 0) return [];
-  const documentPromises = [];
-  documentDetails.forEach((documentDetail) => {
-    documentPromises.push(fetchDocument(documentDetail));
-  });
-  const entityDocuments = await Promise.all(documentPromises);
-  documentStore[entityId] = [];
-  entityDocuments.forEach((document) => {
-    const id = document.owner?.id;
-    if (id) {
-      documentStore[id].push(document);
-    } else {
-      logger.error("Document has no `owner.id`", document);
-    }
-  });
-  return documentStore[entityId];
-};
-const fetchDocument = async (documentDetail) => {
-  const document = await getDocumentService(documentDetail.id);
-  return {
-    ...document,
-    modificationDate: documentDetail.modificationDate
-  };
-};
-const deleteDocument = async (documentId) => deleteDocumentService(documentId);
-const uploadDocuments = async (documents, entityId) => {
-  const uploadPromises = [];
-  documents.forEach((document) => {
-    const existingDocument = getDocument(entityId, document.type);
-    if (existingDocument) {
-      if (hasDocumentChanged(document, entityId)) {
-        uploadPromises.push(updateDocumentService(document, existingDocument.id, entityId));
-      }
-    } else {
-      uploadPromises.push(createDocumentService(document, entityId));
-    }
-  });
-  const uploadedDocuments = await Promise.all(uploadPromises);
-  updateEntityDocuments(uploadedDocuments, entityId);
-  return documentStore[entityId];
-};
-const updateEntityDocuments = (uploadedDocuments, entityId) => {
-  if (!documentStore[entityId]) documentStore[entityId] = [];
-  uploadedDocuments.map(
-    (doc) => ({
-      ...doc,
-      modificationDate: (/* @__PURE__ */ new Date()).toISOString()
-    })
-  ).forEach((uploadedDocument) => {
-    const existingDocumentIndex = documentStore[entityId].findIndex(
-      (document) => document.id === uploadedDocument.id
-    );
-    if (existingDocumentIndex > -1) {
-      documentStore[entityId][existingDocumentIndex] = uploadedDocument;
-    } else {
-      documentStore[entityId].push(uploadedDocument);
-    }
-  });
-};
-const getDocument = (entityId, documentType) => {
-  if (!entityId) {
-    return;
-  }
-  return documentStore[entityId]?.find((document) => document.type === documentType);
-};
-const getIdDocument = (entityId) => documentStore[entityId]?.find((document) => idTypes.includes(document.type));
-const createDocumentRequest = async ({
-  entityId,
-  entityType,
-  documentType,
-  page1,
-  page2,
-  description,
-  existingDocument
-}) => {
-  const pagesToUpload = [page1, page2].filter(
-    (page) => page !== void 0 && isNewlyUploadedFile(page)
-  );
-  const [page1ToUpload, page2ToUpload] = pagesToUpload;
-  const [encodedPage1, encodedPage2] = await Promise.all(pagesToUpload.map(fileToBase64));
-  if (!encodedPage1) {
-    if (existingDocument && existingDocument.description !== description) {
-      return {
-        owner: {
-          id: entityId,
-          type: entityType
-        },
-        type: documentType,
-        description: description || `Document type: ${documentType}`
-      };
-    }
-    return;
-  }
-  return {
-    owner: {
-      id: entityId,
-      type: entityType
-    },
-    type: documentType,
-    description: description || `Document type: ${documentType}`,
-    attachments: page1ToUpload && page2ToUpload && encodedPage1 && encodedPage2 ? [
-      createAttachment(encodedPage1, page1ToUpload.name, "front"),
-      createAttachment(encodedPage2, page2ToUpload.name, "back")
-    ] : [createAttachment(encodedPage1, page1ToUpload.name)]
-  };
-};
-const createAttachment = (content, pageName, pageType) => ({
-  content,
-  pageName,
-  ...pageType && { pageType }
-});
-const hasDocumentChanged = (newDocument, entityId) => {
-  const existingDocument = getDocument(entityId, newDocument.type);
-  if (existingDocument) {
-    return existingDocument.attachments.some(
-      (attachment, index) => attachment.content !== newDocument?.attachments?.[index]?.content
-    ) || existingDocument.description !== newDocument?.description;
-  }
-  return true;
-};
-const fileToBase64 = (file) => new Promise((resolve, reject) => {
-  const reader = new FileReader();
-  reader.readAsDataURL(file);
-  reader.onload = () => {
-    const base64String = reader.result.toString().split(";base64,")[1];
-    resolve(base64String);
-  };
-  reader.onerror = (error) => reject(error);
-});
-const getFileExtention = (fileName) => fileName.split(".").pop();
-const mergeAttachments = (existing, incoming) => {
-  if (!existing?.length) return incoming;
-  if (!incoming?.length) return existing;
-  const incomingFileTypes = incoming.map((attachment) => attachment.pageType);
-  const filteredExisting = existing.filter(
-    (attachment) => !incomingFileTypes.includes(attachment.pageType)
-  );
-  return [...filteredExisting, ...incoming];
-};
-function StateContextSetter({ stateRef }) {
-  if (stateRef.current.setState) {
-    return null;
-  }
-  return /* @__PURE__ */ jsx(StateContext.Consumer, { children: (stateContextValue) => {
-    if (process.env.NODE_ENV === "development" && !stateContextValue) {
-      throw new Error("<StateContextSetter> needs to be mounted inside a <StateProvider>");
-    }
-    const { dispatch, setActiveForms } = stateContextValue;
-    stateRef.current.setState = dispatch;
-    stateRef.current.setActiveForms = setActiveForms;
-    return null;
-  } });
-}
-function bytesToSize(bytes) {
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-  if (bytes === 0) return "n/a";
-  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)).toString());
-  if (i === 0) return `${bytes} ${sizes[i]}`;
-  return `${(bytes / 1024 ** i).toFixed()} ${sizes[i]}`;
-}
-function DropzoneFile(props) {
-  const { file, errorMessage, onDelete } = props;
-  const { t } = useTranslation("common");
-  const userEvents = useAnalyticsContext();
-  let documentIcon;
-  const formatSize = (bytes) => {
-    const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-    if (!bytes || bytes === 0) return "n/a";
-    const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)).toString());
-    if (i === 0) return `${bytes} ${sizes[i]}`;
-    return `${(bytes / 1024 ** i).toFixed(1)} ${sizes[i]}`;
-  };
-  switch (file.type?.split("/")[0]) {
-    case "image":
-      documentIcon = "image";
-      break;
-    default:
-      documentIcon = "document";
-  }
-  useEffect(() => {
-    if (!errorMessage) return;
-    userEvents.addFieldEvent("Encountered error", {
-      actionType: "change",
-      field: "dropzone file",
-      returnType: "validation",
-      returnValue: errorMessage
-    });
-  }, [errorMessage, userEvents]);
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      className: cx("adyen-kyc-dropzone-file", { "adyen-kyc-dropzone-file--error": errorMessage }),
-      children: [
-        /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-dropzone-file__details", children: [
-          /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-dropzone-file__labels", children: [
-            errorMessage ? /* @__PURE__ */ jsx(
-              Icon,
-              {
-                testId: "document-invalid",
-                name: "warning",
-                className: "adyen-kyc-dropzone-file__icon"
-              }
-            ) : /* @__PURE__ */ jsx(
-              Icon,
-              {
-                testId: "document-valid",
-                name: documentIcon,
-                className: "adyen-kyc-dropzone-file__icon"
-              }
-            ),
-            /* @__PURE__ */ jsx(Typography, { variant: "body-stronger", className: "adyen-kyc-dropzone-file__name", children: file.name }),
-            /* @__PURE__ */ jsx(Typography, { className: "adyen-kyc-dropzone-file__size", children: isNewlyUploadedFile(file) && formatSize(file.size) })
-          ] }),
-          errorMessage && /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropzone-file__error", children: t(($) => $[errorMessage]) })
-        ] }),
-        errorMessage ? /* @__PURE__ */ jsx(
-          IconButton,
-          {
-            ariaLabel: t(($) => $["close"]),
-            icon: "cross",
-            variant: "tertiary",
-            onClick: onDelete
-          }
-        ) : /* @__PURE__ */ jsx(
-          IconButton,
-          {
-            ariaLabel: t(($) => $["deleteDocument"]),
-            icon: "bin",
-            variant: "tertiary",
-            onClick: onDelete
-          }
-        )
-      ]
-    }
-  );
-}
-const hasDuplicates = (arr) => arr.some((item, currIndex) => arr.indexOf(item) !== currIndex);
-const defaultFileValidationOptions = {
-  allowedFileTypes: ["JPG", "JPEG", "PNG", "PDF"],
-  maxNumberOfFiles: 1,
-  maxSize: 4194304,
-  // 4MB by default
-  isOptional: false
-};
-const filterOnlyNewlyUploadedFiles = (files) => files.filter(isNewlyUploadedFile);
-const fileValidationRules = ({
-  allowedFileTypes,
-  maxNumberOfFiles,
-  maxSize,
-  isOptional
-}) => [
-  {
-    validate: (files) => {
-      if (isOptional && (!files || files.length === 0)) return true;
-      return Boolean(files && files.length > 0);
-    },
-    errorMessage: "fieldIsRequired",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return files.length <= maxNumberOfFiles;
-    },
-    errorMessage: "tooManyFiles",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return !hasDuplicates(files.map((file) => file.name));
-    },
-    errorMessage: "duplicatedFiles",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return filterOnlyNewlyUploadedFiles(files).every(
-        (file) => allowedFileTypes.some(
-          (filetype) => file.name.toLowerCase().endsWith(filetype.toLowerCase())
-        )
-      );
-    },
-    errorMessage: "unsupportedFiletype",
-    modes: ["blur", "input"]
-  },
-  {
-    validate: (files) => {
-      if (!files) return true;
-      return filterOnlyNewlyUploadedFiles(files).every((file) => !file.size || file.size < maxSize);
-    },
-    errorMessage: "maximumFileSizeExceeded",
-    modes: ["blur", "input"]
-  }
-];
-export {
-  DropzoneFile as D,
-  StateContextSetter as S,
-  getDocument as a,
-  getPropsFromConfigurations as b,
-  createDocumentRequest as c,
-  documentApiUtils as d,
-  composePerScenarioFormConfigurations as e,
-  getFileExtention as f,
-  getIdDocument as g,
-  bytesToSize as h,
-  defaultFileValidationOptions as i,
-  fileValidationRules as j,
-  augmentWithCountryConfigs as k,
-  mergeAttachments as m
-};

package/dist/validationError-DOCbfk7K.js

@@ -1,86 +0,0 @@
-;
-{
-  try {
-    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "90746852-9a9c-4315-b24b-c5e27a2ce189", e._sentryDebugIdIdentifier = "sentry-dbid-90746852-9a9c-4315-b24b-c5e27a2ce189");
-  } catch (e) {
-  }
-}
-;
-import { M as TaskTypes, bq as remediationPayoutApiKeyMapping, br as remediationBusinessDetailsApiKeyMapping, bs as remediationIndividualApiKeyMapping } from "./StoreProvider-BlaJzXSZ.js";
-import { a as assignToProp } from "./utils-DNSfZiio.js";
-const isMaintenanceModeError = (error) => error && typeof error === "object" && "messageCode" in error && error.messageCode === "maintenanceMode";
-const overrideKeyMapping = {
-  [TaskTypes.INDIVIDUAL]: {
-    TAX_ID_NUMBER: "individual.taxInformation"
-  },
-  [TaskTypes.BUSINESS_DETAILS]: {
-    TAX_ID_NUMBER: "organization.taxInformation"
-  }
-};
-const processValidationErrors = (validationError, dropinTask, keyMappings) => {
-  if (validationError?.invalidFields && validationError?.invalidFields.length > 0) {
-    return validationError?.invalidFields.reduce(
-      (acc, invalidField) => {
-        if (invalidField?.name) {
-          let mappedFieldPath = mapField(invalidField?.name, dropinTask);
-          if (keyMappings) {
-            mappedFieldPath = keyMappings[invalidField?.name];
-          }
-          if (mappedFieldPath) {
-            assignToProp(mappedFieldPath, acc, true);
-          }
-        }
-        return acc;
-      },
-      {}
-    );
-  }
-};
-const mapField = (lePath, dropinTask) => {
-  switch (dropinTask) {
-    case TaskTypes.INDIVIDUAL: {
-      const mappedPath = overrideKeyMapping?.[TaskTypes.INDIVIDUAL]?.[lePath];
-      return mappedPath ? mappedPath : remediationIndividualApiKeyMapping[lePath];
-    }
-    case TaskTypes.BUSINESS_DETAILS: {
-      const mappedPath = overrideKeyMapping?.[TaskTypes.BUSINESS_DETAILS]?.[lePath];
-      return mappedPath ? mappedPath : remediationBusinessDetailsApiKeyMapping[lePath];
-    }
-    case TaskTypes.PAYOUT:
-    case TaskTypes.PAYIN:
-      return remediationPayoutApiKeyMapping[lePath];
-    default:
-      return null;
-  }
-};
-const API_VALIDATION_ERROR_CODE = "30_102";
-const ID_DOCUMENT_UPLOAD_ERROR_CODE = "30_105";
-const BANK_STATEMENT_UPLOAD_ERROR_CODE = "30_106";
-const CreateOrUpdateTransferInstrumentErrorMessage = {
-  TRANSFER_INSTRUMENT_LIMIT_HAS_ALREADY_BEEN_MET: "Transfer instrument limit has already been met"
-};
-const validateErrorCode = (error, errorCode) => !!error && typeof error === "object" && "errorCode" in error && error.errorCode === errorCode;
-const isValidationError = (error) => validateErrorCode(error, API_VALIDATION_ERROR_CODE);
-const isIdDocumentUploadError = (error) => validateErrorCode(error, ID_DOCUMENT_UPLOAD_ERROR_CODE);
-const isBankStatementUploadError = (error) => validateErrorCode(error, BANK_STATEMENT_UPLOAD_ERROR_CODE);
-const mapCreateOrUpdateTransferInstrumentErrorMessageToTranslatable = (error) => {
-  if (!error) {
-    return "failedToUpdateDetails";
-  }
-  const message = error?.sourceError?.detail;
-  switch (message) {
-    case CreateOrUpdateTransferInstrumentErrorMessage.TRANSFER_INSTRUMENT_LIMIT_HAS_ALREADY_BEEN_MET:
-      return "transferInstrumentLimitHasAlreadyBeenMet";
-    default:
-      return "failedToUpdateDetails";
-  }
-};
-export {
-  isMaintenanceModeError as a,
-  isIdDocumentUploadError as b,
-  isBankStatementUploadError as c,
-  isValidationError as i,
-  mapCreateOrUpdateTransferInstrumentErrorMessageToTranslatable as m,
-  processValidationErrors as p
-};