@inseefr/lunatic 3.5.4 → 3.5.6

package/src/use-lunatic/commons/fill-components/fill-component.spec.ts

@@ -66,6 +66,7 @@ describe('fillComponents', () => {
 		expect(input.required).toBe(true);
 		expect(input.maxLength).toBe(15);
 		expect(input.conditionFilter).toBe(true);
+		expect(input.shouldBeFiltered).toBe(false);
 	});
 
 	it('should fill a Radio component correctly with options', () => {
@@ -136,6 +137,7 @@ describe('fillComponents', () => {
 		expect(radio.options[0].label).toBe('"oui"');
 		expect(radio.options[1].label).toBe('"non"');
 		expect(radio.conditionFilter).toBe(true);
+		expect(radio.shouldBeFiltered).toBe(false);
 		expect(radio.response.name).toBe('TESTRADIO');
 	});
 
@@ -187,6 +189,7 @@ describe('fillComponents', () => {
 		expect(question.id).toBe('question-m8ilvkbt');
 		expect(question.label).toBe('"Question label"');
 		expect(question.conditionFilter).toBe(true);
+		expect(question.shouldBeFiltered).toBe(false);
 		expect(question.components.length).toBe(1);
 
 		const input = question.components[0];
@@ -258,12 +261,16 @@ describe('fillComponents', () => {
 		expect(input.componentType).toBe('Input');
 		expect(input.response.name).toBe('TESTINPUT');
 		expect(input.maxLength).toBe(100);
+		expect(input.conditionFilter).toBe(true);
+		expect(input.shouldBeFiltered).toBe(false);
 
 		const radio = filledComponents[1];
 		expect(radio.componentType).toBe('Radio');
 		expect(radio.response.name).toBe('TESTRADIO');
 		expect(radio.options[0].label).toBe('"Yes"');
 		expect(radio.options[1].label).toBe('"No"');
+		expect(radio.conditionFilter).toBe(true);
+		expect(radio.shouldBeFiltered).toBe(false);
 	});
 
 	it('should filter out FilterDescription components if disableFiltersDescription is true', () => {
@@ -453,6 +460,7 @@ describe('fillComponents', () => {
 		const input = filledComponents[0];
 		expect(input.id).toBe('input1');
 		expect(input.conditionFilter).toBe(false);
+		expect(input.shouldBeFiltered).toBe(true);
 	});
 
 	it('should transform components into Text with empty label when conditionFilter is false and parentType is RosterForLoop', () => {
@@ -507,6 +515,8 @@ describe('fillComponents', () => {
 		expect(input.componentType).toBe('Text');
 		expect(input.label).toBe('');
 		expect(input.id).toBe('input1');
+		expect(input.conditionFilter).toBe(false);
+		expect(input.shouldBeFiltered).toBe(true);
 
 		// Check the second component that has conditionFilter: true
 		const radio = filledComponents[1];
@@ -569,6 +579,8 @@ describe('fillComponents', () => {
 		// The component should remain unchanged
 		expect(input.componentType).toBe('Input');
 		expect(input.label).toBe('"Input label"');
+		expect(input.conditionFilter).toBe(false);
+		expect(input.shouldBeFiltered).toBe(true);
 
 		// Check the second component that has conditionFilter: true
 		const radio = filledComponents[1];
@@ -578,4 +590,118 @@ describe('fillComponents', () => {
 		expect(radio.options[0].label).toBe('"Yes"');
 		expect(radio.options[1].label).toBe('"No"');
 	});
+
+	it('should tag children components with shouldBeFiltered=true if the parent component should be filtered', () => {
+		const components = [
+			{
+				id: 'question-m8ilvkbt',
+				componentType: 'Question',
+				page: '1',
+				label: {
+					value: '"Question label"',
+					type: 'VTL|MD',
+				},
+				conditionFilter: {
+					type: 'VTL',
+					// value should be string, but did not find how to execute correctly with mocks
+					// for having a false conditionFilter at the end
+					value: false,
+				},
+				components: [
+					{
+						id: 'm8ilvkbt',
+						componentType: 'Input',
+						page: '1',
+						maxLength: 249,
+						response: {
+							name: 'TESTTEXTE',
+						},
+					},
+				],
+			},
+		];
+
+		const mockVariables = LunaticVariablesStore.makeFromObject({
+			TESTTEXTE: 'some value',
+		});
+
+		const mockState = {
+			...defaultMockState,
+			disableFilters: true,
+			variables: mockVariables,
+		};
+
+		const filledComponents = fillComponents(
+			components as LunaticComponentDefinition[],
+			mockState as unknown as FillComponentArgs
+		) as any;
+
+		const question = filledComponents[0];
+
+		expect(question.componentType).toBe('Question');
+		expect(question.conditionFilter).toBe(false);
+		expect(question.shouldBeFiltered).toBe(true);
+
+		const input = question.components[0];
+		expect(input.componentType).toBe('Input');
+		expect(input.conditionFilter).toBe(undefined);
+		expect(input.shouldBeFiltered).toBe(true);
+	});
+
+	it('should tag options with shouldBeFiltered=true if the component should be filtered', () => {
+		const components = [
+			{
+				id: 'radio1',
+				componentType: 'Radio',
+				page: '1',
+				label: {
+					type: 'VTL|MD',
+					value: '"Radio label"',
+				},
+				options: [
+					{ value: 'yes', label: { value: '"Yes"', type: 'VTL|MD' } },
+					{ value: 'no', label: { value: '"No"', type: 'VTL|MD' } },
+				],
+				response: {
+					name: 'TESTRADIO',
+				},
+				conditionFilter: {
+					type: 'VTL',
+					// value should be string, but did not find how to execute correctly with mocks
+					// for having a false conditionFilter at the end
+					value: false,
+				},
+			},
+		];
+
+		const mockVariables = LunaticVariablesStore.makeFromObject({
+			TESTINPUT: 'Filled input',
+			TESTRADIO: 'yes',
+		});
+
+		const mockState = {
+			...defaultMockState,
+			disableFilters: true,
+			variables: mockVariables,
+		};
+
+		const filledComponents = fillComponents(
+			components as LunaticComponentDefinition[],
+			mockState as unknown as FillComponentArgs
+		) as any;
+
+		const radio = filledComponents[0];
+
+		expect(radio.componentType).toBe('Radio');
+		expect(radio.conditionFilter).toBe(false);
+		expect(radio.shouldBeFiltered).toBe(true);
+
+		expect(radio.options[0].label).toBe('"Yes"');
+		expect(radio.options[0].conditionFilter).toBe(undefined);
+		expect(radio.options[0].shouldBeFiltered).toBe(true);
+
+		expect(radio.options[1].label).toBe('"No"');
+		expect(radio.options[1].conditionFilter).toBe(undefined);
+		expect(radio.options[1].shouldBeFiltered).toBe(true);
+	});
 });

package/src/use-lunatic/commons/fill-components/fill-components.ts

@@ -13,6 +13,7 @@ import { getValueProp } from '../../props/propValue';
 import { getIterationsProp } from '../../props/propIterations';
 import { getOptionsProp } from '../../props/propOptions';
 import { LunaticLogger } from '../../logger/type';
+import { VTLScalarExpression } from '../../../type.source';
 
 export type FillComponentArgs = {
 	disableFilters?: boolean;
@@ -35,9 +36,20 @@ export type FillComponentArgs = {
  */
 export const fillComponent = (
 	component: LunaticComponentDefinition,
-	state: FillComponentArgs
+	state: FillComponentArgs,
+	// the given parentConditionFilter is typed as VTLScalarExpression, but it's actually a boolean or undefined
+	parentConditionFilter?: any
 ): LunaticComponentProps & { conditionFilter?: boolean } => {
 	const interpretedProps = fillComponentExpressions(component, state);
+
+	const shouldParentBeFiltered = parentConditionFilter === false;
+
+	const shouldBeFiltered =
+		shouldParentBeFiltered ||
+		('conditionFilter' in interpretedProps
+			? !interpretedProps.conditionFilter
+			: false);
+
 	const value = getValueProp(component, state);
 	return {
 		...interpretedProps,
@@ -48,6 +60,7 @@ export const fillComponent = (
 		shortcut: state.shortcut,
 		goNextPage: state.goNextPage,
 		goPreviousPage: state.goPreviousPage,
+		shouldBeFiltered: shouldBeFiltered,
 		iteration: state.pager.iteration,
 		required: 'isMandatory' in component ? component.isMandatory : false,
 		value: value,
@@ -61,7 +74,8 @@ export const fillComponent = (
 			state.pager.iteration,
 			value,
 			state.logger,
-			state.disableFilters
+			state.disableFilters,
+			shouldBeFiltered
 		),
 		...getComponentTypeProps(interpretedProps, state),
 		// This is too dynamic to be typed correctly, so we allow any here
@@ -74,7 +88,8 @@ export const fillComponent = (
 export function fillComponents(
 	components: LunaticComponentDefinition[],
 	state: FillComponentArgs,
-	parentType?: LunaticComponentDefinition['componentType']
+	parentType?: LunaticComponentDefinition['componentType'],
+	parentConditionFilter?: VTLScalarExpression
 ): LunaticComponentProps[] {
 	// Flatmap to directly remove FilterDescription components if disableFiltersDescription is true
 	const filledComponents = components.flatMap((component) => {
@@ -85,7 +100,7 @@ export function fillComponents(
 			return [];
 		}
 
-		return [fillComponent(component, state)];
+		return [fillComponent(component, state, parentConditionFilter)];
 	});
 
 	if (state.disableFilters) {

package/src/use-lunatic/commons/variables/lunatic-variables-store.spec.ts

@@ -124,6 +124,18 @@ describe('lunatic-variables-store', () => {
 		expect(variables.get('FIRSTNAME')).toEqual('Jane');
 	});
 
+	it('should ignore iteration when updating a scalar value', () => {
+		variables.set('FIRSTNAME', 'John'); // Start with a scalar value
+		expect(variables.get('FIRSTNAME')).toEqual('John');
+		variables.set('FIRSTNAME', 'Jane', {
+			iteration: [1],
+			ignoreIterationOnScalar: true,
+		});
+		expect(variables.get('FIRSTNAME')).toEqual('Jane');
+		variables.set('FIRSTNAME', 'Marc', { iteration: [1] });
+		expect(variables.get('FIRSTNAME')).toEqual([null, 'Marc']);
+	});
+
 	describe('event listener', () => {
 		it('should trigger onChange', () => {
 			variables.set('FIRSTNAME', 'John');

package/src/use-lunatic/commons/variables/lunatic-variables-store.ts

@@ -35,6 +35,8 @@ export type EventArgs = {
 		iteration?: IterationLevel | undefined;
 		/** What triggered this change. */
 		cause?: 'resizing' | 'cleaning';
+		/** Force a vector when an iteration is set and the value was a scalar **/
+		ignoreIterationOnScalar?: boolean;
 		/** Extra sent when setting the variable. */
 		[extra: string]: unknown;
 	};
@@ -168,7 +170,10 @@ export class LunaticVariablesStore {
 	public set(
 		name: string,
 		value: unknown,
-		args: Pick<EventArgs['change'], 'iteration' | 'cause'> = {}
+		args: Pick<
+			EventArgs['change'],
+			'iteration' | 'cause' | 'ignoreIterationOnScalar'
+		> = {}
 	): LunaticVariable {
 		if (!this.dictionary.has(name)) {
 			this.dictionary.set(
@@ -188,7 +193,7 @@ export class LunaticVariablesStore {
 			);
 		}
 		const variable = this.dictionary.get(name)!;
-		if (variable.setValue(value, args.iteration)) {
+		if (variable.setValue(value, args)) {
 			this.eventTarget.dispatchEvent(
 				new CustomEvent('change', {
 					detail: {
@@ -390,7 +395,9 @@ class LunaticVariable {
 		// this.calculatedCount++;
 		// Remember the value
 		try {
-			this.setValue(interpretVTL(this.expression, bindings), iteration);
+			this.setValue(interpretVTL(this.expression, bindings), {
+				iteration: iteration,
+			});
 		} catch {
 			throw new VTLInterpretationError(this.expression!, bindings);
 		}
@@ -401,7 +408,11 @@ class LunaticVariable {
 	/**
 	 * Set the value and returns true if the variable is touched
 	 */
-	setValue(value: unknown, iteration?: IterationLevel): boolean {
+	setValue(
+		value: unknown,
+		opts: { iteration?: IterationLevel; ignoreIterationOnScalar?: boolean }
+	): boolean {
+		const { iteration, ignoreIterationOnScalar } = opts;
 		if (value === this.getSavedValue(iteration)) {
 			return false;
 		}
@@ -411,6 +422,10 @@ class LunaticVariable {
 		}
 		// We want to save a value at a specific iteration, but the value is not an array yet
 		if (iteration !== undefined && !Array.isArray(this.value)) {
+			// Ignore the iteration since the value is not an array
+			if (ignoreIterationOnScalar) {
+				return this.setValue(value, {});
+			}
 			this.value = [];
 		}
 		this.value = !Array.isArray(iteration)
@@ -445,7 +460,7 @@ class LunaticVariable {
 		// Update every item of the array and look if we changed one item
 		const oneValueChanged =
 			times(Math.max(oldSize, newSize), (k) =>
-				this.setValue(value[k], [k])
+				this.setValue(value[k], { iteration: [k] })
 			).find((v) => v) !== undefined;
 		// New array is smaller, shorten the array
 		if (oldSize > newSize && Array.isArray(this.value)) {

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

@@ -45,7 +45,12 @@ function getChildComponents(
 	state: State
 ) {
 	return {
-		components: fillComponents(component.components, state),
+		components: fillComponents(
+			component.components,
+			state,
+			undefined,
+			component.conditionFilter
+		),
 	};
 }
 

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

@@ -208,6 +208,7 @@ describe('getOptionsProp()', () => {
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
+			expect(options[0].shouldBeFiltered).toBe(false);
 		});
 		it('should not filter option (radio) when its conditionFilter evaluation fails', () => {
 			const definition = {
@@ -237,6 +238,7 @@ describe('getOptionsProp()', () => {
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
+			expect(options[0].shouldBeFiltered).toBe(false);
 		});
 		it('should not filter any response (CheckboxGroup) when disableFilters is true', () => {
 			const definition = {
@@ -268,6 +270,8 @@ describe('getOptionsProp()', () => {
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
+			// the option should would have been filtered if we did not disable filters
+			expect(options[0].shouldBeFiltered).toBe(true);
 		});
 		it('should not filter any option (Radio) when disableFilters is true', () => {
 			const definition = {
@@ -296,7 +300,67 @@ describe('getOptionsProp()', () => {
 				true // disableFilters = true
 			);
 
+			// Ensure the option is not filtered
+			expect(options).toHaveLength(1);
+			// the option should would have been filtered if we did not disable filters
+			expect(options[0].shouldBeFiltered).toBe(true);
+		});
+		it('should set the response (CheckboxGroup) shouldBeFiltered=true when the parent component should be filtered', () => {
+			const definition = {
+				...checkboxGroupDefinition,
+				responses: [
+					{
+						label: 'Option 1',
+						response: { name: 'O1' },
+						id: 'id1',
+						conditionFilter: { type: 'VTL', value: 'expression' },
+					},
+				],
+			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger,
+				true, // disableFilters = true
+				true // parent component should be filtered
+			);
+
+			// Ensure the option is not filtered
+			expect(options).toHaveLength(1);
+			// the option would have been filtered if we did not disable filters because its parent would
+			expect(options[0].shouldBeFiltered).toBe(true);
+		});
+		it('should set the option (Radio) shouldBeFiltered=true when the parent component should be filtered', () => {
+			const definition = {
+				...radioDefinition,
+				options: [
+					{
+						label: 'Option 1',
+						value: 'id1',
+						conditionFilter: { type: 'VTL', value: 'expression' },
+					},
+				],
+			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger,
+				true, // disableFilters = true
+				true // parent component should be filtered
+			);
+
+			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
+			// the option would have been filtered if we did not disable filters because its parent would
+			expect(options[0].shouldBeFiltered).toBe(true);
 		});
 	});
 });

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

@@ -8,6 +8,7 @@ import type { DeepTranslateExpression } from '../commons/fill-components/fill-co
 import { isNumber } from '../../utils/number';
 import type { LunaticVariablesStore } from '../commons/variables/lunatic-variables-store';
 import { LunaticLogger } from '../logger/type';
+import { VtlExpression } from '../../components/type';
 
 /* Used for radio option and checkbox one option */
 export type InterpretedOption = {
@@ -32,10 +33,10 @@ export function getOptionsProp(
 	pagerIteration: LunaticState['pager']['iteration'],
 	value: unknown,
 	logger: LunaticLogger,
-	disableFilters?: boolean
+	disableFilters?: boolean,
+	shouldParentBeFiltered?: boolean
 ) {
 	const iteration = isNumber(pagerIteration) ? [pagerIteration] : undefined;
-	//const iteration = pagerIteration ? [pagerIteration] : undefined;
 
 	if (definition.componentType === 'CheckboxGroup') {
 		return definition.responses
@@ -43,16 +44,12 @@ export function getOptionsProp(
 				if (disableFilters || !response.conditionFilter) {
 					return true;
 				}
-				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;
-				}
+				return !isFilteredOutOption(
+					variables,
+					iteration,
+					logger,
+					response.conditionFilter
+				);
 			})
 			.map((response) => ({
 				label: response.label,
@@ -74,6 +71,14 @@ export function getOptionsProp(
 							]);
 						}
 					: undefined,
+				shouldBeFiltered:
+					shouldParentBeFiltered ||
+					isFilteredOutOption(
+						variables,
+						iteration,
+						logger,
+						response.conditionFilter
+					),
 			}));
 	}
 
@@ -90,16 +95,12 @@ export function getOptionsProp(
 			) {
 				return true;
 			}
-			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;
-			}
+			return !isFilteredOutOption(
+				variables,
+				iteration,
+				logger,
+				option.conditionFilter
+			);
 		})
 		.map((option) => ({
 			label: option.label,
@@ -126,5 +127,32 @@ export function getOptionsProp(
 							handleChanges([{ name: option.detail!.response.name, value }]);
 						}
 					: null,
+			shouldBeFiltered:
+				shouldParentBeFiltered ||
+				('conditionFilter' in option &&
+					isFilteredOutOption(
+						variables,
+						iteration,
+						logger,
+						option.conditionFilter
+					)),
 		}));
 }
+
+/**
+ * Check if an option should be filtered, depending on its conditionFilter.
+ */
+function isFilteredOutOption(
+	variables: LunaticVariablesStore,
+	iteration: number[] | undefined,
+	logger: LunaticLogger,
+	conditionFilter?: VtlExpression
+): boolean {
+	if (!conditionFilter) return false;
+	try {
+		return !variables.run(conditionFilter.value, { iteration });
+	} catch (e) {
+		logger({ type: 'ERROR', error: e as Error });
+		return false;
+	}
+}

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

@@ -5,7 +5,7 @@ import { reduceHandleChanges } from './reduce-handle-changes';
 import { reduceGoPreviousPage } from './reduce-go-previous-page';
 import { reduceGoToPage } from './reduce-go-to-page';
 
-// Action that trigger a change in the store
+// Actions that trigger a change in the store
 const commitActions: ActionKind[] = [
 	ActionKind.GO_PREVIOUS_PAGE,
 	ActionKind.GO_NEXT_PAGE,

package/src/use-lunatic/type.ts

@@ -366,5 +366,6 @@ export type LunaticChangesHandler = (
 		name: string;
 		value: any;
 		iteration?: number[];
+		ignoreIterationOnScalar?: boolean;
 	}[]
 ) => void;

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

@@ -59,6 +59,45 @@ describe('use-lunatic()', () => {
 		expect(components[0].id).toBe('kiq5xw5p');
 	});
 
+	describe('handleChange()', () => {
+		it('should change variable value', () => {
+			const { result } = renderHook(() => useLunatic(...defaultParams));
+			act(() => {
+				result.current.handleChanges([
+					{
+						name: 'COMMENT',
+						value: 'Mon commentaire',
+					},
+				]);
+			});
+			act(() => {
+				expect(
+					result.current.getData(false, ['COMMENT']).COLLECTED!.COMMENT
+						.COLLECTED
+				).toBe('Mon commentaire');
+			});
+		});
+		it('should ignore iteration for scalar value', () => {
+			const { result } = renderHook(() => useLunatic(...defaultParams));
+			act(() => {
+				result.current.handleChanges([
+					{
+						name: 'COMMENT',
+						value: 'Mon commentaire 2',
+						iteration: [1],
+						ignoreIterationOnScalar: true,
+					},
+				]);
+			});
+			act(() => {
+				expect(
+					result.current.getData(false, ['COMMENT']).COLLECTED!.COMMENT
+						.COLLECTED
+				).toBe('Mon commentaire 2');
+			});
+		});
+	});
+
 	describe('Provider', () => {
 		it('should not generate a new Provider every render', () => {
 			const { result } = renderHook(() => {