@adyen/kyc-components 3.81.0 → 3.82.0-beta.0

package/dist/validate-nbcWPtZJ.js

@@ -0,0 +1,605 @@
+;
+{
+  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] = "fe42e2d5-1086-431b-8208-36fad333692b", e._sentryDebugIdIdentifier = "sentry-dbid-fe42e2d5-1086-431b-8208-36fad333692b");
+  } catch (e) {
+  }
+}
+;
+import { e as TrustedFieldsProviders } from "./fieldConfigurations-Yf8yD64w.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-B_tFiIdr.js";
+import { g as getLocalizedIdDocumentTypeOptions } from "./utils-7TgDVOvi.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-CInDfoP_.js

@@ -0,0 +1,86 @@
+;
+{
+  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] = "6d974094-658d-4500-a6fa-6d949a6cb2af", e._sentryDebugIdIdentifier = "sentry-dbid-6d974094-658d-4500-a6fa-6d949a6cb2af");
+  } catch (e) {
+  }
+}
+;
+import { M as TaskTypes, bq as remediationPayoutApiKeyMapping, br as remediationBusinessDetailsApiKeyMapping, bs as remediationIndividualApiKeyMapping } from "./StoreProvider-B_tFiIdr.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
+};