@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/dynamic-forms.esm.js

@@ -1,412 +1,10 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
-import { t as isoDateToMs } from "./dateUtils-AksLQmgV.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import "./events-CqGY1yMq.esm.js";
+import "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./xstate.esm-Bomq1a0z.esm.js";
+import "./dateUtils-7-tQYRNN.esm.js";
+import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-BXHcaocI.esm.js";
+import { t as createDynamicFormsManager } from "./dynamicFormsManager-BOefZbyF.esm.js";
 
-//#region src/modules/dynamic-forms/dynamicFormsFields.ts
-function getEffectiveType(question) {
-	return question.inputType ?? question.overrides ?? "TEXT";
-}
-const FORMAT_ERROR_KEY_BY_TYPE = {
-	PHONE: "phone.invalidPhone",
-	EMAIL: "verification.errors.emailInvalid",
-	CPF: "dynamicForms.invalidCpf"
-};
-function buildQuestionValidation(question) {
-	const effectiveType = getEffectiveType(question);
-	const rules = [];
-	if (!question.isOptional) rules.push({ type: "required" });
-	const formatErrorKey = FORMAT_ERROR_KEY_BY_TYPE[effectiveType];
-	if (formatErrorKey) rules.push({
-		type: "formatViaAnswerValidity",
-		errorKey: formatErrorKey
-	});
-	return rules;
-}
-function buildScreenFields(formScreen) {
-	return formScreen.questions.map((q) => ({
-		questionId: q.questionId,
-		inputType: getEffectiveType(q),
-		isOptional: q.isOptional ?? false,
-		validation: buildQuestionValidation(q)
-	}));
-}
-
-//#endregion
-//#region src/modules/dynamic-forms/dynamicFormsValidators.ts
-const VALIDATORS = {
-	required: ({ value }) => value.trim().length === 0 ? "dynamicForms.fieldRequired" : void 0,
-	formatViaAnswerValidity: ({ questionId, answerValidity }, rule) => answerValidity[questionId] === false ? rule.errorKey : void 0
-};
-const normalizeValue = (value) => typeof value === "string" ? value : String(value ?? "");
-function evaluateRules(input, rules) {
-	for (const rule of rules) {
-		const error = rule.type === "required" ? VALIDATORS.required(input) : VALIDATORS.formatViaAnswerValidity(input, rule);
-		if (error) return error;
-	}
-}
-/** Runs full-screen validation. Returns first failing key per field; empty = pass. */
-function validateScreenForm(answers, fields, answerValidity) {
-	return fields.reduce((errors, field) => {
-		const error = evaluateRules({
-			value: normalizeValue(answers[field.questionId]),
-			questionId: field.questionId,
-			answerValidity
-		}, field.validation);
-		if (error) errors[field.questionId] = error;
-		return errors;
-	}, {});
-}
-/** Runs single-field validation (blur). Unknown `questionId` → `undefined`. */
-function validateScreenField(answers, questionId, fields, answerValidity) {
-	const field = fields.find((f) => f.questionId === questionId);
-	if (!field) return void 0;
-	return evaluateRules({
-		value: normalizeValue(answers[questionId]),
-		questionId,
-		answerValidity
-	}, field.validation);
-}
-
-//#endregion
-//#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
-function transformAnswerValue(inputType, value) {
-	switch (inputType) {
-		case "CPF": return value.replace(/[-.]/g, "");
-		case "DATE": return isoDateToMs(value).toString();
-		default: return value;
-	}
-}
-const removeKey = (errors, key) => {
-	if (!errors?.[key]) return errors;
-	const next = { ...errors };
-	delete next[key];
-	return Object.keys(next).length > 0 ? next : void 0;
-};
-const upsertKey = (errors, key, message) => {
-	const next = { ...errors ?? {} };
-	if (message) next[key] = message;
-	else delete next[key];
-	return Object.keys(next).length > 0 ? next : void 0;
-};
-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;
-			const firstScreen = screens[0];
-			return {
-				screens,
-				answers: {},
-				currentScreenFields: firstScreen ? buildScreenFields(firstScreen) : []
-			};
-		}),
-		setAnswer: assign(({ context, event }) => {
-			const e = event;
-			return {
-				answers: {
-					...context.answers,
-					[e.questionId]: e.value
-				},
-				validationErrors: removeKey(context.validationErrors, e.questionId)
-			};
-		}),
-		setAnswerValidity: assign(({ context, event }) => {
-			const e = event;
-			return {
-				answerValidity: {
-					...context.answerValidity,
-					[e.questionId]: e.isValid
-				},
-				validationErrors: removeKey(context.validationErrors, e.questionId)
-			};
-		}),
-		validateFormField: assign(({ context, event }) => {
-			if (event.type !== "VALIDATE_FIELD") return {};
-			const message = validateScreenField(context.answers, event.questionId, context.currentScreenFields, context.answerValidity);
-			return { validationErrors: upsertKey(context.validationErrors, event.questionId, message) };
-		}),
-		computeValidationResult: assign(({ context }) => {
-			const errors = validateScreenForm(context.answers, context.currentScreenFields, context.answerValidity);
-			return { validationErrors: Object.keys(errors).length > 0 ? errors : void 0 };
-		}),
-		advanceScreen: assign(({ context }) => {
-			const nextIndex = context.currentScreenIndex + 1;
-			const nextScreen = context.screens[nextIndex];
-			return {
-				currentScreenIndex: nextIndex,
-				answers: {},
-				answerValidity: {},
-				currentScreenFields: nextScreen ? buildScreenFields(nextScreen) : [],
-				validationErrors: void 0
-			};
-		}),
-		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,
-		isScreenValid: ({ context }) => Object.keys(context.validationErrors ?? {}).length === 0
-	}
-}).createMachine({
-	id: "dynamicForms",
-	initial: "idle",
-	context: ({ input }) => {
-		const screens = input.config.screens ?? [];
-		const firstScreen = screens[0];
-		return {
-			config: input.config,
-			screens,
-			currentScreenIndex: 0,
-			answers: {},
-			answerValidity: {},
-			currentScreenFields: firstScreen ? buildScreenFields(firstScreen) : [],
-			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: {
-			initial: "editing",
-			states: {
-				editing: { on: {
-					ANSWER_CHANGED: { actions: "setAnswer" },
-					ANSWER_VALIDITY_CHANGED: { actions: "setAnswerValidity" },
-					VALIDATE_FIELD: { actions: "validateFormField" },
-					SUBMIT: { target: "validatingSubmit" }
-				} },
-				validatingSubmit: {
-					entry: "computeValidationResult",
-					always: [{
-						guard: "isScreenValid",
-						target: "#dynamicForms.submitting"
-					}, { target: "editing" }]
-				}
-			}
-		},
-		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 hasNoErrors(errors) {
-	return Object.keys(errors ?? {}).length === 0;
-}
-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")) return {
-		status: "inputting",
-		currentScreen: context.screens[context.currentScreenIndex],
-		screenIndex: context.currentScreenIndex,
-		totalScreens: context.screens.length,
-		answers: context.answers,
-		answerValidity: context.answerValidity,
-		validationErrors: context.validationErrors,
-		canSubmit: hasNoErrors(context.validationErrors)
-	};
-	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,
-			validationErrors: context.validationErrors
-		};
-	}
-	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
-			});
-		},
-		validateField(questionId) {
-			actor.send({
-				type: "VALIDATE_FIELD",
-				questionId
-			});
-		},
-		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/dynamicFormsManager-BOefZbyF.esm.js

@@ -0,0 +1,168 @@
+import { n as createManagerInstrumentation, t as topLevelStateName } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-BXHcaocI.esm.js";
+
+//#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 hasNoErrors(errors) {
+	return Object.keys(errors ?? {}).length === 0;
+}
+function hasAnyAnswer(answers) {
+	for (const value of Object.values(answers)) if (typeof value === "string" && value.length > 0) return true;
+	return false;
+}
+/**
+* Maps a Dynamic Forms state-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: Forms and Data entry Figma file
+* (`https://www.figma.com/design/N6otHMuY2Hha5eBqRz0uC3/Forms-and-Data-entry---Latest-Designs?node-id=53-60567`).
+* Family is `forms.*` with a single longform sub-family.
+*
+* `idle`, `loadingScreens`, `submitting`, `misconfigured`, and `closed` are
+* intentionally unmapped — the Figma canvas does not define discrete
+* tracked-event surfaces for them. They fall back to the generic
+* `<module>.<state>` default.
+*/
+function getDynamicFormsScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "inputting": return hasAnyAnswer(snapshot.context.answers) ? "forms.longform.filled" : "forms.longform.default";
+		case "success":
+		case "finished": return "forms.success";
+		default: return;
+	}
+}
+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")) return {
+		status: "inputting",
+		currentScreen: context.screens[context.currentScreenIndex],
+		screenIndex: context.currentScreenIndex,
+		totalScreens: context.screens.length,
+		answers: context.answers,
+		answerValidity: context.answerValidity,
+		validationErrors: context.validationErrors,
+		canSubmit: hasNoErrors(context.validationErrors)
+	};
+	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,
+			validationErrors: context.validationErrors
+		};
+	}
+	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, trackElementClicked }) {
+	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
+			});
+		},
+		validateField(questionId) {
+			actor.send({
+				type: "VALIDATE_FIELD",
+				questionId
+			});
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		close() {
+			trackElementClicked?.("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, { getEventScreenName: getDynamicFormsScreenName })
+	});
+}
+function createDynamicFormsManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.forms, { getEventScreenName: getDynamicFormsScreenName })
+	});
+}
+
+//#endregion
+export { createDynamicFormsManagerFromActor as n, createDynamicFormsManager as t };