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

package/dist/cpf-ocr.d.ts

@@ -0,0 +1,204 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import * as xstate250 from "xstate";
+
+//#region src/modules/cpf-ocr/cpfOcrManager.d.ts
+type CpfOcrIdleState = {
+  status: 'idle';
+};
+type CpfOcrLoadingState = {
+  status: 'loading';
+};
+type CpfOcrInputtingState = {
+  status: 'inputting';
+  cpf: string;
+  isValid: boolean;
+};
+type CpfOcrSubmittingState = {
+  status: 'submitting';
+};
+type CpfOcrErrorState = {
+  status: 'error';
+  error: string;
+};
+type CpfOcrFinishedState = {
+  status: 'finished';
+};
+type CpfOcrState = CpfOcrIdleState | CpfOcrLoadingState | CpfOcrInputtingState | CpfOcrSubmittingState | CpfOcrErrorState | CpfOcrFinishedState;
+declare function createCpfOcrManager(): Manager<CpfOcrState> & {
+  load(): void;
+  setCpf(cpf: string): void;
+  submit(): void;
+  retry(): void;
+};
+type CpfOcrManager = ReturnType<typeof createCpfOcrManager>;
+//#endregion
+//#region src/modules/cpf-ocr/types.d.ts
+type CpfOcrDataResponse = {
+  documentNumber?: string;
+};
+type CpfOcrUpdateResponse = {
+  success?: boolean;
+};
+//#endregion
+//#region src/modules/cpf-ocr/cpfOcrStateMachine.d.ts
+type CpfOcrContext = {
+  cpf: string;
+  isValid: boolean;
+  error: string | undefined;
+};
+type CpfOcrInput = Record<string, never>;
+declare const cpfOcrMachine: xstate250.StateMachine<CpfOcrContext, {
+  type: "LOAD";
+} | {
+  type: "SET_CPF";
+  cpf: string;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate250.ActorRefFromLogic<xstate250.PromiseActorLogic<CpfOcrDataResponse, void, xstate250.EventObject>> | xstate250.ActorRefFromLogic<xstate250.PromiseActorLogic<CpfOcrUpdateResponse, {
+    cpf: string;
+  }, xstate250.EventObject>> | undefined;
+}, xstate250.Values<{
+  fetchCpfOcrData: {
+    src: "fetchCpfOcrData";
+    logic: xstate250.PromiseActorLogic<CpfOcrDataResponse, void, xstate250.EventObject>;
+    id: string | undefined;
+  };
+  submitCpfOcr: {
+    src: "submitCpfOcr";
+    logic: xstate250.PromiseActorLogic<CpfOcrUpdateResponse, {
+      cpf: string;
+    }, xstate250.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate250.Values<{
+  setError: {
+    type: "setError";
+    params: xstate250.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate250.NonReducibleUnknown;
+  };
+  setPrefill: {
+    type: "setPrefill";
+    params: xstate250.NonReducibleUnknown;
+  };
+  setCpf: {
+    type: "setCpf";
+    params: xstate250.NonReducibleUnknown;
+  };
+}>, {
+  type: "isValid";
+  params: unknown;
+}, never, "error" | "idle" | "finished" | "loading" | "submitting" | "inputting", string, CpfOcrInput, xstate250.NonReducibleUnknown, xstate250.EventObject, xstate250.MetaObject, {
+  readonly id: "cpfOcr";
+  readonly initial: "idle";
+  readonly context: {
+    readonly cpf: "";
+    readonly isValid: false;
+    readonly error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: "loading";
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly src: "fetchCpfOcrData";
+        readonly onDone: {
+          readonly target: "inputting";
+          readonly actions: "setPrefill";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly inputting: {
+      readonly on: {
+        readonly SET_CPF: {
+          readonly actions: "setCpf";
+        };
+        readonly SUBMIT: {
+          readonly guard: "isValid";
+          readonly target: "submitting";
+        };
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly src: "submitCpfOcr";
+        readonly input: ({
+          context
+        }: {
+          context: CpfOcrContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "SET_CPF";
+            cpf: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          };
+          self: xstate250.ActorRef<xstate250.MachineSnapshot<CpfOcrContext, {
+            type: "LOAD";
+          } | {
+            type: "SET_CPF";
+            cpf: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          }, Record<string, xstate250.AnyActorRef>, xstate250.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "SET_CPF";
+            cpf: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          }, xstate250.AnyEventObject>;
+        }) => {
+          cpf: string;
+        };
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly SET_CPF: {
+          readonly target: "inputting";
+          readonly actions: "setCpf";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/cpf-ocr/cpfOcrUtils.d.ts
+declare function formatCPF(value: string): string;
+declare function isValidCPF(value: string): boolean;
+//#endregion
+export { type CpfOcrManager, type CpfOcrState, cpfOcrMachine, createCpfOcrManager, formatCPF, isValidCPF };

package/dist/cpf-ocr.esm.js

@@ -0,0 +1,177 @@
+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, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as validateCPF } from "./cpf-PPz2Njto.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)
+	});
+}
+
+//#endregion
+export { cpfOcrMachine, createCpfOcrManager, formatCPF, isValidCPF };

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

@@ -0,0 +1,34 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchManager.d.ts
+type CrossDocumentDataMatchIdleState = {
+  status: 'idle';
+};
+type CrossDocumentDataMatchProcessingState = {
+  status: 'processing';
+};
+type CrossDocumentDataMatchFinishedState = {
+  status: 'finished';
+};
+type CrossDocumentDataMatchState = CrossDocumentDataMatchIdleState | CrossDocumentDataMatchProcessingState | CrossDocumentDataMatchFinishedState;
+declare function createCrossDocumentDataMatchManager(): Manager<CrossDocumentDataMatchState> & {
+  /**
+   * Starts cross-document comparison (spinner + backend processing).
+   */
+  load(): void;
+};
+type CrossDocumentDataMatchManager = ReturnType<typeof createCrossDocumentDataMatchManager>;
+//#endregion
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchStateMachine.d.ts
+declare const crossDocumentDataMatchMachine: any;
+//#endregion
+//#region src/modules/cross-document-data-match/types.d.ts
+/**
+ * Configuration for the cross-document data match module.
+ *
+ * The module runs a backend comparison of OCR data across captured documents
+ * and completes after a minimum display duration (spinner), matching legacy behavior.
+ */
+type CrossDocumentDataMatchConfig = Record<string, never>;
+//#endregion
+export { type CrossDocumentDataMatchConfig, type CrossDocumentDataMatchManager, type CrossDocumentDataMatchState, createCrossDocumentDataMatchManager, crossDocumentDataMatchMachine };

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

@@ -0,0 +1,71 @@
+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";
+
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchServices.ts
+/** Minimum spinner duration (ms), aligned with SDK v1 `ProcessCrossDocumentData`. */
+const MIN_DISPLAY_MS = 3e3;
+async function processCrossDocumentDataMatch(signal) {
+	const [res] = await Promise.all([api.post(endpoints.processCrossDocumentDataMatch, {}, { signal }), sleep(MIN_DISPLAY_MS)]);
+	if (!res.ok) throw new Error(`POST ${endpoints.processCrossDocumentDataMatch} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchStateMachine.ts
+const crossDocumentDataMatchMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { processCrossDocumentDataMatch: fromPromise(async ({ signal }) => {
+		return processCrossDocumentDataMatch(signal);
+	}) }
+}).createMachine({
+	id: "crossDocumentDataMatch",
+	initial: "idle",
+	context: {},
+	states: {
+		idle: { on: { LOAD: { target: "processing" } } },
+		processing: { invoke: {
+			id: "processCrossDocumentDataMatch",
+			src: "processCrossDocumentDataMatch",
+			onDone: { target: "finished" },
+			onError: { target: "finished" }
+		} },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchActor.ts
+function createCrossDocumentDataMatchActor() {
+	return createActor(crossDocumentDataMatchMachine).start();
+}
+
+//#endregion
+//#region src/modules/cross-document-data-match/crossDocumentDataMatchManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return { load() {
+		actor.send({ type: "LOAD" });
+	} };
+}
+function createCrossDocumentDataMatchManager() {
+	return createManager({
+		actor: createCrossDocumentDataMatchActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.crossDocumentDataMatch)
+	});
+}
+
+//#endregion
+export { createCrossDocumentDataMatchManager, crossDocumentDataMatchMachine };

package/dist/curp-validation.d.ts

@@ -0,0 +1,188 @@
+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";
+
+//#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;
+  label: string;
+};
+declare const mexicanStates: MexicanState[];
+//#endregion
+//#region src/modules/curp-validation/curpFields.d.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.
+ */
+declare const GENERATE_CURP_FIELDS: GenerateCurpFieldDef[];
+/**
+ * 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`.
+ */
+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 };