@incodetech/core 2.0.0 → 2.0.1-rc.0

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

package/dist/curp-validation.esm.js

@@ -0,0 +1,110 @@
+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";
+
+//#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 };