@inseefr/lunatic 3.8.0-rc.0 → 3.8.0-rc.ucq-options-variable.0

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

@@ -1,46 +1,14 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { LunaticVariablesStore } from '../commons/variables/lunatic-variables-store';
-import { getOptionsProp } from './propOptions';
+import { computeOptionsFromComponent, InterpretedOption } from './propOptions';
 import type { DeepTranslateExpression } from '../commons/fill-components/fill-component-expressions';
 import type {
 	LunaticChangesHandler,
 	LunaticComponentDefinition,
 } from '../type';
 
-describe('getOptionsProp()', () => {
+describe('computeOptionsFromComponent', () => {
 	let variables: LunaticVariablesStore;
-	const checkboxGroupDefinition = {
-		id: 'CheckboxGroup',
-		componentType: 'CheckboxGroup',
-		responses: [
-			{
-				label: 'Option 1',
-				response: { name: 'O1' },
-				id: 'id1',
-			},
-			{
-				label: 'Option 2',
-				response: { name: 'O2' },
-				id: 'id2',
-			},
-		],
-	} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
-
-	const radioDefinition = {
-		id: 'RadioGroup',
-		componentType: 'Radio',
-		response: { name: 'RADIO' },
-		options: [
-			{
-				label: 'Option 1',
-				value: 'id1',
-			},
-			{
-				label: 'Option 2',
-				value: 'id2',
-			},
-		],
-	} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
 
 	let mockChange: LunaticChangesHandler;
 	const mockLogger = vi.fn();
@@ -50,69 +18,97 @@ describe('getOptionsProp()', () => {
 		variables = new LunaticVariablesStore();
 	});
 
-	describe('CheckboxGroup', () => {
+	describe('Options based on a fixed list', () => {
+		const checkboxGroupDefinition = {
+			id: 'CheckboxGroup',
+			componentType: 'CheckboxGroup',
+			responses: [
+				{
+					label: 'Option 1',
+					response: { name: 'O1' },
+					id: 'id1',
+				},
+				{
+					label: 'Option 2',
+					response: { name: 'O2' },
+					id: 'id2',
+				},
+			],
+		} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+		const radioDefinition = {
+			id: 'RadioGroup',
+			componentType: 'Radio',
+			response: { name: 'RADIO' },
+			options: [
+				{
+					label: 'Option 1',
+					value: 'id1',
+				},
+				{
+					label: 'Option 2',
+					value: 'id2',
+				},
+			],
+		} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
 		it('should check boxes', () => {
 			variables.set('O2', false);
-			let options = getOptionsProp(
-				checkboxGroupDefinition,
+			let options = computeOptionsFromComponent(checkboxGroupDefinition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 			expect(options[1].checked).toBe(false);
 			variables.set('O2', true);
-			options = getOptionsProp(
-				checkboxGroupDefinition,
+			options = computeOptionsFromComponent(checkboxGroupDefinition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 			expect(options[1].checked).toBe(true);
 		});
 		it('should check boxes correctly within iteration', () => {
 			variables.set('O1', []);
 			variables.set('O2', []);
-			let options = getOptionsProp(
-				checkboxGroupDefinition,
+			let options = computeOptionsFromComponent(checkboxGroupDefinition, {
 				variables,
-				mockChange,
-				0,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: 0,
+				value: undefined,
+				logger: mockLogger,
+			});
 			expect(
 				options.filter((o) => o.checked),
 				'Nothing checked when variable empty'
 			).toHaveLength(0);
 
 			variables.set('O1', [true, 0]);
-			options = getOptionsProp(
-				checkboxGroupDefinition,
+			options = computeOptionsFromComponent(checkboxGroupDefinition, {
 				variables,
-				mockChange,
-				0,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: 0,
+				value: undefined,
+				logger: mockLogger,
+			});
 			expect(options[0].checked).toBe(true);
 			expect(options[1].checked).toBe(false);
 		});
 		it('should create handleChange correctly', () => {
 			variables.set('O1', [true, false]);
 			variables.set('O2', [false, true]);
-			const options = getOptionsProp(
-				checkboxGroupDefinition,
+			const options = computeOptionsFromComponent(checkboxGroupDefinition, {
 				variables,
-				mockChange,
-				1,
-				undefined,
-				mockLogger
-			);
-			options[1].onCheck(false);
+				handleChanges: mockChange,
+				pagerIteration: 1,
+				value: undefined,
+				logger: mockLogger,
+			});
+			options[1].onCheck?.(false);
 			expect(mockChange).toHaveBeenLastCalledWith([
 				{ name: 'O2', value: false },
 			]);
@@ -145,14 +141,13 @@ describe('getOptionsProp()', () => {
 
 			variables.set('DETAIL', true);
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 
 			expect(options).toHaveLength(2);
 			expect(options[0].detailLabel).toBe('Precize:');
@@ -188,14 +183,13 @@ describe('getOptionsProp()', () => {
 
 			variables.set('DETAIL', true);
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 
 			expect(options).toHaveLength(2);
 			expect(options[0].detailLabel).toBe('Precize:');
@@ -224,14 +218,13 @@ describe('getOptionsProp()', () => {
 				],
 			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 
 			// First option should be filtered out since its conditionFilter is evaluated to false
 			expect(options).toHaveLength(1);
@@ -254,14 +247,13 @@ describe('getOptionsProp()', () => {
 				],
 			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 
 			// First option should be filtered out since its conditionFilter is evaluated to false
 			expect(options).toHaveLength(1);
@@ -285,14 +277,13 @@ describe('getOptionsProp()', () => {
 				throw new Error('Test error');
 			});
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
@@ -315,14 +306,13 @@ describe('getOptionsProp()', () => {
 				throw new Error('Test error');
 			});
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			});
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
@@ -346,15 +336,14 @@ describe('getOptionsProp()', () => {
 				return false;
 			});
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger,
-				true // disableFilters = true
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+				disableFilters: true,
+			});
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
@@ -378,15 +367,14 @@ describe('getOptionsProp()', () => {
 				return false;
 			});
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger,
-				true // disableFilters = true
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+				disableFilters: true,
+			});
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
@@ -406,16 +394,15 @@ describe('getOptionsProp()', () => {
 				],
 			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger,
-				true, // disableFilters = true
-				true // parent component should be filtered
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+				disableFilters: true,
+				shouldParentBeFiltered: true,
+			});
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
@@ -434,16 +421,15 @@ describe('getOptionsProp()', () => {
 				],
 			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
 
-			const options = getOptionsProp(
-				definition,
+			const options = computeOptionsFromComponent(definition, {
 				variables,
-				mockChange,
-				undefined,
-				undefined,
-				mockLogger,
-				true, // disableFilters = true
-				true // parent component should be filtered
-			);
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+				disableFilters: true,
+				shouldParentBeFiltered: true,
+			});
 
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
@@ -451,4 +437,88 @@ describe('getOptionsProp()', () => {
 			expect(options[0].shouldBeFiltered).toBe(true);
 		});
 	});
+
+	describe('Options based on a source variable', () => {
+		const radioOptionSourceDefinition = {
+			id: 'RadioGroupDynamic',
+			componentType: 'Radio',
+			response: { name: 'RADIO' },
+			optionSource: 'NAME',
+		} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+		it('should build options when the source variable is an array of strings', () => {
+			variables.set('NAME', ['Maëlle', 'Verso']);
+			const options = computeOptionsFromComponent(radioOptionSourceDefinition, {
+				variables,
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			}) as InterpretedOption[]; // force type but it should infer type correctly
+
+			expect(options).toHaveLength(2);
+			expect(options[0].value).toBe('Maëlle');
+			expect(options[0].label).toBe('Maëlle');
+			expect(options[1].value).toBe('Verso');
+			expect(options[1].label).toBe('Verso');
+		});
+
+		it('should build options when the source variable is an array of numbers', () => {
+			variables.set('NAME', [10, 20]);
+			const options = computeOptionsFromComponent(radioOptionSourceDefinition, {
+				variables,
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			}) as InterpretedOption[]; // force type but it should infer type correctly
+
+			expect(options).toHaveLength(2);
+			expect(options[0].value).toBe(10);
+			expect(options[0].label).toBe('10');
+			expect(options[1].value).toBe(20);
+			expect(options[1].label).toBe('20');
+		});
+
+		it('should set the response when selecting a dynamic option', () => {
+			variables.set('NAME', ['Maëlle', 'Verso']);
+			const options = computeOptionsFromComponent(radioOptionSourceDefinition, {
+				variables,
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			}) as InterpretedOption[]; // force type but it should infer type correctly
+
+			options[0].onCheck?.();
+			expect(mockChange).toHaveBeenLastCalledWith([
+				{ name: 'RADIO', value: 'Maëlle' },
+			]);
+
+			options[1].onCheck?.();
+			expect(mockChange).toHaveBeenLastCalledWith([
+				{ name: 'RADIO', value: 'Verso' },
+			]);
+		});
+
+		it('should filter options based on the optionFilter expression', () => {
+			const definition = {
+				...radioOptionSourceDefinition,
+				optionFilter: { type: 'VTL', value: 'AGE >= 18' },
+			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+			variables.set('NAME', ['Maëlle', 'Verso', 'Aline']);
+			variables.set('AGE', [16, 30, 50]);
+
+			const options = computeOptionsFromComponent(definition, {
+				variables,
+				handleChanges: mockChange,
+				pagerIteration: undefined,
+				value: undefined,
+				logger: mockLogger,
+			}) as InterpretedOption[]; // force type but it should infer type correctly
+
+			expect(options.map((option) => option.value)).toEqual(['Verso', 'Aline']);
+		});
+	});
 });

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

@@ -28,15 +28,25 @@ export type InterpretedOption = {
 /**
  * Compute options for checkboxes / radios / dropdown
  */
-export function getOptionsProp(
+export function computeOptionsFromComponent(
 	definition: DeepTranslateExpression<LunaticComponentDefinition>,
-	variables: LunaticVariablesStore,
-	handleChanges: LunaticChangesHandler,
-	pagerIteration: LunaticState['pager']['iteration'],
-	value: unknown,
-	logger: LunaticLogger,
-	disableFilters?: boolean,
-	shouldParentBeFiltered?: boolean
+	{
+		variables,
+		handleChanges,
+		pagerIteration,
+		value,
+		logger,
+		disableFilters,
+		shouldParentBeFiltered,
+	}: {
+		variables: LunaticVariablesStore;
+		handleChanges: LunaticChangesHandler;
+		pagerIteration: LunaticState['pager']['iteration'];
+		value: unknown;
+		logger: LunaticLogger;
+		disableFilters?: boolean;
+		shouldParentBeFiltered?: boolean;
+	}
 ) {
 	const iteration = isNumber(pagerIteration) ? [pagerIteration] : undefined;
 
@@ -85,10 +95,27 @@ export function getOptionsProp(
 			}));
 	}
 
+	// options based on another variable
+	if ('optionSource' in definition && definition.optionSource) {
+		return computeOptionsFromSource(definition.optionSource, {
+			variables,
+			value,
+			handleChanges,
+			responseName: definition.response.name,
+			logger,
+			shouldParentBeFiltered,
+			optionFilter: definition.optionFilter,
+		});
+	}
+
 	if (!('options' in definition)) {
 		return [];
 	}
 
+	if (!definition.options) {
+		return [];
+	}
+
 	return definition.options
 		.filter((option) => {
 			if (
@@ -144,6 +171,68 @@ export function getOptionsProp(
 		}));
 }
 
+/**
+ * Get all options from a source variable, applying filters.
+ */
+function computeOptionsFromSource(
+	optionSource: string,
+	{
+		variables,
+		value,
+		handleChanges,
+		responseName,
+		logger,
+		shouldParentBeFiltered,
+		optionFilter,
+	}: {
+		variables: LunaticVariablesStore;
+		value: unknown;
+		handleChanges: LunaticChangesHandler;
+		responseName: string;
+		logger: LunaticLogger;
+		shouldParentBeFiltered?: boolean;
+		optionFilter?: VtlExpression;
+	}
+): InterpretedOption[] {
+	// we don't know the type of the optionSource values (string, numbers, boolean)
+	const optionValues = variables.get<unknown>(optionSource);
+	if (!optionValues) {
+		return [];
+	}
+
+	const normalizedValues = Array.isArray(optionValues)
+		? optionValues
+		: [optionValues];
+
+	return normalizedValues
+		.filter((option, index) => {
+			// option is an empty value, we remove it from the options list
+			if (option === null || option === undefined) {
+				return false;
+			}
+			// no filter expression, we keep the option
+			if (!optionFilter) {
+				return true;
+			}
+			// apply filter expression on option (applied to its iteration)
+			return !isFilteredOutOption(variables, [index], logger, optionFilter);
+		})
+		.map((option) => {
+			return {
+				label: String(option),
+				value: option,
+				checked: value === option,
+				onCheck: () => {
+					handleChanges([{ name: responseName, value: option }]);
+				},
+				onUncheck: () => {
+					handleChanges([{ name: responseName, value: null }]);
+				},
+				shouldBeFiltered: shouldParentBeFiltered,
+			};
+		});
+}
+
 /**
  * Check if an option should be filtered, depending on its conditionFilter.
  */