@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/{dynamicFormsManager-CKZkE7Wo.d.ts → dynamicFormsManager-fhK0yINk.d.ts}

@@ -1,47 +1,7 @@
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import { t as ActorRefFrom } from "./Actor-BwgmOPkb.js";
-
-//#region src/modules/dynamic-forms/types.d.ts
-
-/**
- * Input types supported by dynamic form questions.
- * `inputType` on `Question` is optional so unknown future API values degrade
- * gracefully to the text fallback rather than requiring this union to be widened.
- */
-type InputType = 'TEXT' | 'DATE' | 'COUNTRY' | 'NATIONALITY' | 'NUMBER' | 'EMAIL' | 'PHONE' | 'CPF' | 'NAME' | 'YESNO' | 'SELECT' | 'MULTISELECT';
-/**
- * A single question within a dynamic form screen.
- */
-type Question = {
-  questionId: string;
-  /** Display label shown to the user */
-  question: string;
-  inputType?: InputType;
-  /** Fallback type used when `inputType` is absent */
-  overrides?: InputType;
-  isPredefined?: boolean;
-  isOptional?: boolean;
-  options?: string[];
-};
-/**
- * A single screen within the dynamic form flow.
- */
-type Screen = {
-  title?: string;
-  hideTitle?: boolean;
-  questions: Question[];
-};
-/**
- * Configuration for the dynamic forms module.
- * Provide either `screens` (pre-loaded) or `flowId` (fetched from API).
- */
-type DynamicFormsConfig = {
-  /** Flow ID used to fetch screens from the API when `screens` is not provided */
-  flowId?: string;
-  /** Pre-loaded screens — skips the API fetch when provided */
-  screens?: Screen[];
-};
-//#endregion
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+import { i as Screen, t as DynamicFormsConfig } from "./types-BSBzhHRH.js";
 //#region src/modules/dynamic-forms/dynamicFormsFields.d.ts
 /** Map of `questionId` → currently-displayed i18n error key. */
 type DynamicFormsValidationErrors = Partial<Record<string, string>>;
@@ -86,6 +46,10 @@ type DynamicFormsInputtingState = {
   answerValidity: Record<string, boolean>;
   validationErrors?: DynamicFormsValidationErrors;
   canSubmit: boolean;
+  /** questionIds that received a prefilled value — show the "from ID" marker. */
+  prefilledQuestionIds: string[];
+  /** questionIds prefilled with a non-editable value — render read-only. */
+  nonEditableQuestionIds: string[];
 };
 /**
  * Submitting the current screen's answers to the backend.
@@ -105,6 +69,10 @@ type DynamicFormsSubmittingState = {
   answers: Record<string, string>;
   answerValidity: Record<string, boolean>;
   validationErrors?: DynamicFormsValidationErrors;
+  /** questionIds that received a prefilled value — show the "from ID" marker. */
+  prefilledQuestionIds: string[];
+  /** questionIds prefilled with a non-editable value — render read-only. */
+  nonEditableQuestionIds: string[];
 };
 /**
  * All screens submitted — success screen visible for ~3 s before
@@ -133,10 +101,18 @@ type DynamicFormsMisconfiguredState = {
 type DynamicFormsClosedState = {
   status: 'closed';
 };
+/**
+ * Login-hint lockout — the backend reported status `4302` ("Login hint attempts
+ * exceeded") on a form-answer rejection. Terminal, non-recoverable screen with
+ * no retry; the module parks here (user must contact their administrator).
+ */
+type DynamicFormsAttemptsExhaustedState = {
+  status: 'attemptsExhausted';
+};
 /**
  * Union of all possible dynamic forms manager states.
  */
-type DynamicFormsState = DynamicFormsIdleState | DynamicFormsLoadingState | DynamicFormsInputtingState | DynamicFormsSubmittingState | DynamicFormsSuccessState | DynamicFormsFinishedState | DynamicFormsMisconfiguredState | DynamicFormsClosedState;
+type DynamicFormsState = DynamicFormsIdleState | DynamicFormsLoadingState | DynamicFormsInputtingState | DynamicFormsSubmittingState | DynamicFormsSuccessState | DynamicFormsFinishedState | DynamicFormsMisconfiguredState | DynamicFormsClosedState | DynamicFormsAttemptsExhaustedState;
 /**
  * Creates a dynamic forms manager for headless or UI-driven usage.
  *
@@ -236,4 +212,4 @@ declare function createDynamicFormsManagerFromActor(actor: DynamicFormsActor): M
 /** Type representing a dynamic forms manager instance. */
 type DynamicFormsManager = ReturnType<typeof createDynamicFormsManager>;
 //#endregion
-export { DynamicFormsActor as a, DynamicFormsValidationErrors as c, Question as d, Screen as f, createDynamicFormsManagerFromActor as i, DynamicFormsConfig as l, DynamicFormsState as n, DynamicFormsResult as o, createDynamicFormsManager as r, dynamicFormsMachine as s, DynamicFormsManager as t, InputType as u };
+export { DynamicFormsActor as a, DynamicFormsValidationErrors as c, createDynamicFormsManagerFromActor as i, DynamicFormsState as n, DynamicFormsResult as o, createDynamicFormsManager as r, dynamicFormsMachine as s, DynamicFormsManager as t };

package/dist/{dynamicFormsStateMachine-DJ1HGZff.esm.js → dynamicFormsStateMachine-D_3oLtOE.esm.js}

@@ -1,8 +1,9 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as isoDateToMs } from "./dateUtils-BW6mBV6p.esm.js";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as toIncodeApiError, t as IncodeApiError } from "./apiError-oiEnJIlk.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { t as isoDateToMs } from "./dateUtils-CvG0FvK8.esm.js";
 //#region src/modules/dynamic-forms/dynamicFormsFields.ts
 function getEffectiveType(question) {
 	return question.inputType ?? question.overrides ?? "TEXT";
@@ -31,7 +32,6 @@ function buildScreenFields(formScreen) {
 		validation: buildQuestionValidation(q)
 	}));
 }
-
 //#endregion
 //#region src/modules/dynamic-forms/dynamicFormsValidators.ts
 const VALIDATORS = {
@@ -67,7 +67,6 @@ function validateScreenField(answers, questionId, fields, answerValidity) {
 		answerValidity
 	}, field.validation);
 }
-
 //#endregion
 //#region src/modules/dynamic-forms/dynamicFormsServices.ts
 async function fetchForms(flowId, signal) {
@@ -76,17 +75,46 @@ async function fetchForms(flowId, 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}`);
+/**
+* Fetches Form Pre-fill values resolved from the interview. Keyed by session
+* token (no flowId param). Called once per form only when >=1 question has a
+* `prefillSource`. A failure throws — the machine degrades to a blank form.
+*/
+async function fetchPrefill(signal) {
+	const res = await api.get(endpoints.dynamicFormsPrefill, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.dynamicFormsPrefill} failed: ${res.status} ${res.statusText}`);
 	return res.data;
 }
-
+async function submitFormAnswer(params, signal) {
+	try {
+		return (await api.post(endpoints.dynamicFormsSubmitAnswer, {
+			questionId: params.questionId,
+			answerDetails: { singleAnswer: params.singleAnswer }
+		}, { signal })).data;
+	} catch (error) {
+		throw toIncodeApiError(endpoints.dynamicFormsSubmitAnswer, error);
+	}
+}
 //#endregion
 //#region src/modules/dynamic-forms/dynamicFormsStateMachine.ts
+const INVALID_LOGIN_HINT_STATUS = 4301;
+const LOGIN_HINT_LOCKED_STATUS = 4302;
+/**
+* Thrown from the submit actor when a form answer is rejected with a login-hint
+* status ({@link INVALID_LOGIN_HINT_STATUS} or {@link LOGIN_HINT_LOCKED_STATUS}).
+* Carries the failing question so the inline error attaches to the right field,
+* the backend status so the machine can decide between "retry" and "locked", and
+* the answers already accepted before the failure so a retry doesn't re-POST them.
+*/
+var LoginHintSubmitError = class extends Error {
+	constructor(questionId, status, submitted) {
+		super("Login hint rejected");
+		this.name = "LoginHintSubmitError";
+		this.questionId = questionId;
+		this.status = status;
+		this.submitted = submitted;
+	}
+};
 function transformAnswerValue(inputType, value) {
 	switch (inputType) {
 		case "CPF": return value.replace(/[-.]/g, "");
@@ -106,6 +134,37 @@ const upsertKey = (errors, key, message) => {
 	else delete next[key];
 	return Object.keys(next).length > 0 ? next : void 0;
 };
+/**
+* Seeds the first screen's sole answer from `config.prefillValue`, but ONLY when
+* the form is exactly one screen with one question — so an unrelated multi-field
+* form never gets a stray value stuffed in. The single-question guard lives here
+* (the machine owns the screens); the seeded answer stays editable. Blank or
+* whitespace-only values (e.g. `?login_hint=%20`) are ignored.
+*/
+function buildPrefillAnswers(screens, prefillValue) {
+	const value = prefillValue?.trim();
+	if (!value || screens.length !== 1) return {};
+	const { questions } = screens[0];
+	if (questions.length !== 1) return {};
+	return { [questions[0].questionId]: value };
+}
+const PREFILL_UNSUPPORTED_TYPES = /* @__PURE__ */ new Set(["PHONE", "MULTISELECT"]);
+function effectiveInputType(question) {
+	return question.inputType ?? question.overrides ?? "TEXT";
+}
+function isPrefillSupported(question) {
+	return !PREFILL_UNSUPPORTED_TYPES.has(effectiveInputType(question));
+}
+/** The prefilled values that belong to a given screen's questions. */
+function pickPrefillForScreen(formScreen, prefilledValues) {
+	if (!formScreen) return {};
+	const picked = {};
+	for (const question of formScreen.questions) {
+		const value = prefilledValues[question.questionId];
+		if (value !== void 0) picked[question.questionId] = value;
+	}
+	return picked;
+}
 const dynamicFormsMachine = setup({
 	types: {
 		context: {},
@@ -116,27 +175,34 @@ const dynamicFormsMachine = setup({
 		fetchScreens: fromPromise(async ({ input, signal }) => {
 			return fetchForms(input.flowId, signal);
 		}),
+		fetchPrefill: fromPromise(async ({ signal }) => fetchPrefill(signal)),
 		submitScreenAnswers: fromPromise(async ({ input, signal }) => {
-			const { screen: formScreen, answers } = input;
+			const { screen: formScreen, answers, submittedAnswers } = input;
+			const submitted = { ...submittedAnswers };
 			for (const question of formScreen.questions) {
 				const singleAnswer = transformAnswerValue(question.inputType ?? question.overrides ?? "TEXT", answers[question.questionId] ?? "");
+				if (submitted[question.questionId] === singleAnswer) continue;
 				try {
 					await submitFormAnswer({
 						questionId: question.questionId,
 						singleAnswer
 					}, signal);
-				} catch {}
+					submitted[question.questionId] = singleAnswer;
+				} catch (error) {
+					if (error instanceof IncodeApiError && (error.status === INVALID_LOGIN_HINT_STATUS || error.status === LOGIN_HINT_LOCKED_STATUS)) throw new LoginHintSubmitError(question.questionId, error.status, submitted);
+				}
 			}
 			return { success: true };
 		})
 	},
 	actions: {
-		setScreens: assign(({ event }) => {
+		setScreens: assign(({ context, event }) => {
 			const screens = event.output.screens;
 			const firstScreen = screens[0];
 			return {
 				screens,
-				answers: {},
+				answers: buildPrefillAnswers(screens, context.config.prefillValue),
+				submittedAnswers: {},
 				currentScreenFields: firstScreen ? buildScreenFields(firstScreen) : []
 			};
 		}),
@@ -174,20 +240,59 @@ const dynamicFormsMachine = setup({
 			const nextScreen = context.screens[nextIndex];
 			return {
 				currentScreenIndex: nextIndex,
-				answers: {},
+				answers: pickPrefillForScreen(nextScreen, context.prefilledValues),
+				submittedAnswers: {},
 				answerValidity: {},
 				currentScreenFields: nextScreen ? buildScreenFields(nextScreen) : [],
 				validationErrors: void 0
 			};
 		}),
+		seedPrefill: assign(({ context, event }) => {
+			const resolved = event.output;
+			const typeById = /* @__PURE__ */ new Map();
+			for (const formScreen of context.screens) for (const question of formScreen.questions) typeById.set(question.questionId, effectiveInputType(question));
+			const prefilledValues = {};
+			const nonEditableQuestionIds = [];
+			for (const questionId of Object.keys(resolved)) {
+				const type = typeById.get(questionId);
+				if (!type || PREFILL_UNSUPPORTED_TYPES.has(type)) continue;
+				prefilledValues[questionId] = resolved[questionId].value;
+				if (resolved[questionId].editable === false) nonEditableQuestionIds.push(questionId);
+			}
+			return {
+				prefilledValues,
+				nonEditableQuestionIds,
+				answers: {
+					...context.answers,
+					...prefilledValues
+				}
+			};
+		}),
 		markCompleted: assign({ result: "completed" }),
-		markSkipped: assign({ result: "skipped" })
+		markSkipped: assign({ result: "skipped" }),
+		setLoginHintError: assign(({ context, event }) => {
+			const err = event.error;
+			if (!(err instanceof LoginHintSubmitError)) return {};
+			return {
+				validationErrors: upsertKey(context.validationErrors, err.questionId, "forms.errors.invalidLoginHint"),
+				submittedAnswers: err.submitted
+			};
+		})
 	},
 	guards: {
 		hasPreloadedScreens: ({ context }) => (context.config.screens?.length ?? 0) > 0,
 		hasFlowId: ({ context }) => !!context.config.flowId,
+		hasPrefillSources: ({ context }) => context.screens.some((formScreen) => formScreen.questions.some((question) => question.prefillSource != null && isPrefillSupported(question))),
 		isLastScreen: ({ context }) => context.currentScreenIndex >= context.screens.length - 1,
-		isScreenValid: ({ context }) => Object.keys(context.validationErrors ?? {}).length === 0
+		isScreenValid: ({ context }) => Object.keys(context.validationErrors ?? {}).length === 0,
+		isLoginHintLocked: ({ event }) => {
+			const err = event.error;
+			return err instanceof LoginHintSubmitError && err.status === LOGIN_HINT_LOCKED_STATUS;
+		},
+		isLoginHintInvalid: ({ event }) => {
+			const err = event.error;
+			return err instanceof LoginHintSubmitError && err.status === INVALID_LOGIN_HINT_STATUS;
+		}
 	}
 }).createMachine({
 	id: "dynamicForms",
@@ -199,16 +304,19 @@ const dynamicFormsMachine = setup({
 			config: input.config,
 			screens,
 			currentScreenIndex: 0,
-			answers: {},
+			answers: buildPrefillAnswers(screens, input.config.prefillValue),
+			submittedAnswers: {},
 			answerValidity: {},
 			currentScreenFields: firstScreen ? buildScreenFields(firstScreen) : [],
+			prefilledValues: {},
+			nonEditableQuestionIds: [],
 			result: null
 		};
 	},
 	states: {
 		idle: { on: { LOAD: [
 			{
-				target: "inputting",
+				target: "resolvingPrefill",
 				guard: "hasPreloadedScreens"
 			},
 			{
@@ -222,7 +330,7 @@ const dynamicFormsMachine = setup({
 			src: "fetchScreens",
 			input: ({ context }) => ({ flowId: context.config.flowId ?? "" }),
 			onDone: {
-				target: "inputting",
+				target: "resolvingPrefill",
 				actions: "setScreens"
 			},
 			onError: {
@@ -230,6 +338,19 @@ const dynamicFormsMachine = setup({
 				actions: "markSkipped"
 			}
 		} },
+		resolvingPrefill: { always: [{
+			guard: "hasPrefillSources",
+			target: "prefilling"
+		}, { target: "inputting" }] },
+		prefilling: { invoke: {
+			id: "fetchPrefill",
+			src: "fetchPrefill",
+			onDone: {
+				target: "inputting",
+				actions: "seedPrefill"
+			},
+			onError: { target: "inputting" }
+		} },
 		inputting: {
 			initial: "editing",
 			states: {
@@ -253,7 +374,8 @@ const dynamicFormsMachine = setup({
 			src: "submitScreenAnswers",
 			input: ({ context }) => ({
 				screen: context.screens[context.currentScreenIndex],
-				answers: context.answers
+				answers: context.answers,
+				submittedAnswers: context.submittedAnswers
 			}),
 			onDone: [{
 				target: "success",
@@ -262,13 +384,18 @@ const dynamicFormsMachine = setup({
 				target: "inputting",
 				actions: "advanceScreen"
 			}],
-			onError: [{
-				target: "success",
-				guard: "isLastScreen"
-			}, {
-				target: "inputting",
-				actions: "advanceScreen"
-			}]
+			onError: [
+				{
+					guard: "isLoginHintLocked",
+					target: "attemptsExhausted"
+				},
+				{
+					guard: "isLoginHintInvalid",
+					target: "inputting",
+					actions: "setLoginHintError"
+				},
+				{ target: "inputting" }
+			]
 		} },
 		success: { after: { 3e3: {
 			target: "finished",
@@ -276,9 +403,9 @@ const dynamicFormsMachine = setup({
 		} } },
 		finished: { type: "final" },
 		misconfigured: { on: { CLOSE: { target: "closed" } } },
+		attemptsExhausted: {},
 		closed: { type: "final" }
 	}
 });
-
 //#endregion
-export { dynamicFormsMachine as t };
+export { dynamicFormsMachine as t };

package/dist/ekyb.d.ts

@@ -1,140 +1,8 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import "./camera-CKU96nwJ.js";
-import "./types-DV3wkhQ4.js";
-import { c as AddressSuggestion, l as FieldDef } from "./types-BgjMAEXl.js";
-import "./canvas-90BqS0NF.js";
-import "./createFaceAvatar-CpdYp9Iy.js";
-import { i as FlowModuleConfig } from "./types-BUgeB2X6.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 EkybValidationRule = {
-  type: 'required';
-} | {
-  type: 'streetLevelRequired';
-} | {
-  type: 'cnpj';
-} | {
-  type: 'postalCodeFormat';
-  country: string;
-};
-type EkybValidationError = {
-  key: string;
-  params?: Record<string, string | number>;
-};
-type EkybValidationErrors = Partial<Record<string, EkybValidationError>>;
-type EkybFieldDef = FieldDef & {
-  optionalForCountries?: string[];
-  validation?: EkybValidationRule[];
-};
-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;
-  validationErrors?: EkybValidationErrors;
-  /**
-   * True when no validation errors are currently displayed.
-   * Optimistic semantic: starts true on initial empty form.
-   * Derived as `Object.keys(validationErrors ?? {}).length === 0`.
-   */
-  isValid: boolean;
-  ubos: UboEntry[];
-  canAddUbo: boolean;
-  addressSuggestions: AddressSuggestion[];
-};
-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 clears its current validation error */
-  setField(name: string, value: string): void;
-  /** Runs single-field validation (call on blur) */
-  validateField(name: 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
+import "./StateMachine-EDpYWy0i.js";
+import { c as AddressSuggestion } from "./types-Bk_6dmDa.js";
+import { i as FlowModuleConfig } from "./types-KPvmag_B.js";
+import { a as EkybValidationError, n as EkybCountry, o as EkybValidationErrors, r as EkybFieldDef, s as UboEntry, t as EkybConfig } from "./types-BfHiko5D.js";
+import { n as EkybState, o as ekybMachine, r as createEkybManager, t as EkybManager } from "./ekybManager-Dzswb_b8.js";
 //#region src/modules/ekyb/ekybServices.d.ts
 type EkybFlowConfig = FlowModuleConfig['EKYB'];
 //#endregion