@incodetech/core 2.0.0 → 2.0.1-rc.0

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 };

package/dist/custom-fields.d.ts

@@ -0,0 +1,115 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+
+//#region src/modules/custom-fields/types.d.ts
+type CustomFieldType = 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';
+type CustomField = {
+  name: string;
+  alias: string;
+  type: CustomFieldType;
+};
+type CustomFieldsConfig = {
+  title: string;
+  customFields: CustomField[];
+};
+//#endregion
+//#region src/modules/custom-fields/customFieldsStateMachine.d.ts
+type CustomFieldsResult = 'success' | 'failed';
+declare const customFieldsMachine: any;
+//#endregion
+//#region src/modules/custom-fields/customFieldsActor.d.ts
+type CreateCustomFieldsActorOptions = {
+  config: CustomFieldsConfig;
+};
+//#endregion
+//#region src/modules/custom-fields/customFieldsManager.d.ts
+/**
+ * A `CustomField` enriched with a computed `label` for display.
+ * Label is derived from `alias` when present, otherwise auto-formatted from `name`.
+ */
+type MappedCustomField = CustomField & {
+  label: string;
+};
+/** Custom fields manager is in initial state, waiting for `load()` to be called */
+type CustomFieldsIdleState = {
+  status: 'idle';
+};
+/**
+ * Ready for field input — use `setField()` and `submit()`
+ * @property title - Form title from configuration
+ * @property customFields - Field definitions with computed display labels
+ * @property canSubmit - True when all non-boolean fields have a non-empty value
+ */
+type CustomFieldsInputtingState = {
+  status: 'inputting';
+  title: string;
+  customFields: MappedCustomField[];
+  canSubmit: boolean;
+};
+/** Fields are being submitted to the backend */
+type CustomFieldsSubmittingState = {
+  status: 'submitting';
+  title: string;
+};
+/** API call succeeded — success page is visible for ~3 s before finishing */
+type CustomFieldsSuccessState = {
+  status: 'success';
+};
+/** Custom fields flow complete. `result` indicates whether the API call succeeded or failed. */
+type CustomFieldsFinishedState = {
+  status: 'finished';
+  result: CustomFieldsResult | null;
+};
+/**
+ * Union of all possible custom fields manager states.
+ */
+type CustomFieldsState = CustomFieldsIdleState | CustomFieldsInputtingState | CustomFieldsSubmittingState | CustomFieldsSuccessState | CustomFieldsFinishedState;
+/**
+ * Creates a custom fields manager for headless or UI-driven usage.
+ *
+ * @param options - Configuration options
+ * @param options.config - Custom fields configuration (title + field definitions)
+ *
+ * @returns Custom fields manager with state, API methods, and subscription
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createCustomFieldsManager({
+ *   config: {
+ *     title: 'Additional Information',
+ *     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
+ *   },
+ * });
+ *
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * manager.setField('company', 'Incode');
+ * manager.submit();
+ * manager.stop();
+ * ```
+ */
+declare function createCustomFieldsManager(options: CreateCustomFieldsActorOptions): Manager<CustomFieldsState> & {
+  /**
+   * Initializes the custom fields flow.
+   * Transitions from 'idle' to 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Updates the value of a single field.
+   * Should be called when state is 'inputting'.
+   *
+   * @param name - The field name (matches CustomField.name)
+   * @param value - The field value (string, number, or boolean)
+   */
+  setField(name: string, value: string | number | boolean): void;
+  /**
+   * Submits all custom field values to the backend.
+   * Transitions to 'submitting', then 'finished' regardless of outcome.
+   */
+  submit(): void;
+};
+/** Type representing a custom fields manager instance. */
+type CustomFieldsManager = ReturnType<typeof createCustomFieldsManager>;
+//#endregion
+export { type CustomField, type CustomFieldType, type CustomFieldsConfig, type CustomFieldsManager, type CustomFieldsState, type MappedCustomField, createCustomFieldsManager, customFieldsMachine };