@inseefr/lunatic 3.5.1 → 3.5.2

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

@@ -25,6 +25,23 @@ describe('getOptionsProp()', () => {
 			},
 		],
 	} 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();
 
@@ -100,6 +117,68 @@ describe('getOptionsProp()', () => {
 				{ name: 'O2', value: false },
 			]);
 		});
+		it('should filter responses (CheckboxGroup) with conditionFilter evaluated to false', () => {
+			const definition = {
+				...checkboxGroupDefinition,
+				responses: [
+					{
+						label: 'Option 1',
+						response: { name: 'O1' },
+						id: 'id1',
+						conditionFilter: { type: 'VTL', value: 'false' },
+					},
+					{
+						label: 'Option 2',
+						response: { name: 'O2' },
+						id: 'id2',
+						conditionFilter: { type: 'VTL', value: 'true' },
+					},
+				],
+			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger
+			);
+
+			// First option should be filtered out since its conditionFilter is evaluated to false
+			expect(options).toHaveLength(1);
+			expect(options[0].label).toBe('Option 2');
+		});
+		it('should filter options (Radio) with conditionFilter evaluated to false', () => {
+			const definition = {
+				...radioDefinition,
+				options: [
+					{
+						label: 'Option 1',
+						value: 'id1',
+						conditionFilter: { type: 'VTL', value: 'false' },
+					},
+					{
+						label: 'Option 2',
+						value: 'id2',
+						conditionFilter: { type: 'VTL', value: 'true' },
+					},
+				],
+			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger
+			);
+
+			// First option should be filtered out since its conditionFilter is evaluated to false
+			expect(options).toHaveLength(1);
+			expect(options[0].label).toBe('Option 2');
+		});
 		it('should not filter response (checkboxGroup) when its conditionFilter evaluation fails', () => {
 			const definition = {
 				...checkboxGroupDefinition,
@@ -132,8 +211,7 @@ describe('getOptionsProp()', () => {
 		});
 		it('should not filter option (radio) when its conditionFilter evaluation fails', () => {
 			const definition = {
-				id: 'RadioGroup',
-				componentType: 'Radio',
+				...radioDefinition,
 				options: [
 					{
 						label: 'Option 1',
@@ -160,5 +238,65 @@ describe('getOptionsProp()', () => {
 			// Ensure the option is not filtered
 			expect(options).toHaveLength(1);
 		});
+		it('should not filter any response (CheckboxGroup) when disableFilters is true', () => {
+			const definition = {
+				...checkboxGroupDefinition,
+				responses: [
+					{
+						label: 'Option 1',
+						response: { name: 'O1' },
+						id: 'id1',
+						conditionFilter: { type: 'VTL', value: 'expression' },
+					},
+				],
+			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+			// ensure interpreted expression is false
+			vi.spyOn(variables, 'run').mockImplementation(() => {
+				return false;
+			});
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger,
+				true // disableFilters = true
+			);
+
+			// Ensure the option is not filtered
+			expect(options).toHaveLength(1);
+		});
+		it('should not filter any option (Radio) when disableFilters is true', () => {
+			const definition = {
+				...radioDefinition,
+				options: [
+					{
+						label: 'Option 1',
+						value: 'id1',
+						conditionFilter: { type: 'VTL', value: 'expression' },
+					},
+				],
+			} as any as DeepTranslateExpression<LunaticComponentDefinition>;
+
+			// ensure interpreted expression is false
+			vi.spyOn(variables, 'run').mockImplementation(() => {
+				return false;
+			});
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger,
+				true // disableFilters = true
+			);
+
+			expect(options).toHaveLength(1);
+		});
 	});
 });

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

@@ -31,7 +31,8 @@ export function getOptionsProp(
 	handleChanges: LunaticChangesHandler,
 	pagerIteration: LunaticState['pager']['iteration'],
 	value: unknown,
-	logger: LunaticLogger
+	logger: LunaticLogger,
+	disableFilters?: boolean
 ) {
 	const iteration = isNumber(pagerIteration) ? [pagerIteration] : undefined;
 	//const iteration = pagerIteration ? [pagerIteration] : undefined;
@@ -39,7 +40,7 @@ export function getOptionsProp(
 	if (definition.componentType === 'CheckboxGroup') {
 		return definition.responses
 			.filter((response) => {
-				if (!response.conditionFilter) {
+				if (disableFilters || !response.conditionFilter) {
 					return true;
 				}
 				try {
@@ -82,7 +83,11 @@ export function getOptionsProp(
 
 	return definition.options
 		.filter((option) => {
-			if (!('conditionFilter' in option) || !option.conditionFilter) {
+			if (
+				disableFilters ||
+				!('conditionFilter' in option) ||
+				!option.conditionFilter
+			) {
 				return true;
 			}
 			try {

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

@@ -35,7 +35,7 @@ const baseState = {
 	overview: [],
 	updateBindings: () => {},
 	executeExpression: <T,>() => null as T,
-	options: { disableFilters: false },
+	options: { disableFilters: false, disableFiltersDescription: true },
 } satisfies LunaticReducerState;
 
 export function reducerInitializer({
@@ -46,6 +46,7 @@ export function reducerInitializer({
 	lastReachedPage = undefined,
 	withOverview = false,
 	disableFilters = false,
+	disableFiltersDescription = true,
 	getReferentiel,
 	onVariableChange,
 	logger,
@@ -57,6 +58,7 @@ export function reducerInitializer({
 	lastReachedPage?: LunaticOptions['lastReachedPage'];
 	withOverview?: LunaticOptions['withOverview'];
 	disableFilters?: LunaticOptions['disableFilters'];
+	disableFiltersDescription?: LunaticOptions['disableFiltersDescription'];
 	getReferentiel?: LunaticOptions['getReferentiel'];
 	onVariableChange: RefObject<LunaticOptions['onVariableChange']>;
 	logger: LunaticLogger;
@@ -149,7 +151,7 @@ export function reducerInitializer({
 		overview: withOverview ? buildOverview(source) : [],
 		updateBindings,
 		executeExpression,
-		options: { disableFilters },
+		options: { disableFilters, disableFiltersDescription },
 	});
 }
 

package/src/use-lunatic/type.ts

@@ -179,6 +179,7 @@ export type LunaticReducerState = {
 	) => unknown;
 	options: {
 		disableFilters?: boolean;
+		disableFiltersDescription?: boolean;
 	};
 };
 
@@ -186,6 +187,10 @@ export type LunaticReducerState = {
 export type LunaticOptions = {
 	/** Ignore filters. (default: `false`) */
 	disableFilters?: boolean;
+
+	/** Disable filters description. (default: `true`) */
+	disableFiltersDescription?: boolean;
+
 	/** Enable VTL and Markdown support. */
 	features?: ('MD' | 'VTL')[];
 	preferences?: ['COLLECTED'];

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

@@ -44,6 +44,7 @@ const DEFAULT_REFUSED = D.RF;
 
 const defaultOptions = {
 	disableFilters: false,
+	disableFiltersDescription: true,
 	features: DEFAULT_FEATURES,
 	preferences: DEFAULT_PREFERENCES,
 	savingType: COLLECTED,
@@ -83,6 +84,7 @@ export function useLunatic(
 	const options = mergeDefault(argOptions, defaultOptions);
 	const {
 		disableFilters,
+		disableFiltersDescription,
 		management,
 		missing,
 		missingStrategy,
@@ -198,6 +200,7 @@ export function useLunatic(
 
 	const components = fillComponents(getComponentsFromState(state), {
 		disableFilters,
+		disableFiltersDescription,
 		handleChanges,
 		preferences,
 		goToPage,

package/src/utils/number.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { between } from './number';
+import { between, isNumberInInterval } from './number';
 
 describe('between', () => {
 	it('should work', () => {
@@ -8,3 +8,47 @@ describe('between', () => {
 		expect(between(-23.22, -5, 100)).toBe(-5);
 	});
 });
+
+describe('isNumberInInterval', () => {
+	it('allows value within range', () => {
+		expect(isNumberInInterval(25, 10, 50)).toBe(true);
+	});
+	it('disallows value above max', () => {
+		expect(isNumberInInterval(55, 10, 50)).toBe(false);
+	});
+	it('disallows value below min', () => {
+		expect(isNumberInInterval(5, 10, 50)).toBe(false);
+	});
+	it('allows negative within bounds', () => {
+		expect(isNumberInInterval(-4, -5, 0)).toBe(true);
+	});
+	it('disallows negative if min is 0 or positive', () => {
+		expect(isNumberInInterval(-1, 0, 10)).toBe(false);
+		expect(isNumberInInterval(-1, 5, 10)).toBe(false);
+	});
+	it('allows only value above min when max is undefined', () => {
+		expect(isNumberInInterval(999, 100)).toBe(true);
+		expect(isNumberInInterval(50, 100)).toBe(false);
+	});
+	it('allows only value below max when min is undefined', () => {
+		expect(isNumberInInterval(50, undefined, 100)).toBe(true);
+		// accepts negative values
+		expect(isNumberInInterval(-50, undefined, 100)).toBe(true);
+		expect(isNumberInInterval(150, undefined, 100)).toBe(false);
+	});
+	it('allows decimal value within range', () => {
+		expect(isNumberInInterval(9.99, 0, 10)).toBe(true);
+	});
+	it('disallows decimal value above max', () => {
+		expect(isNumberInInterval(10.01, 0, 10)).toBe(false);
+	});
+	it('disallows decimal value below min', () => {
+		expect(isNumberInInterval(-5.01, -5, 5)).toBe(false);
+	});
+	it('allows decimal value equal to max', () => {
+		expect(isNumberInInterval(10.0, 0, 10)).toBe(true);
+	});
+	it('allows decimal value equal to min', () => {
+		expect(isNumberInInterval(-5.0, -5, 5)).toBe(true);
+	});
+});

package/src/utils/number.ts

@@ -31,3 +31,21 @@ export function between(n: number, min: number, max: number): number {
 export function isNumber(n: unknown): n is number {
 	return typeof n === 'number' && Number.isFinite(n);
 }
+
+/** Check if a value is within an interval.
+ * Both minimum and maximum can be undefined, then we just compare with the defined bounds.
+ */
+export function isNumberInInterval(
+	value: number,
+	min?: number,
+	max?: number
+): boolean {
+	if (
+		(min !== undefined && value < min) ||
+		(max !== undefined && value > max)
+	) {
+		return false;
+	}
+
+	return true;
+}