@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/curpValidationStateMachine-CitWLr2c.esm.js

@@ -1,595 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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 };