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

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/propOptions.spec.ts

@@ -26,6 +26,7 @@ describe('getOptionsProp()', () => {
 		],
 	} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
 	let mockChange: LunaticChangesHandler;
+	const mockLogger = vi.fn();
 
 	beforeEach(() => {
 		mockChange = vi.fn();
@@ -40,7 +41,8 @@ describe('getOptionsProp()', () => {
 				variables,
 				mockChange,
 				undefined,
-				undefined
+				undefined,
+				mockLogger
 			);
 			expect(options[1].checked).toBe(false);
 			variables.set('O2', true);
@@ -49,7 +51,8 @@ describe('getOptionsProp()', () => {
 				variables,
 				mockChange,
 				undefined,
-				undefined
+				undefined,
+				mockLogger
 			);
 			expect(options[1].checked).toBe(true);
 		});
@@ -61,7 +64,8 @@ describe('getOptionsProp()', () => {
 				variables,
 				mockChange,
 				0,
-				undefined
+				undefined,
+				mockLogger
 			);
 			expect(
 				options.filter((o) => o.checked),
@@ -74,7 +78,8 @@ describe('getOptionsProp()', () => {
 				variables,
 				mockChange,
 				0,
-				undefined
+				undefined,
+				mockLogger
 			);
 			expect(options[0].checked).toBe(true);
 			expect(options[1].checked).toBe(false);
@@ -87,12 +92,73 @@ describe('getOptionsProp()', () => {
 				variables,
 				mockChange,
 				1,
-				undefined
+				undefined,
+				mockLogger
 			);
 			options[1].onCheck(false);
 			expect(mockChange).toHaveBeenLastCalledWith([
 				{ name: 'O2', value: false },
 			]);
 		});
+		it('should not filter response (checkboxGroup) when its conditionFilter evaluation fails', () => {
+			const definition = {
+				...checkboxGroupDefinition,
+				responses: [
+					{
+						label: 'Option 1',
+						response: { name: 'O1' },
+						id: 'id1',
+						conditionFilter: { type: 'VTL', value: 'invalid expression' },
+					},
+				],
+			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+			// mock variables.run for having an error interpreting a variable
+			vi.spyOn(variables, 'run').mockImplementation(() => {
+				throw new Error('Test error');
+			});
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger
+			);
+
+			// Ensure the option is not filtered
+			expect(options).toHaveLength(1);
+		});
+		it('should not filter option (radio) when its conditionFilter evaluation fails', () => {
+			const definition = {
+				id: 'RadioGroup',
+				componentType: 'Radio',
+				options: [
+					{
+						label: 'Option 1',
+						value: 'id1',
+						conditionFilter: { type: 'VTL', value: 'invalid expression' },
+					},
+				],
+			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
+
+			// Mock `variables.run` to throw an error
+			vi.spyOn(variables, 'run').mockImplementation(() => {
+				throw new Error('Test error');
+			});
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger
+			);
+
+			// Ensure the option is not filtered
+			expect(options).toHaveLength(1);
+		});
 	});
 });

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

@@ -7,6 +7,7 @@ import type { ReactNode } from 'react';
 import type { DeepTranslateExpression } from '../commons/fill-components/fill-component-expressions';
 import { isNumber } from '../../utils/number';
 import type { LunaticVariablesStore } from '../commons/variables/lunatic-variables-store';
+import { LunaticLogger } from '../logger/type';
 
 /* Used for radio option and checkbox one option */
 export type InterpretedOption = {
@@ -29,7 +30,8 @@ export function getOptionsProp(
 	variables: LunaticVariablesStore,
 	handleChanges: LunaticChangesHandler,
 	pagerIteration: LunaticState['pager']['iteration'],
-	value: unknown
+	value: unknown,
+	logger: LunaticLogger
 ) {
 	const iteration = isNumber(pagerIteration) ? [pagerIteration] : undefined;
 	//const iteration = pagerIteration ? [pagerIteration] : undefined;
@@ -40,7 +42,16 @@ export function getOptionsProp(
 				if (!response.conditionFilter) {
 					return true;
 				}
-				return variables.run(response.conditionFilter.value, { iteration });
+				try {
+					return variables.run(response.conditionFilter.value, { iteration });
+				} catch (e) {
+					// If there is an error interpreting a variable, we do not filter
+					logger({
+						type: 'ERROR',
+						error: e as Error,
+					});
+					return true;
+				}
 			})
 			.map((response) => ({
 				label: response.label,
@@ -74,7 +85,16 @@ export function getOptionsProp(
 			if (!('conditionFilter' in option) || !option.conditionFilter) {
 				return true;
 			}
-			return variables.run(option.conditionFilter.value, { iteration });
+			try {
+				return variables.run(option.conditionFilter.value, { iteration });
+			} catch (e) {
+				// If there is an error interpreting a variable, we do not filter
+				logger({
+					type: 'ERROR',
+					error: e as Error,
+				});
+				return true;
+			}
 		})
 		.map((option) => ({
 			label: option.label,