@incodetech/core 2.0.1 → 2.1.0-rc.1

package/dist/curpValidationManager-RttixpIc.d.ts

@@ -0,0 +1,184 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import { i as FlowModuleConfig } from "./types-DOUhndhT.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;
+type CurpValidationMachine = typeof curpValidationMachine;
+//#endregion
+//#region src/modules/curp-validation/curpValidationActor.d.ts
+type CreateCurpValidationActorOptions = {
+  config: CurpValidationConfig;
+};
+type CurpValidationActor = ActorRefFrom<CurpValidationMachine>;
+//#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;
+  /** True for auto OCR-prefilled failures; UI shows "Verify manually". */
+  fromAutoVerify: boolean;
+};
+/**
+ * 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;
+};
+/**
+ * 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.
+ */
+declare function createCurpValidationManagerFromActor(actor: CurpValidationActor): 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
+export { CurpValidationActor as a, CurpValidationErrors as c, GenerateCurpFieldDef as d, GenerateCurpFieldType as f, createCurpValidationManagerFromActor as i, CurpValidationRule as l, CurpValidationState as n, curpValidationMachine as o, GenerateCurpForm as p, createCurpValidationManager as r, CurpValidationConfig as s, CurpValidationManager as t, EnterCurpFieldDef as u };

package/dist/{curpValidationStateMachine-CitWLr2c.esm.js → curpValidationStateMachine-B7V_qp66.esm.js}

@@ -1,6 +1,6 @@
 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";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.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)$/;
@@ -196,6 +196,7 @@ const GENERATE_CURP_FIELDS = [
 		labelKey: "curp.labels.firstLast",
 		type: "text",
 		required: true,
+		autoComplete: "family-name",
 		validation: [{ type: "required" }]
 	},
 	{
@@ -216,6 +217,7 @@ const GENERATE_CURP_FIELDS = [
 		labelKey: "curp.labels.dob",
 		type: "date",
 		required: true,
+		autoComplete: "bday",
 		validation: [{ type: "required" }]
 	},
 	{
@@ -392,6 +394,8 @@ const curpValidationMachine = setup({
 		decrementRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
 		setFromGenerate: assign({ fromGenerate: () => true }),
 		clearFromGenerate: assign({ fromGenerate: () => false }),
+		setAutoVerify: assign({ fromAutoVerify: () => true }),
+		clearAutoVerify: assign({ fromAutoVerify: () => false }),
 		setError: assign(({ event }) => ({ error: String(event.error) }))
 	},
 	guards: {
@@ -426,7 +430,8 @@ const curpValidationMachine = setup({
 		retriesLeft: input.config.maxRetries ?? 1,
 		generatedCurp: void 0,
 		error: void 0,
-		fromGenerate: false
+		fromGenerate: false,
+		fromAutoVerify: false
 	}),
 	states: {
 		idle: { on: {
@@ -443,7 +448,7 @@ const curpValidationMachine = setup({
 				onDone: [{
 					target: "verifying",
 					guard: "hasOcrCurp",
-					actions: "setCurpFromOcr"
+					actions: ["setCurpFromOcr", "setAutoVerify"]
 				}, { target: "enterCurp" }],
 				onError: { target: "enterCurp" }
 			},
@@ -469,7 +474,8 @@ const curpValidationMachine = setup({
 					entry: "computeEnterCurpValidationResult",
 					always: [{
 						guard: "shouldVerify",
-						target: "#curpValidation.verifying"
+						target: "#curpValidation.verifying",
+						actions: "clearAutoVerify"
 					}, { target: "inputting" }]
 				}
 			},
@@ -483,13 +489,10 @@ const curpValidationMachine = setup({
 				onDone: [{
 					target: "success",
 					guard: "isVerifySuccess"
-				}, {
-					target: "failure",
-					actions: "decrementRetries"
-				}],
+				}, { target: "failure" }],
 				onError: {
 					target: "failure",
-					actions: ["decrementRetries", "setError"]
+					actions: "setError"
 				}
 			},
 			on: { CLOSE: "closed" }
@@ -502,11 +505,12 @@ const curpValidationMachine = setup({
 			on: {
 				RETRY: [{
 					target: "generateCurp",
-					guard: ({ context }) => context.retriesLeft > 0 && context.fromGenerate
+					guard: ({ context }) => context.retriesLeft > 0 && context.fromGenerate,
+					actions: "decrementRetries"
 				}, {
 					target: "enterCurp",
 					guard: ({ context }) => context.retriesLeft > 0 && !context.fromGenerate,
-					actions: "clearFromGenerate"
+					actions: ["decrementRetries", "clearFromGenerate"]
 				}],
 				CLOSE: "closed"
 			},
@@ -569,7 +573,10 @@ const curpValidationMachine = setup({
 			on: { CLOSE: "closed" }
 		},
 		confirmCurp: { on: {
-			CONFIRM: { target: "verifying" },
+			CONFIRM: {
+				target: "verifying",
+				actions: "clearAutoVerify"
+			},
 			CLOSE: "closed"
 		} },
 		generateError: {

package/dist/custom-fields.d.ts

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
 
 //#region src/modules/custom-fields/types.d.ts
 type CustomFieldType = 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';

package/dist/custom-fields.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, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as isoDateToMs } from "./dateUtils-UoN5xswP.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 isoDateToMs } from "./dateUtils-AksLQmgV.esm.js";
 
 //#region src/modules/custom-fields/customFieldsServices.ts
 async function submitCustomFields(params, signal) {

package/dist/custom-watchlist.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/custom-watchlist/customWatchlistStateMachine.d.ts
 type CustomWatchlistResult = 'success' | 'skipped';

package/dist/custom-watchlist.esm.js

@@ -1,46 +1,9 @@
 import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import "./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 processWatchlist } from "./watchlistServices-DMbUhkBX.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as customWatchlistMachine } from "./customWatchlistStateMachine-HmFybXLX.esm.js";
 
-//#region src/modules/custom-watchlist/customWatchlistStateMachine.ts
-const customWatchlistMachine = setup({
-	types: {
-		context: {},
-		events: {}
-	},
-	actors: { processWatchlist: fromPromise(async ({ signal }) => {
-		await processWatchlist(signal);
-	}) },
-	actions: {
-		markSuccess: assign({ result: "success" }),
-		markSkipped: assign({ result: "skipped" })
-	}
-}).createMachine({
-	id: "customWatchlist",
-	initial: "idle",
-	context: { result: null },
-	states: {
-		idle: { on: { LOAD: { target: "processing" } } },
-		processing: { invoke: {
-			id: "processWatchlist",
-			src: "processWatchlist",
-			onDone: { target: "success" },
-			onError: {
-				target: "finished",
-				actions: "markSkipped"
-			}
-		} },
-		success: { after: { 3e3: {
-			target: "finished",
-			actions: "markSuccess"
-		} } },
-		finished: { type: "final" }
-	}
-});
-
-//#endregion
 //#region src/modules/custom-watchlist/customWatchlistActor.ts
 function createCustomWatchlistActor() {
 	return createActor(customWatchlistMachine).start();

package/dist/customWatchlistStateMachine-HmFybXLX.esm.js

@@ -0,0 +1,50 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+
+//#region src/modules/custom-watchlist/customWatchlistServices.ts
+async function processWatchlist(signal) {
+	const res = await api.post(endpoints.processWatchlist, {}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.processWatchlist} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistStateMachine.ts
+const customWatchlistMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { processWatchlist: fromPromise(async ({ signal }) => {
+		await processWatchlist(signal);
+	}) },
+	actions: {
+		markSuccess: assign({ result: "success" }),
+		markSkipped: assign({ result: "skipped" })
+	}
+}).createMachine({
+	id: "customWatchlist",
+	initial: "idle",
+	context: { result: null },
+	states: {
+		idle: { on: { LOAD: { target: "processing" } } },
+		processing: { invoke: {
+			id: "processWatchlist",
+			src: "processWatchlist",
+			onDone: { target: "success" },
+			onError: {
+				target: "finished",
+				actions: "markSkipped"
+			}
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markSuccess"
+		} } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { customWatchlistMachine as t };

package/dist/{deepsightLoader-Cm4JIT_z.esm.js → deepsightLoader-8tnddNx-.esm.js}

@@ -1,13 +1,16 @@
-import "./BaseWasmProvider-C_DLEI40.esm.js";
-import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-BKWm8rSA.esm.js";
 import "./api-CESGtpbH.esm.js";
-import { r as BrowserEnvironmentProvider, t as IpifyProvider } from "./IpifyProvider-D7jx52AL.esm.js";
-import "./browserSimulation-gxD8cSpM.esm.js";
-import "./camera-PA2Ljri3.esm.js";
-import { t as createDeepsightService } from "./deepsightService-O74l4Y__.esm.js";
-import "./getBrowser-BSXUTWXw.esm.js";
-import "./stats-CIfiPzb1.esm.js";
-import { t as MotionSensorProvider } from "./MotionSensorProvider-4v7xkqAp.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./stats-BMNUG1AU.esm.js";
+import { r as BrowserEnvironmentProvider, t as IpifyProvider } from "./IpifyProvider-D4LWD15E.esm.js";
+import "./browserSimulation-B1dWiXp7.esm.js";
+import "./platform-SKvEfCBh.esm.js";
+import "./getBrowser-C8DP7oTB.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-Bx7Mpzt0.esm.js";
+import "./camera-DJWm3V4g.esm.js";
+import "./canvas-SKcRBxsk.esm.js";
+import { t as createDeepsightService } from "./deepsightService-CrHmvx8X.esm.js";
+import "./getDeviceClass-C0olyNFS.esm.js";
 
 //#region ../infra/src/providers/browser/VisibilityProvider.ts
 var VisibilityProvider = class {
@@ -30,11 +33,17 @@ var VisibilityProvider = class {
 	}
 };
 
+//#endregion
+//#region src/internal/deepsight/wasmDsFlag.ts
+async function setWasmDsFlag(storage, enabled) {
+	await storage.set("ds", enabled ? 1 : 0);
+}
+
 //#endregion
 //#region src/internal/deepsight/deepsightLoader.ts
 const SDK_VERSION = "2.0.0";
 async function loadDeepsightSession(options) {
-	await options.storage.set("ds", options.ds ? 1 : 0);
+	await setWasmDsFlag(options.storage, options.ds === true);
 	const service = createDeepsightService({
 		sdkVersion: SDK_VERSION,
 		wasmUtil: await WasmUtilProvider.getInstance(),