@adyen/kyc-components 4.10.1 → 4.11.0-beta.1

package/dist/ContactDetails-BF42eW3s.js

@@ -0,0 +1,288 @@
+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] = "8f89e7cf-e9db-49b0-8d23-714fd7949a68", e._sentryDebugIdIdentifier = "sentry-dbid-8f89e7cf-e9db-49b0-8d23-714fd7949a68");
+} catch (e) {}
+import { o as createLogger, r as useTranslation } from "./translation-hEYGx0ZB.js";
+import { r as httpPost, s as useApiContext } from "./http-j2zqU8vS.js";
+import { c as entriesOf } from "./AnalyticsContext-C0HNdPss.js";
+import { y as isEmpty } from "./validatorUtils-D5MKiGfL.js";
+import { t as Header } from "./Header-BI6ESU0g.js";
+import { t as CountryCodes } from "./country-code-D3oCpE4i.js";
+import { t as useDataset } from "./useDataset-BfSb3OFK.js";
+import { t as datasetIdentifier } from "./datasetUtil-BZmNUckr.js";
+import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DcRJcDH1.js";
+import { c as nonInputs, l as numericInputs, n as InputEmail, s as makeMask, t as MaskedInput, u as spacer } from "./MaskedInput-Dth7KFNX.js";
+import { n as emailPattern } from "./basePatterns-VqSYMnkh.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-m7oWP1DZ.js";
+import { t as Field } from "./Field-BD_0HjiI.js";
+import { t as Select } from "./Select-CAso7Gvi.js";
+import { t as InputGroup } from "./InputGroup-2FJnD0LO.js";
+import { useCallback, useEffect, useMemo, useState } from "preact/hooks";
+import { jsx, jsxs } from "preact/jsx-runtime";
+import "@tanstack/preact-query";
+//#region src/api/validation/useValidatePhoneNumber.ts
+var validatePhoneNumber = (baseUrl, data) => {
+	return httpPost({
+		baseUrl,
+		path: `validations/phonenumber`
+	}, data);
+};
+var useValidatePhoneNumberImperatively = () => {
+	const { baseUrl } = useApiContext();
+	return useCallback((data) => validatePhoneNumber(baseUrl.value, data), [baseUrl.value]);
+};
+//#endregion
+//#region src/components/Shared/fields/PhoneField/fieldConfig.ts
+var validatePhoneCountryCodeNotEmptyOnBlur = {
+	modes: ["blur"],
+	validate: (phone) => !isEmpty(phone?.phoneCountryCode),
+	errorMessage: "missingPhoneCountryCode"
+};
+var validatePhoneNumberNotEmpty = {
+	modes: ["blur"],
+	validate: (phone) => !isEmpty(phone?.number),
+	errorMessage: "invalidPhoneNumber"
+};
+var getAsyncPhoneValidationRules = (validatePhoneNumber) => ({ phoneNumber: {
+	asyncValidate: async (phone) => {
+		if (!phone?.number) return false;
+		return (await validatePhoneNumber({ number: phone.number })).valid;
+	},
+	errorMessage: "invalidPhoneNumber",
+	modes: ["blur"]
+} });
+var defaultValidators = [validatePhoneCountryCodeNotEmptyOnBlur, validatePhoneNumberNotEmpty];
+var defaultFieldMetadata = { validators: defaultValidators };
+var fieldConfig = {
+	[CountryCodes.Albania]: {
+		validators: defaultValidators,
+		mask: { mask: makeMask(...numericInputs(2), spacer, ...numericInputs(3), spacer, ...numericInputs(4)) }
+	},
+	[CountryCodes.AmericanSamoa]: {
+		validators: defaultValidators,
+		mask: { mask: makeMask(...numericInputs(3), ...nonInputs("-"), ...numericInputs(4)) }
+	},
+	[CountryCodes.Netherlands]: {
+		validators: defaultValidators,
+		mask: { mask: makeMask(...numericInputs(1), spacer, ...numericInputs(8)) }
+	},
+	[CountryCodes.Singapore]: {
+		validators: defaultValidators,
+		mask: { mask: makeMask(...numericInputs(4), spacer, ...numericInputs(4)) }
+	},
+	[CountryCodes.Japan]: {
+		validators: defaultValidators,
+		mask: { mask: makeMask(...numericInputs(2), ...nonInputs("-"), ...numericInputs(4), ...nonInputs("-"), ...numericInputs(4)) }
+	},
+	[CountryCodes.UnitedStates]: {
+		validators: defaultValidators,
+		mask: { mask: makeMask(...nonInputs("(", { displayEagerly: false }), ...numericInputs(3), ...nonInputs(")"), spacer, ...numericInputs(3), ...nonInputs("-"), ...numericInputs(4)) }
+	}
+};
+/**
+* Returns the placeholder text for the phone field based on country.
+*/
+var getPhonePlaceholder = (country) => {
+	switch (country) {
+		case CountryCodes.Albania: return "00 000 0000";
+		case CountryCodes.AmericanSamoa: return "000-0000";
+		case CountryCodes.Netherlands: return "0 00000000";
+		case CountryCodes.Singapore: return "0000 0000";
+		case CountryCodes.Japan: return "00-0000-0000";
+		case CountryCodes.UnitedStates: return "(000) 000-0000";
+		default: return;
+	}
+};
+//#endregion
+//#region src/components/Shared/forms/ContactDetails/validate.ts
+var contactDetailsValidationRules = { email: [{
+	modes: ["blur"],
+	validate: (email) => email ? emailPattern.test(email) : false,
+	errorMessage: "invalidEmail"
+}] };
+//#endregion
+//#region src/components/Shared/fields/PhoneField/PhoneField.tsx
+var PHONE_FIELD = ["phoneNumber"];
+var logger = createLogger();
+var usePhonePrefixes = () => {
+	const [phonePrefixes, setPhonePrefixes] = useState();
+	useEffect(() => {
+		const loadPhonePrefixes = async () => {
+			const loaded = (await import("./phonePrefixes-Czcjgq4w.js").then((n) => n.n)).default;
+			setPhonePrefixes(loaded);
+		};
+		loadPhonePrefixes().catch(logger.error);
+	}, []);
+	return phonePrefixes;
+};
+function PhoneField({ country, name = "phoneNumber", data, valid, errors, label, mask, readonly, optional, placeholder, helper, helperPosition, handleChangeFor }) {
+	const { t } = useTranslation("common");
+	const { dataset: countries } = useDataset(datasetIdentifier.country);
+	const [isFocused, setIsFocused] = useState(false);
+	const phonePrefixes = usePhonePrefixes();
+	const currentPrefix = phonePrefixes?.[data.phoneNumber?.phoneCountryCode ?? country];
+	const numberStrippedOfCountryCode = useMemo(() => {
+		if (!phonePrefixes || !data.phoneNumber?.number) return "";
+		return currentPrefix && data.phoneNumber?.number.startsWith(currentPrefix) ? data.phoneNumber.number.slice(currentPrefix.length) : data.phoneNumber.number;
+	}, [
+		phonePrefixes,
+		data.phoneNumber?.number,
+		currentPrefix
+	]);
+	const selectItems = useMemo(() => {
+		const countryMap = new Map(countries.map((entry) => [entry.id, entry.name]));
+		return entriesOf(phonePrefixes ?? {}).map(([countryCode, prefix]) => {
+			return {
+				id: countryCode,
+				name: `${countryMap.get(countryCode) ?? countryCode} (${prefix})`,
+				selectedOptionName: `${countryCode} (${prefix})`
+			};
+		}).sort((a, b) => a.name.localeCompare(b.name));
+	}, [phonePrefixes, countries]);
+	const handleSelectChange = useCallback((event) => {
+		const newCC = phonePrefixes?.[event.target.value];
+		const withoutCC = currentPrefix && data.phoneNumber?.number?.startsWith(currentPrefix) ? data.phoneNumber?.number?.slice(currentPrefix.length) : data.phoneNumber?.number?.replace(/\D+/g, "");
+		handleChangeFor("phoneNumber", "input")({
+			phoneCountryCode: event.target.value,
+			number: withoutCC ? newCC + withoutCC : newCC,
+			type: "mobile"
+		});
+	}, [
+		currentPrefix,
+		data.phoneNumber?.number,
+		handleChangeFor,
+		phonePrefixes
+	]);
+	const handleOnInput = useCallback((event) => {
+		const onlyDigits = (currentPrefix ? event.replace(currentPrefix, "") : event).replace(/\D+/g, "");
+		const number = currentPrefix ? `${currentPrefix}${onlyDigits}` : onlyDigits;
+		handleChangeFor("phoneNumber", "input")({
+			...data.phoneNumber,
+			number,
+			type: "mobile"
+		});
+	}, [
+		currentPrefix,
+		data.phoneNumber,
+		handleChangeFor
+	]);
+	const handleOnBlur = useCallback((event) => {
+		const onlyDigits = event.currentTarget.value.replace(/\D+/g, "");
+		const number = currentPrefix ? `${currentPrefix}${onlyDigits}` : onlyDigits;
+		setIsFocused(false);
+		handleChangeFor("phoneNumber", "blur")({
+			...data.phoneNumber,
+			number,
+			type: "mobile"
+		});
+	}, [
+		currentPrefix,
+		data.phoneNumber,
+		handleChangeFor
+	]);
+	const transformOnType = useCallback((value) => currentPrefix ? value.startsWith(currentPrefix) ? value.slice(currentPrefix.length) : value : value, [currentPrefix]);
+	useEffect(() => {
+		if (!data.phoneNumber?.phoneCountryCode && country) handleChangeFor("phoneNumber", "input")({
+			...data.phoneNumber,
+			phoneCountryCode: country,
+			type: "mobile"
+		});
+	}, [
+		country,
+		data.phoneNumber?.phoneCountryCode,
+		data?.phoneNumber,
+		handleChangeFor
+	]);
+	return /* @__PURE__ */ jsx(Field, {
+		el: "fieldset",
+		name,
+		label: label ?? t(($) => $["phoneNumber"]),
+		errorMessage: errors.phoneNumber,
+		isValid: Boolean(valid.phoneNumber),
+		optional: Boolean(optional),
+		disabled: Boolean(readonly),
+		helper,
+		helperPosition,
+		children: (childProps) => /* @__PURE__ */ jsxs(InputGroup, {
+			...childProps,
+			id: "phoneInputGroup",
+			isFocused,
+			isInvalid: Boolean(!valid.phoneNumber && errors.phoneNumber),
+			children: [/* @__PURE__ */ jsx(Select, {
+				name: "phoneCountryCode",
+				"aria-label": t(($) => $["phoneNumberPrefix"]),
+				isMulti: false,
+				items: selectItems,
+				selected: data.phoneNumber?.phoneCountryCode,
+				placeholder: t(($) => $["select"]),
+				onChange: handleSelectChange,
+				minimal: true
+			}), /* @__PURE__ */ jsx(MaskedInput, {
+				useFieldComponent: false,
+				name: "phoneNumber",
+				type: "tel",
+				label: label ?? t(($) => $["phoneNumber"]),
+				value: numberStrippedOfCountryCode,
+				"aria-invalid": Boolean(!valid.phoneNumber),
+				isValid: Boolean(valid.phoneNumber),
+				placeholder,
+				shouldValidate: true,
+				errorMessage: errors.phoneNumber,
+				readonly,
+				disabled: readonly,
+				transformOnType,
+				...mask,
+				stripNonAllowedInputs: true,
+				onInput: handleOnInput,
+				onBlur: handleOnBlur,
+				onFocus: () => setIsFocused(true)
+			})]
+		})
+	});
+}
+//#endregion
+//#region src/components/Shared/forms/ContactDetails/ContactDetails.tsx
+var contactDetailFields = [...PHONE_FIELD, "email"];
+function ContactDetails(props) {
+	const { t } = useTranslation("common");
+	const { country, data, errors = {}, handleFieldChange, fieldValidationErrors, valid = {}, ...newProps } = props;
+	let mergedProps = newProps;
+	if (!handleFieldChange) return;
+	mergedProps = mergeFieldMetadataIntoProps("phoneNumber", resolveFieldMetadata(fieldConfig[data?.phoneNumber?.phoneCountryCode ?? country], {}, defaultFieldMetadata), mergedProps);
+	const formUtils = createFormUtils(mergedProps, t);
+	return /* @__PURE__ */ jsxs("div", {
+		role: "form",
+		children: [
+			mergedProps.heading && /* @__PURE__ */ jsx(Header, { title: mergedProps.heading }),
+			formUtils.isRequiredField("email") && /* @__PURE__ */ jsx(Field, {
+				name: "email",
+				label: formUtils.getLabel("email"),
+				errorMessage: formUtils.getErrorMessage("email", errors, fieldValidationErrors),
+				isValid: valid.email,
+				children: (childProps) => /* @__PURE__ */ jsx(InputEmail, {
+					...childProps,
+					name: "email",
+					value: data?.email,
+					readonly: formUtils.isReadOnly("email"),
+					onInput: handleFieldChange("email", "input"),
+					onBlur: handleFieldChange("email", "blur"),
+					"aria-required": true,
+					"aria-invalid": !valid?.email
+				})
+			}),
+			formUtils.isRequiredField("phoneNumber") && /* @__PURE__ */ jsx(PhoneField, {
+				country,
+				data: formUtils.getFieldData(data ?? {}, PHONE_FIELD),
+				valid: formUtils.getFieldValid(valid, PHONE_FIELD),
+				errors: formUtils.getFieldErrors(errors, {}, PHONE_FIELD),
+				placeholder: getPhonePlaceholder(country),
+				optional: formUtils.isOptionalField("phoneNumber"),
+				readonly: formUtils.isReadOnly("phoneNumber"),
+				mask: formUtils.getMask("phoneNumber"),
+				handleChangeFor: handleFieldChange
+			})
+		]
+	});
+}
+//#endregion
+export { defaultFieldMetadata as a, getPhonePlaceholder as c, contactDetailsValidationRules as i, useValidatePhoneNumberImperatively as l, contactDetailFields as n, fieldConfig as o, PhoneField as r, getAsyncPhoneValidationRules as s, ContactDetails as t };

package/dist/ContextGuidance-DUTeagNS.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] = "92dbee60-3ada-4691-9c38-772b6312b1ef", e._sentryDebugIdIdentifier = "sentry-dbid-92dbee60-3ada-4691-9c38-772b6312b1ef");
+} catch (e) {}
+import { t as Alert } from "./Alert-B5ye0DfE.js";
+import { t as useAnalyticsContext } from "./useAnalyticsContext-D6DJZmqu.js";
+import { jsx } from "preact/jsx-runtime";
+//#region src/components/ui/molecules/ContextGuidance/ContextGuidance.tsx
+function ContextGuidance({ title, content, titleId, contentId, trackingParams }) {
+	const userEvents = useAnalyticsContext();
+	const onGuidanceToggle = (status) => {
+		userEvents.addFieldEvent("Clicked accordion", {
+			actionType: status,
+			field: "context guidance",
+			label: titleId,
+			content: contentId,
+			...trackingParams
+		});
+	};
+	return /* @__PURE__ */ jsx(Alert, {
+		title,
+		type: "collapsible",
+		variant: "info",
+		onToggle: onGuidanceToggle,
+		children: content
+	});
+}
+//#endregion
+export { ContextGuidance as t };

package/dist/CountryField-BNRhvO1q.js

@@ -0,0 +1,38 @@
+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] = "61159351-39ba-4c6d-b872-bb3e9a35204b", e._sentryDebugIdIdentifier = "sentry-dbid-61159351-39ba-4c6d-b872-bb3e9a35204b");
+} catch (e) {}
+import { r as useTranslation } from "./translation-hEYGx0ZB.js";
+import { t as useDataset } from "./useDataset-BfSb3OFK.js";
+import { t as datasetIdentifier } from "./datasetUtil-BZmNUckr.js";
+import { t as Field } from "./Field-BD_0HjiI.js";
+import { t as Select } from "./Select-CAso7Gvi.js";
+import { useMemo } from "preact/hooks";
+import { jsx } from "preact/jsx-runtime";
+//#region src/components/Shared/fields/CountryField/CountryField.tsx
+var COUNTRY_FIELD = ["country"];
+function CountryField({ name = "country", data, valid, errors, labels, readonly, handleChangeFor, helperText, allowedCountries, handleBlur }) {
+	const { t } = useTranslation("common");
+	const { dataset: countriesFromApi } = useDataset(datasetIdentifier.country);
+	const countries = useMemo(() => countriesFromApi.filter((country) => allowedCountries ? allowedCountries.includes(country.id) : true), [allowedCountries, countriesFromApi]);
+	return /* @__PURE__ */ jsx(Field, {
+		name,
+		label: labels?.country || t(($) => $["country"]),
+		errorMessage: errors.country,
+		isValid: valid.country,
+		helper: helperText,
+		dataTestId: "country",
+		children: (childProps) => /* @__PURE__ */ jsx(Select, {
+			...childProps,
+			name,
+			placeholder: t(($) => $["selectCountryRegion"]),
+			selected: data.country,
+			items: countries,
+			readonly: (countries.length === 1 || readonly) && !!data,
+			onChange: handleChangeFor("country"),
+			onBlur: handleBlur
+		})
+	});
+}
+//#endregion
+export { CountryField as n, COUNTRY_FIELD as t };

package/dist/Currency-4t6bIyeE.js

@@ -0,0 +1,191 @@
+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] = "381ff2a1-2218-4aa3-8066-60de13c48445", e._sentryDebugIdIdentifier = "sentry-dbid-381ff2a1-2218-4aa3-8066-60de13c48445");
+} catch (e) {}
+import { o as createLogger, r as useTranslation } from "./translation-hEYGx0ZB.js";
+import { n as httpGet, s as useApiContext } from "./http-j2zqU8vS.js";
+import { i as drop } from "./AnalyticsContext-C0HNdPss.js";
+import { S as isUndefinedOrNull } from "./validatorUtils-D5MKiGfL.js";
+import { t as Field } from "./Field-BD_0HjiI.js";
+import { t as Select } from "./Select-CAso7Gvi.js";
+import { r as InputBase, t as InputText } from "./InputText-qdIKYibU.js";
+import { n as isDateOlderThanAYear } from "./utils-BbusgEMl.js";
+import { t as currencyByCountry } from "./types-B_GKWcEZ.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "preact/hooks";
+import { jsx } from "preact/jsx-runtime";
+import { useQuery } from "@tanstack/preact-query";
+//#region src/components/Business/forms/FinancialInformation/mapping/mapFinancialInformationToFinancialReport.ts
+var mapFinancialInformationToFinancialReport = ({ currency, financialReportingDate, numberOfEmployees, balanceSheetTotal, annualTurnover }, dateOfIncorporation) => {
+	if (dateOfIncorporation && !isDateOlderThanAYear(dateOfIncorporation)) return { employeeCount: typeof numberOfEmployees === "number" ? numberOfEmployees.toFixed(0) : numberOfEmployees };
+	return {
+		currencyOfFinancialData: currency,
+		dateOfFinancialData: financialReportingDate,
+		employeeCount: typeof numberOfEmployees === "number" ? numberOfEmployees.toFixed(0) : numberOfEmployees,
+		balanceSheetTotal: balanceSheetTotal?.toFixed(2) ?? void 0,
+		annualTurnover: annualTurnover?.toFixed(2) ?? void 0
+	};
+};
+//#endregion
+//#region src/components/Business/forms/FinancialInformation/mapping/mapFinancialReportsToFinancialInformation.ts
+var mapFinancialReportsToFinancialInformation = (financialReports, withReportedValueOption = true) => {
+	if (financialReports.length === 0) throw new Error("No financial reports");
+	const mostRecentReport = financialReports.reduce((latest, curr) => {
+		if (curr?.dateOfFinancialData && latest?.dateOfFinancialData && curr?.dateOfFinancialData > latest?.dateOfFinancialData) return curr;
+		return latest;
+	}, financialReports[0]);
+	const financialInfo = {
+		numberOfEmployees: mostRecentReport.employeeCount ? parseInt(mostRecentReport.employeeCount) : void 0,
+		financialReportingDate: mostRecentReport.dateOfFinancialData,
+		currency: mostRecentReport.currencyOfFinancialData
+	};
+	if (mostRecentReport.balanceSheetTotal !== void 0) {
+		financialInfo.reportedValueOption = "balanceSheetTotal";
+		financialInfo.balanceSheetTotal = parseFloat(mostRecentReport.balanceSheetTotal);
+	}
+	if (mostRecentReport.annualTurnover !== void 0) {
+		financialInfo.reportedValueOption = "annualTurnover";
+		financialInfo.annualTurnover = parseFloat(mostRecentReport.annualTurnover);
+	}
+	return withReportedValueOption ? financialInfo : drop("reportedValueOption").from(financialInfo);
+};
+//#endregion
+//#region src/api/datasets/useLegalForms.ts
+var getLegalForms = async (countryCode, baseUrl) => {
+	return httpGet({
+		baseUrl,
+		path: `datasets/legalForms/${countryCode}`
+	});
+};
+var useLegalForms = (countryCode, options) => {
+	const { baseUrl } = useApiContext();
+	return useQuery({
+		queryKey: ["legalForms", countryCode],
+		queryFn: () => getLegalForms(countryCode, baseUrl.value),
+		...options
+	});
+};
+//#endregion
+//#region src/components/EFP/fields/LegalFormField/LegalFormField.tsx
+function LegalFormField({ name = "legalForm", data, valid, errorMessage, label, readonly, handleChangeFor, countryCode }) {
+	const { t: commonT } = useTranslation("common");
+	const { data: legalFormsData } = useLegalForms(countryCode);
+	const handleChangeForRef = useRef(handleChangeFor);
+	useEffect(() => {
+		handleChangeForRef.current = handleChangeFor;
+	}, [handleChangeFor]);
+	const handleChangeForLegalForm = useCallback((e) => {
+		const legalFormEvent = { target: {
+			name: "legalForm",
+			value: e.target.value
+		} };
+		handleChangeFor("legalForm")(legalFormEvent);
+	}, [handleChangeFor]);
+	useEffect(() => {
+		const legalFormEvent = { target: {
+			name: "legalFormLabel",
+			value: legalFormsData?.find((legalForm) => legalForm.id === data.legalForm)?.name
+		} };
+		handleChangeForRef.current("legalFormLabel")(legalFormEvent);
+	}, [data.legalForm, legalFormsData]);
+	return /* @__PURE__ */ jsx(Field, {
+		name,
+		label: label || commonT(($) => $["businessStructure"]),
+		errorMessage,
+		isValid: valid.legalForm,
+		children: (childProps) => /* @__PURE__ */ jsx(Select, {
+			...childProps,
+			name,
+			placeholder: commonT(($) => $["selectOne"]),
+			selected: data.legalForm,
+			items: legalFormsData ?? [],
+			readonly: readonly && !!data,
+			onChange: handleChangeForLegalForm
+		})
+	});
+}
+//#endregion
+//#region src/components/ui/molecules/InputCurrency/InputCurrency.tsx
+var logger = createLogger();
+var determineDecimalSeparator = (formatter) => formatter.formatToParts(.1).find((part) => part.type === "decimal").value;
+var determineCurrencySymbol = (formatter) => formatter.formatToParts(0).find((part) => part.type === "currency").value;
+var getNumberFromFormattedCurrency = (formatted, decimalSeparator) => {
+	const lastDecimalIndex = formatted.lastIndexOf(decimalSeparator);
+	const normalized = Array.from(formatted).reduce((acc, curr, i) => {
+		if (/[0-9]/.test(curr)) return acc + curr;
+		if (i === lastDecimalIndex) return `${acc}.`;
+		return acc;
+	}, "");
+	return parseFloat(normalized);
+};
+var InputCurrency = ({ locale, currency, amount, onAmountChanged, ...baseProps }) => {
+	const formatter = useMemo(() => new Intl.NumberFormat(locale, {
+		style: "currency",
+		currency
+	}), [locale, currency]);
+	const decimalSeparator = useMemo(() => determineDecimalSeparator(formatter), [formatter]);
+	const currencySymbol = useMemo(() => determineCurrencySymbol(formatter), [formatter]);
+	const [text, setText] = useState("");
+	const onInput = (e) => {
+		setText(e.currentTarget.value);
+	};
+	const onBlur = (e) => {
+		const rawValue = e.currentTarget.value;
+		const value = getNumberFromFormattedCurrency(rawValue, decimalSeparator);
+		if (Number.isNaN(value)) {
+			logger.warn(`Unable to get number from formatted currency: "${rawValue}"`);
+			setText(isUndefinedOrNull(amount) ? currencySymbol : formatter.format(amount));
+			return;
+		}
+		onAmountChanged(value);
+	};
+	useEffect(() => {
+		setText(isUndefinedOrNull(amount) ? currencySymbol : formatter.format(amount));
+	}, [
+		amount,
+		currencySymbol,
+		formatter
+	]);
+	return /* @__PURE__ */ jsx(InputText, {
+		...baseProps,
+		value: text,
+		onInput,
+		onBlur
+	});
+};
+//#endregion
+//#region src/components/ui/molecules/InputNumber/InputNumber.tsx
+function InputNumber(props) {
+	return /* @__PURE__ */ jsx(InputBase, {
+		...props,
+		type: "number"
+	});
+}
+//#endregion
+//#region src/components/Shared/fields/Currency/Currency.tsx
+var CURRENCY_FIELD = ["currency"];
+function Currency({ data, valid, errors, labels, readonly, handleChangeFor, country }) {
+	const { t } = useTranslation("common");
+	const currenciesForCurrCountry = currencyByCountry[country];
+	const countryCurrenciesItems = currenciesForCurrCountry ? currenciesForCurrCountry.map((currency) => ({
+		id: currency,
+		name: currency
+	})) : [];
+	return /* @__PURE__ */ jsx(Field, {
+		name: "currency",
+		label: labels.currency,
+		errorMessage: errors.currency,
+		isValid: valid.currency,
+		dataTestId: "currency",
+		children: (childProps) => /* @__PURE__ */ jsx(Select, {
+			...childProps,
+			onChange: handleChangeFor("currency", "blur"),
+			name: "currency",
+			placeholder: t(($) => $["currencyPlaceholder"]),
+			selected: data.currency,
+			items: countryCurrenciesItems,
+			readonly: readonly && !!data.currency
+		})
+	});
+}
+//#endregion
+export { LegalFormField as a, InputCurrency as i, Currency as n, mapFinancialReportsToFinancialInformation as o, InputNumber as r, mapFinancialInformationToFinancialReport as s, CURRENCY_FIELD as t };

package/dist/CustomerSupport-Brw718_1.js

@@ -0,0 +1,129 @@
+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] = "8643642b-ed1f-4deb-b99f-31f06b2ab698", e._sentryDebugIdIdentifier = "sentry-dbid-8643642b-ed1f-4deb-b99f-31f06b2ab698");
+} catch (e) {}
+import { o as createLogger, r as useTranslation } from "./translation-hEYGx0ZB.js";
+import { r as Loader, t as Button } from "./Button-CAoywEKy.js";
+import { r as useLegalEntity, t as ROOT_LE } from "./useLegalEntity-CJD0bWSj.js";
+import { t as Header } from "./Header-BI6ESU0g.js";
+import { C as EntityTypes } from "./processCapabilities-CDSEJpB8.js";
+import { t as useAnalyticsContext } from "./useAnalyticsContext-D6DJZmqu.js";
+import { t as useToastContext } from "./useToastContext-d6uY8F_F.js";
+import { n as useCapabilityProblems, t as getProblemsForEntity } from "./getProblemsForEntity-_KT3YxwG.js";
+import { t as useUpdateLegalEntity } from "./useUpdateLegalEntity-24uhTBvq.js";
+import { a as defaultFieldMetadata, i as contactDetailsValidationRules, l as useValidatePhoneNumberImperatively, o as fieldConfig, s as getAsyncPhoneValidationRules, t as ContactDetails } from "./ContactDetails-BF42eW3s.js";
+import { t as ErrorPanel } from "./ErrorPanel-BXe3GGb1.js";
+import { t as createFormUtils } from "./formUtils-DcRJcDH1.js";
+import { t as useMultiForm } from "./useMultiForm-BP_UxwIw.js";
+import { t as useTaskLandedEvent } from "./useTaskLandedEvent-BC_AIUoQ.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-m7oWP1DZ.js";
+import { t as Spacer } from "./Spacer-CIwzVSSs.js";
+import { useCallback, useMemo } from "preact/hooks";
+import { jsx, jsxs } from "preact/jsx-runtime";
+import { useQueryClient } from "@tanstack/preact-query";
+//#region src/components/Shared/tasks/CustomerSupport/mapping/mapCustomerSupportSchemaToCustomerSupportType.ts
+var mapCustomerSupportSchemaToCustomerSupportType = (customerSupport) => {
+	return {
+		email: customerSupport?.customerSupport?.email || "",
+		phone: {
+			number: customerSupport?.customerSupport?.phoneNumber?.number || "",
+			type: "mobile"
+		}
+	};
+};
+//#endregion
+//#region src/components/Shared/tasks/CustomerSupport/CustomerSupport.tsx
+var logger = createLogger();
+var CustomerSupport = (props) => {
+	const { data, isLoading } = useLegalEntity(ROOT_LE);
+	if (isLoading || !data) return /* @__PURE__ */ jsx(Loader, { size: "large" });
+	return /* @__PURE__ */ jsx(CustomerSupportInner, {
+		...props,
+		legalEntity: data
+	});
+};
+function CustomerSupportInner({ country, onSubmit, legalEntity }) {
+	const capabilityProblems = useCapabilityProblems();
+	const problems = capabilityProblems ? getProblemsForEntity(capabilityProblems, EntityTypes.LEGAL_ENTITY, legalEntity.id) : void 0;
+	const { t } = useTranslation("common");
+	const userEvents = useAnalyticsContext();
+	const { showToast } = useToastContext();
+	const formUtils = createFormUtils({}, t);
+	const { mutateAsync: updateLegalEntity } = useUpdateLegalEntity();
+	const queryClient = useQueryClient();
+	const requiredFields = { customerSupport: ["email", "phoneNumber"] };
+	const validators = useCallback((data) => ({ customerSupport: {
+		...contactDetailsValidationRules,
+		phoneNumber: resolveFieldMetadata(fieldConfig[data?.customerSupport?.phoneNumber?.phoneCountryCode ?? country], {}, defaultFieldMetadata)?.validators
+	} }), [country]);
+	const validatePhoneNumber = useValidatePhoneNumberImperatively();
+	const asyncValidators = useMemo(() => ({ customerSupport: { phoneNumber: getAsyncPhoneValidationRules(validatePhoneNumber).phoneNumber } }), [validatePhoneNumber]);
+	const legalEntityType = legalEntity.type;
+	const { data, handleChangeFor, valid, errors, isValid, triggerValidation } = useMultiForm({
+		requiredFields,
+		defaultData: { customerSupport: {
+			phoneNumber: legalEntity[legalEntityType]?.support?.phone,
+			email: legalEntity[legalEntityType]?.support?.email
+		} },
+		rules: validators,
+		asyncRules: asyncValidators
+	});
+	/**
+	* Analytics
+	*/
+	useTaskLandedEvent("CUSTOMER_SUPPORT");
+	const submitForm = async () => {
+		const isAsyncValidationValid = await triggerValidation("customerSupport");
+		if (!isValid?.customerSupport || !isAsyncValidationValid) return;
+		const support = mapCustomerSupportSchemaToCustomerSupportType(data);
+		const payload = { [legalEntityType]: { support } };
+		try {
+			await updateLegalEntity({
+				...payload,
+				id: legalEntity.id
+			});
+			queryClient.invalidateQueries({ queryKey: ["legalEntity", legalEntity?.id] });
+			onSubmit();
+			userEvents.addTaskEvent("Success", { actionType: "submit" });
+		} catch {
+			const label = t(($) => $["failedToUpdateDetails"]);
+			logger.error(label, payload);
+			showToast({
+				label,
+				variant: "error"
+			});
+		}
+	};
+	const handleFieldChange = (fieldName, mode) => handleChangeFor(fieldName, "customerSupport", mode);
+	return /* @__PURE__ */ jsxs("form", {
+		"aria-describedby": "ariaErrorField",
+		children: [
+			/* @__PURE__ */ jsx(Header, {
+				title: t(($) => $["customerSupport"]),
+				description: t(($) => $["howYourCustomersCanReachYou"])
+			}),
+			/* @__PURE__ */ jsx(ErrorPanel, {
+				verificationErrors: problems?.verificationErrors?.["customerSupport"],
+				formUtils,
+				id: "ariaErrorField"
+			}),
+			/* @__PURE__ */ jsx(ContactDetails, {
+				data: data.customerSupport,
+				errors: errors.customerSupport,
+				valid: valid.customerSupport,
+				country,
+				requiredFields: requiredFields?.customerSupport,
+				handleFieldChange
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				class: "adyen-kyc-u-display-flex adyen-kyc-u-margin-top-48",
+				children: [/* @__PURE__ */ jsx(Spacer, {}), /* @__PURE__ */ jsx(Button, {
+					onClick: submitForm,
+					children: t(($) => $["submit"])
+				})]
+			})
+		]
+	});
+}
+//#endregion
+export { CustomerSupport };