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

package/dist/camera.d.ts

@@ -0,0 +1,15 @@
+import { n as PermissionStatus, t as PermissionResult } from "./types-CAD4va6a.js";
+
+//#region src/internal/permissions/permissionServices.d.ts
+type RequestPermissionOptions = {
+  requestMotion?: boolean;
+};
+declare function checkPermission(): Promise<PermissionResult>;
+/**
+ * Requests camera permission by attempting to access the camera, then immediately
+ * stops the obtained stream. Also requests motion sensor permission (required on iOS
+ * to be called during a user gesture). This function does not keep or return the stream.
+ */
+declare function requestPermission(options?: RequestPermissionOptions): Promise<PermissionResult>;
+//#endregion
+export { type PermissionResult, type PermissionStatus, checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/camera.esm.js

@@ -0,0 +1,5 @@
+import "./camera-PA2Ljri3.esm.js";
+import "./MotionSensorProvider-4v7xkqAp.esm.js";
+import { n as requestPermission, t as checkPermission } from "./permissionServices-D_i6nzEw.esm.js";
+
+export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/consent.d.ts

@@ -0,0 +1,398 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import * as xstate182 from "xstate";
+
+//#region src/modules/consent/types.d.ts
+type ConsentConfig = {
+  combinedConsents?: string;
+  consentId?: string;
+};
+type ConsentCheckbox = {
+  id: string;
+  label: string;
+  required: boolean;
+  checked: boolean;
+};
+type FetchCombinedConsentResponse = {
+  languageConsentId: string;
+  terms: string;
+  title: string;
+  consents: Array<{
+    checkboxId: string;
+    consentText: string;
+    optional: boolean;
+  }>;
+};
+//#endregion
+//#region src/modules/consent/consentStateMachine.d.ts
+type ConsentContext = {
+  config: ConsentConfig;
+  title: string;
+  richText: string;
+  languageConsentId: string;
+  checkboxes: ConsentCheckbox[];
+  error: string | undefined;
+};
+type ConsentInput = {
+  config: ConsentConfig;
+};
+declare const consentMachine: xstate182.StateMachine<ConsentContext, {
+  type: "LOAD";
+} | {
+  type: "TOGGLE_CHECKBOX";
+  checkboxId: string;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "RETRY";
+} | {
+  type: "RESET";
+}, {
+  [x: string]: xstate182.ActorRefFromLogic<xstate182.PromiseActorLogic<FetchCombinedConsentResponse, {
+    consentId: string;
+  }, xstate182.EventObject>> | xstate182.ActorRefFromLogic<xstate182.PromiseActorLogic<void, {
+    languageConsentId: string;
+    checkboxes: ConsentCheckbox[];
+  }, xstate182.EventObject>> | undefined;
+}, xstate182.Values<{
+  fetchConsent: {
+    src: "fetchConsent";
+    logic: xstate182.PromiseActorLogic<FetchCombinedConsentResponse, {
+      consentId: string;
+    }, xstate182.EventObject>;
+    id: string | undefined;
+  };
+  submitConsent: {
+    src: "submitConsent";
+    logic: xstate182.PromiseActorLogic<void, {
+      languageConsentId: string;
+      checkboxes: ConsentCheckbox[];
+    }, xstate182.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate182.Values<{
+  setError: {
+    type: "setError";
+    params: xstate182.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate182.NonReducibleUnknown;
+  };
+  resetContext: {
+    type: "resetContext";
+    params: xstate182.NonReducibleUnknown;
+  };
+  setConsentData: {
+    type: "setConsentData";
+    params: xstate182.NonReducibleUnknown;
+  };
+  toggleCheckbox: {
+    type: "toggleCheckbox";
+    params: xstate182.NonReducibleUnknown;
+  };
+}>, {
+  type: "canSubmit";
+  params: unknown;
+}, never, "error" | "idle" | "finished" | "loading" | "display" | "submitting", string, ConsentInput, xstate182.NonReducibleUnknown, xstate182.EventObject, xstate182.MetaObject, {
+  readonly id: "consent";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
+        src: "fetchConsent";
+        logic: xstate182.PromiseActorLogic<FetchCombinedConsentResponse, {
+          consentId: string;
+        }, xstate182.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchConsent";
+        logic: xstate182.PromiseActorLogic<FetchCombinedConsentResponse, {
+          consentId: string;
+        }, xstate182.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate182.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate182.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate182.RequiredActorOptions<T>]: unknown }) | undefined], xstate182.IsNotNever<xstate182.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitConsent";
+        logic: xstate182.PromiseActorLogic<void, {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        }, xstate182.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitConsent";
+        logic: xstate182.PromiseActorLogic<void, {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        }, xstate182.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate182.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate182.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate182.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate182.IsNotNever<xstate182.RequiredActorOptions<T_1>>> : never : never : never)): xstate182.ActorRefFromLogic<xstate182.GetConcreteByKey<xstate182.Values<{
+        fetchConsent: {
+          src: "fetchConsent";
+          logic: xstate182.PromiseActorLogic<FetchCombinedConsentResponse, {
+            consentId: string;
+          }, xstate182.EventObject>;
+          id: string | undefined;
+        };
+        submitConsent: {
+          src: "submitConsent";
+          logic: xstate182.PromiseActorLogic<void, {
+            languageConsentId: string;
+            checkboxes: ConsentCheckbox[];
+          }, xstate182.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate182.AnyActorLogic>(src: TLogic, ...[options]: xstate182.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate182.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate182.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate182.IsNotNever<xstate182.RequiredLogicInput<TLogic>>>): xstate182.ActorRefFromLogic<TLogic>;
+    };
+    input: ConsentInput;
+    self: xstate182.ActorRef<xstate182.MachineSnapshot<ConsentContext, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE_CHECKBOX";
+      checkboxId: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, Record<string, xstate182.AnyActorRef | undefined>, xstate182.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE_CHECKBOX";
+      checkboxId: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, xstate182.AnyEventObject>;
+  }) => {
+    config: ConsentConfig;
+    title: string;
+    richText: string;
+    languageConsentId: string;
+    checkboxes: never[];
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "fetchConsent";
+        readonly src: "fetchConsent";
+        readonly input: ({
+          context
+        }: {
+          context: ConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate182.ActorRef<xstate182.MachineSnapshot<ConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate182.AnyActorRef>, xstate182.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate182.AnyEventObject>;
+        }) => {
+          consentId: string;
+        };
+        readonly onDone: {
+          readonly target: "display";
+          readonly actions: "setConsentData";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly display: {
+      readonly on: {
+        readonly TOGGLE_CHECKBOX: {
+          readonly actions: "toggleCheckbox";
+        };
+        readonly SUBMIT: {
+          readonly target: "submitting";
+          readonly guard: "canSubmit";
+        };
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly id: "submitConsent";
+        readonly src: "submitConsent";
+        readonly input: ({
+          context
+        }: {
+          context: ConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate182.ActorRef<xstate182.MachineSnapshot<ConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate182.AnyActorRef>, xstate182.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate182.AnyEventObject>;
+        }) => {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        };
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "display";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly RESET: {
+          readonly target: "idle";
+          readonly actions: "resetContext";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/consent/consentActor.d.ts
+type CreateConsentActorOptions = {
+  config: ConsentConfig;
+};
+//#endregion
+//#region src/modules/consent/consentManager.d.ts
+type ConsentIdleState = {
+  status: 'idle';
+};
+type ConsentLoadingState = {
+  status: 'loading';
+};
+type ConsentDisplayState = {
+  status: 'display';
+  title: string;
+  richText: string;
+  checkboxes: ConsentCheckbox[];
+  canSubmit: boolean;
+  error?: string;
+};
+type ConsentSubmittingState = {
+  status: 'submitting';
+  title: string;
+  richText: string;
+  checkboxes: ConsentCheckbox[];
+  canSubmit: false;
+};
+type ConsentFinishedState = {
+  status: 'finished';
+};
+type ConsentErrorState = {
+  status: 'error';
+  error: string;
+};
+type ConsentState = ConsentIdleState | ConsentLoadingState | ConsentDisplayState | ConsentSubmittingState | ConsentFinishedState | ConsentErrorState;
+declare function createConsentManager(options: CreateConsentActorOptions): Manager<ConsentState> & {
+  load(): void;
+  toggleCheckbox(checkboxId: string): void;
+  submit(): void;
+  retry(): void;
+  reset(): void;
+};
+type ConsentManager = ReturnType<typeof createConsentManager>;
+//#endregion
+export { type ConsentCheckbox, type ConsentConfig, type ConsentManager, type ConsentState, consentMachine, createConsentManager };

package/dist/consent.esm.js

@@ -0,0 +1,79 @@
+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 { t as consentMachine } from "./consentStateMachine-CCT-B60O.esm.js";
+
+//#region src/modules/consent/consentActor.ts
+function createConsentActor(options) {
+	return createActor(consentMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/consent/consentManager.ts
+function getCanSubmit(checkboxes) {
+	return checkboxes.filter((checkbox) => checkbox.required).every((checkbox) => checkbox.checked);
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	const canSubmit = getCanSubmit(context.checkboxes);
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("display")) return {
+		status: "display",
+		title: context.title,
+		richText: context.richText,
+		checkboxes: context.checkboxes,
+		canSubmit,
+		error: context.error
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		title: context.title,
+		richText: context.richText,
+		checkboxes: context.checkboxes,
+		canSubmit: false
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		toggleCheckbox(checkboxId) {
+			actor.send({
+				type: "TOGGLE_CHECKBOX",
+				checkboxId
+			});
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+function createConsentManager(options) {
+	return createManager({
+		actor: createConsentActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent)
+	});
+}
+
+//#endregion
+export { consentMachine, createConsentManager };

package/dist/consentStateMachine-CCT-B60O.esm.js

@@ -0,0 +1,151 @@
+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";
+
+//#region src/modules/consent/consentServices.ts
+async function fetchCombinedConsent(consentId, signal) {
+	if (!consentId) throw new Error("Combined consent id is required");
+	const res = await api.get(endpoints.getCombinedConsent, {
+		signal,
+		query: {
+			id: consentId,
+			language: "en"
+		}
+	});
+	if (!res.ok) throw new Error(`GET ${endpoints.getCombinedConsent} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function submitCombinedConsent(params, signal) {
+	const res = await api.post(endpoints.signCombinedConsent, params, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.signCombinedConsent} failed: ${res.status} ${res.statusText}`);
+}
+
+//#endregion
+//#region src/modules/consent/consentStateMachine.ts
+function toCheckboxRecord(checkboxes) {
+	return checkboxes.reduce((acc, checkbox) => {
+		acc[checkbox.id] = checkbox.checked;
+		return acc;
+	}, {});
+}
+const consentMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchConsent: fromPromise(async ({ input, signal }) => {
+			return fetchCombinedConsent(input.consentId, signal);
+		}),
+		submitConsent: fromPromise(async ({ input, signal }) => {
+			await submitCombinedConsent({
+				languageConsentId: input.languageConsentId,
+				checkboxes: toCheckboxRecord(input.checkboxes)
+			}, signal);
+		})
+	},
+	actions: {
+		setConsentData: assign(({ event }) => {
+			const output = event.output;
+			return {
+				title: output.title,
+				richText: output.terms,
+				languageConsentId: output.languageConsentId,
+				checkboxes: output.consents.map((consent) => ({
+					id: consent.checkboxId,
+					label: consent.consentText,
+					required: !consent.optional,
+					checked: false
+				})),
+				error: void 0
+			};
+		}),
+		toggleCheckbox: assign(({ context, event }) => {
+			const checkboxId = event.checkboxId;
+			return { checkboxes: context.checkboxes.map((checkbox) => checkbox.id === checkboxId ? {
+				...checkbox,
+				checked: !checkbox.checked
+			} : checkbox) };
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			title: "",
+			richText: "",
+			languageConsentId: "",
+			checkboxes: [],
+			error: void 0
+		}))
+	},
+	guards: { canSubmit: ({ context }) => context.checkboxes.filter((checkbox) => checkbox.required).every((checkbox) => checkbox.checked) }
+}).createMachine({
+	id: "consent",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		title: "",
+		richText: "",
+		languageConsentId: "",
+		checkboxes: [],
+		error: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: {
+			target: "loading",
+			actions: "clearError"
+		} } },
+		loading: { invoke: {
+			id: "fetchConsent",
+			src: "fetchConsent",
+			input: ({ context }) => ({ consentId: String(context.config.combinedConsents ?? context.config.consentId ?? "") }),
+			onDone: {
+				target: "display",
+				actions: "setConsentData"
+			},
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		display: { on: {
+			TOGGLE_CHECKBOX: { actions: "toggleCheckbox" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "canSubmit"
+			},
+			RETRY: {
+				target: "loading",
+				actions: "clearError"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitConsent",
+			src: "submitConsent",
+			input: ({ context }) => ({
+				languageConsentId: context.languageConsentId,
+				checkboxes: context.checkboxes
+			}),
+			onDone: { target: "finished" },
+			onError: {
+				target: "display",
+				actions: "setError"
+			}
+		} },
+		error: { on: {
+			RETRY: {
+				target: "loading",
+				actions: "clearError"
+			},
+			RESET: {
+				target: "idle",
+				actions: "resetContext"
+			}
+		} },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { consentMachine as t };

package/dist/cpf-PPz2Njto.esm.js

@@ -0,0 +1,38 @@
+//#region src/shared/validators/cpf.ts
+const INVALID_CPF_PATTERNS = [
+	"00000000000",
+	"11111111111",
+	"22222222222",
+	"33333333333",
+	"44444444444",
+	"55555555555",
+	"66666666666",
+	"77777777777",
+	"88888888888",
+	"99999999999"
+];
+/**
+* Validates a Brazilian CPF number (11-digit checksum).
+* Accepts formatted (000.000.000-00) or unformatted input.
+*/
+function validateCPF(cpfString) {
+	let cpf = cpfString;
+	if (cpf.length === 14) cpf = cpf.replace(/\./g, "").replace(/-/g, "");
+	if (cpf.length !== 11) return false;
+	if (!/^\d+$/.test(cpf)) return false;
+	if (INVALID_CPF_PATTERNS.includes(cpf)) return false;
+	let sum = 0;
+	for (let i = 0; i < 9; i++) sum += Number.parseInt(cpf.charAt(i), 10) * (10 - i);
+	let firstDigit = 11 - sum % 11;
+	if (firstDigit >= 10) firstDigit = 0;
+	if (cpf.charAt(9) !== firstDigit.toString()) return false;
+	sum = 0;
+	for (let i = 0; i < 10; i++) sum += Number.parseInt(cpf.charAt(i), 10) * (11 - i);
+	let secondDigit = 11 - sum % 11;
+	if (secondDigit >= 10) secondDigit = 0;
+	if (cpf.charAt(10) !== secondDigit.toString()) return false;
+	return true;
+}
+
+//#endregion
+export { validateCPF as t };