@adyen/kyc-components 3.91.0-beta.3 → 3.92.0-beta.0

package/dist/{utils-C3GxwDJj.js → utils-BGoLwepn.js}

@@ -2,16 +2,16 @@
 {
   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] = "df2806a9-2598-4063-9629-e204458a0604", e._sentryDebugIdIdentifier = "sentry-dbid-df2806a9-2598-4063-9629-e204458a0604");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d0533543-dff1-4e72-a6a5-9885cc5da7e1", e._sentryDebugIdIdentifier = "sentry-dbid-d0533543-dff1-4e72-a6a5-9885cc5da7e1");
   } catch (e) {
   }
 }
 ;
-import { C as CompanyTypesValues } from "./IndividualOnfido-CFoYrGlk.js";
-import { g as getLegalEntityCountry, bz as getCapabilities, r as LegalEntityTypes, H as hasOwnEntityAssociationOfType, C as CountryCodes } from "./StoreProvider-1OKeIzng.js";
-import { d as allowIndividualWithoutSoleProp } from "./OnboardingDropinComponent-bB8igIVw.js";
-import { S as SOLE_PROP_COUNTRIES } from "./rules-BLYJxwVa.js";
-import { A as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./types-19iBAg7T.js";
+import { C as CompanyTypesValues } from "./bafinUtils-DWV_aQ7N.js";
+import { g as getLegalEntityCountry, by as getCapabilities, r as LegalEntityTypes, K as hasOwnEntityAssociationOfType, C as CountryCodes } from "./StoreProvider-W47xsQUu.js";
+import { d as allowIndividualWithoutSoleProp } from "./OnboardingDropinComponent-DduSUFwg.js";
+import { S as SOLE_PROP_COUNTRIES } from "./rules-DEF6yHR3.js";
+import { A as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./types-D6ybrcVj.js";
 const TRUST_COUNTRIES = [CountryCodes.Australia, CountryCodes.NewZealand];
 const BUSINESS_BANK_ACCOUNT_COUNTRIES = [
   CountryCodes.UnitedStates,

package/dist/utils-BiZgCW0f.js

@@ -0,0 +1,58 @@
+;
+{
+  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] = "433587e6-41c2-4aa5-903b-fd5ad83b81d3", e._sentryDebugIdIdentifier = "sentry-dbid-433587e6-41c2-4aa5-903b-fd5ad83b81d3");
+  } catch (e) {
+  }
+}
+;
+import { al as entriesOf } from "./StoreProvider-W47xsQUu.js";
+class ValidationResult {
+  validationResults;
+  constructor(results) {
+    this.validationResults = results;
+  }
+  /** Checks if all validation rules have passed */
+  get isValid() {
+    return this.validationResults.reduce((acc, result) => acc && result.isValid, true);
+  }
+  /** Checks if any validation rule returned an error */
+  hasError() {
+    return Boolean(this.getError());
+  }
+  /** Returns the first validation result that returned an error */
+  getError() {
+    return this.validationResults.find((result) => result.hasError);
+  }
+  /** Used to add async validation results to the static validation result*/
+  addError(result) {
+    this.validationResults.push(result);
+    return this.validationResults;
+  }
+}
+const omitKeys = (obj, omit) => Object.keys(obj).filter((k) => !omit.includes(k)).reduce((a, c) => {
+  a[c] = obj[c];
+  return a;
+}, {});
+const addKeys = (obj, add, initialValue, defaultData, pendingData) => add.reduce(
+  (a, c) => ({
+    ...a,
+    [c]: a[c] ?? pendingData?.[c] ?? defaultData?.[c] ?? initialValue
+  }),
+  obj
+);
+function getDataByFields(formData, fieldKeys) {
+  return entriesOf(formData).reduce((acc, [key, val]) => {
+    if (fieldKeys.includes(key)) {
+      return { ...acc, [key]: val };
+    }
+    return acc;
+  }, {});
+}
+export {
+  ValidationResult as V,
+  addKeys as a,
+  getDataByFields as g,
+  omitKeys as o
+};

package/dist/utils-Cd-fDpb4.js

@@ -0,0 +1,165 @@
+;
+{
+  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] = "f1eb724b-09f7-4ff4-b173-73b06b9f3706", e._sentryDebugIdIdentifier = "sentry-dbid-f1eb724b-09f7-4ff4-b173-73b06b9f3706");
+  } catch (e) {
+  }
+}
+;
+import { s as summaryItem } from "./summaryItem-CAQCQSkt.js";
+import { C as CountryCodes } from "./StoreProvider-W47xsQUu.js";
+const addressFields = [
+  "address",
+  "otherAddressInformation",
+  "postalCode",
+  "city",
+  "stateOrProvince",
+  "country"
+];
+const [ADDRESS, OTHER_ADDRESS_INFORMATION, POSTAL_CODE, CITY, STATE, COUNTRY] = addressFields;
+const COUNTRIES_WITH_STATES_DATASET = [
+  CountryCodes.Australia,
+  CountryCodes.Brazil,
+  CountryCodes.Canada,
+  CountryCodes.NewZealand,
+  CountryCodes.UnitedStates,
+  CountryCodes.Japan
+];
+const COUNTRIES_WITH_HOUSE_NUMBER_FIRST = [
+  CountryCodes.Australia,
+  CountryCodes.Canada,
+  CountryCodes.NewZealand,
+  CountryCodes.PuertoRico,
+  CountryCodes.UnitedStates,
+  CountryCodes.UnitedKingdom,
+  CountryCodes.France
+];
+const ADDRESS_SCHEMAS = {
+  [CountryCodes.Australia]: [COUNTRY, ADDRESS, OTHER_ADDRESS_INFORMATION, CITY, STATE, POSTAL_CODE],
+  [CountryCodes.Canada]: [COUNTRY, ADDRESS, OTHER_ADDRESS_INFORMATION, CITY, POSTAL_CODE, STATE],
+  [CountryCodes.UnitedKingdom]: [COUNTRY, ADDRESS, OTHER_ADDRESS_INFORMATION, CITY, POSTAL_CODE],
+  [CountryCodes.UnitedStates]: [
+    COUNTRY,
+    ADDRESS,
+    OTHER_ADDRESS_INFORMATION,
+    CITY,
+    STATE,
+    POSTAL_CODE
+  ],
+  [CountryCodes.PuertoRico]: [
+    // should exactly match CountryCodes.UnitedStates
+    COUNTRY,
+    ADDRESS,
+    OTHER_ADDRESS_INFORMATION,
+    CITY,
+    POSTAL_CODE
+  ],
+  [CountryCodes.HongKong]: [COUNTRY, ADDRESS, OTHER_ADDRESS_INFORMATION, CITY, STATE],
+  [CountryCodes.NewZealand]: [
+    COUNTRY,
+    ADDRESS,
+    OTHER_ADDRESS_INFORMATION,
+    POSTAL_CODE,
+    CITY,
+    STATE
+  ],
+  [CountryCodes.UnitedArabEmirates]: [COUNTRY, ADDRESS, OTHER_ADDRESS_INFORMATION, CITY],
+  default: [COUNTRY, ADDRESS, OTHER_ADDRESS_INFORMATION, POSTAL_CODE, CITY, STATE]
+};
+const CONDENSED_ADDRESS_FIELDS = {
+  [CountryCodes.UnitedStates]: [CITY, STATE, POSTAL_CODE]
+};
+const LABELS = {
+  city: {
+    default: CITY,
+    [CountryCodes.UnitedKingdom]: "cityTown"
+  },
+  country: {
+    default: COUNTRY
+  },
+  otherAddressInformation: {
+    default: OTHER_ADDRESS_INFORMATION,
+    [CountryCodes.Canada]: "apartmentSuiteOther",
+    [CountryCodes.PuertoRico]: "apartmentSuiteOther",
+    // should exactly match CountryCodes.UnitedStates
+    [CountryCodes.UnitedStates]: "apartmentSuiteOther"
+  },
+  postalCode: {
+    default: POSTAL_CODE,
+    [CountryCodes.PuertoRico]: "zipCode",
+    // should exactly match CountryCodes.UnitedStates
+    [CountryCodes.UnitedStates]: "zipCode"
+  },
+  stateOrProvince: {
+    default: STATE,
+    [CountryCodes.Australia]: "state",
+    [CountryCodes.Brazil]: "state",
+    [CountryCodes.Canada]: "provinceOrTerritory",
+    [CountryCodes.NewZealand]: "region",
+    [CountryCodes.UnitedStates]: "state"
+  },
+  stateOrProvince__placeHolder: {
+    default: "stateOrProvince__placeHolder",
+    [CountryCodes.Australia]: "selectState",
+    [CountryCodes.Brazil]: "selectState",
+    [CountryCodes.Canada]: "selectProvinceOrTerritory",
+    [CountryCodes.UnitedStates]: "stateOrProvince__placeHolder__US"
+  },
+  address: {
+    default: ADDRESS
+  }
+};
+const getKeyForField = (fieldName, country) => country ? LABELS[fieldName][country] || LABELS[fieldName].default : LABELS[fieldName].default;
+const getAddressSchemaForCountry = (country) => country && ADDRESS_SCHEMAS[country] ? ADDRESS_SCHEMAS[country] : ADDRESS_SCHEMAS.default;
+const getAddressSchemaLabelsByCountry = (country) => {
+  const schema = getAddressSchemaForCountry(country);
+  return schema.reduce(
+    (labels, field) => ({
+      ...labels,
+      [field]: getKeyForField(field, country)
+    }),
+    {}
+  );
+};
+const mapAddressLabels = (data, datasetUtils) => {
+  if (data?.country) {
+    const addressSchema = getAddressSchemaForCountry(data.country);
+    return addressSchema.reduce((mappedAddress, field) => {
+      const labelKey = getKeyForField(field, data.country);
+      const value = data?.[field];
+      if (!value) return mappedAddress;
+      switch (field) {
+        case "country":
+          return {
+            ...mappedAddress,
+            [field]: summaryItem(
+              labelKey,
+              datasetUtils.getCountryName(value) ?? value
+            )
+          };
+        case "stateOrProvince":
+          return {
+            ...mappedAddress,
+            [field]: summaryItem(
+              labelKey,
+              datasetUtils.getStateName(value, data.country) ?? value
+            )
+          };
+        default:
+          return { ...mappedAddress, [field]: summaryItem(labelKey, value) };
+      }
+    }, {});
+  }
+  return data;
+};
+export {
+  COUNTRIES_WITH_STATES_DATASET as C,
+  getAddressSchemaLabelsByCountry as a,
+  addressFields as b,
+  getKeyForField as c,
+  COUNTRIES_WITH_HOUSE_NUMBER_FIRST as d,
+  CONDENSED_ADDRESS_FIELDS as e,
+  getAddressSchemaForCountry as g,
+  mapAddressLabels as m
+};

package/dist/utils-D_3K0EUL.js

@@ -0,0 +1,29 @@
+;
+{
+  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] = "6d6727c7-09ae-4095-b404-06287c535d4f", e._sentryDebugIdIdentifier = "sentry-dbid-6d6727c7-09ae-4095-b404-06287c535d4f");
+  } catch (e) {
+  }
+}
+;
+import { C as CountryCodes } from "./StoreProvider-W47xsQUu.js";
+function getLocalizedIdDocumentTypeOptions(country) {
+  switch (country) {
+    case CountryCodes.Japan:
+      return [
+        { id: "driversLicense", name: "driversLicense", hasBackPage: true },
+        { id: "passport", name: "passport", hasBackPage: false },
+        { id: "identityCard", name: "identityCard__JP", hasBackPage: true }
+      ];
+    default:
+      return [
+        { id: "driversLicense", name: "driversLicense", hasBackPage: true },
+        { id: "passport", name: "passport", hasBackPage: false },
+        { id: "identityCard", name: "identityCard", hasBackPage: true }
+      ];
+  }
+}
+export {
+  getLocalizedIdDocumentTypeOptions as g
+};

package/dist/{documentUtils-BCFAvcv3.js → validate-BKUb24fK.js}

@@ -2,13 +2,16 @@
 {
   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] = "69d2fc2d-f3a2-447d-9d20-244be71a9f6d", e._sentryDebugIdIdentifier = "sentry-dbid-69d2fc2d-f3a2-447d-9d20-244be71a9f6d");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "efa559a2-482e-4bf7-9f1f-05ea1fb7368d", e._sentryDebugIdIdentifier = "sentry-dbid-efa559a2-482e-4bf7-9f1f-05ea1fb7368d");
   } catch (e) {
   }
 }
 ;
-import { k as httpPost, aN as httpDelete, m as httpGet, P as createLogger } from "./StoreProvider-1OKeIzng.js";
-import { w as getLocalizedIdDocumentTypeOptions, A as isNewlyUploadedFile } from "./Spacer-C_wuUjGk.js";
+import { k as httpPost, an as httpDelete, m as httpGet, H as createLogger, bm as StateContext, u as useTranslation, V as useAnalyticsContext, W as Icon, G as Typography, L as Loader, X as IconButton } from "./StoreProvider-W47xsQUu.js";
+import { g as getLocalizedIdDocumentTypeOptions } from "./utils-D_3K0EUL.js";
+import { jsx, jsxs } from "preact/jsx-runtime";
+import cx from "classnames";
+import { useEffect } from "preact/hooks";
 const createDocument = async (context, document, ownerId) => {
   const { baseUrl, rootLegalEntityId } = context;
   return httpPost(
@@ -43,6 +46,8 @@ const updateDocument = async (context, document, documentId, ownerId) => {
     document
   );
 };
+const isExistingFile = (file) => "existing" in file && file.existing;
+const isNewlyUploadedFile = (file) => !isExistingFile(file);
 const logger = createLogger();
 const documentStore = {};
 const idDocumentTypeOptions = getLocalizedIdDocumentTypeOptions();
@@ -256,14 +261,173 @@ const mergeProofOfOwnershipAttachments = (existing, incoming) => {
   const result = [...incoming, ...filteredExisting].slice(0, 2);
   return result;
 };
+function StateContextSetter({ stateRef }) {
+  if (stateRef.current.setState) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(StateContext.Consumer, { children: (stateContextValue) => {
+    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, loading } = 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]) })
+        ] }),
+        loading ? /* @__PURE__ */ jsx("div", { className: "adyen-kyc-dropzone-file__loading", children: /* @__PURE__ */ jsx(Loader, { size: "medium" }) }) : 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,
   getFileExtention as b,
   createDocumentRequest as c,
   documentApiUtils as d,
-  getDocuments as e,
-  fileToBase64 as f,
+  bytesToSize as e,
+  defaultFileValidationOptions as f,
   getIdDocument as g,
-  mergeProofOfOwnershipAttachments as h,
+  fileValidationRules as h,
+  fileToBase64 as i,
+  getDocuments as j,
+  mergeProofOfOwnershipAttachments as k,
   mergeAttachments as m
 };