@incodetech/core 2.4.1-agentic.4 → 2.4.1-agentic.6

package/dist/ekycRules-B7vXnbdg.esm.js

@@ -0,0 +1,319 @@
+import { t as getLocalIsoDate } from "./IBrowserEnvironmentCapability-D7JG7ML3.esm.js";
+import { n as loadPhoneValidation, t as getPhoneValidation } from "./phoneValidation-OggtfjRt.esm.js";
+import { a as isValidRut, i as isValidInDrivingLicenseNumber, n as isValidEsDni, r as isValidFiPersonalIdentityCode, t as isValidCurp } from "./nationalIds-B91f_RuB.esm.js";
+import { a as getPostalCodeMaxLength, i as getPostalCodeErrorKey, n as FIXED_DIGIT_POSTAL_CODE_LENGTH, o as validatePostalCode, s as STREET_LEVEL_REQUIRED_ERROR } from "./definitionSource-1vPLtuXE.esm.js";
+import { r as DYNAMIC_REQUIRED_KEY } from "./resolveForm-f9PhUo9j.esm.js";
+import { t as validateCPF } from "./cpf-BIADjddF.esm.js";
+import { a as hasNameCharacters, c as isWithinMaxAge, i as hasDigitCount, l as matchesCharTemplate, o as isInNumericRange, r as hasAllowedCharacters, s as isNotFuture } from "./phoneFormat-DEpESpz2.esm.js";
+//#region src/modules/ekyc/ekycValidators.ts
+async function loadPhoneValidator() {
+	if (!await loadPhoneValidation()) throw new Error("Failed to load the phone validation rules");
+}
+/** Progressively formats an SSN as XXX-XX-XXXX */
+function formatSSN(value) {
+	const ssn = value?.replace(/\D/g, "") ?? "";
+	if (ssn.length < 4) return ssn;
+	if (ssn.length < 6) return `${ssn.slice(0, 3)}-${ssn.slice(3)}`;
+	return `${ssn.slice(0, 3)}-${ssn.slice(3, 5)}-${ssn.slice(5, 9)}`;
+}
+/**
+* Strips characters a name can't contain, as the user types. Keeps everything
+* `nameCharacters` allows (letters from any script with their combining marks,
+* spaces, hyphens, and straight or typographic apostrophes), plus the commas
+* and acute accents (´) SDKv1 kept, so it never strips a valid name.
+*/
+function cleanName(name) {
+	return (name ?? "").replace(/[^\p{L}\p{M}\s,'’´-]/gu, "").slice(0, 100);
+}
+const PO_BOX_REGEX = /POBox|P\.O\.Box|pobox|postofficebox|postbox|po\.box|p\.o\.box/i;
+/** Returns true if the address looks like a P.O. Box */
+function isPoBox(address) {
+	return PO_BOX_REGEX.test(address.replace(/\s/g, ""));
+}
+function validatePhone(phone, country) {
+	return getPhoneValidation()?.isValid(phone, country) ?? false;
+}
+/** The phone's national significant number, or the value as typed. */
+function formatPhoneNational(phone, country) {
+	return getPhoneValidation()?.nationalNumber(phone, country) ?? phone;
+}
+const ONE_OF_REQUIRED_ERROR_KEY = "verification.errors.dobOrSsnRequired";
+/** The error key a `oneOfRequired` group shows: its own message, or DOB-or-SSN. */
+const oneOfRequiredErrorKey = (rule) => rule.message ?? "verification.errors.dobOrSsnRequired";
+const PHONE_INVALID_KEY = "verification.errors.phoneInvalid";
+const INVALID_ID_NUMBER_KEY = "verification.errors.invalidIdNumber";
+/** The digitCount message: one length, a list of lengths, or a range. */
+const digitCountError = (rule) => {
+	if (rule.lengths?.length === 1) return {
+		key: "verification.errors.exactDigits",
+		params: { length: rule.lengths[0] }
+	};
+	if (rule.lengths) return {
+		key: "verification.errors.digitsOneOf",
+		params: { lengths: rule.lengths }
+	};
+	return {
+		key: "verification.errors.digitsBetween",
+		params: {
+			min: rule.min ?? 0,
+			max: rule.max ?? 0
+		}
+	};
+};
+/**
+* A national ID check: blank passes, anything else must satisfy `isValid`.
+* The error is the vocabulary's message for these rules; a definition names
+* its own with the rule's `message`.
+*/
+const idNumberValidator = (isValid) => (value) => {
+	if (value.trim().length === 0) return void 0;
+	if (isValid(value)) return void 0;
+	return { key: INVALID_ID_NUMBER_KEY };
+};
+const normalizeFieldValue = (value) => typeof value === "string" ? value : String(value ?? "");
+const SSN_FORMAT_REGEX = /^\d{3}-\d{2}-\d{4}$/;
+const EMAIL_FORMAT_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const buildPostalCodeParams = (country) => {
+	const fixedLen = FIXED_DIGIT_POSTAL_CODE_LENGTH[country];
+	if (fixedLen !== void 0) return { length: fixedLen };
+	let maxLen = getPostalCodeMaxLength(country);
+	if (country === "US" || country === "BR") maxLen = maxLen - 1;
+	return { maxLength: maxLen };
+};
+const requiredError = (field) => {
+	const fieldName = field.displayLabel ?? field.label;
+	return fieldName ? {
+		key: DYNAMIC_REQUIRED_KEY,
+		params: { fieldName }
+	} : { key: DYNAMIC_REQUIRED_KEY };
+};
+const isFilled = (values, name) => normalizeFieldValue(values[name]).trim().length > 0;
+const createValidators = () => {
+	const validators = {
+		required: (value, _rule, field) => {
+			if (value.trim().length > 0) return void 0;
+			return requiredError(field);
+		},
+		requiredIfFilled: (value, rule, field, values) => {
+			if (rule.type !== "requiredIfFilled") return void 0;
+			if (value.trim().length > 0) return void 0;
+			return rule.fields.some((name) => isFilled(values, name)) ? requiredError(field) : void 0;
+		},
+		rulesByOption: (value, rule, field, values) => {
+			if (rule.type !== "rulesByOption") return void 0;
+			if (value.trim().length === 0) return void 0;
+			const option = normalizeFieldValue(values[rule.selector]).trim();
+			const rules = Object.prototype.hasOwnProperty.call(rule.cases, option) ? rule.cases[option] : void 0;
+			return evaluateRules(value, rules, field, values, validators);
+		},
+		streetLevelRequired: (value) => {
+			if (value.trim().length > 0) return void 0;
+			return STREET_LEVEL_REQUIRED_ERROR;
+		},
+		cpf: (value) => {
+			if (value.trim().length === 0) return void 0;
+			return validateCPF(value) ? void 0 : { key: "verification.errors.invalidTaxId" };
+		},
+		ssnFormat: (value) => {
+			if (value.trim().length === 0) return void 0;
+			return SSN_FORMAT_REGEX.test(value) ? void 0 : { key: "verification.errors.ssnFormat" };
+		},
+		noPoBox: (value) => {
+			if (value.trim().length === 0) return void 0;
+			return isPoBox(value) ? { key: "verification.errors.poBox" } : void 0;
+		},
+		postalCodeFormat: (value, rule) => {
+			if (rule.type !== "postalCodeFormat") return void 0;
+			if (value.trim().length === 0) return void 0;
+			if (validatePostalCode(value, rule.country)) return void 0;
+			return {
+				key: getPostalCodeErrorKey(rule.country),
+				params: buildPostalCodeParams(rule.country)
+			};
+		},
+		phoneFormat: (value, rule) => {
+			if (rule.type !== "phoneFormat") return void 0;
+			const trimmed = value.trim();
+			if (rule.optional && trimmed.length === 0) return void 0;
+			return validatePhone(trimmed, rule.country) ? void 0 : { key: "verification.errors.phoneInvalid" };
+		},
+		emailFormat: (value) => {
+			if (value.trim().length === 0) return void 0;
+			return EMAIL_FORMAT_REGEX.test(value) ? void 0 : { key: "verification.errors.emailInvalid" };
+		},
+		exactLength: (value, rule) => {
+			if (rule.type !== "exactLength") return void 0;
+			if (value.trim().length === 0) return void 0;
+			return value.length === rule.length ? void 0 : { key: "verification.errors.exactly10Characters" };
+		},
+		nameCharacters: (value) => {
+			if (value.trim().length === 0) return void 0;
+			return hasNameCharacters(value.trim()) ? void 0 : { key: "verification.errors.nameCharacters" };
+		},
+		notFuture: (value) => {
+			if (value.trim().length === 0) return void 0;
+			return isNotFuture(value.trim(), getLocalIsoDate()) ? void 0 : { key: "verification.errors.futureDate" };
+		},
+		maxAge: (value, rule) => {
+			if (rule.type !== "maxAge") return void 0;
+			if (value.trim().length === 0) return void 0;
+			return isWithinMaxAge(value.trim(), getLocalIsoDate(), rule.years) ? void 0 : { key: "verification.errors.dateOfBirthMaxAge" };
+		},
+		phoneDigits: (value, rule) => {
+			if (rule.type !== "phoneDigits") return void 0;
+			const trimmed = value.trim();
+			if (trimmed.length === 0) return void 0;
+			const national = getPhoneValidation()?.nationalNumber(trimmed, rule.country);
+			if (!national) return { key: PHONE_INVALID_KEY };
+			return national.length >= rule.min && national.length <= rule.max ? void 0 : { key: PHONE_INVALID_KEY };
+		},
+		digitCount: (value, rule) => {
+			if (rule.type !== "digitCount") return void 0;
+			if (value.trim().length === 0) return void 0;
+			return hasDigitCount(value.trim(), rule) ? void 0 : digitCountError(rule);
+		},
+		allowedCharacters: (value, rule) => {
+			if (rule.type !== "allowedCharacters") return void 0;
+			if (value.trim().length === 0) return void 0;
+			return hasAllowedCharacters(value.trim(), rule.classes, rule.extra) ? void 0 : { key: "verification.errors.invalidCharacters" };
+		},
+		charTemplate: (value, rule) => {
+			if (rule.type !== "charTemplate") return void 0;
+			if (value.trim().length === 0) return void 0;
+			return matchesCharTemplate(value.trim(), rule.templates, rule.ignoreCase) ? void 0 : { key: "verification.errors.invalidFormat" };
+		},
+		numericRange: (value, rule) => {
+			if (rule.type !== "numericRange") return void 0;
+			if (value.trim().length === 0) return void 0;
+			return isInNumericRange(value.trim(), rule.min, rule.max) ? void 0 : {
+				key: "verification.errors.numberBetween",
+				params: {
+					min: rule.min,
+					max: rule.max
+				}
+			};
+		},
+		rut: idNumberValidator(isValidRut),
+		esDni: idNumberValidator(isValidEsDni),
+		fiPersonalIdentityCode: idNumberValidator(isValidFiPersonalIdentityCode),
+		inDrivingLicenseNumber: idNumberValidator(isValidInDrivingLicenseNumber),
+		curp: idNumberValidator((value) => isValidCurp(value.trim())),
+		oneOfRequired: (_value, rule, _field, values) => {
+			if (rule.type !== "oneOfRequired") return void 0;
+			return rule.fields.some((name) => isFilled(values, name)) ? void 0 : { key: oneOfRequiredErrorKey(rule) };
+		}
+	};
+	return validators;
+};
+/**
+* A rule's own message key shows instead of the validator's, keeping its
+* params. `oneOfRequired` already shows its message.
+*/
+const withRuleMessage = (error, rule) => !rule.message || error.key === rule.message ? error : {
+	...error,
+	key: rule.message
+};
+const evaluateRules = (value, rules, field, values, validators) => {
+	if (!rules) return void 0;
+	for (const rule of rules) {
+		const error = validators[rule.type](value, rule, field, values);
+		if (error) return withRuleMessage(error, rule);
+	}
+};
+function validateEkycForm(values, fields) {
+	const validators = createValidators();
+	return fields.reduce((errors, field) => {
+		const value = normalizeFieldValue(values[field.name]);
+		const error = evaluateRules(value, field.validation, field, values, validators);
+		if (error) errors[field.name] = error;
+		return errors;
+	}, {});
+}
+function validateEkycField(values, fieldName, fields) {
+	const field = fields.find((f) => f.name === fieldName);
+	if (!field) return void 0;
+	const validators = createValidators();
+	const value = normalizeFieldValue(values[field.name]);
+	return evaluateRules(value, field.validation, field, values, validators);
+}
+//#endregion
+//#region src/modules/ekyc/ekycRules.ts
+/** Vocabulary rules expressed as today's `EkycValidationRule` objects. */
+const RULES = {
+	cpf: () => ({ type: "cpf" }),
+	ssnFormat: () => ({ type: "ssnFormat" }),
+	noPoBox: () => ({ type: "noPoBox" }),
+	emailFormat: () => ({ type: "emailFormat" }),
+	postalCodeFormat: ({ country }) => ({
+		type: "postalCodeFormat",
+		country
+	}),
+	phoneFormat: ({ country, required }) => ({
+		type: "phoneFormat",
+		country,
+		optional: !required
+	}),
+	exactLength: ({ params }) => ({
+		type: "exactLength",
+		length: params.length
+	}),
+	nameCharacters: () => ({ type: "nameCharacters" }),
+	notFuture: () => ({ type: "notFuture" }),
+	maxAge: ({ params }) => ({
+		type: "maxAge",
+		years: params.years
+	}),
+	phoneDigits: ({ country, params }) => ({
+		type: "phoneDigits",
+		country,
+		min: params.min,
+		max: params.max
+	}),
+	digitCount: ({ params }) => ({
+		type: "digitCount",
+		...params.lengths !== void 0 && { lengths: [...params.lengths] },
+		...params.min !== void 0 && { min: params.min },
+		...params.max !== void 0 && { max: params.max }
+	}),
+	allowedCharacters: ({ params }) => ({
+		type: "allowedCharacters",
+		classes: [...params.classes],
+		...params.extra !== void 0 && { extra: params.extra }
+	}),
+	charTemplate: ({ params }) => ({
+		type: "charTemplate",
+		templates: [...params.templates],
+		...params.ignoreCase !== void 0 && { ignoreCase: params.ignoreCase }
+	}),
+	numericRange: ({ params }) => ({
+		type: "numericRange",
+		min: params.min,
+		max: params.max
+	}),
+	rut: () => ({ type: "rut" }),
+	esDni: () => ({ type: "esDni" }),
+	fiPersonalIdentityCode: () => ({ type: "fiPersonalIdentityCode" }),
+	inDrivingLicenseNumber: () => ({ type: "inDrivingLicenseNumber" }),
+	curp: () => ({ type: "curp" })
+};
+/**
+* A field's vocabulary rules as today's `EkycValidationRule`s, which
+* `validateEkycField` runs. eKYC Pre-fill validates with them too.
+*/
+function projectRules(rules, country, required) {
+	return rules.flatMap((rule) => {
+		const project = RULES[rule.id];
+		if (!project) return [];
+		const projected = project({
+			country,
+			required,
+			params: rule.params ?? {}
+		});
+		return [rule.message ? {
+			...projected,
+			message: rule.message.key
+		} : projected];
+	});
+}
+//#endregion
+export { formatPhoneNational as a, oneOfRequiredErrorKey as c, cleanName as i, validateEkycField as l, projectRules as n, formatSSN as o, ONE_OF_REQUIRED_ERROR_KEY as r, loadPhoneValidator as s, RULES as t, validateEkycForm as u };