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

package/dist/id-ocr.d.ts

@@ -0,0 +1,635 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import * as xstate601 from "xstate";
+
+//#region src/modules/id-ocr/types.d.ts
+type IdOcrConfig = {
+  /** Allows user to edit OCR information @default false */
+  editableOcr?: boolean;
+  /**
+   * When true (from flow/onboarding), after the first ID OCR step completes the
+   * machine loads and optionally edits OCR for the second captured ID.
+   */
+  secondId?: boolean;
+  /**
+   * Session flow id (injected by orchestrated flow UI). When listed in `CPFFlowIds`
+   * (`idOcrConsts`), only the CPF field is shown and validated; it maps to `documentNumber` on OCR.
+   */
+  flowId?: string;
+};
+type NameBean = {
+  fullName?: string;
+  firstName?: string;
+  middleName?: string;
+  givenName?: string;
+  nameSuffix?: string;
+  paternalLastName?: string;
+  maternalLastName?: string;
+  lastNameMrz?: string;
+};
+type AddressBean = {
+  street?: string;
+  colony?: string;
+  postalCode?: string;
+  city?: string;
+  state?: string;
+  label?: string;
+  confidentGeolocation?: boolean;
+};
+type AddressStatements = {
+  _id: string;
+  dateType: string;
+  addressStatementTimestamp: number;
+};
+type OcrData = {
+  name: NameBean;
+  givenName?: string;
+  firstName?: string;
+  middleName?: string;
+  nameSuffix?: string;
+  mothersSurname?: string;
+  fathersSurname?: string;
+  nickName?: string;
+  address?: string;
+  street?: string;
+  colony?: string;
+  postalCode?: string;
+  city?: string;
+  state?: string;
+  stateCode?: string;
+  countryCode?: string;
+  addressFields?: AddressBean;
+  fullAddress?: boolean;
+  invalidAddress?: boolean;
+  checkedAddress?: string;
+  checkedAddressBean?: AddressBean;
+  exteriorNumber?: string;
+  interiorNumber?: string;
+  addressFromStatement?: string;
+  addressFieldsFromStatement?: AddressBean;
+  invalidAddressFromStatement?: boolean;
+  addressStatementEmissionDate?: number;
+  documentType?: string;
+  addressStatementTimestamps?: AddressStatements[];
+  poaName?: string;
+  typeOfId?: string;
+  documentFrontSubtype?: string;
+  documentBackSubtype?: string;
+  birthDate?: number | string;
+  gender?: string;
+  claveDeElector?: string;
+  curp?: string;
+  numeroEmisionCredencial?: string;
+  cic?: string;
+  ocr?: string;
+  documentNumber?: string;
+  personalNumber?: string;
+  refNumber?: string;
+  nue?: string;
+  externalId?: string;
+  issuedAt?: string;
+  expireAt?: string;
+  expirationDate?: number;
+  issueDate?: number;
+  registrationDate?: number;
+  issuingCountry?: string;
+  issuingState?: string;
+  birthPlace?: string;
+  issuingAuthority?: string;
+  height?: string;
+  weight?: string;
+  eyeColor?: string;
+  hairColor?: string;
+  bloodType?: string;
+  maritalStatus?: string;
+  nationality?: string;
+  nationalityMrz?: string;
+  classes?: string;
+  cond?: string;
+  mentions?: string;
+  restrictions?: string;
+  mrz1?: string;
+  mrz2?: string;
+  mrz3?: string;
+  fullNameMrz?: string;
+  documentNumberCheckDigit?: string;
+  dateOfBirthCheckDigit?: string;
+  expirationDateCheckDigit?: string;
+  fathersName?: string;
+  mothersName?: string;
+  federalRevenueNumber?: string;
+  originDocumentId?: string;
+  driversLicenseCategory?: string;
+  controlNumber?: string;
+  renach?: string;
+  ocrReliabilityConfidence?: number;
+  ocrDataConfidence?: unknown;
+};
+type UpdateOcrDataParams = {
+  address?: string;
+  documentNumber?: string;
+  name?: string;
+  firstName?: string;
+  lastName?: string;
+  paternalLastName?: string;
+  maternalLastName?: string;
+  personalNumber?: string;
+  curp?: string;
+  email?: string;
+  birthDate?: string;
+  expireAt?: string;
+  gender?: string;
+  issuingCountry?: string;
+};
+type ValidationRule = {
+  type: 'required';
+} | {
+  type: 'minAge';
+  years: number;
+} | {
+  type: 'cpf';
+};
+type OcrFieldConfig = {
+  key: keyof UpdateOcrDataParams;
+  labelKey: string;
+  type: 'text' | 'date' | 'radio';
+  options?: {
+    label: string;
+    value: string;
+  }[];
+  validation?: ValidationRule[];
+  required: boolean;
+};
+type UpdateOcrResponse = {
+  success: boolean;
+};
+//#endregion
+//#region src/modules/id-ocr/idOcrStateMachine.d.ts
+type IdOcrOcrDocument = 'first' | 'second';
+type IdOcrContext = {
+  config: IdOcrConfig;
+  error?: string;
+  formData: UpdateOcrDataParams;
+  editedFields: UpdateOcrDataParams;
+  activeOcrDocument: IdOcrOcrDocument;
+  validationErrors?: Partial<Record<keyof UpdateOcrDataParams, string>>;
+};
+type IdOcrInput = {
+  config: IdOcrConfig;
+};
+declare const idOcrStateMachine: xstate601.StateMachine<IdOcrContext, {
+  type: "LOAD";
+} | {
+  type: "DATA_CHANGED";
+  field: keyof UpdateOcrDataParams;
+  value: string;
+} | {
+  type: "VALIDATE_FIELD";
+  field: keyof UpdateOcrDataParams;
+} | {
+  type: "CONTINUE";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate601.ActorRefFromLogic<xstate601.PromiseActorLogic<OcrData, {
+    isSecondId: boolean;
+  }, xstate601.EventObject>> | xstate601.ActorRefFromLogic<xstate601.PromiseActorLogic<UpdateOcrResponse, {
+    params: UpdateOcrDataParams;
+    isSecondId: boolean;
+  }, xstate601.EventObject>> | undefined;
+}, xstate601.Values<{
+  getOcrData: {
+    src: "getOcrData";
+    logic: xstate601.PromiseActorLogic<OcrData, {
+      isSecondId: boolean;
+    }, xstate601.EventObject>;
+    id: string | undefined;
+  };
+  updateOcrData: {
+    src: "updateOcrData";
+    logic: xstate601.PromiseActorLogic<UpdateOcrResponse, {
+      params: UpdateOcrDataParams;
+      isSecondId: boolean;
+    }, xstate601.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate601.Values<{
+  setError: {
+    type: "setError";
+    params: xstate601.NonReducibleUnknown;
+  };
+  setInitialData: {
+    type: "setInitialData";
+    params: xstate601.NonReducibleUnknown;
+  };
+  updateField: {
+    type: "updateField";
+    params: xstate601.NonReducibleUnknown;
+  };
+  clearFieldValidationError: {
+    type: "clearFieldValidationError";
+    params: xstate601.NonReducibleUnknown;
+  };
+  setOcrValidationErrors: {
+    type: "setOcrValidationErrors";
+    params: xstate601.NonReducibleUnknown;
+  };
+  validateFormField: {
+    type: "validateFormField";
+    params: xstate601.NonReducibleUnknown;
+  };
+  beginSecondIdOcrPhase: {
+    type: "beginSecondIdOcrPhase";
+    params: xstate601.NonReducibleUnknown;
+  };
+  resetForRetry: {
+    type: "resetForRetry";
+    params: xstate601.NonReducibleUnknown;
+  };
+  computeValidationResult: {
+    type: "computeValidationResult";
+    params: xstate601.NonReducibleUnknown;
+  };
+}>, xstate601.Values<{
+  isOcrEditable: {
+    type: "isOcrEditable";
+    params: unknown;
+  };
+  shouldLoadSecondOcrAfterFirst: {
+    type: "shouldLoadSecondOcrAfterFirst";
+    params: unknown;
+  };
+  isOcrFormValid: {
+    type: "isOcrFormValid";
+    params: unknown;
+  };
+  shouldSubmit: {
+    type: "shouldSubmit";
+    params: unknown;
+  };
+  shouldProceedWithoutSubmitToSecondId: {
+    type: "shouldProceedWithoutSubmitToSecondId";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "success" | "finished" | "loading" | "submitting" | "inputting" | "readonly" | "validatingContinue", string, IdOcrInput, xstate601.NonReducibleUnknown, xstate601.EventObject, xstate601.MetaObject, {
+  readonly id: "idOcr";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "getOcrData" | "updateOcrData">(logic: TSrc, ...[options]: ({
+        src: "getOcrData";
+        logic: xstate601.PromiseActorLogic<OcrData, {
+          isSecondId: boolean;
+        }, xstate601.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "getOcrData";
+        logic: xstate601.PromiseActorLogic<OcrData, {
+          isSecondId: boolean;
+        }, xstate601.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate601.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate601.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate601.RequiredActorOptions<T>]: unknown }) | undefined], xstate601.IsNotNever<xstate601.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "updateOcrData";
+        logic: xstate601.PromiseActorLogic<UpdateOcrResponse, {
+          params: UpdateOcrDataParams;
+          isSecondId: boolean;
+        }, xstate601.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "updateOcrData";
+        logic: xstate601.PromiseActorLogic<UpdateOcrResponse, {
+          params: UpdateOcrDataParams;
+          isSecondId: boolean;
+        }, xstate601.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate601.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate601.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate601.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate601.IsNotNever<xstate601.RequiredActorOptions<T_1>>> : never : never : never)): xstate601.ActorRefFromLogic<xstate601.GetConcreteByKey<xstate601.Values<{
+        getOcrData: {
+          src: "getOcrData";
+          logic: xstate601.PromiseActorLogic<OcrData, {
+            isSecondId: boolean;
+          }, xstate601.EventObject>;
+          id: string | undefined;
+        };
+        updateOcrData: {
+          src: "updateOcrData";
+          logic: xstate601.PromiseActorLogic<UpdateOcrResponse, {
+            params: UpdateOcrDataParams;
+            isSecondId: boolean;
+          }, xstate601.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate601.AnyActorLogic>(src: TLogic, ...[options]: xstate601.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate601.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate601.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate601.IsNotNever<xstate601.RequiredLogicInput<TLogic>>>): xstate601.ActorRefFromLogic<TLogic>;
+    };
+    input: IdOcrInput;
+    self: xstate601.ActorRef<xstate601.MachineSnapshot<IdOcrContext, {
+      type: "LOAD";
+    } | {
+      type: "DATA_CHANGED";
+      field: keyof UpdateOcrDataParams;
+      value: string;
+    } | {
+      type: "VALIDATE_FIELD";
+      field: keyof UpdateOcrDataParams;
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "RETRY";
+    }, Record<string, xstate601.AnyActorRef | undefined>, xstate601.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "DATA_CHANGED";
+      field: keyof UpdateOcrDataParams;
+      value: string;
+    } | {
+      type: "VALIDATE_FIELD";
+      field: keyof UpdateOcrDataParams;
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "RETRY";
+    }, xstate601.AnyEventObject>;
+  }) => {
+    config: IdOcrConfig;
+    formData: UpdateOcrDataParams;
+    editedFields: {};
+    activeOcrDocument: IdOcrOcrDocument;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: readonly [{
+          readonly target: "loading";
+        }];
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly src: "getOcrData";
+        readonly input: ({
+          context
+        }: {
+          context: IdOcrContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          };
+          self: xstate601.ActorRef<xstate601.MachineSnapshot<IdOcrContext, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, Record<string, xstate601.AnyActorRef>, xstate601.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, xstate601.AnyEventObject>;
+        }) => {
+          isSecondId: boolean;
+        };
+        readonly onDone: readonly [{
+          readonly target: "inputting";
+          readonly guard: "isOcrEditable";
+          readonly actions: "setInitialData";
+        }, {
+          readonly target: "readonly";
+          readonly actions: "setInitialData";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly readonly: {
+      readonly on: {
+        readonly CONTINUE: readonly [{
+          readonly target: "loading";
+          readonly guard: "shouldLoadSecondOcrAfterFirst";
+          readonly actions: "beginSecondIdOcrPhase";
+        }, {
+          readonly target: "success";
+        }];
+      };
+    };
+    readonly inputting: {
+      readonly on: {
+        readonly DATA_CHANGED: {
+          readonly actions: readonly ["updateField", "clearFieldValidationError"];
+        };
+        readonly VALIDATE_FIELD: {
+          readonly actions: "validateFormField";
+        };
+        readonly CONTINUE: {
+          readonly target: "validatingContinue";
+        };
+      };
+    };
+    readonly validatingContinue: {
+      readonly entry: "computeValidationResult";
+      readonly always: readonly [{
+        readonly guard: "shouldSubmit";
+        readonly target: "submitting";
+      }, {
+        readonly guard: "shouldProceedWithoutSubmitToSecondId";
+        readonly target: "loading";
+        readonly actions: "beginSecondIdOcrPhase";
+      }, {
+        readonly guard: "isOcrFormValid";
+        readonly target: "success";
+      }, {
+        readonly target: "inputting";
+      }];
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly src: "updateOcrData";
+        readonly input: ({
+          context
+        }: {
+          context: IdOcrContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          };
+          self: xstate601.ActorRef<xstate601.MachineSnapshot<IdOcrContext, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, Record<string, xstate601.AnyActorRef>, xstate601.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "DATA_CHANGED";
+            field: keyof UpdateOcrDataParams;
+            value: string;
+          } | {
+            type: "VALIDATE_FIELD";
+            field: keyof UpdateOcrDataParams;
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "RETRY";
+          }, xstate601.AnyEventObject>;
+        }) => {
+          params: UpdateOcrDataParams;
+          isSecondId: boolean;
+        };
+        readonly onDone: readonly [{
+          readonly target: "loading";
+          readonly guard: "shouldLoadSecondOcrAfterFirst";
+          readonly actions: "beginSecondIdOcrPhase";
+        }, {
+          readonly target: "success";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "resetForRetry";
+        };
+      };
+    };
+    readonly success: {
+      readonly after: {
+        readonly 3000: "finished";
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/id-ocr/idOcrActor.d.ts
+type CreateIdOcrActorOptions = {
+  config: IdOcrConfig;
+};
+//#endregion
+//#region src/modules/id-ocr/idOcrManager.d.ts
+type IdOcrIdleState = {
+  status: 'idle';
+};
+type IdOcrLoadingState = {
+  status: 'loading';
+  ocrDocument: IdOcrOcrDocument;
+};
+type IdOcrReadonlyState = {
+  status: 'readonly';
+  formData: UpdateOcrDataParams;
+  editableOcr: boolean;
+  ocrDocument: IdOcrOcrDocument;
+};
+type IdOcrInputtingState = {
+  status: 'inputting';
+  formData: UpdateOcrDataParams;
+  editedFields: UpdateOcrDataParams;
+  editableOcr: boolean;
+  ocrDocument: IdOcrOcrDocument;
+  validationErrors?: Partial<Record<keyof UpdateOcrDataParams, string>>;
+};
+type IdOcrSubmittingState = {
+  status: 'submitting';
+  ocrDocument: IdOcrOcrDocument;
+};
+type IdOcrFinishedState = {
+  status: 'finished';
+};
+type IdOcrErrorState = {
+  status: 'error';
+  error: string;
+};
+type IdOcrSuccessState = {
+  status: 'success';
+};
+type IdOcrState = IdOcrIdleState | IdOcrLoadingState | IdOcrReadonlyState | IdOcrInputtingState | IdOcrSubmittingState | IdOcrFinishedState | IdOcrErrorState | IdOcrSuccessState;
+declare function createIdOcrManager(options: CreateIdOcrActorOptions): Manager<IdOcrState> & {
+  load(): void;
+  setField(field: keyof UpdateOcrDataParams, value: string): void;
+  validateField(field: keyof UpdateOcrDataParams): void;
+  continue(): void;
+  retry(): void;
+};
+type IdOcrManager = ReturnType<typeof createIdOcrManager>;
+//#endregion
+//#region src/modules/id-ocr/idOcrFields.d.ts
+declare const OCR_FIELDS: OcrFieldConfig[];
+declare const getOcrFields: (config: Pick<IdOcrConfig, "flowId">) => OcrFieldConfig[];
+//#endregion
+//#region src/modules/id-ocr/idOcrConsts.d.ts
+declare const MIN_AGE = 18;
+declare const CPFFlowIds: string[];
+//#endregion
+export { CPFFlowIds, type IdOcrConfig, type IdOcrManager, type IdOcrOcrDocument, type IdOcrState, MIN_AGE, OCR_FIELDS, type OcrData, type OcrFieldConfig, type UpdateOcrDataParams, type ValidationRule, createIdOcrManager, getOcrFields, idOcrStateMachine };

package/dist/id-ocr.esm.js

@@ -0,0 +1,86 @@
+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 "./cpf-PPz2Njto.esm.js";
+import { a as MIN_AGE, i as CPFFlowIds, n as OCR_FIELDS, r as getOcrFields, t as idOcrStateMachine } from "./idOcrStateMachine-YbjjC_Gg.esm.js";
+
+//#region src/modules/id-ocr/idOcrActor.ts
+function createIdOcrActor(options) {
+	return createActor(idOcrStateMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/id-ocr/idOcrManager.ts
+function mapState(snapshot) {
+	const { context } = snapshot;
+	const editableOcr = context.config.editableOcr === true;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("loading")) return {
+		status: "loading",
+		ocrDocument: context.activeOcrDocument
+	};
+	if (snapshot.matches("readonly")) return {
+		status: "readonly",
+		formData: context.formData,
+		editableOcr,
+		ocrDocument: context.activeOcrDocument
+	};
+	if (snapshot.matches("inputting")) return {
+		status: "inputting",
+		formData: context.formData,
+		editedFields: context.editedFields,
+		editableOcr,
+		ocrDocument: context.activeOcrDocument,
+		validationErrors: context.validationErrors
+	};
+	if (snapshot.matches("submitting")) return {
+		status: "submitting",
+		ocrDocument: context.activeOcrDocument
+	};
+	if (snapshot.matches("success")) return { status: "success" };
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setField(field, value) {
+			actor.send({
+				type: "DATA_CHANGED",
+				field,
+				value
+			});
+		},
+		validateField(field) {
+			actor.send({
+				type: "VALIDATE_FIELD",
+				field
+			});
+		},
+		continue() {
+			actor.send({ type: "CONTINUE" });
+			trackElementClicked?.("continue");
+		},
+		retry() {
+			actor.send({ type: "RETRY" });
+		}
+	};
+}
+function createIdOcrManager(options) {
+	return createManager({
+		actor: createIdOcrActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.idOcr)
+	});
+}
+
+//#endregion
+export { CPFFlowIds, MIN_AGE, OCR_FIELDS, createIdOcrManager, getOcrFields, idOcrStateMachine };