@incodetech/core 2.0.1 → 2.1.0-rc.0

package/dist/cpf-ocr.d.ts

@@ -1,204 +1,9 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import * as xstate738 from "xstate";
+import "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import { a as CpfOcrActor, i as createCpfOcrManagerFromActor, n as CpfOcrState, o as cpfOcrMachine, r as createCpfOcrManager, t as CpfOcrManager } from "./cpfOcrManager-BnieFXuG.js";
 
-//#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: xstate738.StateMachine<CpfOcrContext, {
-  type: "LOAD";
-} | {
-  type: "SET_CPF";
-  cpf: string;
-} | {
-  type: "SUBMIT";
-} | {
-  type: "RETRY";
-}, {
-  [x: string]: xstate738.ActorRefFromLogic<xstate738.PromiseActorLogic<CpfOcrDataResponse, void, xstate738.EventObject>> | xstate738.ActorRefFromLogic<xstate738.PromiseActorLogic<CpfOcrUpdateResponse, {
-    cpf: string;
-  }, xstate738.EventObject>> | undefined;
-}, xstate738.Values<{
-  fetchCpfOcrData: {
-    src: "fetchCpfOcrData";
-    logic: xstate738.PromiseActorLogic<CpfOcrDataResponse, void, xstate738.EventObject>;
-    id: string | undefined;
-  };
-  submitCpfOcr: {
-    src: "submitCpfOcr";
-    logic: xstate738.PromiseActorLogic<CpfOcrUpdateResponse, {
-      cpf: string;
-    }, xstate738.EventObject>;
-    id: string | undefined;
-  };
-}>, xstate738.Values<{
-  setError: {
-    type: "setError";
-    params: xstate738.NonReducibleUnknown;
-  };
-  clearError: {
-    type: "clearError";
-    params: xstate738.NonReducibleUnknown;
-  };
-  setPrefill: {
-    type: "setPrefill";
-    params: xstate738.NonReducibleUnknown;
-  };
-  setCpf: {
-    type: "setCpf";
-    params: xstate738.NonReducibleUnknown;
-  };
-}>, {
-  type: "isValid";
-  params: unknown;
-}, never, "error" | "idle" | "finished" | "loading" | "submitting" | "inputting", string, CpfOcrInput, xstate738.NonReducibleUnknown, xstate738.EventObject, xstate738.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: xstate738.ActorRef<xstate738.MachineSnapshot<CpfOcrContext, {
-            type: "LOAD";
-          } | {
-            type: "SET_CPF";
-            cpf: string;
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "RETRY";
-          }, Record<string, xstate738.AnyActorRef>, xstate738.StateValue, string, unknown, any, any>, {
-            type: "LOAD";
-          } | {
-            type: "SET_CPF";
-            cpf: string;
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "RETRY";
-          }, xstate738.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 };
+export { type CpfOcrActor, type CpfOcrManager, type CpfOcrState, cpfOcrMachine, createCpfOcrManager, createCpfOcrManagerFromActor, formatCPF, isValidCPF };

package/dist/cpf-ocr.esm.js

@@ -1,177 +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 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 };
+import "./api-CESGtpbH.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { a as isValidCPF, i as formatCPF, n as createCpfOcrManagerFromActor, r as cpfOcrMachine, t as createCpfOcrManager } from "./cpfOcrManager-sSKegxox.esm.js";
+import "./cpf-BRzggV8G.esm.js";
+
+export { cpfOcrMachine, createCpfOcrManager, createCpfOcrManagerFromActor, formatCPF, isValidCPF };

package/dist/cpfOcrManager-BnieFXuG.d.ts

@@ -0,0 +1,216 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import * as xstate1019 from "xstate";
+
+//#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: xstate1019.StateMachine<CpfOcrContext, {
+  type: "LOAD";
+} | {
+  type: "SET_CPF";
+  cpf: string;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate1019.ActorRefFromLogic<xstate1019.PromiseActorLogic<CpfOcrDataResponse, void, xstate1019.EventObject>> | xstate1019.ActorRefFromLogic<xstate1019.PromiseActorLogic<CpfOcrUpdateResponse, {
+    cpf: string;
+  }, xstate1019.EventObject>> | undefined;
+}, xstate1019.Values<{
+  fetchCpfOcrData: {
+    src: "fetchCpfOcrData";
+    logic: xstate1019.PromiseActorLogic<CpfOcrDataResponse, void, xstate1019.EventObject>;
+    id: string | undefined;
+  };
+  submitCpfOcr: {
+    src: "submitCpfOcr";
+    logic: xstate1019.PromiseActorLogic<CpfOcrUpdateResponse, {
+      cpf: string;
+    }, xstate1019.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate1019.Values<{
+  setError: {
+    type: "setError";
+    params: xstate1019.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate1019.NonReducibleUnknown;
+  };
+  setPrefill: {
+    type: "setPrefill";
+    params: xstate1019.NonReducibleUnknown;
+  };
+  setCpf: {
+    type: "setCpf";
+    params: xstate1019.NonReducibleUnknown;
+  };
+}>, {
+  type: "isValid";
+  params: unknown;
+}, never, "error" | "idle" | "finished" | "loading" | "submitting" | "inputting", string, CpfOcrInput, xstate1019.NonReducibleUnknown, xstate1019.EventObject, xstate1019.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: xstate1019.ActorRef<xstate1019.MachineSnapshot<CpfOcrContext, {
+            type: "LOAD";
+          } | {
+            type: "SET_CPF";
+            cpf: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          }, Record<string, xstate1019.AnyActorRef>, xstate1019.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "SET_CPF";
+            cpf: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          }, xstate1019.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";
+    };
+  };
+}>;
+type CpfOcrMachine = typeof cpfOcrMachine;
+//#endregion
+//#region src/modules/cpf-ocr/cpfOcrActor.d.ts
+type CpfOcrActor = ActorRefFrom<CpfOcrMachine>;
+//#endregion
+//#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;
+};
+/**
+ * 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.
+ */
+declare function createCpfOcrManagerFromActor(actor: CpfOcrActor): Manager<CpfOcrState> & {
+  load(): void;
+  setCpf(cpf: string): void;
+  submit(): void;
+  retry(): void;
+};
+type CpfOcrManager = ReturnType<typeof createCpfOcrManager>;
+//#endregion
+export { CpfOcrActor as a, createCpfOcrManagerFromActor as i, CpfOcrState as n, cpfOcrMachine as o, createCpfOcrManager as r, CpfOcrManager as t };