@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/curp-validation.esm.js

@@ -0,0 +1,110 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { i as mexicanStates, n as ENTER_CURP_FIELD, r as GENERATE_CURP_FIELDS, t as curpValidationMachine } from "./curpValidationStateMachine-CitWLr2c.esm.js";
+
+//#region src/modules/curp-validation/curpValidationActor.ts
+function createCurpValidationActor(options) {
+	return createActor(curpValidationMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/curp-validation/curpValidationManager.ts
+const hasNoErrors = (errors) => Object.keys(errors ?? {}).length === 0;
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("enterCurp")) return {
+		status: "enterCurp",
+		curp: context.curp,
+		isValid: hasNoErrors(context.enterCurpValidationErrors),
+		validationErrors: context.enterCurpValidationErrors
+	};
+	if (typedSnapshot.matches("verifying")) return { status: "verifying" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("failure")) return {
+		status: "failure",
+		retriesLeft: context.retriesLeft
+	};
+	if (typedSnapshot.matches("generateCurp")) return {
+		status: "generateCurp",
+		form: context.generateForm,
+		isValid: hasNoErrors(context.generateCurpValidationErrors),
+		validationErrors: context.generateCurpValidationErrors
+	};
+	if (typedSnapshot.matches("generating")) return { status: "generating" };
+	if (typedSnapshot.matches("confirmCurp")) return {
+		status: "confirmCurp",
+		curp: context.curp
+	};
+	if (typedSnapshot.matches("generateError")) return {
+		status: "generateError",
+		retriesLeft: context.retriesLeft
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setCurp(curp) {
+			actor.send({
+				type: "SET_CURP",
+				curp
+			});
+		},
+		validateField(field) {
+			actor.send({
+				type: "VALIDATE_FIELD",
+				field
+			});
+		},
+		verify() {
+			trackElementClicked?.("verify");
+			actor.send({ type: "VERIFY" });
+		},
+		switchToGenerate() {
+			trackElementClicked?.("switchToGenerate");
+			actor.send({ type: "SWITCH_TO_GENERATE" });
+		},
+		setGenerateForm(form) {
+			actor.send({
+				type: "SET_GENERATE_FORM",
+				form
+			});
+		},
+		generate() {
+			trackElementClicked?.("generate");
+			actor.send({ type: "GENERATE" });
+		},
+		confirmGenerated() {
+			trackElementClicked?.("confirmGenerated");
+			actor.send({ type: "CONFIRM" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+function createCurpValidationManager(options) {
+	return createManager({
+		actor: createCurpValidationActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.curpValidation)
+	});
+}
+
+//#endregion
+export { ENTER_CURP_FIELD, GENERATE_CURP_FIELDS, createCurpValidationManager, curpValidationMachine, mexicanStates };

package/dist/curpValidationStateMachine-CitWLr2c.esm.js

@@ -0,0 +1,595 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/curp-validation/curpValidationUtils.ts
+const CURP_PATTERN = /^([A-Z][AEIOUX][A-Z]{2}\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])[HMX](?:AS|B[CS]|C[CLMSH]|D[FG]|G[TR]|HG|JC|M[CNS]|N[ETL]|OC|PL|Q[TR]|S[PLR]|T[CSL]|VZ|YN|ZS)[B-DF-HJ-NP-TV-Z]{3}[A-Z\d])(\d)$/;
+const CURP_LENGTH = 18;
+function isValidCurp(curp) {
+	return typeof curp === "string" && curp.length === CURP_LENGTH && CURP_PATTERN.test(curp.toUpperCase());
+}
+/** Convert YYYY-MM-DD to DD/MM/YYYY for the API */
+function formatDateForApi(date) {
+	const [year, month, day] = date.split("-");
+	return `${day}/${month}/${year}`;
+}
+const mexicanStates = [
+	{
+		value: "NE",
+		label: "Born Abroad"
+	},
+	{
+		value: "AS",
+		label: "Aguascalientes"
+	},
+	{
+		value: "BC",
+		label: "Baja California"
+	},
+	{
+		value: "BS",
+		label: "Baja California Sur"
+	},
+	{
+		value: "CC",
+		label: "Campeche"
+	},
+	{
+		value: "CL",
+		label: "Coahuila de Zaragoza"
+	},
+	{
+		value: "CM",
+		label: "Colima"
+	},
+	{
+		value: "CS",
+		label: "Chiapas"
+	},
+	{
+		value: "CH",
+		label: "Chihuahua"
+	},
+	{
+		value: "DF",
+		label: "Distrito Federal"
+	},
+	{
+		value: "DG",
+		label: "Durango"
+	},
+	{
+		value: "GT",
+		label: "Guanajuato"
+	},
+	{
+		value: "GR",
+		label: "Guerrero"
+	},
+	{
+		value: "HG",
+		label: "Hidalgo"
+	},
+	{
+		value: "JC",
+		label: "Jalisco"
+	},
+	{
+		value: "MC",
+		label: "Estado de México"
+	},
+	{
+		value: "MN",
+		label: "Michoacan de Ocampo"
+	},
+	{
+		value: "MS",
+		label: "Morelos"
+	},
+	{
+		value: "NT",
+		label: "Nayarit"
+	},
+	{
+		value: "NL",
+		label: "Nuevo León"
+	},
+	{
+		value: "OC",
+		label: "Oaxaca"
+	},
+	{
+		value: "PL",
+		label: "Puebla"
+	},
+	{
+		value: "QT",
+		label: "Queretaro de Arteaga"
+	},
+	{
+		value: "QR",
+		label: "Quintana Roo"
+	},
+	{
+		value: "SP",
+		label: "San Luis Potosi"
+	},
+	{
+		value: "SL",
+		label: "Sinaloa"
+	},
+	{
+		value: "SR",
+		label: "Sonora"
+	},
+	{
+		value: "TC",
+		label: "Tabasco"
+	},
+	{
+		value: "TS",
+		label: "Tamaulipas"
+	},
+	{
+		value: "TL",
+		label: "Tlaxcala"
+	},
+	{
+		value: "VZ",
+		label: "Veracruz"
+	},
+	{
+		value: "YN",
+		label: "Yucatan"
+	},
+	{
+		value: "ZS",
+		label: "Zacatecas"
+	}
+];
+
+//#endregion
+//#region src/modules/curp-validation/curpValidationServices.ts
+async function fetchOcrData(signal) {
+	const res = await api.get(endpoints.ocrData, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.ocrData} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addCurp(curp, signal) {
+	const res = await api.post(endpoints.addCurp, { curp }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCurp} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addCurpV2(form, signal) {
+	const payload = {
+		name: form.name,
+		firstLastName: form.firstLastName,
+		secondLastName: form.secondLastName,
+		gender: form.gender,
+		birthDate: formatDateForApi(form.birthDate),
+		state: form.birthState
+	};
+	const res = await api.post(endpoints.addCurpV2, payload, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCurpV2} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/curp-validation/curpFields.ts
+/**
+* Declarative schema for the CURP generation form.
+*
+* `secondLastName` is intentionally optional: many people in Mexico have
+* only a single paternal surname. It carries no validation rules.
+*/
+const GENERATE_CURP_FIELDS = [
+	{
+		key: "name",
+		labelKey: "curp.labels.firstName",
+		type: "text",
+		required: true,
+		autoComplete: "given-name",
+		validation: [{ type: "required" }]
+	},
+	{
+		key: "firstLastName",
+		labelKey: "curp.labels.firstLast",
+		type: "text",
+		required: true,
+		validation: [{ type: "required" }]
+	},
+	{
+		key: "secondLastName",
+		labelKey: "curp.labels.secondLast",
+		type: "text",
+		required: false
+	},
+	{
+		key: "gender",
+		labelKey: "curp.labels.genderV2",
+		type: "dropdown",
+		required: true,
+		validation: [{ type: "required" }]
+	},
+	{
+		key: "birthDate",
+		labelKey: "curp.labels.dob",
+		type: "date",
+		required: true,
+		validation: [{ type: "required" }]
+	},
+	{
+		key: "birthState",
+		labelKey: "curp.labels.birthState",
+		type: "dropdown",
+		required: true,
+		validation: [{ type: "required" }]
+	}
+];
+/**
+* Config for the single field on the CURP entry gateway screen.
+*
+* Validation contains only `curpFormat` — there is intentionally no
+* `required` rule. The user can legitimately leave this field empty
+* and use the "I don't have my CURP" button to switch to the Generate
+* flow; surfacing a "required" error on blur of an empty field would
+* be misleading.
+*
+* The Continue button on this screen is gated by a UI-level no-op guard
+* (`curp.length === 0`) instead, which lives in `curpInput.tsx`.
+*/
+const ENTER_CURP_FIELD = {
+	key: "curp",
+	labelKey: "curp.placeholder.curp",
+	validation: [{ type: "curpFormat" }]
+};
+
+//#endregion
+//#region src/modules/curp-validation/curpValidators.ts
+/**
+* Registry of pure validator functions keyed by rule type.
+*
+* Each validator returns an i18n key when the value violates the rule,
+* or `undefined` when the rule passes. Order of evaluation for a field
+* is the order rules appear in that field's `validation` array; the
+* first failing rule wins.
+*/
+const createValidators = () => ({
+	required: (value) => value.trim().length === 0 ? "curp.errors.fieldRequired" : void 0,
+	curpFormat: (value) => {
+		if (value.trim().length === 0) return void 0;
+		return isValidCurp(value) ? void 0 : "curp.errors.invalidCurpFormat";
+	}
+});
+const normalizeFieldValue = (value) => typeof value === "string" ? value : String(value ?? "");
+const evaluateRules = (value, validation, validators) => {
+	if (!validation) return void 0;
+	for (const rule of validation) {
+		const error = validators[rule.type](value);
+		if (error) return error;
+	}
+};
+/**
+* Runs every Generate-CURP field through its validation rules and returns
+* a map of field-key → first failing i18n error key. Fields that pass are
+* absent from the result. An empty object signals "no errors".
+*/
+const validateGenerateCurpForm = (data, fields) => {
+	const validators = createValidators();
+	return fields.reduce((errors, field) => {
+		const error = evaluateRules(normalizeFieldValue(data[field.key]), field.validation, validators);
+		if (error) errors[field.key] = error;
+		return errors;
+	}, {});
+};
+/**
+* Runs a single Generate-CURP field through its validation rules.
+* Returns the first failing i18n error key, or `undefined`.
+*/
+const validateGenerateCurpField = (data, fieldKey, fields) => {
+	const field = fields.find((f) => f.key === fieldKey);
+	if (!field) return void 0;
+	const validators = createValidators();
+	return evaluateRules(normalizeFieldValue(data[fieldKey]), field.validation, validators);
+};
+/**
+* Runs the single CURP-entry field through its validation rules.
+* Used by both the on-blur validator and the submit-click validator
+* on the CURP entry gateway screen.
+*/
+const validateEnterCurpField = (curp, field = ENTER_CURP_FIELD) => {
+	const validators = createValidators();
+	return evaluateRules(normalizeFieldValue(curp), field.validation, validators);
+};
+
+//#endregion
+//#region src/modules/curp-validation/curpValidationStateMachine.ts
+const DEFAULT_GENERATE_FORM = {
+	name: "",
+	firstLastName: "",
+	secondLastName: "",
+	gender: "",
+	birthDate: "",
+	birthState: ""
+};
+const removeKey = (errors, key) => {
+	if (!errors?.[key]) return errors;
+	const next = { ...errors };
+	delete next[key];
+	return Object.keys(next).length > 0 ? next : void 0;
+};
+const removeKeys = (errors, keys) => {
+	if (!errors) return void 0;
+	const next = { ...errors };
+	for (const key of keys) delete next[key];
+	return Object.keys(next).length > 0 ? next : void 0;
+};
+const upsertKey = (errors, key, message) => {
+	const next = { ...errors ?? {} };
+	if (message) next[key] = message;
+	else delete next[key];
+	return Object.keys(next).length > 0 ? next : void 0;
+};
+const curpValidationMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchOcrData: fromPromise(async ({ signal }) => {
+			return fetchOcrData(signal);
+		}),
+		verifyCurp: fromPromise(async ({ input, signal }) => {
+			return addCurp(input.curp, signal);
+		}),
+		generateCurpActor: fromPromise(async ({ input, signal }) => {
+			return addCurpV2(input.form, signal);
+		})
+	},
+	actions: {
+		setCurpFromOcr: assign(({ event }) => {
+			return { curp: (event.output?.curp ?? "").toUpperCase() };
+		}),
+		setCurp: assign(({ event }) => {
+			return { curp: event.curp.toUpperCase() };
+		}),
+		clearEnterCurpFieldError: assign(({ context }) => ({ enterCurpValidationErrors: removeKey(context.enterCurpValidationErrors, "curp") })),
+		validateEnterCurpFieldAction: assign(({ context }) => ({ enterCurpValidationErrors: upsertKey(context.enterCurpValidationErrors, "curp", validateEnterCurpField(context.curp)) })),
+		computeEnterCurpValidationResult: assign(({ context }) => {
+			const message = validateEnterCurpField(context.curp);
+			return { enterCurpValidationErrors: message ? { curp: message } : void 0 };
+		}),
+		resetEnterCurpValidationErrors: assign({ enterCurpValidationErrors: () => void 0 }),
+		setGenerateForm: assign(({ context, event }) => {
+			const e = event;
+			return {
+				generateForm: {
+					...context.generateForm,
+					...e.form
+				},
+				generateCurpValidationErrors: removeKeys(context.generateCurpValidationErrors, Object.keys(e.form))
+			};
+		}),
+		validateGenerateCurpFieldAction: assign(({ context, event }) => {
+			if (event.type !== "VALIDATE_FIELD") return {};
+			if (event.field === "curp") return {};
+			const message = validateGenerateCurpField(context.generateForm, event.field, GENERATE_CURP_FIELDS);
+			return { generateCurpValidationErrors: upsertKey(context.generateCurpValidationErrors, event.field, message) };
+		}),
+		computeGenerateValidationResult: assign(({ context }) => {
+			const errors = validateGenerateCurpForm(context.generateForm, GENERATE_CURP_FIELDS);
+			return { generateCurpValidationErrors: Object.keys(errors).length > 0 ? errors : void 0 };
+		}),
+		resetGenerateCurpValidationErrors: assign({ generateCurpValidationErrors: () => void 0 }),
+		setGeneratedCurp: assign(({ event }) => {
+			const curp = event.output?.curp ?? "";
+			return {
+				generatedCurp: curp,
+				curp
+			};
+		}),
+		decrementRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
+		setFromGenerate: assign({ fromGenerate: () => true }),
+		clearFromGenerate: assign({ fromGenerate: () => false }),
+		setError: assign(({ event }) => ({ error: String(event.error) }))
+	},
+	guards: {
+		hasPrefillFromOcr: ({ context }) => context.config.prefillFromOcr !== false,
+		hasOcrCurp: ({ event }) => {
+			return !!event.output?.curp?.trim();
+		},
+		canRetry: ({ context }) => context.retriesLeft > 0,
+		isDeceased: ({ event }) => {
+			return event.output?.deceasedStatus === "DECEASED";
+		},
+		isScrapingFallback: ({ event }) => {
+			return event.output?.result === "Attempting validation by scraping method";
+		},
+		isGenerateSuccess: ({ event }) => {
+			const output = event.output;
+			return !!(output?.success && output?.curp);
+		},
+		isVerifySuccess: ({ event }) => {
+			return event.output?.success === true;
+		},
+		shouldVerify: ({ context }) => context.curp.trim().length > 0 && Object.keys(context.enterCurpValidationErrors ?? {}).length === 0,
+		isGenerateFormValidGuard: ({ context }) => Object.keys(context.generateCurpValidationErrors ?? {}).length === 0
+	}
+}).createMachine({
+	id: "curpValidation",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		curp: "",
+		generateForm: { ...DEFAULT_GENERATE_FORM },
+		retriesLeft: input.config.maxRetries ?? 1,
+		generatedCurp: void 0,
+		error: void 0,
+		fromGenerate: false
+	}),
+	states: {
+		idle: { on: {
+			LOAD: [{
+				target: "loading",
+				guard: "hasPrefillFromOcr"
+			}, { target: "enterCurp" }],
+			CLOSE: "closed"
+		} },
+		loading: {
+			invoke: {
+				id: "fetchOcrData",
+				src: "fetchOcrData",
+				onDone: [{
+					target: "verifying",
+					guard: "hasOcrCurp",
+					actions: "setCurpFromOcr"
+				}, { target: "enterCurp" }],
+				onError: { target: "enterCurp" }
+			},
+			on: { CLOSE: "closed" }
+		},
+		enterCurp: {
+			entry: "resetEnterCurpValidationErrors",
+			initial: "inputting",
+			states: {
+				inputting: { on: {
+					SET_CURP: { actions: ["setCurp", "clearEnterCurpFieldError"] },
+					VALIDATE_FIELD: {
+						guard: ({ event }) => event.field === "curp",
+						actions: "validateEnterCurpFieldAction"
+					},
+					VERIFY: { target: "validatingVerify" },
+					SWITCH_TO_GENERATE: {
+						target: "#curpValidation.generateCurp",
+						actions: "setFromGenerate"
+					}
+				} },
+				validatingVerify: {
+					entry: "computeEnterCurpValidationResult",
+					always: [{
+						guard: "shouldVerify",
+						target: "#curpValidation.verifying"
+					}, { target: "inputting" }]
+				}
+			},
+			on: { CLOSE: "#curpValidation.closed" }
+		},
+		verifying: {
+			invoke: {
+				id: "verifyCurp",
+				src: "verifyCurp",
+				input: ({ context }) => ({ curp: context.curp }),
+				onDone: [{
+					target: "success",
+					guard: "isVerifySuccess"
+				}, {
+					target: "failure",
+					actions: "decrementRetries"
+				}],
+				onError: {
+					target: "failure",
+					actions: ["decrementRetries", "setError"]
+				}
+			},
+			on: { CLOSE: "closed" }
+		},
+		success: {
+			after: { 3e3: "finished" },
+			on: { CLOSE: "closed" }
+		},
+		failure: {
+			on: {
+				RETRY: [{
+					target: "generateCurp",
+					guard: ({ context }) => context.retriesLeft > 0 && context.fromGenerate
+				}, {
+					target: "enterCurp",
+					guard: ({ context }) => context.retriesLeft > 0 && !context.fromGenerate,
+					actions: "clearFromGenerate"
+				}],
+				CLOSE: "closed"
+			},
+			after: { 3e3: [{
+				target: "finished",
+				guard: ({ context }) => context.retriesLeft <= 0
+			}] }
+		},
+		generateCurp: {
+			entry: "resetGenerateCurpValidationErrors",
+			initial: "inputting",
+			states: {
+				inputting: { on: {
+					SET_GENERATE_FORM: { actions: "setGenerateForm" },
+					VALIDATE_FIELD: {
+						guard: ({ event }) => event.field !== "curp",
+						actions: "validateGenerateCurpFieldAction"
+					},
+					GENERATE: { target: "validatingGenerate" }
+				} },
+				validatingGenerate: {
+					entry: "computeGenerateValidationResult",
+					always: [{
+						guard: "isGenerateFormValidGuard",
+						target: "#curpValidation.generating"
+					}, { target: "inputting" }]
+				}
+			},
+			on: { CLOSE: "#curpValidation.closed" }
+		},
+		generating: {
+			invoke: {
+				id: "generateCurpActor",
+				src: "generateCurpActor",
+				input: ({ context }) => ({ form: context.generateForm }),
+				onDone: [
+					{
+						target: "finished",
+						guard: "isScrapingFallback"
+					},
+					{
+						target: "finished",
+						guard: "isDeceased"
+					},
+					{
+						target: "confirmCurp",
+						guard: "isGenerateSuccess",
+						actions: "setGeneratedCurp"
+					},
+					{
+						target: "generateError",
+						actions: "setFromGenerate"
+					}
+				],
+				onError: {
+					target: "generateError",
+					actions: ["setFromGenerate", "setError"]
+				}
+			},
+			on: { CLOSE: "closed" }
+		},
+		confirmCurp: { on: {
+			CONFIRM: { target: "verifying" },
+			CLOSE: "closed"
+		} },
+		generateError: {
+			on: {
+				RETRY: {
+					target: "generateCurp",
+					guard: "canRetry",
+					actions: "decrementRetries"
+				},
+				CLOSE: "closed"
+			},
+			after: { 3e3: [{
+				target: "finished",
+				guard: ({ context }) => context.retriesLeft <= 0
+			}] }
+		},
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+export { mexicanStates as i, ENTER_CURP_FIELD as n, GENERATE_CURP_FIELDS as r, curpValidationMachine as t };