@incodetech/core 2.0.1-rc.0 → 2.1.0-rc.0

package/dist/cpfOcrManager-sSKegxox.esm.js

@@ -0,0 +1,190 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as validateCPF } from "./cpf-BRzggV8G.esm.js";
+
+//#region src/modules/cpf-ocr/cpfOcrServices.ts
+async function fetchCpfOcrData(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 submitCpfOcr(documentNumber, signal) {
+	const res = await api.put(endpoints.updateSession, { documentNumber }, { signal });
+	if (!res.ok) throw new Error(`PUT ${endpoints.updateSession} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/cpf-ocr/cpfOcrUtils.ts
+function formatCPF(value) {
+	const digits = value.replace(/\D/g, "").slice(0, 11);
+	const first = digits.slice(0, 3);
+	const second = digits.slice(3, 6);
+	const third = digits.slice(6, 9);
+	const verifier = digits.slice(9, 11);
+	if (digits.length > 9) return `${first}.${second}.${third}-${verifier}`;
+	if (digits.length > 6) return `${first}.${second}.${third}`;
+	if (digits.length > 3) return `${first}.${second}`;
+	return first;
+}
+function isValidCPF(value) {
+	return validateCPF(value);
+}
+
+//#endregion
+//#region src/modules/cpf-ocr/cpfOcrStateMachine.ts
+const cpfOcrMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchCpfOcrData: fromPromise(async ({ signal }) => fetchCpfOcrData(signal)),
+		submitCpfOcr: fromPromise(async ({ input, signal }) => submitCpfOcr(input.cpf, signal))
+	},
+	actions: {
+		setPrefill: assign(({ event }) => {
+			const output = event.output;
+			const cpf = formatCPF(output.documentNumber ?? "");
+			return {
+				cpf,
+				isValid: isValidCPF(cpf),
+				error: void 0
+			};
+		}),
+		setCpf: assign(({ event }) => {
+			const cpf = formatCPF(event.cpf);
+			return {
+				cpf,
+				isValid: isValidCPF(cpf),
+				error: void 0
+			};
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 })
+	},
+	guards: { isValid: ({ context }) => context.isValid }
+}).createMachine({
+	id: "cpfOcr",
+	initial: "idle",
+	context: {
+		cpf: "",
+		isValid: false,
+		error: void 0
+	},
+	states: {
+		idle: { on: { LOAD: "loading" } },
+		loading: { invoke: {
+			src: "fetchCpfOcrData",
+			onDone: {
+				target: "inputting",
+				actions: "setPrefill"
+			},
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		inputting: { on: {
+			SET_CPF: { actions: "setCpf" },
+			SUBMIT: {
+				guard: "isValid",
+				target: "submitting"
+			}
+		} },
+		submitting: { invoke: {
+			src: "submitCpfOcr",
+			input: ({ context }) => ({ cpf: context.cpf }),
+			onDone: { target: "finished" },
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		error: { on: {
+			RETRY: {
+				target: "loading",
+				actions: "clearError"
+			},
+			SET_CPF: {
+				target: "inputting",
+				actions: "setCpf"
+			}
+		} },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/cpf-ocr/cpfOcrActor.ts
+function createCpfOcrActor() {
+	return createActor(cpfOcrMachine, { input: {} }).start();
+}
+
+//#endregion
+//#region src/modules/cpf-ocr/cpfOcrManager.ts
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("loading")) return { status: "loading" };
+	if (snapshot.matches("inputting")) return {
+		status: "inputting",
+		cpf: context.cpf,
+		isValid: context.isValid
+	};
+	if (snapshot.matches("submitting")) return { status: "submitting" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	if (snapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setCpf(cpf) {
+			actor.send({
+				type: "SET_CPF",
+				cpf
+			});
+		},
+		submit() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "SUBMIT" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		}
+	};
+}
+function createCpfOcrManager() {
+	return createManager({
+		actor: createCpfOcrActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.idOcr)
+	});
+}
+/**
+* Creates a CPF-OCR manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createCpfOcrManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.idOcr)
+	});
+}
+
+//#endregion
+export { isValidCPF as a, formatCPF as i, createCpfOcrManagerFromActor as n, cpfOcrMachine as r, createCpfOcrManager as t };

package/dist/cross-document-data-match.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
 
 //#region src/modules/cross-document-data-match/crossDocumentDataMatchManager.d.ts
 type CrossDocumentDataMatchIdleState = {

package/dist/cross-document-data-match.esm.js

@@ -1,8 +1,8 @@
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, c as createManager, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as sleep } from "./ITimerCapability-C67ZRskg.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, c as createManager, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as sleep } from "./ITimerCapability-CB0I1Uf2.esm.js";
 
 //#region src/modules/cross-document-data-match/crossDocumentDataMatchServices.ts
 /** Minimum spinner duration (ms), aligned with SDK v1 `ProcessCrossDocumentData`. */

package/dist/curp-validation.d.ts

@@ -1,161 +1,11 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
-import "./camera-DBSxa6ML.js";
-import "./types-CFV9G_7j.js";
-import { i as FlowModuleConfig } from "./types-BP1m8VRw.js";
+import "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import "./camera-SRBpPq2X.js";
+import "./types-Bj9hdFjU.js";
+import "./types-DvGZI7BF.js";
+import "./types-DOUhndhT.js";
+import { a as CurpValidationActor, c as CurpValidationErrors, d as GenerateCurpFieldDef, f as GenerateCurpFieldType, i as createCurpValidationManagerFromActor, l as CurpValidationRule, n as CurpValidationState, o as curpValidationMachine, p as GenerateCurpForm, r as createCurpValidationManager, s as CurpValidationConfig, t as CurpValidationManager, u as EnterCurpFieldDef } from "./curpValidationManager-RttixpIc.js";
 
-//#region src/modules/curp-validation/types.d.ts
-type CurpValidationConfig = FlowModuleConfig['CURP_VALIDATION'] & {
-  /** Maximum validation retries before auto-advancing. @default 1 */
-  maxRetries?: number;
-  /** Whether to attempt OCR pre-fill on load. @default true */
-  prefillFromOcr?: boolean;
-};
-/** CURP generation form data */
-type GenerateCurpForm = {
-  name: string;
-  firstLastName: string;
-  secondLastName: string;
-  gender: 'H' | 'M' | 'X' | '';
-  birthDate: string;
-  birthState: string;
-};
-type GenerateCurpFieldType = 'text' | 'date' | 'dropdown';
-/**
- * Discriminated union of validation rules supported across both CURP screens.
- * `required` is used by Generate-CURP fields; `curpFormat` is used by the
- * single-field CURP entry.
- */
-type CurpValidationRule = {
-  type: 'required';
-} | {
-  type: 'curpFormat';
-};
-type GenerateCurpFieldDef = {
-  key: keyof GenerateCurpForm;
-  labelKey: string;
-  type: GenerateCurpFieldType;
-  required: boolean;
-  autoComplete?: string;
-  /**
-   * Validation rules evaluated by the state machine on blur (per-field) and
-   * on submit (full form). Required fields should include `{ type: 'required' }`.
-   * Optional fields (e.g. `secondLastName`) omit this entirely.
-   */
-  validation?: CurpValidationRule[];
-};
-/**
- * Configuration for the single CURP-entry field on the gateway screen.
- * Intentionally has no `required` rule: the user can leave it empty and
- * use the "I don't have my CURP" escape-hatch button instead.
- */
-type EnterCurpFieldDef = {
-  key: 'curp';
-  labelKey: string;
-  validation?: CurpValidationRule[];
-};
-/**
- * Map of field-key → i18n error key currently displayed for that field.
- * Empty/undefined means no errors are currently shown. The state machine
- * is the single source of truth for which entries exist here — UI must
- * render this map as-is without further gating.
- */
-type CurpValidationErrors = Partial<Record<string, string>>;
-//#endregion
-//#region src/modules/curp-validation/curpValidationStateMachine.d.ts
-
-declare const curpValidationMachine: any;
-//#endregion
-//#region src/modules/curp-validation/curpValidationActor.d.ts
-type CreateCurpValidationActorOptions = {
-  config: CurpValidationConfig;
-};
-//#endregion
-//#region src/modules/curp-validation/curpValidationManager.d.ts
-type CurpValidationIdleState = {
-  status: 'idle';
-};
-type CurpValidationLoadingState = {
-  status: 'loading';
-};
-/**
- * State exposed to UI for the CURP entry gateway screen.
- *
- * `isValid` is **derived** from `validationErrors`: it is `true` whenever
- * no errors are currently displayed (including the initial empty render).
- * The UI must not treat `isValid` as "the form would pass full validation
- * right now" — that was the old pessimistic semantic. Use the absence of
- * errors plus an additional `curp.length === 0` no-op guard on the submit
- * button instead.
- */
-type CurpValidationEnterCurpState = {
-  status: 'enterCurp';
-  curp: string;
-  isValid: boolean;
-  validationErrors?: CurpValidationErrors;
-};
-type CurpValidationVerifyingState = {
-  status: 'verifying';
-};
-type CurpValidationSuccessState = {
-  status: 'success';
-};
-type CurpValidationFailureState = {
-  status: 'failure';
-  retriesLeft: number;
-};
-/**
- * State exposed to UI for the multi-field Generate CURP form.
- *
- * `isValid` is derived: `true` when no errors are currently displayed.
- * Validation runs on blur (single field) and on submit (full form);
- * `validationErrors` reflects exactly what should be rendered next
- * to each input.
- */
-type CurpValidationGenerateCurpState = {
-  status: 'generateCurp';
-  form: GenerateCurpForm;
-  isValid: boolean;
-  validationErrors?: CurpValidationErrors;
-};
-type CurpValidationGeneratingState = {
-  status: 'generating';
-};
-type CurpValidationConfirmCurpState = {
-  status: 'confirmCurp';
-  curp: string;
-};
-type CurpValidationGenerateErrorState = {
-  status: 'generateError';
-  retriesLeft: number;
-};
-type CurpValidationFinishedState = {
-  status: 'finished';
-};
-type CurpValidationClosedState = {
-  status: 'closed';
-};
-type CurpValidationState = CurpValidationIdleState | CurpValidationLoadingState | CurpValidationEnterCurpState | CurpValidationVerifyingState | CurpValidationSuccessState | CurpValidationFailureState | CurpValidationGenerateCurpState | CurpValidationGeneratingState | CurpValidationConfirmCurpState | CurpValidationGenerateErrorState | CurpValidationFinishedState | CurpValidationClosedState;
-declare function createCurpValidationManager(options: CreateCurpValidationActorOptions): Manager<CurpValidationState> & {
-  load(): void;
-  setCurp(curp: string): void;
-  /**
-   * Triggers single-field on-blur validation. The state machine routes
-   * the event to the validator for the currently active screen and
-   * updates the corresponding `validationErrors` map. Sending a field
-   * key that does not belong to the active screen is a no-op.
-   */
-  validateField(field: "curp" | keyof GenerateCurpForm): void;
-  verify(): void;
-  switchToGenerate(): void;
-  setGenerateForm(form: Partial<GenerateCurpForm>): void;
-  generate(): void;
-  confirmGenerated(): void;
-  retry(): void;
-  close(): void;
-};
-type CurpValidationManager = ReturnType<typeof createCurpValidationManager>;
-//#endregion
 //#region src/modules/curp-validation/curpValidationUtils.d.ts
 type MexicanState = {
   value: string;
@@ -185,4 +35,4 @@ declare const GENERATE_CURP_FIELDS: GenerateCurpFieldDef[];
  */
 declare const ENTER_CURP_FIELD: EnterCurpFieldDef;
 //#endregion
-export { type CurpValidationConfig, type CurpValidationErrors, type CurpValidationManager, type CurpValidationRule, type CurpValidationState, ENTER_CURP_FIELD, type EnterCurpFieldDef, GENERATE_CURP_FIELDS, type GenerateCurpFieldDef, type GenerateCurpFieldType, type GenerateCurpForm, createCurpValidationManager, curpValidationMachine, mexicanStates };
+export { type CurpValidationActor, type CurpValidationConfig, type CurpValidationErrors, type CurpValidationManager, type CurpValidationRule, type CurpValidationState, ENTER_CURP_FIELD, type EnterCurpFieldDef, GENERATE_CURP_FIELDS, type GenerateCurpFieldDef, type GenerateCurpFieldType, type GenerateCurpForm, createCurpValidationManager, createCurpValidationManagerFromActor, curpValidationMachine, mexicanStates };

package/dist/curp-validation.esm.js

@@ -1,110 +1,8 @@
 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";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { i as mexicanStates, n as ENTER_CURP_FIELD, r as GENERATE_CURP_FIELDS, t as curpValidationMachine } from "./curpValidationStateMachine-B7V_qp66.esm.js";
+import { n as createCurpValidationManagerFromActor, t as createCurpValidationManager } from "./curpValidationManager-CFem6zP9.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 };
+export { ENTER_CURP_FIELD, GENERATE_CURP_FIELDS, createCurpValidationManager, createCurpValidationManagerFromActor, curpValidationMachine, mexicanStates };

package/dist/curpValidationManager-CFem6zP9.esm.js

@@ -0,0 +1,122 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as curpValidationMachine } from "./curpValidationStateMachine-B7V_qp66.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,
+		fromAutoVerify: context.fromAutoVerify
+	};
+	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)
+	});
+}
+/**
+* Creates a CURP-validation manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createCurpValidationManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.curpValidation)
+	});
+}
+
+//#endregion
+export { createCurpValidationManagerFromActor as n, createCurpValidationManager as t };