@inseefr/lunatic 3.5.0-rc.3 → 3.5.1-rc.1743691949561

package/src/use-lunatic/props/propValue.spec.ts

@@ -25,7 +25,7 @@ describe('fillComponentValue', () => {
 		);
 	};
 
-	describe('response', () => {
+	describe('single response', () => {
 		const component = {
 			response: { name: 'PRENOM' },
 		} as LunaticComponentDefinition<'Input'>;
@@ -44,7 +44,7 @@ describe('fillComponentValue', () => {
 			);
 		});
 	});
-	describe('responses', () => {
+	describe('multiple responses', () => {
 		const component = {
 			responses: times(3, (k) => ({
 				response: { name: `NAME${k}` },
@@ -64,4 +64,107 @@ describe('fillComponentValue', () => {
 			});
 		});
 	});
+
+	describe('Loop component with nested components', () => {
+		const loopComponent = {
+			id: 'm7j9kwro',
+			componentType: 'Loop',
+			components: [
+				{
+					id: 'm7j9iem8',
+					componentType: 'Sequence',
+				},
+				{
+					id: 'question-m7j9q1ep',
+					componentType: 'Question',
+					components: [
+						{
+							id: 'm7j9q1ep',
+							componentType: 'Input',
+							response: { name: 'VOTREPRENO' },
+						},
+					],
+				},
+				{
+					id: 'question-m7jb81xh',
+					componentType: 'Question',
+					components: [
+						{
+							id: 'm7jb81xh',
+							componentType: 'InputNumber',
+							response: { name: 'VOTREAGE' },
+						},
+					],
+				},
+			],
+		} as LunaticComponentDefinition;
+
+		it('should correctly extract values from nested responses as arrays', () => {
+			const values = {
+				VOTREPRENO: ['Alice', 'Bob', 'Charlie'],
+				VOTREAGE: [22, 30, 40],
+			};
+
+			expectFilledComponent(loopComponent, values).toEqual(values);
+		});
+
+		it('should return null for missing responses', () => {
+			expectFilledComponent(loopComponent).toEqual({
+				VOTREPRENO: null,
+				VOTREAGE: null,
+			});
+		});
+	});
+
+	describe('RosterForLoop', () => {
+		const rosterForLoopComponent = {
+			id: 'loop-prenom',
+			componentType: 'RosterForLoop',
+			bindingDependencies: ['PRENOM'],
+			lines: {
+				min: {
+					value: '1',
+					type: 'VTL',
+				},
+				max: {
+					value: '10',
+					type: 'VTL',
+				},
+			},
+			page: '1',
+			components: [
+				{
+					componentType: 'Input',
+					label: {
+						value: '"Prénom"',
+						type: 'VTL|MD',
+					},
+					conditionFilter: {
+						value: 'true',
+						type: 'VTL',
+					},
+					maxLength: 30,
+					bindingDependencies: ['PRENOM'],
+					id: 'prenom',
+					response: {
+						name: 'PRENOM',
+					},
+				},
+			],
+		} as any as LunaticComponentDefinition<'RosterForLoop'>;
+
+		it('should correctly extract values from nested responses as arrays', () => {
+			const values = {
+				PRENOM: ['Alice', 'Bob', 'Charlie'],
+			};
+
+			expectFilledComponent(rosterForLoopComponent, values).toEqual(values);
+		});
+
+		it('should return null for missing responses', () => {
+			expectFilledComponent(rosterForLoopComponent).toEqual({
+				PRENOM: null,
+			});
+		});
+	});
 });

package/src/use-lunatic/props/propValue.ts

@@ -27,14 +27,32 @@ export function getValueProp(
 	if (hasResponse(component)) {
 		return args.variables.get(component.response.name, iteration);
 	}
-	// For loop, value will be a map of child component values
-	if ('components' in component) {
-		return Object.fromEntries(
-			component.components
-				.map((c) => ('response' in c ? c.response.name : null))
-				.filter((name) => name !== null)
-				.map((name) => [name, args.variables.get(name!)])
-		);
+	// For Loop and RosterForLoop, value will be a map of child component values
+	if (
+		component.componentType === 'Loop' ||
+		component.componentType === 'RosterForLoop'
+	) {
+		return getChildResponseValues(component.components, args.variables);
 	}
 	return null;
 }
+
+/**
+ * Get the values of every child components recursively.
+ */
+function getChildResponseValues(
+	components: LunaticComponentDefinition[],
+	variables: LunaticVariablesStore
+): Record<string, unknown> {
+	return Object.fromEntries(
+		components.flatMap((c) => {
+			if ('response' in c) {
+				return [[c.response.name, variables.get(c.response.name)]];
+			}
+			if ('components' in c) {
+				return Object.entries(getChildResponseValues(c.components, variables));
+			}
+			return [];
+		})
+	);
+}

package/src/use-lunatic/reducer/reducerInitializer.tsx

@@ -38,8 +38,6 @@ const baseState = {
 	options: { disableFilters: false },
 } satisfies LunaticReducerState;
 
-const onChange = { current: () => {} };
-
 export function reducerInitializer({
 	source,
 	data,
@@ -49,8 +47,8 @@ export function reducerInitializer({
 	withOverview = false,
 	disableFilters = false,
 	getReferentiel,
-	onVariableChange = onChange,
-	logger = console.error,
+	onVariableChange,
+	logger,
 }: {
 	source: LunaticSource;
 	data: LunaticData;
@@ -60,13 +58,14 @@ export function reducerInitializer({
 	withOverview?: LunaticOptions['withOverview'];
 	disableFilters?: LunaticOptions['disableFilters'];
 	getReferentiel?: LunaticOptions['getReferentiel'];
-	onVariableChange?: RefObject<LunaticOptions['onVariableChange']>;
-	logger?: LunaticLogger;
+	onVariableChange: RefObject<LunaticOptions['onVariableChange']>;
+	logger: LunaticLogger;
 }): LunaticReducerState {
 	const variables = LunaticVariablesStore.makeFromSource(
 		source,
 		data,
-		onVariableChange
+		onVariableChange,
+		disableFilters
 	);
 	const pages = checkLoops(createMapPages(source));
 
@@ -112,13 +111,11 @@ export function reducerInitializer({
 			}
 			return result as any;
 		} catch (e) {
-			if (logger) {
-				// If there is an error interpreting a variable, return the raw expression
-				logger({
-					type: 'ERROR',
-					error: e as Error,
-				});
-			}
+			// If there is an error interpreting a variable, return the raw expression
+			logger({
+				type: 'ERROR',
+				error: e as Error,
+			});
 			return expressionString;
 		}
 	};
@@ -135,9 +132,9 @@ export function reducerInitializer({
 	const pager = {
 		page: initialPager?.page ?? 1,
 		maxPage: source.maxPage ? parseInt(source.maxPage, 10) : 1,
-		subPage: initialPager?.subPage,
+		subPage: undefined,
 		nbSubPages: undefined,
-		iteration: initialPager?.iteration,
+		iteration: undefined,
 		nbIterations: undefined,
 		lastReachedPage: lastReachedPage ?? initialPage,
 	};
@@ -147,7 +144,7 @@ export function reducerInitializer({
 		pager,
 		previousPager: pager,
 		pages,
-		isInLoop: pager.subPage !== undefined,
+		isInLoop: false,
 		updatedAt: Date.now(),
 		overview: withOverview ? buildOverview(source) : [],
 		updateBindings,
@@ -165,29 +162,22 @@ function fillPagerForLoop(state: LunaticReducerState): LunaticReducerState {
 		return state;
 	}
 	const { isLoop, subPages, iterations, loopDependencies } = pages[pager.page];
-
-	if (
-		// For loop, jump at the first page
-		isLoop ||
-		// For roundabout, jump at the desired iteration / subpage (only if defined)
-		(pager?.iteration !== undefined && subPages)
-	) {
-		return {
-			...state,
-			isInLoop: true,
-			pager: {
-				...pager,
-				subPage: pager?.subPage ?? 1,
-				nbSubPages: (subPages ?? []).length,
-				iteration: pager?.iteration ?? 0,
-				nbIterations: forceInt(
-					state.executeExpression(iterations, {
-						deps: loopDependencies,
-					})
-				),
-			},
-		};
+	if (!isLoop) {
+		return state;
 	}
-
-	return state;
+	return {
+		...state,
+		isInLoop: true,
+		pager: {
+			...pager,
+			subPage: pager?.subPage ?? 0,
+			nbSubPages: (subPages ?? []).length,
+			iteration: pager?.iteration ?? 0,
+			nbIterations: forceInt(
+				state.executeExpression(iterations, {
+					deps: loopDependencies,
+				})
+			),
+		},
+	};
 }

package/src/use-lunatic/test.utils.ts

@@ -0,0 +1,17 @@
+import { LunaticData } from './type';
+
+export const dataFromObject = (o: Record<string, unknown>): LunaticData => {
+	return {
+		EXTERNAL: {},
+		COLLECTED: Object.keys(o).reduce(
+			(acc, k) => ({
+				...acc,
+				[k]: {
+					COLLECTED: o[k],
+				},
+			}),
+			{}
+		),
+		CALCULATED: {},
+	};
+};

package/src/use-lunatic/type.ts

@@ -74,10 +74,6 @@ export type PageTag = `${number}.${number}#${number}` | `${number}`;
 export type LunaticVariable = Variable;
 export type LunaticCollectedValue = Partial<{
 	COLLECTED: unknown;
-	EDITED: unknown;
-	FORCED: unknown;
-	INPUTTED: unknown;
-	PREVIOUS: unknown;
 }>;
 
 // We need a mapped type to correlate type and variableType
@@ -337,10 +333,24 @@ export type LunaticState = {
 	resetChangedData: () => void;
 	/** Return `true` as soon as the current page has at least one answer. */
 	hasPageResponse: () => boolean;
-	/** Used for testing purpose only. */
-	testing: {
-		handleChanges: LunaticChangesHandler;
-	};
+	/**
+	 * Change several variable values.
+	 *
+	 * Be careful when using this function.
+	 *
+	 * In most cases, you don't need this function.
+	 * It's used directly by the components (and available as a props.)
+	 *
+	 * - With only one change or with serveral changes
+	 * @example
+	 * handleChanges([{name: "MY_VAR", value: "new value"}])
+	 *
+	 * handleChanges([
+	 * 	{name: "MY_VAR", value: "new value"},
+	 * 	{name: "MY_VAR_2", value: "new value 2"}
+	 * ])
+	 */
+	handleChanges: LunaticChangesHandler;
 };
 
 /** Function taking as arguments the various changes the user has made. */

package/src/use-lunatic/use-lunatic.test.ts

@@ -9,29 +9,10 @@ import sourceCheckboxGroup from '../stories/checkbox-group/source.json';
 import dataOverview from '../stories/overview/dataLoop.json';
 import sourceCleaningLoop from '../stories/behaviour/cleaning/source-loop.json';
 import sourceCleaningResizing from '../stories/behaviour/resizing/source-resizing-cleaning.json';
-import type { LunaticData, PageTag } from './type';
+import type { PageTag } from './type';
 import { useLunatic } from './use-lunatic';
 import { useCallback } from 'react';
-
-const dataFromObject = (o: Record<string, unknown>): LunaticData => {
-	return {
-		EXTERNAL: {},
-		COLLECTED: Object.keys(o).reduce(
-			(acc, k) => ({
-				...acc,
-				[k]: {
-					EDITED: null,
-					FORCED: null,
-					INPUTTED: null,
-					PREVIOUS: null,
-					COLLECTED: o[k],
-				},
-			}),
-			{}
-		),
-		CALCULATED: {},
-	};
-};
+import { dataFromObject } from './test.utils';
 
 describe('use-lunatic()', () => {
 	const defaultParams = [
@@ -252,7 +233,7 @@ describe('use-lunatic()', () => {
 				useLunatic(sourceCleaningLoop as any, undefined, {})
 			);
 			act(() => {
-				result.current.testing.handleChanges([
+				result.current.handleChanges([
 					{
 						name: 'PRENOM',
 						value: ['John', 'Doe', 'Marc'],
@@ -270,7 +251,7 @@ describe('use-lunatic()', () => {
 			};
 			expectCollectedAgeToEqual([18, 18, 18]);
 			act(() => {
-				result.current.testing.handleChanges([
+				result.current.handleChanges([
 					{
 						name: 'HIDE_AGE',
 						value: true,
@@ -290,15 +271,11 @@ describe('use-lunatic()', () => {
 					onChange: spy,
 				})
 			);
-			act(() =>
-				result.current.testing.handleChanges([{ name: 'NB', value: 3 }])
-			);
+			act(() => result.current.handleChanges([{ name: 'NB', value: 3 }]));
 			expect(
 				(result.current.getData(true).COLLECTED?.PRENOMS as any).COLLECTED
 			).toEqual([null, null, null]);
-			act(() =>
-				result.current.testing.handleChanges([{ name: 'NB', value: 2 }])
-			);
+			act(() => result.current.handleChanges([{ name: 'NB', value: 2 }]));
 			expect(
 				(result.current.getData(true).COLLECTED?.PRENOMS as any).COLLECTED
 			).toEqual([null, null]);
@@ -312,13 +289,13 @@ describe('use-lunatic()', () => {
 				useLunatic(sourceSimpsons as any, undefined, {})
 			);
 			act(() => {
-				result.current.testing.handleChanges([
+				result.current.handleChanges([
 					{
 						name: 'COMMENT',
 						value: 'Mon commentaire',
 					},
 				]);
-				result.current.testing.handleChanges([{ name: 'READY', value: true }]);
+				result.current.handleChanges([{ name: 'READY', value: true }]);
 			});
 			hookRef = result;
 		});
@@ -347,7 +324,7 @@ describe('use-lunatic()', () => {
 		});
 		it('should return changes since the last update', () => {
 			act(() => {
-				hookRef.current.testing.handleChanges([
+				hookRef.current.handleChanges([
 					{ name: 'COMMENT', value: 'Mon commentaire' },
 					{ name: 'READY', value: true },
 				]);
@@ -365,10 +342,10 @@ describe('use-lunatic()', () => {
 		});
 		it('should reset changes with true parameter', () => {
 			act(() => {
-				hookRef.current.testing.handleChanges([
+				hookRef.current.handleChanges([
 					{ name: 'COMMENT', value: 'Mon commentaire' },
 				]);
-				hookRef.current.testing.handleChanges([{ name: 'READY', value: true }]);
+				hookRef.current.handleChanges([{ name: 'READY', value: true }]);
 			});
 			const data = hookRef.current.getChangedData(true);
 			expect(data).toMatchObject({
@@ -385,7 +362,7 @@ describe('use-lunatic()', () => {
 		});
 		it('should reset changes with resetChanges()', () => {
 			act(() => {
-				hookRef.current.testing.handleChanges([
+				hookRef.current.handleChanges([
 					{
 						name: 'COMMENT',
 						value: 'Mon commentaire',
@@ -396,9 +373,7 @@ describe('use-lunatic()', () => {
 			hookRef.current.resetChangedData();
 			expect(hookRef.current.getChangedData().COLLECTED).toEqual({});
 			act(() => {
-				hookRef.current.testing.handleChanges([
-					{ name: 'READY', value: false },
-				]);
+				hookRef.current.handleChanges([{ name: 'READY', value: false }]);
 			});
 			expect(hookRef.current.getChangedData().COLLECTED).toMatchObject({
 				READY: {
@@ -414,9 +389,7 @@ describe('use-lunatic()', () => {
 				useLunatic(sourceCheckboxGroup as any, undefined, {})
 			);
 			act(() => {
-				result.current.testing.handleChanges([
-					{ name: 'NATIO1N1', value: true },
-				]);
+				result.current.handleChanges([{ name: 'NATIO1N1', value: true }]);
 			});
 			expect(result.current.hasPageResponse()).toBeTruthy();
 		});
@@ -425,9 +398,7 @@ describe('use-lunatic()', () => {
 				useLunatic(sourceCheckboxGroup as any, undefined, {})
 			);
 			act(() => {
-				result.current.testing.handleChanges([
-					{ name: 'NATIO1N1', value: false },
-				]);
+				result.current.handleChanges([{ name: 'NATIO1N1', value: false }]);
 			});
 			expect(result.current.hasPageResponse()).toBeFalsy();
 		});

package/src/use-lunatic/use-lunatic.ts

@@ -6,17 +6,18 @@ import {
 	handleChangesAction,
 } from './actions';
 import { getPageTag, isFirstLastPage } from './commons';
+
+import D from '../i18n';
+import { COLLECTED } from '../utils/constants';
+import { createLunaticProvider } from './lunatic-context';
 import type {
+	LunaticSource,
 	LunaticChangesHandler,
 	LunaticData,
 	LunaticOptions,
 	LunaticState,
 	PageTag,
 } from './type';
-import D from '../i18n';
-import { COLLECTED } from '../utils/constants';
-import { createLunaticProvider } from './lunatic-context';
-import type { LunaticSource } from './type';
 import { compileControls as compileControlsLib } from './commons/compile-controls';
 import { useLoopVariables } from './hooks/use-loop-variables';
 import { getQuestionnaireData } from './commons/variables/get-questionnaire-data';
@@ -204,6 +205,7 @@ export function useLunatic(
 		goNextPage,
 		goPreviousPage,
 		management,
+		logger,
 		...state,
 	});
 
@@ -232,8 +234,6 @@ export function useLunatic(
 		hasPageResponse: usePageHasResponse(components, state.executeExpression),
 		// Components
 		Provider,
-		testing: {
-			handleChanges,
-		},
+		handleChanges,
 	} satisfies LunaticState;
 }

package/src/utils/cast.ts

@@ -0,0 +1,67 @@
+/**
+ * Cast functions that force an unknown type to a specific type
+ */
+
+/**
+ * Force a number (throw if it cannot be converted)
+ */
+export function castNumber(v: unknown): number {
+	if (typeof v === 'number') {
+		return v;
+	}
+	if (typeof v === 'string') {
+		return parseInt(v, 10);
+	}
+	if (Array.isArray(v) && v.length > 0) {
+		return castNumber(v[0]);
+	}
+	throw new Error(`Cannot cast "${v}" to number`);
+}
+
+/**
+ * Force a number, with a default value if an unmanageable type is encountered
+ */
+export const castNumberWithDefault =
+	(initial: number = 0) =>
+	(v: unknown): number => {
+		try {
+			return castNumber(v);
+		} catch {
+			return initial;
+		}
+	};
+
+/**
+ * Force a bool
+ */
+export function castBool(v: unknown): boolean {
+	if (typeof v === 'boolean') {
+		return v;
+	}
+	if (Array.isArray(v) && v.length > 0) {
+		return castBool(v[0]);
+	}
+	if (Array.isArray(v)) {
+		return false;
+	}
+	return Boolean(v);
+}
+
+/**
+ * Force a string
+ */
+export function castString(v: unknown): string {
+	if (typeof v === 'string') {
+		return v;
+	}
+	if (typeof v === 'number') {
+		return v.toString();
+	}
+	if (Array.isArray(v)) {
+		return v.map(castString).join(', ');
+	}
+	if (!v) {
+		return '';
+	}
+	return v.toString();
+}

package/src/utils/constants/variable-status.ts

@@ -1,5 +1 @@
-export const PREVIOUS = 'PREVIOUS' as const;
 export const COLLECTED = 'COLLECTED' as const;
-export const FORCED = 'FORCED' as const;
-export const EDITED = 'EDITED' as const;
-export const INPUTTED = 'INPUTTED' as const;

package/src/utils/variables.spec.ts

@@ -15,10 +15,6 @@ const data = {
 		},
 		PRENOMS: {
 			COLLECTED: ['Paul', 'Pierre'],
-			EDITED: [],
-			INPUTTED: [],
-			FORCED: [],
-			PREVIOUS: [],
 		},
 		AGE: {},
 	},
@@ -49,10 +45,6 @@ const loopCollectedVariable = {
 	variableType: 'COLLECTED',
 	values: {
 		COLLECTED: [],
-		PREVIOUS: [],
-		FORCED: [],
-		EDITED: [],
-		INPUTTED: [],
 	},
 	name: 'PRENOMS',
 } as LunaticVariable;