@adyen/kyc-components 4.23.0 → 4.24.0-beta.0

package/dist/IdentityNumber-3V6ZqvHB.js

@@ -0,0 +1,540 @@
+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] = "c4269a41-4dea-45a9-95e0-eea1e9fbb594", e._sentryDebugIdIdentifier = "sentry-dbid-c4269a41-4dea-45a9-95e0-eea1e9fbb594");
+} catch (e) {}
+import { r as useTranslation } from "./translation-DbATp_35.js";
+import { t as CountryCodes } from "./country-code-CJk2hdPu.js";
+import { r as translateTranslatable } from "./utils-CYUYe54m.js";
+import { n as mergeFieldMetadataIntoProps, t as createFormUtils } from "./formUtils-DVDcdZsP.js";
+import { t as Field } from "./Field-DwDJQVSS.js";
+import { t as Checkbox } from "./Checkbox-qfdF12cF.js";
+import { o as validatePatternOnBlur } from "./patternValidators-DsrZkuOO.js";
+import { t as resolveFieldMetadata } from "./fieldConfigurations-CZCFghnK.js";
+import { a as nonInputs, c as MaskedInput, i as makeMask, n as alphanumericInputs, o as numericInputs, r as customInputs, s as spacer, t as alphaInputs } from "./maskHelpers-C0wnCoJl.js";
+import { t as uppercase } from "./uppercase-DvjwUM0n.js";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+//#region src/utils/regex/countryIdNumberPatterns.ts
+var CountryIdNumberPatterns = {
+	[CountryCodes.Brazil]: /^\d{11}$/,
+	[CountryCodes.Canada]: /^\d{9}$/,
+	[CountryCodes.Croatia]: /^\d{11}$/,
+	[CountryCodes.Denmark]: /^\d{10}$/,
+	[CountryCodes.Italy]: /^[A-Z]{6}[0-9]{2}[ABCDEHLMPRST][0-9]{2}[A-Z][0-9]{3}[A-Z]$/,
+	[CountryCodes.Mexico]: /^[A-Z]{4}\d{6}[A-Z]{6}[A-Z\d]\d$/,
+	[CountryCodes.Poland]: /^\d{11}$/,
+	[CountryCodes.Romania]: /^\d{13}$/,
+	[CountryCodes.Singapore]: /^[A-Z][0-9]{7}[A-Z]$/,
+	[CountryCodes.Spain]: {
+		dni: /(^[KL]?\d{8}[A-Z]$)/,
+		nie: /(^[MXYZ]\d{7,8}[A-Z]$)/
+	},
+	[CountryCodes.Sweden]: /^\d{10}$|^\d{12}$/,
+	[CountryCodes.UnitedStates]: {
+		ssn: /^\d{9}$/,
+		ssnLastFour: /^\d{4}$/
+	}
+};
+//#endregion
+//#region src/utils/regex/driversLicenseCardNumberPatterns.ts
+var DriversLicenseCardNumberPatterns = {
+	[CountryCodes.NewZealand]: /^[\d]{3}$/,
+	[CountryCodes.Australia]: /^[A-Z0-9]{5,11}$/
+};
+//#endregion
+//#region src/utils/regex/driversLicenseNumberPatterns.ts
+var DriversLicenseNumberPatterns = {
+	[CountryCodes.Australia]: /^[A-Za-z0-9]{5,11}$/,
+	[CountryCodes.HongKong]: /^[A-Z0-9]{8}$/,
+	[CountryCodes.NewZealand]: /^[A-Z]{2}[0-9]{6}$/
+};
+//#endregion
+//#region src/utils/regex/passportNumberPatterns.ts
+var PassportNumberPatterns = {
+	[CountryCodes.Australia]: /^[A-Z0-9]{8,9}$/,
+	[CountryCodes.HongKong]: /^[A-Z0-9]{9}$/,
+	[CountryCodes.NewZealand]: /^[A-Z0-9]{8,9}$/
+};
+//#endregion
+//#region src/utils/regex/proofOfIdentityCardPatterns.ts
+var ProofOfIdentityCardPatterns = { [CountryCodes.HongKong]: /^[A-Z]{1,2}[0-9]{6}[0-9A]$/ };
+//#endregion
+//#region src/utils/verification/helpers/verifyIdNumber.ts
+var COUNTRY_ID_NUMBER_MASKS = {
+	[CountryCodes.PuertoRico]: { length: 4 },
+	[CountryCodes.UnitedStates]: { length: 4 }
+};
+var COUNTRY_ID_NUMBER_UNMASKED = {
+	[CountryCodes.PuertoRico]: { length: 9 },
+	[CountryCodes.UnitedStates]: { length: 9 }
+};
+var ID_NUMBER_VERIFICATION_COUNTRIES = [CountryCodes.PuertoRico, CountryCodes.UnitedStates];
+var FIELD = "idNumber";
+var handleVerifyIdNumber = async (formData, basicDetails, verifyFn) => {
+	const country = formData.country;
+	const verified = {
+		field: "idNumber",
+		isVerified: true
+	};
+	if (formData.idNumberExempt || !country) return verified;
+	if (!ID_NUMBER_VERIFICATION_COUNTRIES.includes(country)) return verified;
+	const isCountryWithMaskedIdNumber = Object.keys(COUNTRY_ID_NUMBER_MASKS).includes(country);
+	const isValueMasked = formData.idNumber?.length === COUNTRY_ID_NUMBER_MASKS[country]?.length;
+	const hasCompleteValue = formData.idNumber?.length === COUNTRY_ID_NUMBER_UNMASKED[country]?.length;
+	if (isCountryWithMaskedIdNumber && isValueMasked) return verified;
+	if (!hasCompleteValue) return {
+		field: "idNumber",
+		isVerified: false
+	};
+	const response = await verifyFn({
+		name: {
+			firstName: basicDetails.firstName || "",
+			lastName: basicDetails.lastName || ""
+		},
+		countryCode: country,
+		idNumber: formData.idNumber || ""
+	});
+	if (response?.status === 422 || response?.verified === "false") return {
+		field: FIELD,
+		isVerified: false
+	};
+	return {
+		field: FIELD,
+		isVerified: true
+	};
+};
+//#endregion
+//#region src/components/Individual/fields/IdentityNumber/fieldConfig.ts
+var getAsyncIdNumberValidationRule = (verifyIdNumber, additionalPersonalDetails, basicDetails) => ({ idNumber: {
+	asyncValidate: async (idNumber) => {
+		if (!idNumber || !additionalPersonalDetails || !basicDetails) return false;
+		return (await handleVerifyIdNumber(additionalPersonalDetails, basicDetails, verifyIdNumber)).isVerified;
+	},
+	errorMessage: "unableToVerifyTheIdNumber",
+	modes: ["blur", "input"]
+} });
+var defaultFieldMetadata = { label: "idNumber" };
+var defaultFieldConfig = {
+	[CountryCodes.Brazil]: {
+		label: "cadastroDePessoasFisicas",
+		mask: { mask: makeMask(...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" . "), ...numericInputs(3), ...nonInputs(" - "), ...numericInputs(2)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Brazil]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "231.002.999-00"
+			}
+		}
+	},
+	[CountryCodes.Canada]: {
+		label: "socialInsuranceNumber",
+		mask: { mask: makeMask(...numericInputs(3), spacer, ...numericInputs(3), spacer, ...numericInputs(3)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Canada]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "9",
+				example: "046 454 286"
+			}
+		}
+	},
+	[CountryCodes.Croatia]: {
+		label: "oib",
+		mask: { mask: makeMask(...numericInputs(11)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Croatia]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "94577403194"
+			}
+		}
+	},
+	[CountryCodes.Denmark]: {
+		label: "detCentralePersonregister",
+		mask: { mask: makeMask(...numericInputs(6), ...nonInputs(" - "), ...numericInputs(4)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Denmark]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "10",
+				example: "010111-1113"
+			}
+		}
+	},
+	[CountryCodes.Italy]: {
+		label: "codiceFiscale",
+		mask: {
+			mask: makeMask(...alphaInputs(6), ...numericInputs(2), ...customInputs(1, /^[ABCDEHLMPRST]$/), ...numericInputs(2), ...alphaInputs(1), ...numericInputs(3), ...alphaInputs(1)),
+			transformOnType: uppercase
+		},
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Italy]),
+		guidanceText: {
+			key: "enterNCharactersWithAMixForExample",
+			values: {
+				numChars: "16",
+				example: "YULSQG40E60L271T"
+			}
+		}
+	},
+	[CountryCodes.Mexico]: {
+		label: "curp",
+		mask: {
+			mask: makeMask(...alphaInputs(4), ...numericInputs(6), ...alphaInputs(6), ...alphanumericInputs(1), ...numericInputs(1)),
+			transformOnType: uppercase
+		},
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Mexico]),
+		guidanceText: {
+			key: "enterNCharactersWithAMixForExample",
+			values: {
+				numChars: "18",
+				example: "GOMC800101HDFRRL09"
+			}
+		}
+	},
+	[CountryCodes.Poland]: {
+		label: "peselNumber",
+		mask: { mask: makeMask(...numericInputs(11)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Poland]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "11",
+				example: "23012224757"
+			}
+		}
+	},
+	[CountryCodes.PuertoRico]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "ssn": return {
+				label: "socialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(3), ...nonInputs(" - "), ...numericInputs(2), ...nonInputs(" - "), ...numericInputs(4)) },
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.UnitedStates].ssn),
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "9",
+						example: "123-12-1234"
+					}
+				}
+			};
+			default: return {
+				label: "last4DigitsOfSocialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(4)) },
+				validators: {
+					modes: ["blur"],
+					validate: (val) => !!val && CountryIdNumberPatterns[CountryCodes.UnitedStates].ssnLastFour.test(val),
+					errorMessage: "mustContain4Digits"
+				}
+			};
+		}
+	},
+	[CountryCodes.Romania]: {
+		label: "codNumericPersonal",
+		mask: { mask: makeMask(...numericInputs(13)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Romania]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "13",
+				example: "8001011234567"
+			}
+		}
+	},
+	[CountryCodes.Singapore]: {
+		label: "nric",
+		mask: {
+			mask: makeMask(...alphaInputs(1), ...numericInputs(7), ...alphaInputs(1)),
+			transformOnType: uppercase
+		},
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Singapore]),
+		guidanceText: {
+			key: "enterNCharactersWithAMixForExample",
+			values: {
+				numChars: "9",
+				example: "T9123456J"
+			}
+		}
+	},
+	[CountryCodes.Spain]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "dni": return {
+				label: "dni",
+				mask: {
+					mask: makeMask(...customInputs(1, /^[KL]$/, true), ...numericInputs(8), ...alphaInputs(1)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Spain].dni),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "9",
+						maxChars: "10",
+						example: "12345678A or L12345678A"
+					}
+				}
+			};
+			default: return {
+				label: "nie",
+				mask: {
+					mask: makeMask(...customInputs(1, /^[MXYZ]$/), ...numericInputs(7), ...numericInputs(1, true), ...alphaInputs(1)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Spain].nie),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "9",
+						maxChars: "10",
+						example: "X12345678A or Z6527153N"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Sweden]: {
+		label: "personnummer",
+		mask: { mask: makeMask(...numericInputs(6), ...numericInputs(2, true), ...nonInputs(" - "), ...numericInputs(4)) },
+		validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.Sweden]),
+		guidanceText: {
+			key: "enterXOrYDigitsForExample",
+			values: {
+				xDigits: "10",
+				yDigits: "12",
+				example: "640823-3234 or 19640823-3234"
+			}
+		}
+	},
+	[CountryCodes.UnitedStates]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "ssn": return {
+				label: "socialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(3), ...nonInputs(" - "), ...numericInputs(2), ...nonInputs(" - "), ...numericInputs(4)) },
+				validators: validatePatternOnBlur(CountryIdNumberPatterns[CountryCodes.UnitedStates].ssn),
+				guidanceText: {
+					key: "enterNDigitsForExample",
+					values: {
+						numDigits: "9",
+						example: "123-12-1234"
+					}
+				}
+			};
+			default: return {
+				label: "last4DigitsOfSocialSecurityNumber",
+				mask: { mask: makeMask(...numericInputs(4)) },
+				validators: {
+					modes: ["blur"],
+					validate: (val) => !!val && CountryIdNumberPatterns[CountryCodes.UnitedStates].ssnLastFour.test(val),
+					errorMessage: "mustContain4Digits"
+				}
+			};
+		}
+	},
+	[CountryCodes.NewZealand]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "passport": return {
+				label: "passportNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(9)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(PassportNumberPatterns[CountryCodes.NewZealand]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "8",
+						maxChars: "9",
+						example: "RA000750"
+					}
+				}
+			};
+			default: return {
+				label: "licenseNumber",
+				mask: {
+					mask: makeMask(...alphaInputs(2), ...numericInputs(6)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(DriversLicenseNumberPatterns[CountryCodes.NewZealand]),
+				guidanceText: {
+					key: "enterNCharactersWithAMixForExample",
+					values: {
+						numChars: "8",
+						example: "KA111112"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.HongKong]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "proofOfIdentityCard": return {
+				label: "hkid",
+				mask: {
+					mask: makeMask(...alphaInputs(1), ...alphaInputs(1, true), ...numericInputs(6), ...nonInputs("(", { displayEagerly: false }), ...customInputs(1, /^[0-9A]$/), ...nonInputs(")")),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(ProofOfIdentityCardPatterns[CountryCodes.HongKong]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "8",
+						maxChars: "9",
+						example: "Z683365(5) or AB123456(A)"
+					}
+				}
+			};
+			case "passport": return {
+				label: "passportNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(9)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(PassportNumberPatterns[CountryCodes.HongKong]),
+				guidanceText: {
+					key: "enterNCharactersWithAMixForExample",
+					values: {
+						numChars: "9",
+						example: "H12345678"
+					}
+				}
+			};
+			default: return {
+				label: "licenseNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(7), spacer, ...alphanumericInputs(1)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(DriversLicenseNumberPatterns[CountryCodes.HongKong]),
+				guidanceText: {
+					key: "enterNCharactersForExample",
+					values: {
+						numChars: "8",
+						example: "A123452 0"
+					}
+				}
+			};
+		}
+	},
+	[CountryCodes.Australia]: ({ idNumberType }) => {
+		switch (idNumberType) {
+			case "passport": return {
+				label: "passportNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(9)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(PassportNumberPatterns[CountryCodes.Australia]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "8",
+						maxChars: "9",
+						example: "RA0123456"
+					}
+				}
+			};
+			default: return {
+				label: "licenseNumber",
+				mask: {
+					mask: makeMask(...alphanumericInputs(6), ...alphanumericInputs(5, true)),
+					transformOnType: uppercase
+				},
+				validators: validatePatternOnBlur(DriversLicenseNumberPatterns[CountryCodes.Australia]),
+				guidanceText: {
+					key: "enterXToYCharactersWithAMixForExample",
+					values: {
+						minChars: "5",
+						maxChars: "11",
+						example: "2093628291"
+					}
+				}
+			};
+		}
+	}
+};
+var licenseCardNumberDefaultMetadata = { label: "licenseCardNumber" };
+var licenseCardNumberDefaultConfig = {
+	[CountryCodes.NewZealand]: {
+		label: "licenceVersionNumber",
+		mask: { mask: makeMask(...numericInputs(3)) },
+		validators: validatePatternOnBlur(DriversLicenseCardNumberPatterns[CountryCodes.NewZealand]),
+		guidanceText: {
+			key: "enterNDigitsForExample",
+			values: {
+				numDigits: "3",
+				example: "108"
+			}
+		}
+	},
+	[CountryCodes.Australia]: {
+		label: "licenseCardNumber",
+		mask: {
+			mask: makeMask(...alphanumericInputs(6), ...alphanumericInputs(5, true)),
+			transformOnType: uppercase
+		},
+		validators: validatePatternOnBlur(DriversLicenseCardNumberPatterns[CountryCodes.Australia]),
+		guidanceText: {
+			key: "enterXToYCharactersWithAMixForExample",
+			values: {
+				minChars: "5",
+				maxChars: "11",
+				example: "2093628291"
+			}
+		}
+	}
+};
+var idNumberExemptDefaultMetadata = { label: "identityNumberExempt" };
+var idNumberExemptDefaultConfig = {
+	[CountryCodes.UnitedStates]: { label: "identityNumberExempt__US" },
+	[CountryCodes.Canada]: { label: "identityNumberExempt__CA" },
+	[CountryCodes.Mexico]: { label: "identityNumberExempt__MX" },
+	[CountryCodes.Singapore]: { label: "uploadDocumentForNric" }
+};
+//#endregion
+//#region src/components/Individual/fields/IdentityNumber/IdentityNumber.tsx
+var idNumberFields = ["idNumber", "idNumberExempt"];
+function IdentityNumber(props) {
+	const { t } = useTranslation("common");
+	const { country, data, errors, fieldValidationErrors, idNumberType, obscuredFields, requiredFields, optionalFields, fieldConfig: propFieldConfig, readOnlyFields, handleFieldChange, valid } = props;
+	if (!handleFieldChange) return;
+	const metadata = resolveFieldMetadata((propFieldConfig ?? defaultFieldConfig)[country], { idNumberType }, defaultFieldMetadata);
+	const formUtils = createFormUtils(mergeFieldMetadataIntoProps("idNumberExempt", resolveFieldMetadata(idNumberExemptDefaultConfig[country], {}, idNumberExemptDefaultMetadata), mergeFieldMetadataIntoProps("idNumber", metadata, {
+		requiredFields,
+		optionalFields,
+		obscuredFields,
+		readOnlyFields
+	})), t);
+	const errorMessage = formUtils.getErrorMessage("idNumber", errors, fieldValidationErrors);
+	return /* @__PURE__ */ jsx("div", { children: formUtils.isVisibleField("idNumber") && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(MaskedInput, {
+		name: "idNumber",
+		type: "text",
+		label: formUtils.getLabel("idNumber", "idNumber"),
+		formatGuidance: translateTranslatable(t, metadata.guidanceText),
+		errorMessage,
+		shouldValidate: errors?.idNumber?.hasError,
+		isValid: !!valid?.idNumber,
+		"aria-required": formUtils.isRequiredField("idNumber"),
+		"aria-invalid": !valid?.idNumber,
+		disabled: data?.idNumberExempt,
+		onBlur: handleFieldChange("idNumber", "blur"),
+		readonly: formUtils.isReadOnly("idNumber"),
+		value: data?.idNumberExempt ? "" : data?.idNumber ?? "",
+		onInput: (e) => {
+			handleFieldChange("idNumber", "input")(e);
+			handleFieldChange("idNumberExempt", "input")(false);
+		},
+		acceptObscuredValue: formUtils?.isObscured("idNumber"),
+		...formUtils.getMask("idNumber")
+	}), formUtils.isVisibleField("idNumberExempt") && /* @__PURE__ */ jsx(Field, {
+		name: "idNumberExempt",
+		children: (childProps) => /* @__PURE__ */ jsx(Checkbox, {
+			...childProps,
+			label: formUtils.getLabel("idNumberExempt"),
+			checked: Boolean(data?.idNumberExempt),
+			name: "idNumberExempt",
+			onChange: handleFieldChange("idNumberExempt")
+		})
+	})] }) });
+}
+//#endregion
+export { getAsyncIdNumberValidationRule as a, defaultFieldMetadata as i, idNumberFields as n, licenseCardNumberDefaultConfig as o, defaultFieldConfig as r, licenseCardNumberDefaultMetadata as s, IdentityNumber as t };

package/dist/IdentityNumberFieldGroup-CAjlgTWn.js

@@ -0,0 +1,57 @@
+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] = "9df7f798-5a71-4e37-9f58-a88b06fc13f6", e._sentryDebugIdIdentifier = "sentry-dbid-9df7f798-5a71-4e37-9f58-a88b06fc13f6");
+} catch (e) {}
+import { t as IdentityNumber } from "./IdentityNumber-3V6ZqvHB.js";
+import { n as withForm } from "./formHook-Dgi2CgbT.js";
+import { useCallback } from "preact/hooks";
+import { jsx } from "preact/jsx-runtime";
+import { useStore } from "@tanstack/preact-form";
+//#region src/adaptiveWorkflow/components/Fields/IdentityNumber/IdentityNumberFieldGroup.tsx
+function getNestedValue(obj, path) {
+	return path.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function getEventValue(value) {
+	if (value && typeof value === "object" && "currentTarget" in value) {
+		const currentTarget = value.currentTarget;
+		if (currentTarget?.type === "checkbox") return currentTarget.checked;
+		return currentTarget?.value;
+	}
+	return value;
+}
+var IdentityNumberFieldGroup = withForm({
+	defaultValues: {},
+	props: {},
+	render: function IdentityNumberFieldGroupRender({ form, basePath, country, idNumberType, optionalFields, readOnlyFields, obscuredFields }) {
+		const idNumberPath = `${basePath}.idNumber`;
+		const idNumberExemptPath = `${basePath}.idNumberExempt`;
+		return /* @__PURE__ */ jsx(IdentityNumber, {
+			country,
+			data: useStore(form.store, (s) => ({
+				idNumber: getNestedValue(s.values, idNumberPath),
+				idNumberExempt: getNestedValue(s.values, idNumberExemptPath)
+			})),
+			errors: {},
+			fieldValidationErrors: {},
+			handleFieldChange: useCallback((fieldName, _mode) => (value) => {
+				const fieldPath = fieldName === "idNumber" ? idNumberPath : idNumberExemptPath;
+				form.setFieldValue(fieldPath, getEventValue(value));
+			}, [
+				form,
+				idNumberPath,
+				idNumberExemptPath
+			]),
+			idNumberType,
+			obscuredFields,
+			optionalFields,
+			readOnlyFields,
+			requiredFields: ["idNumber"],
+			valid: {
+				idNumber: true,
+				idNumberExempt: true
+			}
+		});
+	}
+});
+//#endregion
+export { IdentityNumberFieldGroup };