@adyen/kyc-components
Version:
This guide assumes that you have already an account with Adyen. A legalEntity needs to be created, and you need to have a `legalEntityId` to instatiate a Component.
952 lines • 83.7 kB
JavaScript
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] = "7df79a83-6d10-4b77-8a1e-7d533ba690b7", e._sentryDebugIdIdentifier = "sentry-dbid-7df79a83-6d10-4b77-8a1e-7d533ba690b7");
} catch (e) {}
import { i as Typography, n as addResourceBundles, r as useTranslation } from "./translation-BFxyJ1c5.js";
import { r as Loader } from "./Button-oj6H8OrC.js";
import { s as useApiContext } from "./http-D1NDkBxF.js";
import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-yxi9XhLi.js";
import { t as LegalEntityTypes } from "./legal-entity-type-VIfNYnJP.js";
import { t as getLegalEntityCountry } from "./getLegalEntityCountry-C6bSV6sB.js";
import { a as drop, c as objectsDeepEqual, d as keysOf, r as cloneObject, u as entriesOf } from "./useAnalyticsContext-BVFDMrVE.js";
import { t as useToggleContext } from "./useToggleContext-DaQUBF8O.js";
import { C as isValidMinLength, _ as hasText, a as NO_ALPHABET_REGEX, g as hasRepeatedCharacters, n as EMOJI_REGEX, s as OTHER_ENTITIES_VALID_CHAR_REGEX, w as matchesRegex, x as isInvalidName, y as isEmpty } from "./validatorUtils-DRapRJ6z.js";
import { t as _rolldown_dynamic_import_helper_default } from "./_rolldown_dynamic_import_helper-rq_tsyLP.js";
import { t as Header } from "./Header-CPmJyuoP.js";
import { t as CountryCodes } from "./country-code-CX5KqMBr.js";
import { t as useCapabilities } from "./useCapabilities-BW9uTmoB.js";
import { n as datasetUtilities } from "./datasetUtil-Zd4TCTDn.js";
import { t as Alert } from "./Alert-C6gL3JIt.js";
import { C as EntityTypes, a as trustComponentsKeyMapping, i as trustApiKeyMapping, o as trustDocumentMapping, y as reverseMapping } from "./processCapabilities-DlZY9-Jc.js";
import { p as TaskTypes, s as getOwnEntityAssociations } from "./entityAssociationUtil-BEzUdPbm.js";
import { t as getCountrySpecificTrustTypeOptions } from "./trustUtil-BTHvlo55.js";
import { t as useToastContext } from "./useToastContext-CYgfHjSb.js";
import { n as useCapabilityProblems, t as getProblemsForEntity } from "./getProblemsForEntity-BLcIg3x_.js";
import { t as useAssociatedLegalEntity } from "./useAssociatedLegalEntity-zrU8J6iw.js";
import { t as useCreateLegalEntity } from "./useCreateLegalEntity-BK1XURnK.js";
import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-CtaRaKZ6.js";
import { t as Address } from "./Address-D5EL-3iQ.js";
import { n as FormFlow, r as FormContextProvider, t as useFormContext } from "./useFormContext-Cx9-3iXR.js";
import { n as composePerScenarioFormConfigurations, r as getPropsFromConfigurations, t as augmentWithCountryConfigs } from "./process-field-configurations-C7MuEj5q.js";
import { i as useFormComposer, n as getRequiredForms, t as addValidityToForms } from "./dropinUtils-IdasFZCU.js";
import { t as ErrorPanel } from "./ErrorPanel-B536hgSc.js";
import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DCvL3uZG.js";
import { t as useMultiForm } from "./useMultiForm-B3e1ImN3.js";
import { a as useScenarioConfiguration, r as getPageName, t as mapExistingFile } from "./mapExistingFile-wp3Nf1-m.js";
import { t as useTaskLandedEvent } from "./useTaskLandedEvent-DInxWeqN.js";
import { i as mapAddressLabels } from "./utils-CfTVU2Hq.js";
import { i as isValidationError, o as processValidationErrors, s as isMaintenanceModeError } from "./validationError-BzQCrJPn.js";
import { c as getDocument, o as createDocumentRequest, s as documentApiUtils } from "./validate-DDKy88ac.js";
import { i as getProp, r as formatObject } from "./utils-oc3EdK6K.js";
import { T as getFieldsWithExistingData, _ as exemptedFromTaxDefaultFieldConfig, b as taxInformationDefaultFieldConfig, n as TaxInformationField, r as COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT, t as TAX_INFORMATION_FIELD, u as countryToTaxInfoTypeMap, v as exemptedFromTaxDefaultFieldMetadata, x as taxInformationDefaultFieldMetadata } from "./TaxInformationField-DVc2iorX.js";
import { a as validateNotEmptyOnBlur } from "./patternValidators-BaQxw3ki.js";
import { t as resolveFieldMetadata } from "./fieldConfigurations-m7oWP1DZ.js";
import { t as Field } from "./Field-pcJkjIG_.js";
import { t as Select } from "./Select-CcSRI-H0.js";
import { t as useForm } from "./useForm-pUkvCLc9.js";
import { n as getFormProps, r as getNestedOuterFormPropsFromOuterFormProps } from "./getProps-CkZCnNxW.js";
import { t as InputText } from "./InputText-C30dZxS4.js";
import { n as CountryField, t as COUNTRY_FIELD } from "./CountryField-Dh4DfjBf.js";
import { t as RadioGroup } from "./RadioGroup-7g7Xv9rl.js";
import { t as createFormRules } from "./form-rules-ZiRm6ke_.js";
import { t as ContextGuidance } from "./ContextGuidance-DdoORtLt.js";
import { t as isEmpty$1 } from "./isEmpty-Dw2W8jeR.js";
import { a as useStateContext, i as FormWrapper, n as useGlobalDataSlice } from "./useGlobalData-DD00rA9R.js";
import { C as exemptFromRegistrationNumberDefaultFieldMetadata, E as registrationNumberDefaultFieldMetadata, S as exemptFromRegistrationNumberDefaultFieldConfig, T as registrationNumberDefaultFieldConfig, _ as BusinessRegistrationNumberField, a as operationalAddressIsSameItems, b as getCompanyRegistrationNumberOptions, c as getDefaultVatNumberType, f as doingBusinessAsAbsentFieldMetadata, g as BUSINESS_REGISTRATION_NUMBER_FIELD, h as DBA_NAME_FIELD, i as operationalAddressIsSameIds, l as defaultFieldConfig, m as DBANameField, n as RegistrationAddress, o as VAT_NUMBER_FIELD, p as doingBusinessAsFieldMetadata, r as registrationAddressFields, s as VatNumberField, t as MemoizedConstitutionalDocument, u as defaultFieldMetadata, v as getDefaultRegistrationNumberType, w as getRegistrationNumberHelperText, y as inferCompanyRegistrationNumberType } from "./ConstitutionalDocument-CnNB3LUI.js";
import { a as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED, i as UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL, n as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL, o as UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL, r as UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED, t as ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES } from "./types-tKfEYBOO.js";
import { useCallback, useEffect, useMemo, useRef, useState } from "preact/hooks";
import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
import { skipToken } from "@tanstack/preact-query";
//#region src/context/StateContext/hasDataChanged.ts
var hasDataChanged = (initialData, currentData) => entriesOf(currentData ?? {}).some(([key, value]) => {
if (typeof value === "object") return !objectsDeepEqual(value, initialData?.[key]);
return value !== initialData?.[key];
});
//#endregion
//#region src/components/Trust/mapping/mapApiDocumentToTrustDocument.ts
var mapApiDocumentToTrustDocument = (entityId) => {
const constitutionalDocument = getDocument(entityId, "constitutionalDocument") || null;
return { trustConstitutionalDocument: constitutionalDocument ? { constitutionalDocument: [mapExistingFile(getPageName(constitutionalDocument))] } : void 0 };
};
//#endregion
//#region src/components/UnincorporatedPartnership/mapping/unincorporatedPartnershipKeyMappings.ts
var unincorporatedPartnershipBaseMapping = {
"trustRegistrationDetails.trustType": "unincorporatedPartnership.type",
"trustRegistrationDetails.legalName": "unincorporatedPartnership.name",
"trustRegistrationDetails.doingBusinessAs": "unincorporatedPartnership.doingBusinessAs",
"trustRegistrationDetails.hasDoingBusinessAs": "unincorporatedPartnership.doingBusinessAsAbsent",
"trustRegistrationDetails.country": "unincorporatedPartnership.countryOfGoverningLaw",
"trustRegistrationDetails.registrationNumber": "unincorporatedPartnership.registrationNumber",
"trustRegistrationDetails.taxInformation": "unincorporatedPartnership.taxInformation",
"trustRegistrationDetails.vatNumber": "unincorporatedPartnership.vatNumber",
"trustRegistrationAddress.registrationAddress.city": "unincorporatedPartnership.registeredAddress.city",
"trustRegistrationAddress.registrationAddress.country": "unincorporatedPartnership.registeredAddress.country",
"trustRegistrationAddress.registrationAddress.postalCode": "unincorporatedPartnership.registeredAddress.postalCode",
"trustRegistrationAddress.registrationAddress.stateOrProvince": "unincorporatedPartnership.registeredAddress.stateOrProvince",
"trustRegistrationAddress.registrationAddress.address": "unincorporatedPartnership.registeredAddress.street",
"trustRegistrationAddress.registrationAddress.otherAddressInformation": "unincorporatedPartnership.registeredAddress.street2",
"trustRegistrationAddress.operationalAddress.city": "unincorporatedPartnership.principalPlaceOfBusiness.city",
"trustRegistrationAddress.operationalAddress.country": "unincorporatedPartnership.principalPlaceOfBusiness.country",
"trustRegistrationAddress.operationalAddress.postalCode": "unincorporatedPartnership.principalPlaceOfBusiness.postalCode",
"trustRegistrationAddress.operationalAddress.stateOrProvince": "unincorporatedPartnership.principalPlaceOfBusiness.stateOrProvince",
"trustRegistrationAddress.operationalAddress.address": "unincorporatedPartnership.principalPlaceOfBusiness.street",
"trustRegistrationAddress.operationalAddress.otherAddressInformation": "unincorporatedPartnership.principalPlaceOfBusiness.street2"
};
var unincorporatedPartnershipComponentsKeyMapping = {
"trustRegistrationDetails.exemptedFromVat": "unincorporatedPartnership.vatAbsenceReason",
...unincorporatedPartnershipBaseMapping
};
var unincorporatedPartnershipApiKeyMapping = { ...reverseMapping(unincorporatedPartnershipBaseMapping) };
//#endregion
//#region src/components/UnincorporatedPartnership/mapping/mapLegalEntityToUnincorporatedPartnership.ts
var mapLegalEntityToUnincorporatedPartnership = (legalEntity, isFeatureEnabled) => {
if (!legalEntity.unincorporatedPartnership) throw new Error("LE missing unincorporatedPartnership field");
let trustCompData = formatObject(legalEntity, unincorporatedPartnershipComponentsKeyMapping);
if (!trustCompData?.trustRegistrationDetails) return {};
trustCompData.trustRegistrationDetails.country = legalEntity.unincorporatedPartnership.countryOfGoverningLaw;
if (legalEntity.unincorporatedPartnership.description) trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.unincorporatedPartnership.description;
if (legalEntity.unincorporatedPartnership.principalPlaceOfBusiness) trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
else {
if (!trustCompData.trustRegistrationAddress) trustCompData.trustRegistrationAddress = {};
trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
}
if (legalEntity.unincorporatedPartnership.taxInformation?.length) {
const { country } = legalEntity.unincorporatedPartnership.registeredAddress;
const countryTaxInformation = legalEntity.unincorporatedPartnership.taxInformation.find((info) => info.country === country);
if (countryTaxInformation?.type === "UEN") trustCompData.trustRegistrationDetails.isUen = true;
if (countryTaxInformation?.type === "GST") trustCompData.trustRegistrationDetails.isUen = false;
const taxNumberAbsent = countryTaxInformation?.numberAbsent;
if (taxNumberAbsent !== void 0) trustCompData.trustRegistrationDetails.exemptedFromTax = taxNumberAbsent;
}
if (legalEntity.documentDetails?.length) trustCompData = {
...trustCompData,
...mapApiDocumentToTrustDocument(legalEntity?.id)
};
if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
if (typeof trustCompData.trustRegistrationDetails?.hasDoingBusinessAs === "boolean") {
trustCompData.trustRegistrationDetails.hasDoingBusinessAs = !legalEntity.unincorporatedPartnership.doingBusinessAsAbsent;
if (!trustCompData.trustRegistrationDetails.hasDoingBusinessAs) delete legalEntity.unincorporatedPartnership.doingBusinessAs;
}
} else {
trustCompData.trustRegistrationDetails.hasDoingBusinessAs = legalEntity.unincorporatedPartnership.doingBusinessAs ? legalEntity.unincorporatedPartnership.doingBusinessAs !== legalEntity.unincorporatedPartnership.name : void 0;
trustCompData.trustRegistrationDetails.doingBusinessAs = legalEntity.unincorporatedPartnership.doingBusinessAs;
}
return trustCompData;
};
//#endregion
//#region src/components/UnincorporatedPartnership/mapping/mapUnincorporatedPartnershipToLegalEntity.ts
var mapUnincorporatedPartnershipToLegalEntity = (data, isFeatureEnabled) => {
const requestObj = { ...formatObject(data, unincorporatedPartnershipApiKeyMapping) };
if (!requestObj.unincorporatedPartnership) return requestObj;
if (requestObj.unincorporatedPartnership?.taxInformation?.[0]?.type === "GST") requestObj.unincorporatedPartnership.taxInformation[0].type = "UEN";
if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
if (typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined") requestObj.unincorporatedPartnership.doingBusinessAsAbsent = !data.trustRegistrationDetails?.hasDoingBusinessAs;
} else {
requestObj.unincorporatedPartnership.doingBusinessAs = data.trustRegistrationDetails?.doingBusinessAs || data.trustRegistrationDetails?.legalName || "";
delete requestObj.unincorporatedPartnership.doingBusinessAsAbsent;
}
requestObj.type = LegalEntityTypes.UNINCORPORATED_PARTNERSHIP;
return requestObj;
};
//#endregion
//#region src/components/Trust/forms/Trust/rules.ts
var COUNTRIES_THAT_USE_REGISTRATION_NUMBER = [CountryCodes.NewZealand];
var rules = ({ data, country, taskType }) => createFormRules({
countryUsesTaxId: () => {
if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED.includes(country)) return "REQUIRED";
if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL.includes(country)) return "OPTIONAL";
}
if (country !== CountryCodes.NewZealand && COUNTRIES_THAT_USE_TAX_ID_INSTEAD_OF_VAT.includes(country)) return "REQUIRED";
},
countryRequiresRegistrationNumberForTrust: () => {
if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED.includes(country)) return "REQUIRED";
if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL.includes(country)) return "OPTIONAL";
}
if (COUNTRIES_THAT_USE_REGISTRATION_NUMBER.includes(country)) return "REQUIRED";
},
registrationNumberType: () => {
if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED.includes(country)) return "OPTIONAL";
if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL.includes(country)) return "OPTIONAL";
}
if (COUNTRIES_THAT_USE_REGISTRATION_NUMBER.includes(country)) return "OPTIONAL";
},
countryUsesVatNumber: () => {
if (taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP) {
if (UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL.includes(country)) return "OPTIONAL";
}
},
trustTypeHasDescription: () => {
if (data?.trustRegistrationDetails?.trustType === "charitableTrust") return "REQUIRED";
},
requireDoingBusinessAsName: () => {
return data?.trustRegistrationDetails?.hasDoingBusinessAs ? "REQUIRED" : void 0;
},
requiresTrustType: () => {
if (taskType === TaskTypes.TRUST) return "REQUIRED";
}
});
//#endregion
//#region src/components/Trust/forms/TrustRegistrationDetails/validate.ts
var 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
};
var 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
};
//#endregion
//#region src/components/Trust/forms/TrustRegistrationDetails/TrustRegistrationDetails.tsx
var trustRegistrationDetailsFields = [
"legalName",
...DBA_NAME_FIELD,
"country",
"trustType",
"objectOfTrust",
...TAX_INFORMATION_FIELD,
...BUSINESS_REGISTRATION_NUMBER_FIELD,
...VAT_NUMBER_FIELD
];
var ALLOWED_TRUST_COUNTRIES$1 = [CountryCodes.Australia, CountryCodes.NewZealand];
function TrustRegistrationDetails(props) {
let mergedProps = props;
const TRUST_REGISTRATION_DETAILS = mergedProps.id || trustForms$1.trustRegistrationDetails.formId;
const { t: commonT } = useTranslation("common");
const { t: trustT } = useTranslation("trust");
const { isFeatureEnabled } = useToggleContext();
const { updateStateSlice, sliceData } = useGlobalDataSlice(TRUST_REGISTRATION_DETAILS);
const isStrictNameAndAddressValidationEnabled = isFeatureEnabled("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$1(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 ?? getDefaultRegistrationNumberType(sliceData?.registrationNumber, country, "trust")
}, registrationNumberDefaultFieldMetadata), mergedProps);
mergedProps = mergeFieldMetadataIntoProps("exemptedFromRegistrationNumber", resolveFieldMetadata(exemptFromRegistrationNumberDefaultFieldConfig[country], {}, exemptFromRegistrationNumberDefaultFieldMetadata), mergedProps);
mergedProps = mergeFieldMetadataIntoProps("vatNumber", resolveFieldMetadata(defaultFieldConfig[country], { vatNumberType: sliceData?.vatNumberType ?? getDefaultVatNumberType(sliceData?.vatNumber, country) }, 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,
data: defaultData,
requiredFields,
fieldValidationErrors: mergedProps.fieldValidationErrors,
formVerificationErrors: mergedProps.formVerificationErrors
}, commonT);
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: [
mergedProps.heading && /* @__PURE__ */ jsx(Header, { title: 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: trustT(($) => $["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$1,
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),
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: trustT(($) => $[trust])
})),
placeholder: trustT(($) => $["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"),
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"),
helperText: getRegistrationNumberHelperText(trustT, {
country,
companyType: LegalEntityTypes.TRUST
}),
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" }),
optional: formUtils.isOptionalField("vatNumber"),
readonly: formUtils.isReadOnly("vatNumber"),
handleChangeFor,
country,
canExempt: formUtils.isRequiredField("exemptedFromVat"),
shouldValidate: mergedProps.shouldValidate
})
]
}) });
}
//#endregion
//#region src/components/Trust/forms/Trust/Trust.tsx
var trustForms$1 = {
trustRegistrationDetails: {
formId: "trustRegistrationDetails",
formName: "registrationDetails",
fields: [...trustRegistrationDetailsFields]
},
trustRegistrationAddress: {
formId: "trustRegistrationAddress",
formName: "addressDetails",
fields: registrationAddressFields
},
trustConstitutionalDocument: {
formId: "trustConstitutionalDocument",
formName: "constitutionalDocument",
fields: ["constitutionalDocument"]
}
};
var trustRegistrationAddressFormId$1 = trustForms$1.trustRegistrationAddress.formId;
var trustRegistrationDetailsFormId$1 = trustForms$1.trustRegistrationDetails.formId;
var trustConstitutionalDocumentFormId$1 = trustForms$1.trustConstitutionalDocument.formId;
function Trust(props) {
const { t } = useTranslation(["common", "trust"]);
const { country, activeForm, taskType } = props;
const trustRegistrationDetailsFormProps = getFormProps(props, trustRegistrationDetailsFormId$1);
const trustRegistrationAddressFormProps = getNestedOuterFormPropsFromOuterFormProps(props, trustRegistrationAddressFormId$1);
const trustDocumentFormProps = getFormProps(props, trustConstitutionalDocumentFormId$1);
const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
const renderActiveForm = (activeForm) => /* @__PURE__ */ jsxs("div", {
className: "adyen-kyc-trust",
children: [
/* @__PURE__ */ jsx("div", {
className: activeForm.formId !== trustRegistrationDetailsFormId$1 ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
children: /* @__PURE__ */ jsx(TrustRegistrationDetails, {
...trustRegistrationDetailsFormProps,
heading: t(($) => $["registrationDetails"]),
id: trustRegistrationDetailsFormId$1,
country,
taskType
})
}),
/* @__PURE__ */ jsx("div", {
className: activeForm.formId !== trustRegistrationAddressFormId$1 ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
children: /* @__PURE__ */ jsx(RegistrationAddress, {
...trustRegistrationAddressFormProps,
heading: t(($) => $["addressDetails"]),
description: !isUnincorporatedPartnership ? t(($) => $["registeredAddressTrustHeaderDescription"], { ns: "trust" }) : t(($) => $["registeredAddressUnincorporatedPartnershipHeaderDescription"], { ns: "trust" }),
id: trustRegistrationAddressFormId$1,
country,
problems: props?.problems,
labels: { operationalAddressIsSame: !isUnincorporatedPartnership ? "isTrustOperationAddressSame" : "isPartnershipOperationAddressSame" }
})
}),
/* @__PURE__ */ jsx("div", {
className: activeForm.formId !== trustConstitutionalDocumentFormId$1 ? "adyen-kyc-form-wrapper adyen-kyc-form-wrapper--hidden" : "adyen-kyc-form-wrapper",
children: /* @__PURE__ */ jsx(MemoizedConstitutionalDocument, {
...trustDocumentFormProps,
id: trustConstitutionalDocumentFormId$1,
legalEntityType: isUnincorporatedPartnership ? LegalEntityTypes.UNINCORPORATED_PARTNERSHIP : LegalEntityTypes.TRUST,
country
})
})
]
});
return /* @__PURE__ */ jsx("div", {
className: "adyen-kyc-trust",
children: renderActiveForm(activeForm || trustForms$1.trustRegistrationDetails)
});
}
//#endregion
//#region src/components/Trust/mapping/mapLegalEntityToTrust.ts
var mapLegalEntityToTrust = (legalEntity, isFeatureEnabled) => {
if (!legalEntity.trust) throw new Error("LE missing trust field");
let trustCompData = formatObject(legalEntity, trustComponentsKeyMapping);
if (!trustCompData?.trustRegistrationDetails) return {};
trustCompData.trustRegistrationDetails.vatNumberType = getDefaultVatNumberType(legalEntity.trust.vatNumber, legalEntity.trust.countryOfGoverningLaw);
trustCompData.trustRegistrationDetails.registrationNumberType = getDefaultRegistrationNumberType(legalEntity.trust.registrationNumber, legalEntity.trust.countryOfGoverningLaw, LegalEntityTypes.TRUST);
trustCompData.trustRegistrationDetails.country = legalEntity.trust.countryOfGoverningLaw;
if (legalEntity.trust.description) trustCompData.trustRegistrationDetails.objectOfTrust = legalEntity.trust.description;
if (legalEntity.trust.principalPlaceOfBusiness) trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
else {
if (!trustCompData.trustRegistrationAddress) trustCompData.trustRegistrationAddress = {};
trustCompData.trustRegistrationAddress.operationalAddressIsSame = operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_SAME;
}
if (legalEntity.trust.taxInformation?.length) {
const { country } = legalEntity.trust.registeredAddress;
const countryTaxInformation = legalEntity.trust.taxInformation.find((info) => info.country === country);
if (countryTaxInformation?.type === "UEN") trustCompData.trustRegistrationDetails.isUen = true;
if (countryTaxInformation?.type === "GST") trustCompData.trustRegistrationDetails.isUen = false;
const taxNumberAbsent = countryTaxInformation?.numberAbsent;
if (taxNumberAbsent !== void 0) trustCompData.trustRegistrationDetails.exemptedFromTax = taxNumberAbsent;
}
if (legalEntity.documentDetails?.length) trustCompData = {
...trustCompData,
...mapApiDocumentToTrustDocument(legalEntity?.id)
};
if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
if (typeof trustCompData.trustRegistrationDetails?.hasDoingBusinessAs === "boolean") {
trustCompData.trustRegistrationDetails.hasDoingBusinessAs = !legalEntity.trust.doingBusinessAsAbsent;
if (!trustCompData.trustRegistrationDetails.hasDoingBusinessAs) delete legalEntity.trust?.doingBusinessAs;
}
} else {
trustCompData.trustRegistrationDetails.hasDoingBusinessAs = legalEntity.trust.doingBusinessAs ? legalEntity.trust.doingBusinessAs !== legalEntity.trust.name : void 0;
trustCompData.trustRegistrationDetails.doingBusinessAs = legalEntity.trust.doingBusinessAs;
}
return trustCompData;
};
//#endregion
//#region src/components/Trust/mapping/mapTrustDocumentToApiDocument.ts
var mapTrustDocumentToApiDocument = async (data, entityId) => {
const constitutionalDocument = data?.trustConstitutionalDocument?.constitutionalDocument;
if (!constitutionalDocument) throw new Error("Constitutional document missing");
const page1 = constitutionalDocument[0];
if (!page1) throw new Error("Document needs at least one page");
return await createDocumentRequest({
entityId,
entityType: "legalEntity",
documentType: "constitutionalDocument",
page1,
existingDocument: getDocument(entityId, "constitutionalDocument")
});
};
//#endregion
//#region src/components/Trust/mapping/mapTrustToLegalEntity.ts
var mapTrustToLegalEntity = (data, isFeatureEnabled) => {
const requestObj = { ...formatObject(data, trustApiKeyMapping) };
if (!requestObj.trust) return requestObj;
if (data.trustRegistrationDetails?.objectOfTrust) requestObj.trust.description = data.trustRegistrationDetails.objectOfTrust;
if (isFeatureEnabled("EnableDoingBusinessAsNameV4")) {
requestObj.trust.doingBusinessAsAbsent = typeof data.trustRegistrationDetails?.hasDoingBusinessAs !== "undefined" ? !data.trustRegistrationDetails?.hasDoingBusinessAs : void 0;
if (requestObj.trust.doingBusinessAsAbsent) requestObj.trust.doingBusinessAs = "";
} else {
delete requestObj.trust?.doingBusinessAsAbsent;
requestObj.trust.doingBusinessAs = data.trustRegistrationDetails?.doingBusinessAs || data.trustRegistrationDetails?.legalName;
}
requestObj.type = LegalEntityTypes.TRUST;
return requestObj;
};
//#endregion
//#region src/components/Trust/tasks/TrustDropin/mandatoryFields.ts
var MANDATORY_FIELDS_TRUST = ["trustRegistrationDetails.legalName", "trustRegistrationDetails.country"];
//#endregion
//#region src/components/Trust/tasks/TrustDropin/trustFormConfig.ts
var trustBase = {
trustType: { rule: "requiresTrustType" },
objectOfTrust: { rule: "trustTypeHasDescription" },
legalName: { rule: "REQUIRED" },
hasDoingBusinessAs: { rule: "REQUIRED" },
doingBusinessAs: { rule: "requireDoingBusinessAsName" },
country: { rule: "REQUIRED" },
taxInformation: { rule: "countryUsesTaxId" },
registrationAddress: { rule: "REQUIRED" },
operationalAddress: { rule: "OPTIONAL" },
constitutionalDocument: { rule: "REQUIRED" },
registrationNumber: { rule: "countryRequiresRegistrationNumberForTrust" },
registrationNumberType: { rule: "registrationNumberType" },
vatNumber: { rule: "countryUsesVatNumber" },
vatNumberType: { rule: "countryUsesVatNumber" },
operationalAddressIsSame: { rule: "REQUIRED" }
};
var trustFieldsPerScenario = {
L0: { ...trustBase },
L1: { ...trustBase },
L: { ...trustBase }
};
var trustCountryConfig = {};
//#endregion
//#region src/components/Trust/tasks/TrustDropin/TrustDropin.tsx
var parseTrustScenarios$1 = (scenarios, country) => augmentWithCountryConfigs(trustCountryConfig[country], composePerScenarioFormConfigurations(scenarios, trustFieldsPerScenario));
var parseConfiguration$1 = ({ scenarios, country }) => parseTrustScenarios$1(scenarios, country);
function TrustDropin({ parentLegalEntity, capabilities, country: countryProp, existingTrust, taskType, problems: problemsProp, onSubmit: externalOnSubmit, onChange, hideSidebar, handleHomeClick }) {
const { state: { currentState } } = useStateContext();
const formValidity = currentState.validityByForm;
useEffect(() => {
onChange?.(currentState);
}, [currentState, onChange]);
const { baseUrl, rootLegalEntityId } = useApiContext();
const { t, i18n } = useTranslation(["common", "trust"]);
const [validationErrors, setValidationErrors] = useState();
const datasetUtils = datasetUtilities(i18n.language);
const { isFeatureEnabled } = useToggleContext();
const { showToast } = useToastContext();
const [loadingStatus, setLoadingStatus] = useState("success");
const isUnincorporatedPartnership = taskType === TaskTypes.UNINCORPORATED_PARTNERSHIP;
const problems = useMemo(() => ({
...problemsProp,
validationErrors
}), [problemsProp, validationErrors]);
const trustData = useMemo(() => {
if (!existingTrust) return {};
return isUnincorporatedPartnership ? mapLegalEntityToUnincorporatedPartnership(existingTrust, isFeatureEnabled) : mapLegalEntityToTrust(existingTrust, isFeatureEnabled);
}, [
isFeatureEnabled,
existingTrust,
isUnincorporatedPartnership
]);
const currentCountry = useMemo(() => currentState.data.trustRegistrationDetails?.country ?? countryProp, [countryProp, currentState.data.trustRegistrationDetails?.country]);
const [initialData, setInitialData] = useState(trustData);
/**
* Analytics
*/
useTaskLandedEvent(taskType);
useEffect(() => {
if (!existingTrust?.documentDetails?.length) return;
try {
documentUtils.fetchDocuments(existingTrust.documentDetails, existingTrust.id).then(() => {
const mappedDocuments = mapApiDocumentToTrustDocument(existingTrust.id);
setInitialData({
...initialData,
...mappedDocuments
});
}).catch(() => {
showToast({
label: t(($) => $["failedToFetchRelevantDocuments"]),
variant: "error"
});
});
} catch {
showToast({
label: t(($) => $["failedToFetchRelevantDocuments"]),
variant: "error"
});
}
}, []);
/**
* Fetch Configurations
*/
const { fieldConfigurations, requiredFields } = useScenarioConfiguration({
parseConfiguration: parseConfiguration$1,
legalEntityType: LegalEntityTypes.TRUST,
setLoadingStatus,
country: currentCountry
});
const fieldsFromCustomRules = useMemo(() => rules({
data: currentState.data,
country: currentCountry,
taskType,
requiredFields,
isFeatureEnabled
}), [
currentCountry,
currentState.data,
taskType,
requiredFields,
isFeatureEnabled
]);
const derivedProps = useMemo(() => getPropsFromConfigurations({
scenarioConfiguration: fieldConfigurations,
forms: trustForms$1,
remediationActions: problems?.remediationActions ? Object.values(problems?.remediationActions) : [],
dataMissingErrors: problems?.missingData ?? [],
fieldsWithExistingData: existingTrust ? getFieldsWithExistingData(existingTrust, trustApiKeyMapping, trustDocumentMapping) : [],
customRules: fieldsFromCustomRules,
legalEntityType: existingTrust?.type
}), [
fieldConfigurations,
problems?.remediationActions,
problems?.missingData,
existingTrust,
fieldsFromCustomRules
]);
const forms = useMemo(() => {
return addValidityToForms(getRequiredForms(trustForms$1, derivedProps?.requiredFields, derivedProps?.optionalFields), formValidity, problems);
}, [
derivedProps,
formValidity,
problems
]);
const onSubmitTrust = async () => {
setLoadingStatus("loading");
const trustDetails = mapTrustToLegalEntity(currentState.data, isFeatureEnabled);
try {
const updatedTrust = await submitTrustDetails(trustDetails);
await submitDocuments({
forms,
legalEntity: updatedTrust,
dataSubmitted: currentState.data
});
await attachTrustToParentLegalEntity(updatedTrust);
setLoadingStatus("success");
showToast({
label: t(($) => $["successfullyUpdatedDetails"]),
variant: "success"
});
externalOnSubmit?.(currentState.data);
} catch (e) {
showToast({
label: t(($) => $["failedToUpdateDetails"]),
variant: "error"
});
if (isValidationError(e)) setValidationErrors(processValidationErrors(e, taskType));
else if (isMaintenanceModeError(e)) showToast({
label: t(($) => $["maintenanceModeMessage"]),
variant: "error",
duration: "indefinite"
});
setLoadingStatus("success");
}
};
const onSubmitUnincorporatedPartnership = async () => {
setLoadingStatus("loading");
const unincorporatedPartnershipDetails = mapUnincorporatedPartnershipToLegalEntity(currentState.data, isFeatureEnabled);
try {
const updatedUnincorporatedPartnershipDetails = await submitTrustDetails(unincorporatedPartnershipDetails);
await submitDocuments({
forms,
legalEntity: updatedUnincorporatedPartnershipDetails,
dataSubmitted: currentState.data
});
await attachTrustToParentLegalEntity(updatedUnincorporatedPartnershipDetails);
setLoadingStatus("success");
showToast({
label: t(($) => $["successfullyUpdatedDetails"]),
variant: "success"
});
externalOnSubmit?.(currentState.data);
} catch (e) {
showToast({
label: t(($) => $["failedToUpdateDetails"]),
variant: "error"
});
if (isValidationError(e)) setValidationErrors(processValidationErrors(e, taskType));
else if (isMaintenanceModeError(e)) showToast({
label: t(($) => $["maintenanceModeMessage"]),
variant: "error",
duration: "indefinite"
});
setLoadingStatus("success");
}
};
const { mutateAsync: createLegalEntity } = useCreateLegalEntity();
const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
const submitTrustDetails = async (legalEntity) => {
if (!existingTrust) return await createLegalEntity(legalEntity);
else return await updateLegalEntity({
...drop("type").from(legalEntity),
id: existingTrust.id
});
};
const documentUtils = documentApiUtils({
baseUrl: baseUrl.value,
rootLegalEntityId: rootLegalEntityId.value
});
const submitDocuments = async ({ forms, legalEntity, dataSubmitted }) => {
if (isDocumentsRequired(forms)) {
const formattedDocument = await mapTrustDocumentToApiDocument(dataSubmitted, legalEntity.id);
if (formattedDocument) await documentUtils.uploadDocuments([formattedDocument], legalEntity.id);
}
};
const isDocumentsRequired = (forms) => forms.some((form) => form.formId === trustForms$1.trustConstitutionalDocument.formId);
const attachTrustToParentLegalEntity = async (trust) => {
if (existingTrust?.id) return;
const existingEntityAssociations = getOwnEntityAssociations(parentLegalEntity);
await updateLegalEntity({
entityAssociations: [{
type: trust.type,
legalEntityId: trust.id
}, ...existingEntityAssociations],
id: parentLegalEntity.id
});
};
const formatDataForSummary = (formData, forms) => {
let summaryData = cloneObject(formData) || {};
const country = formData.trustRegistrationDetails?.country ?? (existingTrust ? getLegalEntityCountry(existingTrust) : getLegalEntityCountry(parentLegalEntity));
if (formData.trustRegistrationDetails) {
const trustCountry = formData.trustRegistrationDetails.country && datasetUtils.getCountryName(formData.trustRegistrationDetails.country);
const trustType = formData.trustRegistrationDetails.trustType && t(($) => $[formData.trustRegistrationDetails.trustType], { ns: "trust" });
const registrationNumberLabel = resolveFieldMetadata(registrationNumberDefaultFieldConfig[country], {
companyType: LegalEntityTypes.TRUST,
registrationNumberType: formData.trustRegistrationDetails.registrationNumber ? inferCompanyRegistrationNumberType(formData.trustRegistrationDetails.registrationNumber, country, LegalEntityTypes.TRUST) : getCompanyRegistrationNumberOptions(country, LegalEntityTypes.TRUST)?.[0]?.id
}, registrationNumberDefaultFieldMetadata).label;
const taxIdLabel = resolveFieldMetadata(taxInformationDefaultFieldConfig[country], {
companyType: LegalEntityTypes.TRUST,
taxIdNumberType: countryToTaxInfoTypeMap[country]
}, taxInformationDefaultFieldMetadata).label;
summaryData.trustRegistrationDetails = {
[isUnincorporatedPartnership ? "legalName" : "nameOfTrustAgreement"]: formData.trustRegistrationDetails?.legalName,
doingBusinessAs: formData.trustRegistrationDetails?.doingBusinessAs,
countryRegionOfEstablishment: trustCountry,
typeOfTrustAgreement: isUnincorporatedPartnership ? void 0 : trustType,
objectOfTrust: formData.trustRegistrationDetails?.objectOfTrust,
[taxIdLabel]: formData.trustRegistrationDetails?.taxInformation?.find((taxId) => country === taxId.country)?.number,
[registrationNumberLabel]: formData.trustRegistrationDetails.registrationNumber
};
}
if (formData.trustRegistrationAddress?.registrationAddress) {
summaryData.trustRegistrationAddress.hasInnerForms = true;
summaryData.trustRegistrationAddress.registrationAddress = mapAddressLabels(formData.trustRegistrationAddress.registrationAddress, datasetUtils);
}
if (formData.trustRegistrationAddress?.operationalAddress) summaryData.trustRegistrationAddress.operationalAddress = mapAddressLabels(formData.trustRegistrationAddress.operationalAddress, datasetUtils);
if (isDocumentsRequired(forms)) summaryData = {
...summaryData,
...formatFileSummaryData(formData.trustConstitutionalDocument)
};
else delete summaryData[trustConstitutionalDocumentFormId$1];
return summaryData;
};
const formatFileSummaryData = (trustConstitutionalDocument) => {
const constitutionalDocument = trustConstitutionalDocument?.constitutionalDocument?.[0];
return { ...constitutionalDocument && { trustConstitutionalDocument: { fileName: constitutionalDocument.name } } };
};
const canSubmit = (formData) => MANDATORY_FIELDS_TRUST.every((detail) => {
return !isEmpty(getProp(formData, detail));
});
const { handleNextClick, handleBackClick, activeForm, shouldValidate, setShouldValidate, gotoFormByFormIndex, gotoFormByFormId, steps } = useFormComposer({
problems,
forms,
onSubmit: isUnincorporatedPartnership ? onSubmitUnincorporatedPartnership : onSubmitTrust
});
return /* @__PURE__ */ jsx(FormWrapper, {
taskName: isUnincorporatedPartnership ? "unincorporatedDetails" : "trustDetails",
handleNextClick,
handleBackClick,
gotoFormByFormIndex,
gotoFormByFormId,
loadingStatus,
forms,
activeForm,
onSubmit: isUnincorporatedPartnership ? onSubmitUnincorporatedPartnership : onSubmitTrust,
hideSidebar,
handleHomeClick,
validateForm: () => setShouldValidate(true),
canSubmit: canSubmit(currentState.data) && hasDataChanged(initialData, currentState.data),
problems,
summary: {
data: formatDataForSummary(currentState.data, forms),
omitted: { keys: ["operationalAddressIsSame"] }
},
steps,
children: /* @__PURE__ */ jsx(Trust, {
...derivedProps,
activeForm,
capabilities,
data: initialData,
country: currentCountry,
problems,
shouldValidate,
taskType
})
});
}
//#endregion
//#region src/components/Shared/forms/RegistrationAddress/RegistrationAddressMultiform.tsx
var registrationAddressFormID = {
registrationAddress: {
formId: "registrationAddress",
formName: "registeredAddress",
fields: ["address"]
},
operationalAddress: {
formId: "operationalAddress",
formName: "operationalAddressHeader",
fields: ["address"]
}
}.registrationAddress.formId;
function RegistrationAddressMultiform(props) {
const { t } = useTranslation("common");
const { id, heading, description, country, problems } = props;
const { form } = useFormContext();
const data = form.data.trustRegistrationAddress;
const { requiredFields: registrationAddressRequiredFields, optionalFields: registrationAddressOptionalFields, readOnlyFields: registrationAddressReadOnlyFields, obscuredFields: registrationAddressObscuredFields, verifyFields: registrationAddressVerifyFields, trustedFields: registrationAddressTrustedFields } = getFormProps(props, registrationAddressFormID);
const formUtils = createFormUtils({
...props,
requiredFields: registrationAddressRequiredFields,
optionalFields: registrationAddressOptionalFields,
readOnlyFields: registrationAddressReadOnlyFields,
obscuredFields: registrationAddressObscuredFields,
verifyFields: registrationAddressVerifyFields,
trustedFields: registrationAddressTrustedFields
}, t);
const isOperationAddressNotSame = () => data?.operationalAddressIsSame === operationalAddressIsSameIds.OPERATIONAL_ADDRESS_IS_NOT_SAME;
const registrationAddressValidRef = useRef(Boolean(form.valid.trustRegistrationAddress?.registrationAddress));
const operationalAddressValidRef = useR