@adyen/kyc-components 4.0.0-beta.5 → 4.0.0-beta.6

package/dist/{TrustDetailsPage-J4MShc8J.js → TrustDetailsPage-BLeUJoAV.js}

@@ -2,17 +2,37 @@
 {
   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] = "5a56a705-f5e8-4e4a-a573-88e455e5b4d8", e._sentryDebugIdIdentifier = "sentry-dbid-5a56a705-f5e8-4e4a-a573-88e455e5b4d8");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d53f2179-a3b4-44a0-8a96-b16673be04b6", e._sentryDebugIdIdentifier = "sentry-dbid-d53f2179-a3b4-44a0-8a96-b16673be04b6");
   } catch (e) {
   }
 }
 ;
-import { jsx } from "preact/jsx-runtime";
-import { cg as getDocument, ch as mapExistingFile, ci as getPageName, bz as reverseMapping, bA as formatObject, dY as operationalAddressIsSameIds, O as LegalEntityTypes, cR as createFormRules, $ as TaskTypes, fm as UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL, fn as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED, fo as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL, as as CountryCodes, fp as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED, fq as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL, f8 as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, fr as trustComponentsKeyMapping, f4 as getDefaultVatNumberType, f3 as getDefaultRegistrationNumberType, cl as createDocumentRequest, fs as trustApiKeyMapping, ff as useStateContext, a as useApiContext, u as useI18nContext, a3 as useAnalyticsContext, ba as datasetUtilities, aa as useExperimentsContext, a9 as useToastContext, bP as getAssociatedLeAnalyticsPayload, cp as documentApiUtils, cx as useScenarioConfiguration, cy as getPropsFromConfigurations, ft as trustForms, bQ as getRequiredForms, bR as addValidityToForms, bS as useFormComposer, fk as FormWrapper, fu as Trust, fv as augmentWithCountryConfigs, fw as trustDocumentMapping, bU as isValidationError, bV as processValidationErrors, bW as isMaintenanceModeError, bk as cloneObject, g as getLegalEntityCountry, av as resolveFieldMetadata, e6 as registrationNumberDefaultFieldMetadata, fb as inferCompanyRegistrationNumberType, fc as getCompanyRegistrationNumberOptions, e7 as registrationNumberDefaultFieldConfig, cb as taxInformationDefaultFieldMetadata, fd as countryToTaxInfoTypeMap, cc as taxInformationDefaultFieldConfig, cG as mapAddressLabels, fx as trustConstitutionalDocumentFormId, f9 as getProp, at as isEmpty, cD as composePerScenarioFormConfigurations, co as drop, ao as getOwnEntityAssociations, d as useLegalEntity, B as skipToken, R as ROOT_LE, dr as useCapabilities, af as useCapabilityProblems, b5 as getProblemsForEntity, L as Loader, dg as keysOf, Z as EntityTypes } from "./StoreProvider-QThALSrj.js";
-import { useEffect, useState, useRef, useMemo } from "preact/hooks";
-import { u as useCreateLegalEntity, a as useUpdateLegalEntity } from "./useUpdateLegalEntity-56mDjaQA.js";
-import { h as hasDataChanged } from "./hasDataChanged-CTE9vdfO.js";
-import { g as getFieldsWithExistingData } from "./getFieldsWithExistingData-CUMH8N-C.js";
+import { jsx, Fragment, jsxs } from "preact/jsx-runtime";
+import { aS as reverseMapping, y as LegalEntityTypes, M as TaskTypes, a8 as CountryCodes, an as hasText, ao as isValidMinLength, ap as matchesRegex, aq as NO_ALPHABET_REGEX, ar as EMOJI_REGEX, as as hasRepeatedCharacters, at as isInvalidName, au as OTHER_ENTITIES_VALID_CHAR_REGEX, a as useTranslation, u as useI18nContext, X as useExperimentsContext, x as Typography, bI as getCountrySpecificTrustTypeOptions, bJ as trustComponentsKeyMapping, bK as trustApiKeyMapping, b as useApiContext, U as useAnalyticsContext, bL as trustDocumentMapping, ay as cloneObject, g as getLegalEntityCountry, a9 as isEmpty$1, b1 as drop, a6 as getOwnEntityAssociations, c as useLegalEntity, q as skipToken, R as ROOT_LE, L as Loader, aD as keysOf, J as EntityTypes } from "./StoreProvider-DOveEVCE.js";
+import { c as validateNotEmptyOnBlur, r as resolveFieldMetadata, b as useCapabilityProblems, g as getProblemsForEntity } from "./fieldConfigurations-DPY7jB8k.js";
+import { j as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, c as TAX_INFORMATION_FIELD, t as taxInformationDefaultFieldMetadata, b as taxInformationDefaultFieldConfig, e as exemptedFromTaxDefaultFieldMetadata, d as exemptedFromTaxDefaultFieldConfig, T as TaxInformationField, g as getFieldsWithExistingData, k as getCompanyRegistrationNumberOptions, l as countryToTaxInfoTypeMap, u as useCapabilities } from "./TaxInformationField-BjN-COCm.js";
+import { useMemo, useCallback, useEffect, useState, useRef } from "preact/hooks";
+import { u as useCreateLegalEntity, a as useUpdateLegalEntity } from "./RadioGroup-C1kODuZr.js";
+import { h as hasDataChanged } from "./hasDataChanged-Of2J5c2Y.js";
+import { u as useGlobalDataSlice, c as useStateContext, F as FormWrapper } from "./useGlobalData-BrYDijKl.js";
+import { u as useToastContext } from "./useToastContext-DuFRr5GY.js";
+import { g as getAssociatedLeAnalyticsPayload } from "./analytics-2hGA-cx1.js";
+import { a as getDocument, c as createDocumentRequest, d as documentApiUtils, b as getPropsFromConfigurations, k as augmentWithCountryConfigs, e as composePerScenarioFormConfigurations } from "./validate-BtJFnIGb.js";
+import { g as getRequiredForms, a as addValidityToForms, u as useFormComposer } from "./dropinUtils-1GeCqEl1.js";
+import { m as mapExistingFile, g as getPageName, b as useScenarioConfiguration } from "./mapExistingFile-gPqgSwUG.js";
+import { D as DBA_NAME_FIELD, B as BUSINESS_REGISTRATION_NUMBER_FIELD, V as VAT_NUMBER_FIELD, e as doingBusinessAsAbsentFieldMetadata, c as doingBusinessAsFieldMetadata, r as registrationNumberDefaultFieldMetadata, b as registrationNumberDefaultFieldConfig, i as exemptFromRegistrationNumberDefaultFieldMetadata, l as exemptFromRegistrationNumberDefaultFieldConfig, d as defaultFieldMetadata, a as defaultFieldConfig, f as DBANameField, g as BusinessRegistrationNumberField, h as VatNumberField, j as registrationAddressFields, R as RegistrationAddress, M as MemoizedConstitutionalDocument, k as getDefaultVatNumberType, m as getDefaultRegistrationNumberType, n as inferCompanyRegistrationNumberType } from "./RegistrationAddress-bS2rqYF2.js";
+import { m as mapAddressLabels } from "./utils-Ble2523K.js";
+import { i as isValidationError, p as processValidationErrors, a as isMaintenanceModeError } from "./validationError-Dr817hGf.js";
+import { a as datasetUtilities } from "./useDataset-D4mnA6DC.js";
+import { f as formatObject, g as getProp } from "./utils-DNSfZiio.js";
+import { o as operationalAddressIsSameIds } from "./Address-T_L756Fd.js";
+import { c as createFormRules } from "./form-rules-DhbF2mY4.js";
+import { U as UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL, a as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED, b as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL, c as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED, d as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL, A as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./types-DHWLJwxd.js";
+import { m as mergeFieldMetadataIntoProps, c as createFormUtils, F as FormHeader, E as ErrorPanel, C as CountryField, a as COUNTRY_FIELD, f as getFormProps, i as getNestedOuterFormPropsFromOuterFormProps } from "./CountryField-DrVg4pbc.js";
+import { a as useForm, F as Field, c as Select } from "./useForm-B58-dXq6.js";
+import { a as Alert } from "./Alert-BZ-Nbp3n.js";
+import { I as InputText } from "./InputText-oE96xgGf.js";
+import { i as isEmpty } from "./isEmpty-DBj6NFoa.js";
 const mapApiDocumentToTrustDocument = (entityId) => {
   const constitutionalDocument = getDocument(entityId, "constitutionalDocument") || null;
   return {
@@ -185,6 +205,475 @@ const rules = ({
     }
   }
 });
+const trustRegistrationDetailsValidations = {
+  trustType: {
+    modes: ["blur"],
+    validate: (trustType) => !!trustType,
+    errorMessage: "fieldIsRequired"
+  },
+  country: {
+    modes: ["blur"],
+    validate: (country) => !!country,
+    errorMessage: "fieldIsRequired"
+  },
+  legalName: {
+    modes: ["blur"],
+    validate: (legalName) => !!legalName,
+    errorMessage: "fieldIsRequired"
+  },
+  objectOfTrust: {
+    modes: ["blur"],
+    validate: (objectOfTrust) => !!objectOfTrust,
+    errorMessage: "fieldIsRequired"
+  },
+  hasDoingBusinessAs: validateNotEmptyOnBlur,
+  doingBusinessAs: validateNotEmptyOnBlur
+};
+const trustRegistrationDetailsValidationsV4 = {
+  trustType: {
+    modes: ["blur"],
+    validate: (trustType) => !!trustType,
+    errorMessage: "fieldIsRequired"
+  },
+  country: {
+    modes: ["blur"],
+    validate: (country) => !!country,
+    errorMessage: "fieldIsRequired"
+  },
+  legalName: [
+    {
+      modes: ["blur"],
+      validate: hasText,
+      errorMessage: "fieldIsRequired"
+    },
+    {
+      modes: ["blur"],
+      validate: (input) => !matchesRegex(NO_ALPHABET_REGEX, input),
+      errorMessage: "nameMustContainLetters"
+    },
+    {
+      modes: ["blur"],
+      validate: (input) => !matchesRegex(EMOJI_REGEX, input) && !hasRepeatedCharacters(input) && isValidMinLength(input, 3) && !isInvalidName(input) && matchesRegex(OTHER_ENTITIES_VALID_CHAR_REGEX, input),
+      errorMessage: "checkForTypos"
+    }
+  ],
+  objectOfTrust: {
+    modes: ["blur"],
+    validate: (objectOfTrust) => !!objectOfTrust,
+    errorMessage: "fieldIsRequired"
+  },
+  hasDoingBusinessAs: validateNotEmptyOnBlur,
+  doingBusinessAs: validateNotEmptyOnBlur
+};
+const trustRegistrationDetailsFields = [
+  "legalName",
+  ...DBA_NAME_FIELD,
+  "country",
+  "trustType",
+  "objectOfTrust",
+  ...TAX_INFORMATION_FIELD,
+  ...BUSINESS_REGISTRATION_NUMBER_FIELD,
+  ...VAT_NUMBER_FIELD
+];
+const ALLOWED_TRUST_COUNTRIES = [CountryCodes.Australia, CountryCodes.NewZealand];
+function TrustRegistrationDetails(props) {
+  let mergedProps = props;
+  const TRUST_REGISTRATION_DETAILS = mergedProps.id || trustForms.trustRegistrationDetails.formId;
+  const { t } = useTranslation("common");
+  const { i18n } = useI18nContext();
+  const { isExperimentEnabled } = useExperimentsContext();
+  const { updateStateSlice, sliceData } = useGlobalDataSlice(TRUST_REGISTRATION_DETAILS);
+  const isStrictNameAndAddressValidationEnabled = isExperimentEnabled(
+    "StrictNameAndAddressValidationV4"
+  );
+  const { taskType } = props;
+  const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
+  const country = sliceData?.country ?? mergedProps.country;
+  const defaultData = useMemo(
+    () => ({ ...mergedProps.data, country }),
+    [country, mergedProps.data]
+  );
+  const requiredFields = isEmpty(mergedProps.requiredFields) ? trustRegistrationDetailsFields : mergedProps.requiredFields;
+  mergedProps = mergeFieldMetadataIntoProps(
+    "hasDoingBusinessAs",
+    doingBusinessAsAbsentFieldMetadata,
+    mergedProps
+  );
+  mergedProps = mergeFieldMetadataIntoProps(
+    "doingBusinessAs",
+    doingBusinessAsFieldMetadata,
+    mergedProps
+  );
+  mergedProps = mergeFieldMetadataIntoProps(
+    "taxInformation",
+    resolveFieldMetadata(
+      taxInformationDefaultFieldConfig[country],
+      {
+        taxIdNumberType: sliceData?.taxInformation?.find((taxId) => taxId.country === country)?.type,
+        companyType: LegalEntityTypes.TRUST
+      },
+      taxInformationDefaultFieldMetadata
+    ),
+    mergedProps
+  );
+  mergedProps = mergeFieldMetadataIntoProps(
+    "exemptedFromTax",
+    resolveFieldMetadata(
+      exemptedFromTaxDefaultFieldConfig[country],
+      {},
+      exemptedFromTaxDefaultFieldMetadata
+    ),
+    mergedProps
+  );
+  mergedProps = mergeFieldMetadataIntoProps(
+    "registrationNumber",
+    resolveFieldMetadata(
+      registrationNumberDefaultFieldConfig[country],
+      {
+        companyType: LegalEntityTypes.TRUST,
+        registrationNumberType: sliceData?.registrationNumberType,
+        isExperimentEnabled
+      },
+      registrationNumberDefaultFieldMetadata
+    ),
+    mergedProps
+  );
+  mergedProps = mergeFieldMetadataIntoProps(
+    "exemptedFromRegistrationNumber",
+    resolveFieldMetadata(
+      exemptFromRegistrationNumberDefaultFieldConfig[country],
+      {},
+      exemptFromRegistrationNumberDefaultFieldMetadata
+    ),
+    mergedProps
+  );
+  mergedProps = mergeFieldMetadataIntoProps(
+    "vatNumber",
+    resolveFieldMetadata(
+      defaultFieldConfig[country],
+      { vatNumberType: sliceData?.vatNumberType },
+      defaultFieldMetadata
+    ),
+    mergedProps
+  );
+  mergedProps.validators = {
+    ...mergedProps.validators,
+    legalName: isStrictNameAndAddressValidationEnabled ? trustRegistrationDetailsValidationsV4.legalName : trustRegistrationDetailsValidations.legalName
+  };
+  const getFormSchema = useCallback(
+    (currentData) => {
+      const fieldsToRemove = [];
+      if (!currentData.hasDoingBusinessAs) {
+        fieldsToRemove.push("doingBusinessAs");
+      }
+      return requiredFields.filter((field) => !fieldsToRemove.includes(field));
+    },
+    [requiredFields]
+  );
+  const { handleChangeFor, data, valid, errors, setData, fieldProblems, schema } = useForm({
+    ...mergedProps,
+    schema: getFormSchema,
+    defaultData,
+    rules: mergedProps.validators || (isStrictNameAndAddressValidationEnabled ? trustRegistrationDetailsValidationsV4 : trustRegistrationDetailsValidations),
+    fieldProblems: mergedProps.fieldValidationErrors
+  });
+  const formUtils = createFormUtils(
+    {
+      ...mergedProps,
+      requiredFields,
+      fieldValidationErrors: mergedProps.fieldValidationErrors,
+      formVerificationErrors: mergedProps.formVerificationErrors
+    },
+    t
+  );
+  useEffect(() => {
+    updateStateSlice({
+      schema,
+      data,
+      errors,
+      valid,
+      fieldProblems
+    });
+  }, [data, errors, fieldProblems, schema, updateStateSlice, valid]);
+  const changeTrustType = (e) => {
+    handleChangeFor("trustType", "blur")(e);
+    if (e.target.value !== "charitableTrust") {
+      setData("objectOfTrust", void 0);
+    }
+  };
+  const trustTypeOptions = getCountrySpecificTrustTypeOptions(country) ?? [];
+  const showField = (field) => formUtils.isRequiredField(field) || formUtils.isOptionalField(field);
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs("form", { id: TRUST_REGISTRATION_DETAILS, className: "adyen-kyc-trust__registration-details", children: [
+    /* @__PURE__ */ jsx(FormHeader, { heading: mergedProps.heading }),
+    /* @__PURE__ */ jsx(
+      ErrorPanel,
+      {
+        verificationErrors: mergedProps.formVerificationErrors,
+        validationErrors: mergedProps.fieldValidationErrors,
+        formUtils,
+        id: "ariaErrorField"
+      }
+    ),
+    !isUnincorporatedPartnership && /* @__PURE__ */ jsx(
+      Alert,
+      {
+        variant: "info",
+        title: /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "secondary", children: i18n.get("makeSureToHaveYourTrustDeed") }),
+        className: "adyen-kyc-u-margin-bottom-16"
+      }
+    ),
+    formUtils.isRequiredField("country") && /* @__PURE__ */ jsx(
+      CountryField,
+      {
+        data: formUtils.getFieldData(data, COUNTRY_FIELD),
+        valid: formUtils.getFieldValid(valid, COUNTRY_FIELD),
+        errors: formUtils.getFieldErrors(errors, fieldProblems, COUNTRY_FIELD),
+        labels: formUtils.getFieldLabels(COUNTRY_FIELD, {
+          country: "countryRegionOfEstablishment"
+        }),
+        readonly: formUtils.isReadOnly("country"),
+        allowedCountries: isUnincorporatedPartnership ? ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES : ALLOWED_TRUST_COUNTRIES,
+        handleChangeFor: () => (e) => {
+          handleChangeFor("country", "input")(e);
+          if (mergedProps.onCountryChange) mergedProps.onCountryChange(e);
+        }
+      }
+    ),
+    formUtils.isRequiredField("legalName") && /* @__PURE__ */ jsx(
+      Field,
+      {
+        name: "legalName",
+        label: formUtils.getLabel(
+          !isUnincorporatedPartnership ? "nameOfTrustAgreement" : "legalName"
+        ),
+        errorMessage: formUtils.getErrorMessage("legalName", errors, fieldProblems),
+        isValid: valid.legalName,
+        children: (childProps) => /* @__PURE__ */ jsx(
+          InputText,
+          {
+            ...childProps,
+            name: "legalName",
+            value: data.legalName,
+            readonly: formUtils.isReadOnly("legalName"),
+            onInput: handleChangeFor("legalName", "input"),
+            onBlur: handleChangeFor("legalName", "blur"),
+            "aria-required": true,
+            "aria-invalid": !valid.legalName
+          }
+        )
+      }
+    ),
+    formUtils.isRequiredField("hasDoingBusinessAs") && /* @__PURE__ */ jsx(
+      DBANameField,
+      {
+        data: formUtils.getFieldData(data, DBA_NAME_FIELD),
+        valid: formUtils.getFieldValid(valid, DBA_NAME_FIELD),
+        errors: formUtils.getFieldErrors(errors, fieldProblems, DBA_NAME_FIELD),
+        labels: formUtils.getFieldLabels(DBA_NAME_FIELD, {
+          hasDoingBusinessAs: "hasDba"
+        }),
+        readonly: formUtils.isReadOnly("doingBusinessAs"),
+        handleChangeFor
+      }
+    ),
+    formUtils.isRequiredField("trustType") && !isUnincorporatedPartnership && /* @__PURE__ */ jsx(
+      Field,
+      {
+        name: "trustType",
+        label: formUtils.getLabel("trustType", "typeOfTrustAgreement"),
+        errorMessage: formUtils.getErrorMessage("trustType", errors, fieldProblems),
+        isValid: valid.trustType,
+        dataTestId: "trust-type",
+        children: (childProps) => /* @__PURE__ */ jsx(
+          Select,
+          {
+            ...childProps,
+            name: "trustType",
+            onChange: changeTrustType,
+            selected: data.trustType,
+            items: trustTypeOptions.map((trust) => ({
+              id: trust,
+              name: i18n.get(trust)
+            })),
+            placeholder: i18n.get("trustType")
+          }
+        )
+      }
+    ),
+    formUtils.isRequiredField("objectOfTrust") && /* @__PURE__ */ jsx(
+      Field,
+      {
+        name: "objectOfTrust",
+        label: formUtils.getLabel("objectOfCharitableTrust"),
+        helper: formUtils.getLabel("pleaseProvideThePurposeOfCharitableTrust"),
+        errorMessage: formUtils.getErrorMessage("objectOfTrust", errors, fieldProblems),
+        isValid: valid.objectOfTrust,
+        children: (childProps) => /* @__PURE__ */ jsx(
+          InputText,
+          {
+            ...childProps,
+            name: "objectOfTrust",
+            value: data.objectOfTrust,
+            readonly: formUtils.isReadOnly("objectOfTrust"),
+            onInput: handleChangeFor("objectOfTrust", "input"),
+            onBlur: handleChangeFor("objectOfTrust", "blur"),
+            "aria-required": true,
+            "aria-invalid": !valid.objectOfTrust
+          }
+        )
+      }
+    ),
+    showField("taxInformation") && /* @__PURE__ */ jsx(
+      TaxInformationField,
+      {
+        data: formUtils.getFieldData(data, TAX_INFORMATION_FIELD),
+        valid: formUtils.getFieldValid(valid, TAX_INFORMATION_FIELD),
+        errors: formUtils.getFieldErrors(errors, fieldProblems, TAX_INFORMATION_FIELD),
+        labels: formUtils.getFieldLabels(TAX_INFORMATION_FIELD, {
+          exemptedFromTax: "iDontHaveATaxId"
+        }),
+        mask: formUtils.getMask("taxInformation"),
+        guidanceText: formUtils.getFieldGuidanceText(TAX_INFORMATION_FIELD),
+        readonly: formUtils.isReadOnly("taxInformation"),
+        shouldValidate: mergedProps.shouldValidate,
+        handleChangeFor,
+        optional: formUtils.isOptionalField("taxInformation"),
+        canExempt: formUtils.isRequiredField("exemptedFromTax"),
+        country,
+        entityType: LegalEntityTypes.TRUST,
+        defaultData: mergedProps.data?.taxInformation,
+        registrationNumber: data.registrationNumber
+      }
+    ),
+    showField("registrationNumber") && /* @__PURE__ */ jsx(
+      BusinessRegistrationNumberField,
+      {
+        data: formUtils.getFieldData(data, BUSINESS_REGISTRATION_NUMBER_FIELD),
+        valid: formUtils.getFieldValid(valid, BUSINESS_REGISTRATION_NUMBER_FIELD),
+        errors: formUtils.getFieldErrors(
+          errors,
+          fieldProblems,
+          BUSINESS_REGISTRATION_NUMBER_FIELD
+        ),
+        labels: formUtils.getFieldLabels(BUSINESS_REGISTRATION_NUMBER_FIELD, {
+          exemptedFromRegistrationNumber: "iDontHaveARegistrationNumber"
+        }),
+        mask: formUtils.getMask("registrationNumber"),
+        guidanceText: formUtils.getFieldGuidanceText(BUSINESS_REGISTRATION_NUMBER_FIELD),
+        placeholders: formUtils.getFieldPlaceholders(BUSINESS_REGISTRATION_NUMBER_FIELD),
+        helperText: formUtils.getFieldHelperText(BUSINESS_REGISTRATION_NUMBER_FIELD),
+        readonly: formUtils.isReadOnly("registrationNumber"),
+        optional: formUtils.isOptionalField("registrationNumber"),
+        shouldValidate: mergedProps.shouldValidate,
+        handleChangeFor,
+        country,
+        canExempt: formUtils.isRequiredField("exemptedFromRegistrationNumber"),
+        companyType: LegalEntityTypes.TRUST
+      }
+    ),
+    showField("vatNumber") && /* @__PURE__ */ jsx(
+      VatNumberField,
+      {
+        data: formUtils.getFieldData(data, VAT_NUMBER_FIELD),
+        valid: formUtils.getFieldValid(valid, VAT_NUMBER_FIELD),
+        errors: formUtils.getFieldErrors(errors, fieldProblems, VAT_NUMBER_FIELD),
+        labels: formUtils.getFieldLabels(VAT_NUMBER_FIELD, {
+          exemptedFromVat: "iDontHaveAVatNumber"
+        }),
+        guidanceText: formUtils.getFieldGuidanceText(VAT_NUMBER_FIELD),
+        placeholders: formUtils.getFieldPlaceholders(VAT_NUMBER_FIELD),
+        optional: formUtils.isOptionalField("vatNumber"),
+        readonly: formUtils.isReadOnly("vatNumber"),
+        handleChangeFor,
+        country,
+        canExempt: formUtils.isRequiredField("exemptedFromVat"),
+        shouldValidate: mergedProps.shouldValidate
+      }
+    )
+  ] }) });
+}
+const trustForms = {
+  trustRegistrationDetails: {
+    formId: "trustRegistrationDetails",
+    formName: "registrationDetails",
+    fields: [...trustRegistrationDetailsFields]
+  },
+  trustRegistrationAddress: {
+    formId: "trustRegistrationAddress",
+    formName: "addressDetails",
+    fields: registrationAddressFields
+  },
+  trustConstitutionalDocument: {
+    formId: "trustConstitutionalDocument",
+    formName: "constitutionalDocument",
+    fields: ["constitutionalDocument"]
+  }
+};
+const trustRegistrationAddressFormId = trustForms.trustRegistrationAddress.formId;
+const trustRegistrationDetailsFormId = trustForms.trustRegistrationDetails.formId;
+const trustConstitutionalDocumentFormId = trustForms.trustConstitutionalDocument.formId;
+function Trust(props) {
+  const { i18n } = useI18nContext();
+  const { country, activeForm, taskType } = props;
+  const trustRegistrationDetailsFormProps = getFormProps(props, trustRegistrationDetailsFormId);
+  const trustRegistrationAddressFormProps = getNestedOuterFormPropsFromOuterFormProps(props, trustRegistrationAddressFormId);
+  const trustDocumentFormProps = getFormProps(props, trustConstitutionalDocumentFormId);
+  const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
+  const renderActiveForm = (activeForm2) => /* @__PURE__ */ jsxs("div", { className: "adyen-kyc-trust", children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: activeForm2.formId !== trustRegistrationDetailsFormId ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
+        children: /* @__PURE__ */ jsx(
+          TrustRegistrationDetails,
+          {
+            ...trustRegistrationDetailsFormProps,
+            heading: i18n.get("registrationDetails"),
+            id: trustRegistrationDetailsFormId,
+            country,
+            taskType
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: activeForm2.formId !== trustRegistrationAddressFormId ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
+        children: /* @__PURE__ */ jsx(
+          RegistrationAddress,
+          {
+            ...trustRegistrationAddressFormProps,
+            heading: i18n.get("addressDetails"),
+            description: !isUnincorporatedPartnership ? i18n.get("registeredAddressTrustHeaderDescription") : i18n.get("registeredAddressUnincorporatedPartnershipHeaderDescription"),
+            id: trustRegistrationAddressFormId,
+            country,
+            problems: props?.problems,
+            labels: {
+              operationalAddressIsSame: !isUnincorporatedPartnership ? "isTrustOperationAddressSame" : "isPartnershipOperationAddressSame"
+            }
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: activeForm2.formId !== trustConstitutionalDocumentFormId ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
+        children: /* @__PURE__ */ jsx(
+          MemoizedConstitutionalDocument,
+          {
+            ...trustDocumentFormProps,
+            id: trustConstitutionalDocumentFormId,
+            legalEntityType: isUnincorporatedPartnership ? LegalEntityTypes.UNINCORPORATED_PARTNERSHIP : LegalEntityTypes.TRUST,
+            country
+          }
+        )
+      }
+    )
+  ] });
+  return /* @__PURE__ */ jsx("div", { className: "adyen-kyc-trust", children: renderActiveForm(activeForm || trustForms.trustRegistrationDetails) });
+}
 const mapLegalEntityToTrust = (legalEntity, isExperimentEnabled) => {
   if (!legalEntity.trust) throw new Error("LE missing trust field");
   let trustCompData = formatObject(legalEntity, trustComponentsKeyMapping);
@@ -424,17 +913,15 @@ function TrustDropin({
     [currentCountry, currentState.data, taskType, requiredFields, isExperimentEnabled]
   );
   const derivedProps = useMemo(
-    () => getPropsFromConfigurations(
-      fieldConfigurations,
-      trustForms,
-      problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
-      problems?.missingData ?? [],
-      existingTrust ? getFieldsWithExistingData(existingTrust, trustApiKeyMapping, trustDocumentMapping) : [],
-      fieldsFromCustomRules,
-      {},
-      {},
-      existingTrust?.type
-    ),
+    () => getPropsFromConfigurations({
+      scenarioConfiguration: fieldConfigurations,
+      forms: trustForms,
+      remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
+      dataMissingErrors: problems?.missingData ?? [],
+      fieldsWithExistingData: existingTrust ? getFieldsWithExistingData(existingTrust, trustApiKeyMapping, trustDocumentMapping) : [],
+      customRules: fieldsFromCustomRules,
+      legalEntityType: existingTrust?.type
+    }),
     [
       fieldConfigurations,
       problems?.remediationActions,
@@ -626,7 +1113,7 @@ function TrustDropin({
   };
   const canSubmit = (formData) => MANDATORY_FIELDS_TRUST.every((detail) => {
     const value = getProp(formData, detail);
-    return !isEmpty(value);
+    return !isEmpty$1(value);
   });
   const {
     handleNextClick,

package/dist/TrustMemberCompanyPage-Bsm7gi_e.js

@@ -0,0 +1,60 @@
+;
+{
+  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] = "7c54d4ad-5f8f-47cc-9196-6764c5e52644", e._sentryDebugIdIdentifier = "sentry-dbid-7c54d4ad-5f8f-47cc-9196-6764c5e52644");
+  } catch (e) {
+  }
+}
+;
+import { a as addResourceBundles, _ as __variableDynamicImportRuntimeHelper } from "./translation-IYHo-_Mc.js";
+import { jsx } from "preact/jsx-runtime";
+import { a as useTranslation, c as useLegalEntity, R as ROOT_LE, q as skipToken, L as Loader, g as getLegalEntityCountry, M as TaskTypes, J as EntityTypes } from "./StoreProvider-DOveEVCE.js";
+import { l as useTrustMembers } from "./OnboardingDropinComponent-DpN0iLAh.js";
+import { b as useCapabilityProblems, g as getProblemsForEntity } from "./fieldConfigurations-DPY7jB8k.js";
+import { _ as BusinessDetailsDropin } from "./BusinessDetailsDropin-BCEl6ugY.js";
+function TrustMemberCompanyPage({
+  trustId,
+  trustMemberCompanyId,
+  newMember,
+  isTargetLegalEntityType = false,
+  onSubmit,
+  handleHomeClick
+}) {
+  const { i18n } = useTranslation();
+  const { data: rootLe } = useLegalEntity(ROOT_LE);
+  const { data: trustLe } = useLegalEntity(trustId);
+  const { data: trustMemberCompanyLe } = useLegalEntity(trustMemberCompanyId ?? skipToken);
+  const trustMembers = useTrustMembers();
+  const capabilityProblems = useCapabilityProblems();
+  addResourceBundles(i18n, i18n.language, [
+    { ns: "business", importFn: () => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "../../Business/language/bg-BG.json": () => import("./bg-BG-9uVrFuHv.js"), "../../Business/language/cs-CZ.json": () => import("./cs-CZ-Wzc382q6.js"), "../../Business/language/da-DK.json": () => import("./da-DK-CeNMXUfE.js"), "../../Business/language/de-DE.json": () => import("./de-DE-JI-7mvxy.js"), "../../Business/language/el-GR.json": () => import("./el-GR-DfNOPkLq.js"), "../../Business/language/en-US.json": () => import("./en-US-DHq7VYFs.js"), "../../Business/language/es-ES.json": () => import("./es-ES-DOVPTeyf.js"), "../../Business/language/et-EE.json": () => import("./et-EE-BJIsPOnh.js"), "../../Business/language/fi-FI.json": () => import("./fi-FI-D522KHGk.js"), "../../Business/language/fr-FR.json": () => import("./fr-FR-DInQKkTd.js"), "../../Business/language/hr-HR.json": () => import("./hr-HR-DzS44Gpv.js"), "../../Business/language/hu-HU.json": () => import("./hu-HU-xCvNM5TU.js"), "../../Business/language/it-IT.json": () => import("./it-IT-CjEYONJg.js"), "../../Business/language/ja-JP.json": () => import("./ja-JP-BUz3qN-V.js"), "../../Business/language/lt-LT.json": () => import("./lt-LT-B6CJ4ULI.js"), "../../Business/language/lv-LV.json": () => import("./lv-LV-DTtuyfHS.js"), "../../Business/language/nl-NL.json": () => import("./nl-NL-Zcq0bXd-.js"), "../../Business/language/no-NO.json": () => import("./no-NO-BxReX6oF.js"), "../../Business/language/pl-PL.json": () => import("./pl-PL-T6uD5--R.js"), "../../Business/language/pt-PT.json": () => import("./pt-PT-N0njcfLO.js"), "../../Business/language/ro-RO.json": () => import("./ro-RO-Ic1SzBgx.js"), "../../Business/language/sk-SK.json": () => import("./sk-SK-CiD0FeLN.js"), "../../Business/language/sl-SI.json": () => import("./sl-SI-MZoDApq9.js"), "../../Business/language/sv-SE.json": () => import("./sv-SE-DCFSf4Oj.js") }), `../../Business/language/${i18n.language}.json`, 5) }
+  ]);
+  if (!rootLe || !trustLe || trustMemberCompanyId && !trustMemberCompanyLe) {
+    return /* @__PURE__ */ jsx(Loader, {});
+  }
+  const problems = capabilityProblems && trustMemberCompanyId ? getProblemsForEntity(capabilityProblems, EntityTypes.LEGAL_ENTITY, trustMemberCompanyId) : void 0;
+  const country = getLegalEntityCountry(trustMemberCompanyLe ?? trustLe);
+  const trustMember = newMember ?? trustMembers.find(
+    (tm) => tm.trustMemberType !== "undefinedBeneficiary" && tm.legalEntityId === trustMemberCompanyId
+  );
+  return /* @__PURE__ */ jsx(
+    BusinessDetailsDropin,
+    {
+      taskType: TaskTypes.TRUST_MEMBER_COMPANY,
+      taskName: "businessTrusteeDetails",
+      legalEntityResponse: rootLe,
+      associatedLegalArrangement: trustLe,
+      nestedLegalEntity: trustMemberCompanyLe,
+      nestedLegalEntityDetails: trustMember,
+      problems,
+      country,
+      isTargetLegalEntityType,
+      onSubmit,
+      handleHomeClick
+    }
+  );
+}
+export {
+  TrustMemberCompanyPage
+};