@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/dynamic-forms.esm.js

@@ -0,0 +1,323 @@
+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";
+import { t as isoDateToMs } from "./dateUtils-UoN5xswP.esm.js";
+
+//#region src/modules/dynamic-forms/dynamicFormsServices.ts
+async function fetchForms(flowId, signal) {
+	const url = `${endpoints.moduleConfig}?id=${encodeURIComponent(flowId)}&moduleKey=DYNAMIC_FORMS`;
+	const res = await api.get(url, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.moduleConfig} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function submitFormAnswer(params, signal) {
+	const res = await api.post(endpoints.dynamicFormsSubmitAnswer, {
+		questionId: params.questionId,
+		answerDetails: { singleAnswer: params.singleAnswer }
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.dynamicFormsSubmitAnswer} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsStateMachine.ts
+/**
+* Returns default answers for a screen, seeding 'NO' for every YESNO question.
+* An untouched checkbox must submit a value — this is a domain rule, not a UI concern.
+*/
+function seedDefaultAnswers(formScreen) {
+	if (!formScreen) return {};
+	const defaults = {};
+	for (const q of formScreen.questions) if ((q.inputType ?? q.overrides) === "YESNO") defaults[q.questionId] = "NO";
+	return defaults;
+}
+/**
+* Transforms a raw answer value before submission based on question type.
+* - CPF: strips formatting characters (dots and dash)
+* - DATE: converts ISO date string (YYYY-MM-DD) to Unix milliseconds string
+* - All others: pass through as-is
+*/
+function transformAnswerValue(inputType, value) {
+	switch (inputType) {
+		case "CPF": return value.replace(/[-.]/g, "");
+		case "DATE": return isoDateToMs(value).toString();
+		default: return value;
+	}
+}
+const dynamicFormsMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchScreens: fromPromise(async ({ input, signal }) => {
+			return fetchForms(input.flowId, signal);
+		}),
+		submitScreenAnswers: fromPromise(async ({ input, signal }) => {
+			const { screen: formScreen, answers } = input;
+			for (const question of formScreen.questions) {
+				const singleAnswer = transformAnswerValue(question.inputType ?? question.overrides ?? "TEXT", answers[question.questionId] ?? "");
+				try {
+					await submitFormAnswer({
+						questionId: question.questionId,
+						singleAnswer
+					}, signal);
+				} catch {}
+			}
+			return { success: true };
+		})
+	},
+	actions: {
+		setScreens: assign(({ event }) => {
+			const screens = event.output.screens;
+			return {
+				screens,
+				answers: seedDefaultAnswers(screens[0])
+			};
+		}),
+		setAnswer: assign(({ context, event }) => {
+			const e = event;
+			const question = context.screens[context.currentScreenIndex]?.questions.find((q) => q.questionId === e.questionId);
+			const effectiveType = question?.inputType ?? question?.overrides;
+			const newAnswerValidity = { ...context.answerValidity };
+			if (effectiveType === "CPF") newAnswerValidity[e.questionId] = validateCPF(e.value);
+			return {
+				answers: {
+					...context.answers,
+					[e.questionId]: e.value
+				},
+				answerValidity: newAnswerValidity
+			};
+		}),
+		setAnswerValidity: assign(({ context, event }) => {
+			const e = event;
+			return { answerValidity: {
+				...context.answerValidity,
+				[e.questionId]: e.isValid
+			} };
+		}),
+		advanceScreen: assign(({ context }) => {
+			const nextIndex = context.currentScreenIndex + 1;
+			return {
+				currentScreenIndex: nextIndex,
+				answers: seedDefaultAnswers(context.screens[nextIndex]),
+				answerValidity: {}
+			};
+		}),
+		markCompleted: assign({ result: "completed" }),
+		markSkipped: assign({ result: "skipped" })
+	},
+	guards: {
+		hasPreloadedScreens: ({ context }) => (context.config.screens?.length ?? 0) > 0,
+		hasFlowId: ({ context }) => !!context.config.flowId,
+		isLastScreen: ({ context }) => context.currentScreenIndex >= context.screens.length - 1
+	}
+}).createMachine({
+	id: "dynamicForms",
+	initial: "idle",
+	context: ({ input }) => {
+		const screens = input.config.screens ?? [];
+		return {
+			config: input.config,
+			screens,
+			currentScreenIndex: 0,
+			answers: seedDefaultAnswers(screens[0]),
+			answerValidity: {},
+			result: null
+		};
+	},
+	states: {
+		idle: { on: { LOAD: [
+			{
+				target: "inputting",
+				guard: "hasPreloadedScreens"
+			},
+			{
+				target: "loadingScreens",
+				guard: "hasFlowId"
+			},
+			{ target: "misconfigured" }
+		] } },
+		loadingScreens: { invoke: {
+			id: "fetchScreens",
+			src: "fetchScreens",
+			input: ({ context }) => ({ flowId: context.config.flowId ?? "" }),
+			onDone: {
+				target: "inputting",
+				actions: "setScreens"
+			},
+			onError: {
+				target: "finished",
+				actions: "markSkipped"
+			}
+		} },
+		inputting: { on: {
+			ANSWER_CHANGED: { actions: "setAnswer" },
+			ANSWER_VALIDITY_CHANGED: { actions: "setAnswerValidity" },
+			SUBMIT: { target: "submitting" }
+		} },
+		submitting: { invoke: {
+			id: "submitScreenAnswers",
+			src: "submitScreenAnswers",
+			input: ({ context }) => ({
+				screen: context.screens[context.currentScreenIndex],
+				answers: context.answers
+			}),
+			onDone: [{
+				target: "success",
+				guard: "isLastScreen"
+			}, {
+				target: "inputting",
+				actions: "advanceScreen"
+			}],
+			onError: [{
+				target: "success",
+				guard: "isLastScreen"
+			}, {
+				target: "inputting",
+				actions: "advanceScreen"
+			}]
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markCompleted"
+		} } },
+		finished: { type: "final" },
+		misconfigured: { on: { CLOSE: { target: "closed" } } },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsActor.ts
+function createDynamicFormsActor(options) {
+	return createActor(dynamicFormsMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsManager.ts
+/**
+* @module @incodetech/core/dynamic-forms
+*
+* Dynamic Forms module for the Incode Web SDK.
+* Drives multi-screen forms defined by backend configuration.
+*
+* @example Headless usage
+* ```typescript
+* import { createDynamicFormsManager } from '@incodetech/core/dynamic-forms';
+* import { setup } from '@incodetech/core';
+*
+* setup({ apiURL: 'https://api.example.com', token: 'your-token' });
+*
+* const manager = createDynamicFormsManager({
+*   config: { flowId: 'flow-123' },
+* });
+*
+* manager.subscribe((state) => {
+*   if (state.status === 'inputting') {
+*     console.log('Screen:', state.currentScreen.title);
+*   }
+*   if (state.status === 'finished') {
+*     console.log('Result:', state.result); // 'completed' | 'skipped'
+*   }
+* });
+*
+* manager.load();
+* manager.stop();
+* ```
+*/
+function isScreenComplete(answers, formScreen) {
+	return formScreen.questions.every((q) => {
+		if (q.isOptional) return true;
+		if ((q.inputType ?? q.overrides) === "YESNO") return true;
+		const value = answers[q.questionId];
+		return value !== void 0 && value !== "";
+	});
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loadingScreens")) return { status: "loadingScreens" };
+	if (typedSnapshot.matches("inputting")) {
+		const currentScreen = context.screens[context.currentScreenIndex];
+		const allFormatsValid = !Object.values(context.answerValidity).some((v) => v === false);
+		return {
+			status: "inputting",
+			currentScreen,
+			screenIndex: context.currentScreenIndex,
+			totalScreens: context.screens.length,
+			answers: context.answers,
+			answerValidity: context.answerValidity,
+			canSubmit: currentScreen ? isScreenComplete(context.answers, currentScreen) && allFormatsValid : false
+		};
+	}
+	if (typedSnapshot.matches("submitting")) {
+		const currentScreen = context.screens[context.currentScreenIndex];
+		return {
+			status: "submitting",
+			screenIndex: context.currentScreenIndex,
+			totalScreens: context.screens.length,
+			currentScreen,
+			answers: context.answers,
+			answerValidity: context.answerValidity
+		};
+	}
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		result: context.result
+	};
+	if (typedSnapshot.matches("misconfigured")) return { status: "misconfigured" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setAnswer(questionId, value) {
+			actor.send({
+				type: "ANSWER_CHANGED",
+				questionId,
+				value
+			});
+		},
+		setAnswerValidity(questionId, isValid) {
+			actor.send({
+				type: "ANSWER_VALIDITY_CHANGED",
+				questionId,
+				isValid
+			});
+		},
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		},
+		close() {
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+/**
+* Creates a dynamic forms manager for headless or UI-driven usage.
+*
+* @param options - Configuration options
+* @param options.config - Dynamic forms configuration (flowId or pre-loaded screens)
+*
+* @returns Dynamic forms manager with state, API methods, and subscription
+*/
+function createDynamicFormsManager(options) {
+	return createManager({
+		actor: createDynamicFormsActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.forms)
+	});
+}
+
+//#endregion
+export { createDynamicFormsManager, dynamicFormsMachine };

package/dist/ekyb.d.ts

@@ -0,0 +1,148 @@
+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";
+import { n as AddressSuggestion, r as FieldDef, t as DisplayErrorsResult } from "./displayErrors-DqJ_IbsG.js";
+
+//#region src/modules/ekyb/types.d.ts
+type UboEntry = {
+  id: string;
+  name: string;
+  surname: string;
+};
+type EkybFormValues = {
+  country: string;
+  businessName?: string;
+  street?: string;
+  houseNo?: string;
+  addressLine2?: string;
+  city?: string;
+  state?: string;
+  postalCode?: string;
+  taxId?: string;
+};
+type EkybConfig = {
+  flowId?: string;
+  verificationFields?: string[];
+  checkBusinessName?: boolean;
+  checkAddress?: boolean;
+  checkTaxId?: boolean;
+  checkUniqueBeneficialOwner?: boolean;
+};
+type EkybFieldDef = FieldDef & {
+  optionalForCountries?: string[];
+};
+type EkybCountry = 'BR' | 'US' | 'GB' | 'ES' | 'IT' | 'FR' | 'DE' | 'IL' | 'MX' | 'CN' | 'NG' | 'CM' | 'KE';
+//#endregion
+//#region src/modules/ekyb/ekybStateMachine.d.ts
+declare const ekybMachine: any;
+//#endregion
+//#region src/modules/ekyb/ekybActor.d.ts
+type CreateEkybActorOptions = {
+  config: EkybConfig;
+};
+//#endregion
+//#region src/modules/ekyb/ekybManager.d.ts
+type EkybLoadingState = {
+  status: 'loading';
+};
+type EkybFormState = {
+  status: 'form';
+  country: string;
+  availableCountries: readonly string[];
+  fields: EkybFieldDef[];
+  values: EkybFormValues;
+  errors: Record<string, string>;
+  isValid: boolean;
+  ubos: UboEntry[];
+  canAddUbo: boolean;
+  addressSuggestions: AddressSuggestion[];
+  submitAttempted: boolean;
+};
+type EkybSubmittingState = {
+  status: 'submitting';
+};
+type EkybSuccessState = {
+  status: 'success';
+};
+type EkybErrorState = {
+  status: 'error';
+  errorMessage: string;
+};
+type EkybFinishedState = {
+  status: 'finished';
+};
+type EkybClosedState = {
+  status: 'closed';
+};
+/**
+ * Discriminated union of all possible eKYB manager states.
+ */
+type EkybState = EkybLoadingState | EkybFormState | EkybSubmittingState | EkybSuccessState | EkybErrorState | EkybFinishedState | EkybClosedState;
+/**
+ * Creates an eKYB manager for headless or UI-driven usage.
+ */
+declare function createEkybManager(options: CreateEkybActorOptions): Manager<EkybState> & {
+  /** Initializes the eKYB flow — builds form fields from the provided config */
+  load(): void;
+  /** Sets the country and resets/revalidates fields */
+  setCountry(country: string): void;
+  /** Sets a form field value and triggers revalidation */
+  setField(name: string, value: string): void;
+  /** Adds a new UBO entry (max 8) */
+  addUbo(): void;
+  /** Removes a UBO entry by index */
+  removeUbo(index: number): void;
+  /** Sets a UBO field (name or surname) */
+  setUboField(index: number, field: "name" | "surname", value: string): void;
+  /** Searches for address suggestions (debounced) */
+  searchAddress(query: string): void;
+  /** Fills address fields from a selected suggestion */
+  selectAddress(suggestion: AddressSuggestion): void;
+  /** Submits the form (requires isValid to be true) */
+  submit(): void;
+  /** Retries from failure state, returning to the form */
+  retry(): void;
+  /** Closes/dismisses the module */
+  close(): void;
+};
+type EkybManager = ReturnType<typeof createEkybManager>;
+//#endregion
+//#region src/modules/ekyb/ekybActions.d.ts
+declare function computeDisplayErrors(errors: Record<string, string>, touched: Record<string, boolean>, submitAttempted: boolean, country: string, fields?: EkybFieldDef[]): DisplayErrorsResult;
+//#endregion
+//#region src/modules/ekyb/ekybServices.d.ts
+type EkybFlowConfig = FlowModuleConfig['EKYB'];
+//#endregion
+//#region src/modules/ekyb/ekybUtils.d.ts
+/**
+ * Normalizes any supported eKYB config input into a manager-ready `EkybConfig`.
+ *
+ * Accepts either:
+ *  - A manager-ready `EkybConfig` (with `flowId` or `verificationFields`) →
+ *    returned unchanged.
+ *  - A raw backend `EkybFlowConfig` (with `*Source` companions) → stripped to
+ *    the four `check*` fields the manager consumes.
+ *
+ * Idempotent: `toEkybConfig(toEkybConfig(x))` equals `toEkybConfig(x)`.
+ */
+declare function toEkybConfig(config: Partial<EkybFlowConfig> & Partial<EkybConfig>): EkybConfig;
+//#endregion
+//#region src/modules/ekyb/ekybConstants.d.ts
+/**
+ * Countries available in all environments.
+ * Sorted alphabetically by display name.
+ */
+declare const SUPPORTED_COUNTRIES: readonly EkybCountry[];
+/**
+ * Additional countries available only in dev/staging environments.
+ */
+declare const DEV_ONLY_COUNTRIES: readonly EkybCountry[];
+/**
+ * Union of all recognized country codes (prod + dev).
+ */
+declare const ALL_COUNTRIES: readonly EkybCountry[];
+declare function isSupportedCountry(code: string): code is EkybCountry;
+//#endregion
+export { ALL_COUNTRIES, DEV_ONLY_COUNTRIES, type AddressSuggestion as EkybAddressSuggestion, type EkybConfig, type EkybCountry, type EkybFieldDef, type EkybFlowConfig, type EkybManager, type EkybState, SUPPORTED_COUNTRIES, type UboEntry, computeDisplayErrors as computeEkybDisplayErrors, createEkybManager, ekybMachine, isSupportedCountry, toEkybConfig };

package/dist/ekyb.esm.js

@@ -0,0 +1,127 @@
+import "./BrowserTimerProvider-DhNc_x02.esm.js";
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./session-CGtQJJzB.esm.js";
+import "./IpifyProvider-D7jx52AL.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { a as DEV_ONLY_COUNTRIES, i as ALL_COUNTRIES, n as computeDisplayErrors, o as SUPPORTED_COUNTRIES, r as toEkybConfig, s as isSupportedCountry, t as ekybMachine } from "./ekybStateMachine-BR2let5f.esm.js";
+import "./addressSearch-BpTbTWCa.esm.js";
+import "./flowServices-DG3IdWw6.esm.js";
+
+//#region src/modules/ekyb/ekybActor.ts
+/**
+* Creates and starts an eKYB actor.
+* The actor begins directly in 'form' state (no loading phase).
+*/
+function createEkybActor(options) {
+	return createActor(ekybMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/ekyb/ekybManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle") || typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("form")) return {
+		status: "form",
+		country: context.country,
+		availableCountries: context.availableCountries,
+		fields: context.fields,
+		values: context.values,
+		errors: context.errors,
+		isValid: context.isValid,
+		ubos: context.ubos,
+		canAddUbo: context.canAddUbo,
+		addressSuggestions: context.addressSuggestions,
+		submitAttempted: context.submitAttempted
+	};
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		errorMessage: context.errorMessage
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	return { status: "loading" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setCountry(country) {
+			actor.send({
+				type: "SET_COUNTRY",
+				country
+			});
+		},
+		setField(name, value) {
+			actor.send({
+				type: "SET_FIELD",
+				name,
+				value
+			});
+		},
+		addUbo() {
+			trackElementClicked?.("addUbo");
+			actor.send({ type: "ADD_UBO" });
+		},
+		removeUbo(index) {
+			trackElementClicked?.(`removeUbo.${index}`);
+			actor.send({
+				type: "REMOVE_UBO",
+				index
+			});
+		},
+		setUboField(index, field, value) {
+			actor.send({
+				type: "SET_UBO_FIELD",
+				index,
+				field,
+				value
+			});
+		},
+		searchAddress(query) {
+			actor.send({
+				type: "SEARCH_ADDRESS",
+				query
+			});
+		},
+		selectAddress(suggestion) {
+			actor.send({
+				type: "SELECT_ADDRESS",
+				suggestion
+			});
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+/**
+* Creates an eKYB manager for headless or UI-driven usage.
+*/
+function createEkybManager(options) {
+	return createManager({
+		actor: createEkybActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.ekyb)
+	});
+}
+
+//#endregion
+export { ALL_COUNTRIES, DEV_ONLY_COUNTRIES, SUPPORTED_COUNTRIES, computeDisplayErrors as computeEkybDisplayErrors, createEkybManager, ekybMachine, isSupportedCountry, toEkybConfig };