@inseefr/lunatic 3.5.0-rc.2 → 3.5.0

package/src/use-lunatic/hooks/use-page-has-response.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it, vi } from 'vitest';
+import { usePageHasResponse } from './use-page-has-response';
+import { type LunaticComponentProps } from '../../components/type';
+import { renderHook } from '@testing-library/react';
+
+const defaultComponentValues = {
+	id: 'a',
+	value: null,
+	handleChanges: vi.fn(),
+};
+
+describe('usePageHasResponse', () => {
+	it('should be true when there are no components', () => {
+		const components: LunaticComponentProps[] = [];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, vi.fn())
+		);
+		expect(result.current()).toBeTruthy();
+	});
+
+	it('should be false when there is no value', () => {
+		const components: LunaticComponentProps[] = [
+			{ ...defaultComponentValues, componentType: 'Text' },
+		];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, vi.fn())
+		);
+		expect(result.current()).toBeFalsy();
+	});
+
+	it('should be true when there is a value', () => {
+		const components: LunaticComponentProps[] = [
+			{
+				...defaultComponentValues,
+				componentType: 'Text',
+				value: 'my awesome value',
+			},
+		];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, vi.fn())
+		);
+		expect(result.current()).toBeTruthy();
+	});
+
+	it('should be true for a Question component', () => {
+		const components: LunaticComponentProps[] = [
+			{
+				...defaultComponentValues,
+				componentType: 'Question',
+				components: [
+					{
+						...defaultComponentValues,
+						componentType: 'Text',
+					},
+				],
+				value: { t1: 'my awesome value' },
+			},
+		];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, vi.fn())
+		);
+		expect(result.current()).toBeTruthy();
+	});
+
+	it('should be true when there is an arbitrary response', () => {
+		const components: LunaticComponentProps[] = [
+			{
+				...defaultComponentValues,
+				componentType: 'Suggester',
+				allowArbitrary: true,
+				arbitraryValue: 'my arbitrary value',
+			} as any,
+		];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, vi.fn())
+		);
+		expect(result.current()).toBeTruthy();
+	});
+
+	it('should be true when there is a missing response', () => {
+		const components: LunaticComponentProps[] = [
+			{
+				...defaultComponentValues,
+				componentType: 'Text',
+				missingResponse: { name: 'a_MISSING', value: 'my missing value' },
+			},
+		];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, vi.fn())
+		);
+		expect(result.current()).toBeTruthy();
+	});
+
+	it('should be true for a QCM table', () => {
+		const mockExecuteExpression = vi.fn();
+		mockExecuteExpression.mockReturnValueOnce('my value');
+		const components: LunaticComponentProps[] = [
+			{
+				...defaultComponentValues,
+				componentType: 'Table',
+				body: [
+					[
+						{
+							...defaultComponentValues,
+							id: 't1',
+							componentType: 'CheckboxBoolean',
+							response: { name: 't1' },
+						},
+					],
+				],
+				header: [{ label: 'my label' }],
+				executeExpression: vi.fn(),
+				iteration: 0,
+				value: {},
+			},
+		];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, mockExecuteExpression)
+		);
+		expect(result.current()).toBeTruthy();
+	});
+
+	it('should be true for a QCM table in a Question', () => {
+		const mockExecuteExpression = vi.fn();
+		mockExecuteExpression.mockReturnValueOnce('my value');
+		const components: LunaticComponentProps[] = [
+			{
+				...defaultComponentValues,
+				componentType: 'Question',
+				components: [
+					{
+						...defaultComponentValues,
+						componentType: 'Table',
+						body: [
+							[
+								{
+									...defaultComponentValues,
+									id: 't1',
+									componentType: 'CheckboxBoolean',
+									response: { name: 't1' },
+								},
+							],
+						],
+						header: [{ label: 'my label' }],
+						executeExpression: vi.fn(),
+						iteration: 0,
+						value: { t1: true },
+					},
+				],
+				value: {},
+			},
+		];
+		const { result } = renderHook(() =>
+			usePageHasResponse(components, mockExecuteExpression)
+		);
+		expect(result.current()).toBeTruthy();
+	});
+});
+
+it('should be true for a loop component with values', () => {
+	const mockExecuteExpression = vi.fn();
+	mockExecuteExpression.mockReturnValueOnce('my value');
+
+	const values = {
+		VOTREPRENO: ['Alice', 'Bob', 'Charlie'],
+		VOTREAGE: [22, 30, 40],
+	};
+
+	const components = [
+		{
+			...defaultComponentValues,
+			componentType: 'Loop',
+			components: [
+				{
+					...defaultComponentValues,
+					componentType: 'Question',
+					components: [
+						{
+							...defaultComponentValues,
+							componentType: 'Input',
+							response: { name: 'VOTREPRENO' },
+						},
+						{
+							...defaultComponentValues,
+							componentType: 'InputNumber',
+							response: { name: 'VOTREAGE' },
+						},
+					],
+				},
+			],
+			value: values,
+		},
+	] as any as LunaticComponentProps[];
+
+	const { result } = renderHook(() =>
+		usePageHasResponse(components, mockExecuteExpression)
+	);
+
+	expect(result.current()).toBeTruthy();
+});

package/src/use-lunatic/hooks/use-page-has-response.ts

@@ -11,59 +11,82 @@ export function usePageHasResponse(
 	executeExpression: LunaticReducerState['executeExpression']
 ): () => boolean {
 	return useCallback(() => {
-		if (!Array.isArray(components) || components.length === 0) {
+		return hasOneResponse(components, executeExpression);
+	}, [components, executeExpression]);
+}
+
+function hasOneResponse(
+	components: LunaticComponentProps[],
+	executeExpression: LunaticReducerState['executeExpression']
+): boolean {
+	if (!Array.isArray(components) || components.length === 0) {
+		return true;
+	}
+
+	for (const component of components) {
+		// Some components are considered as "filled" by default
+		// We assume they are not in the same page has other components
+		if (
+			['PairwiseLinks', 'Roundabout', 'Sequence', 'Subsequence'].includes(
+				component.componentType ?? ''
+			)
+		) {
 			return true;
 		}
 
-		for (const component of components) {
-			// Some components are considered as "filled" by default
-			// We assume they are not in the same page has other components
-			if (
-				['PairwiseLinks', 'Roundabout', 'Sequence', 'Subsequence'].includes(
-					component.componentType ?? ''
-				)
-			) {
-				return true;
-			}
+		// We have a missing response for this component
+		if (
+			'missingResponse' in component &&
+			component.missingResponse &&
+			component.missingResponse.value
+		) {
+			return true;
+		}
 
-			// We have a missing response for this component
-			if (
-				'missingResponse' in component &&
-				component.missingResponse &&
-				component.missingResponse.value
-			) {
-				return true;
-			}
+		// We have an arbitrary response for this component
+		if ('arbitraryValue' in component && component.arbitraryValue) {
+			return true;
+		}
 
-			// For Table, we have to extract components from its body and apply isSubComponentsEmpty function
-			if (component.componentType === 'Table') {
-				// Body is array for array (row), each "cell" could be an Label or Component, so we filter array.
-				const childrenComponent = component.body.reduce((_, row) => {
-					const componentsInRow = row.filter(
-						(cell) => isObject(cell) && 'componentType' in cell
-					);
-					return [..._, ...componentsInRow];
-				}, [] as LunaticComponentProps[]);
-				return !isSubComponentsEmpty(childrenComponent, executeExpression);
-			}
+		// For Table, we have to extract components from its body and apply isSubComponentsEmpty function
+		if (component.componentType === 'Table') {
+			// Body is array for array (row), each "cell" could be an Label or Component, so we filter array.
+			const childrenComponent = component.body.reduce((_, row) => {
+				const componentsInRow = row.filter(
+					(cell) => isObject(cell) && 'componentType' in cell
+				);
+				return [..._, ...componentsInRow];
+			}, [] as LunaticComponentProps[]);
+			return !isSubComponentsEmpty(childrenComponent, executeExpression);
+		}
 
-			// We found a value in one of the root component
-			if ('value' in component && !isEmpty(component.value)) {
-				return true;
-			}
+		// We found a value in one of the root component. Used for Loop
+		if ('value' in component && !isEmpty(component.value)) {
+			return true;
+		}
 
-			// For rosterForLoop we need to inspect child components
-			if (
-				'components' in component &&
-				Array.isArray(component.components) &&
-				!isSubComponentsEmpty(component.components, executeExpression)
-			) {
-				return true;
-			}
+		// For Question, we need to check subcomponents
+		if (
+			component.componentType === 'Question' &&
+			'components' in component &&
+			Array.isArray(component.components) &&
+			hasOneResponse(component.components, executeExpression)
+		) {
+			return true;
 		}
 
-		return false;
-	}, [components, executeExpression]);
+		// For rosterForLoop we need to inspect child components
+		if (
+			component.componentType === 'RosterForLoop' &&
+			'components' in component &&
+			Array.isArray(component.components) &&
+			!isSubComponentsEmpty(component.components, executeExpression)
+		) {
+			return true;
+		}
+	}
+
+	return false;
 }
 
 /**

package/src/use-lunatic/hooks/useOverview.spec.ts

@@ -0,0 +1,42 @@
+import { renderHook } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import source from '../../stories/overview/sourceWithHierarchy.json';
+import { useLunatic } from '../use-lunatic';
+import { dataFromObject } from '../test.utils';
+
+describe('use-overview test with useLunatic()', () => {
+	it('should initialize correctly with disableFilters: false (without data)', () => {
+		const params = [
+			source as any,
+			dataFromObject({}),
+			{ withOverview: true },
+		] as const;
+		const { result } = renderHook(() => useLunatic(...params));
+		expect(result.current.overview.length).toBe(3);
+	});
+
+	it('should initialize correctly with disableFilters: false (with data)', () => {
+		const params = [
+			source as any,
+			dataFromObject({
+				READY: true,
+			}),
+			{ withOverview: true },
+		] as const;
+
+		const { result } = renderHook(() => useLunatic(...params));
+		expect(result.current.overview.length).toBe(9);
+	});
+
+	it('should initialize correctly with disableFilters: true (without data)', () => {
+		const params = [
+			source as any,
+			dataFromObject({}),
+			{ withOverview: true, disableFilters: true },
+		] as const;
+
+		const { result } = renderHook(() => useLunatic(...params));
+		// All elements have to be presents
+		expect(result.current.overview.length).toBe(9);
+	});
+});

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

@@ -1,4 +1,5 @@
 import type {
+	LunaticOptions,
 	LunaticOverviewItem,
 	LunaticReducerState,
 	PageTag,
@@ -25,13 +26,23 @@ export const useOverview = (
 		overview,
 		executeExpression,
 		pager,
-	}: Pick<LunaticReducerState, 'executeExpression' | 'overview' | 'pager'>,
+		options,
+	}: Pick<
+		LunaticReducerState,
+		'executeExpression' | 'overview' | 'pager' | 'options'
+	>,
 	deps: DependencyList
 ) => {
 	return useMemo(
-		() => interpretOverview(overview, executeExpression, pager),
+		() =>
+			interpretOverview(
+				overview,
+				executeExpression,
+				pager,
+				options.disableFilters
+			),
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[...deps, overview]
+		[...deps, overview, options.disableFilters]
 	);
 };
 
@@ -41,11 +52,16 @@ export const useOverview = (
 const interpretOverview = (
 	overviewItems: LunaticOverviewItem[],
 	executeExpression: LunaticReducerState['executeExpression'],
-	pager?: LunaticReducerState['pager']
+	pager?: LunaticReducerState['pager'],
+	disableFilters?: LunaticOptions['disableFilters']
 ) => {
 	// Flat structure of the overview
 	let items = overviewItems.reduce(
-		(acc, item) => interpretOverviewItem(acc, item, executeExpression, pager),
+		(acc, item) =>
+			interpretOverviewItem(acc, item, executeExpression, {
+				pager,
+				disableFilters,
+			}),
 		[] as InterpretedLunaticOverviewItem[]
 	);
 	// Sort using the page logic
@@ -77,7 +93,11 @@ const interpretOverviewItem = (
 	items: InterpretedLunaticOverviewItem[],
 	item: LunaticOverviewItem,
 	executeExpression: LunaticReducerState['executeExpression'],
-	pager?: LunaticReducerState['pager'],
+	state: {
+		pager?: LunaticReducerState['pager'];
+		disableFilters?: LunaticOptions['disableFilters'];
+	},
+
 	iteration?: number
 ): InterpretedLunaticOverviewItem[] => {
 	// We reached a loop item, we need to add it multiple time
@@ -85,19 +105,21 @@ const interpretOverviewItem = (
 		const iterations = executeExpression<number>(item.iterations) ?? 0;
 		return Array.from({ length: iterations }).reduce(
 			(acc: InterpretedLunaticOverviewItem[], _, k) => {
-				return interpretOverviewItem(acc, item, executeExpression, pager, k);
+				return interpretOverviewItem(acc, item, executeExpression, state, k);
 			},
 			items
 		);
 	}
 
-	const isVisible = item.conditionFilter
-		? Boolean(
-				executeExpression(item.conditionFilter, {
-					iteration: iteration,
-				})
-			)
-		: true;
+	// if disableFilters is set to true, item are visible and reached by default
+	const isVisible = (() => {
+		if (state.disableFilters || !item.conditionFilter) return true;
+		return Boolean(
+			executeExpression(item.conditionFilter, {
+				iteration: iteration,
+			})
+		);
+	})();
 
 	if (!isVisible) {
 		return items;
@@ -106,6 +128,10 @@ const interpretOverviewItem = (
 	// Append the item to the list of items
 	const page =
 		`${item.pageTag}${iteration !== undefined ? `#${iteration + 1}` : ''}` as PageTag;
+
+	const reached =
+		pageTagComparator(state.pager ? getPageTag(state.pager) : '-1', page) >= 0;
+
 	return [
 		...items,
 		{
@@ -116,10 +142,7 @@ const interpretOverviewItem = (
 				? executeExpression(item.description, { iteration })
 				: undefined,
 			children: [],
-			reached:
-				pageTagComparator(pager ? getPageTag(pager) : '-1', page) >= 0
-					? true
-					: false,
+			reached: reached,
 			page: page,
 			current: false,
 		},

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 [];
+		})
+	);
+}