@inseefr/lunatic 3.5.0-rc.2 → 3.5.0

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

@@ -31,6 +31,16 @@ export function isPageEmpty(state: LunaticReducerState): boolean {
 		if (options.disableFilters) {
 			return true;
 		}
+
+		// The component is a paginated loop, consider it invisible if iteration size is 0
+		if ('paginatedLoop' in component && component.paginatedLoop) {
+			const iterations = state.executeExpression<number>(component.iterations);
+			if (!iterations) {
+				return false;
+			}
+		}
+
+		// Use condition filter if present
 		if ('conditionFilter' in component && component.conditionFilter) {
 			return executeConditionFilter(
 				component.conditionFilter,

package/src/use-lunatic/commons/variables/behaviours/cleaning-behaviour.ts

@@ -1,6 +1,10 @@
-import type { LunaticVariablesStore } from '../lunatic-variables-store';
+import type {
+	IterationLevel,
+	LunaticVariablesStore,
+} from '../lunatic-variables-store';
 import type { LunaticSource } from '../../../type';
 import { depth } from '../../../../utils/array';
+import { castBool } from '../../../../utils/cast';
 
 /**
  * Cleaning behaviour for the store
@@ -9,13 +13,30 @@ import { depth } from '../../../../utils/array';
 export function cleaningBehaviour(
 	store: LunaticVariablesStore,
 	cleaning: LunaticSource['cleaning'],
-	// Value used as default when cleaning a variable
-	initialValues: Record<string, unknown> = {}
+	// Value used as default when cleaning a variable, correspoding to value of variable in source.json (not data)
+	sourceValues: Record<string, unknown> = {}
 ) {
 	if (!cleaning) {
 		return;
 	}
 
+	// Create calculated variables from cleaning expressions
+	for (const source in cleaning) {
+		for (const target in cleaning[source]) {
+			if (Array.isArray(cleaning[source][target])) {
+				for (const cleaningInfo of cleaning[source][target]) {
+					store.setCalculated(
+						cleaningInfo.expression,
+						cleaningInfo.expression,
+						{
+							shapeFrom: cleaningInfo.shapeFrom,
+						}
+					);
+				}
+			}
+		}
+	}
+
 	// Create a map to improve performance
 	const cleaningMap = new Map(Object.entries(cleaning));
 
@@ -30,28 +51,28 @@ export function cleaningBehaviour(
 
 		for (const variableName in cleaningInfo) {
 			try {
-				const skipCleaning = store.run(cleaningInfo[variableName], {
-					iteration,
+				// First: check if variable is already cleaned i.e, value is `null`, empty or list of `null`
+				if (isAlreadyCleaned(store, variableName)) continue;
+				// Second: check if variable should be clean i.e one of expressions is true
+
+				// shouldClean is simple boolean or array of boolean if there have a shapeFrom
+				const shouldCleanResult = shouldClean(store, {
+					expressions: cleaningInfo[variableName],
+					iteration: iteration,
+					isResizing: e.detail.cause === 'resizing',
 				});
-				if (skipCleaning) {
+
+				if (Array.isArray(shouldCleanResult)) {
+					cleanArrayVariableAccordingCondition(
+						store,
+						sourceValues,
+						variableName,
+						shouldCleanResult
+					);
 					continue;
 				}
-
-				// Variable may be top level, so we need to deduce expected iteration
-				const variableDepth = depth(initialValues[variableName]);
-				const variableIteration =
-					variableDepth === 0
-						? undefined
-						: iteration?.slice(0, depth(initialValues[variableName]));
-
-				store.set(
-					variableName,
-					getValueAtIteration(initialValues[variableName], variableIteration),
-					{
-						iteration: variableIteration,
-						cause: 'cleaning',
-					}
-				);
+				if (shouldCleanResult)
+					cleanVariable(store, sourceValues, variableName, iteration);
 			} catch (e) {
 				// If we have an error, skip this cleaning
 				console.error(e);
@@ -60,14 +81,151 @@ export function cleaningBehaviour(
 	});
 }
 
+function isAlreadyCleaned(store: LunaticVariablesStore, variableName: string) {
+	const value = store.get(variableName);
+	if (Array.isArray(value)) return value.every((v) => v === null);
+	if (value === null) return true;
+}
+
+/**
+ * Check if a variable need to be cleaned
+ */
+function shouldClean(
+	store: LunaticVariablesStore,
+	{
+		// The expressions are a list of condition filter to display the variable, so we should clean if the filter is evaluated to false (false = variable is not visible)
+		expressions,
+		iteration,
+		isResizing,
+	}: {
+		expressions:
+			| string
+			| {
+					expression: string;
+					shapeFrom?: string;
+					isAggregatorUsed: boolean;
+			  }[];
+		iteration?: number[];
+		isResizing: boolean;
+	}
+) {
+	// Legacy cleaning used a simple string
+	if (typeof expressions === 'string') {
+		return !castBool(
+			store.run(expressions, {
+				iteration,
+			})
+		);
+	}
+
+	// New format use tuples { expression, shapeFrom,  isAggregatorUsed }
+	if (isResizing) {
+		// If we are resizing a variable, only run expression containing aggregators (count(), sum()...)
+		expressions = expressions.filter((expr) => expr.isAggregatorUsed);
+	}
+
+	// here, value has change in root scope, but we have to to check for each iteration of variable
+	if (hasShapeFrom(expressions) && !iteration) {
+		const shapeFromVariable = store.get(
+			expressions[0].shapeFrom as string
+		) as Array<unknown>;
+
+		const shouldCleanArray = new Array(shapeFromVariable.length).fill(
+			false
+		) as Array<boolean>;
+
+		for (const [iterationIndex] of shouldCleanArray.entries()) {
+			shouldCleanArray[iterationIndex] = shouldClean(store, {
+				expressions,
+				iteration: [iterationIndex],
+				isResizing,
+			}) as boolean;
+		}
+		return shouldCleanArray;
+	} else {
+		// if only one expression is false, we have to clean (condition is display condition)
+		for (const expression of expressions) {
+			// Run the expression to check if cleaning should happen
+			if (
+				!store.run(expression.expression, {
+					iteration,
+				})
+			)
+				return true;
+		}
+
+		return false;
+	}
+}
+
 function getValueAtIteration(value: unknown, iteration?: number[]) {
 	if (!iteration || iteration.length === 0) {
 		return value ?? null;
 	}
-
 	if (!Array.isArray(value)) {
 		return null;
 	}
-
 	return getValueAtIteration(value[iteration[0]], iteration.slice(1));
 }
+
+/**
+ * hasShapeFrom
+ * actually, in cleaning modelisation,
+ * all expressions have no shapeFrom or have the **same** shapeFrom
+ * @param expressions
+ * @returns boolean if all expression has shapeFrom
+ *
+ */
+function hasShapeFrom(
+	expressions: {
+		expression: string;
+		shapeFrom?: string;
+		isAggregatorUsed: boolean;
+	}[]
+) {
+	return expressions.every(
+		(expression) =>
+			expression.shapeFrom !== null && expression.shapeFrom !== undefined
+	);
+}
+
+function cleanArrayVariableAccordingCondition(
+	store: LunaticVariablesStore,
+	sourceValues: Record<string, unknown>,
+	variableName: string,
+	shouldClean: boolean[]
+) {
+	for (const [iteration, shouldCleanByIteration] of shouldClean.entries()) {
+		if (shouldCleanByIteration)
+			cleanVariable(store, sourceValues, variableName, [iteration]);
+	}
+}
+
+/**
+ * cleanVariable: this function set to null (and not initalValue) the variable at iteration
+ * @param store
+ * @param variableName
+ * @param iteration
+ */
+function cleanVariable(
+	store: LunaticVariablesStore,
+	sourceValues: Record<string, unknown>,
+	variableName: string,
+	iteration: IterationLevel | undefined
+) {
+	// Variable may be top level, so we need to deduce expected iteration
+	const variableDepth = depth(sourceValues[variableName]);
+	const variableIteration =
+		variableDepth === 0
+			? undefined
+			: iteration?.slice(0, depth(sourceValues[variableName]));
+
+	store.set(
+		variableName,
+		getValueAtIteration(sourceValues[variableName], variableIteration),
+		{
+			iteration: variableIteration,
+			cause: 'cleaning',
+		}
+	);
+}

package/src/use-lunatic/commons/variables/get-questionnaire-data.ts

@@ -13,10 +13,6 @@ export function getQuestionnaireData(
 		COLLECTED: {} as Record<
 			string,
 			{
-				EDITED: unknown;
-				FORCED: unknown;
-				INPUTTED: unknown;
-				PREVIOUS: unknown;
 				COLLECTED: unknown;
 			}
 		>,
@@ -34,10 +30,6 @@ export function getQuestionnaireData(
 				variableNames.map((name) => [
 					name,
 					{
-						EDITED: null,
-						FORCED: null,
-						INPUTTED: null,
-						PREVIOUS: null,
 						COLLECTED: store.get(name),
 					},
 				])
@@ -53,10 +45,6 @@ export function getQuestionnaireData(
 
 		if (variable.variableType === 'COLLECTED') {
 			result.COLLECTED[variable.name] = {
-				PREVIOUS: null,
-				FORCED: null,
-				EDITED: null,
-				INPUTTED: null,
 				...variable.values,
 				COLLECTED: store.get(variable.name),
 			};

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

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { cleaningBehaviour } from './behaviours/cleaning-behaviour';
+import * as cleaningModule from './behaviours/cleaning-behaviour';
 import { missingBehaviour } from './behaviours/missing-behaviour';
 import { resizingBehaviour } from './behaviours/resizing-behaviour';
 import { LunaticVariablesStore } from './lunatic-variables-store';
@@ -103,6 +104,17 @@ describe('lunatic-variables-store', () => {
 		expect(() => variables.run('Hello world')).toThrowError();
 	});
 
+	it('should handle calculated with aggregates', () => {
+		variables.set('AGES', [1, 2, 3]);
+		variables.setCalculated('NB_HAB', 'count(AGES)');
+		variables.setCalculated('AGES_PLUS_NBHAB', 'NB_HAB + AGES', {
+			shapeFrom: 'AGES',
+		});
+		expect(variables.get('NB_HAB')).toBe(3);
+		expect(variables.get('AGES_PLUS_NBHAB', [0])).toBe(4);
+		expect(variables.get('AGES_PLUS_NBHAB')).toEqual([4, 5, 6]);
+	});
+
 	describe('event listener', () => {
 		it('should trigger onChange', () => {
 			variables.set('FIRSTNAME', 'John');
@@ -414,6 +426,106 @@ describe('lunatic-variables-store', () => {
 			variables.set('READY', false, { iteration: [1] });
 			expect(variables.get('PRENOM')).toEqual(null);
 		});
+		it('should handle the new array format', () => {
+			variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+			variables.set('READY', [true, true, true]);
+			cleaningBehaviour(
+				variables,
+				{
+					READY: {
+						PRENOM: [
+							{
+								expression: 'READY',
+								shapeFrom: 'READY',
+								isAggregatorUsed: false,
+							},
+						],
+					},
+				},
+				{ PRENOM: [null] }
+			);
+			variables.set('READY', false, { iteration: [1] });
+			expect(variables.get('PRENOM')).toEqual(['John', null, 'Marc']);
+		});
+		it('should handle cleaning on aggregations', () => {
+			variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+			variables.set('READY', [true, true, true]);
+			variables.setCalculated('NB_HAB', 'count(PRENOM)');
+			cleaningBehaviour(
+				variables,
+				{
+					READY: {
+						PRENOM: [
+							{
+								expression: 'READY',
+								shapeFrom: 'READY',
+								isAggregatorUsed: false,
+							},
+							{
+								expression: 'NB_HAB > 1',
+								isAggregatorUsed: true,
+							},
+						],
+					},
+				},
+				{ PRENOM: [null] }
+			);
+			variables.set('READY', false, { iteration: [1], cause: 'resizing' });
+			expect(variables.get('PRENOM')).toEqual(['John', 'Jane', 'Marc']);
+			variables.set('PRENOM', ['John'], { cause: 'resizing' });
+			variables.set('READY', [true], { cause: 'resizing' });
+			expect(variables.get('PRENOM')).toEqual([null]);
+		});
+
+		it('should evaluate cleaning for each iteration', () => {
+			variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+			variables.set('READY', [true, true, true]);
+			cleaningBehaviour(
+				variables,
+				{
+					READY: {
+						PRENOM: [
+							{
+								expression: 'READY',
+								shapeFrom: 'READY',
+								isAggregatorUsed: false,
+							},
+						],
+					},
+				},
+				{ PRENOM: [null] }
+			);
+			variables.set('READY', [true, true, false]);
+			expect(variables.get('PRENOM')).toEqual(['John', 'Jane', null]);
+		});
+		it('should evaluate cleaning for each iteration at root levl', () => {
+			variables.set('PRENOM', ['John', 'Jane', 'Marc']);
+			variables.set('AGE', [18, 21, 23]);
+			variables.setCalculated('NB_HAB', 'count(PRENOM)');
+			resizingBehaviour(variables, {
+				PRENOM: {
+					size: 'count(PRENOM)',
+					variables: ['AGE'],
+				},
+			});
+			cleaningBehaviour(
+				variables,
+				{
+					PRENOM: {
+						AGE: [
+							{
+								expression: 'NB_HAB >= 3',
+								shapeFrom: 'PRENOM',
+								isAggregatorUsed: true,
+							},
+						],
+					},
+				},
+				{ PRENOM: [], AGE: [] }
+			);
+			variables.set('PRENOM', ['John', 'Jane']);
+			expect(variables.get('AGE')).toEqual([null, null]);
+		});
 	});
 
 	describe('missing', () => {
@@ -449,10 +561,6 @@ describe('lunatic-variables-store', () => {
 						{
 							name: 'PRENOM',
 							values: {
-								EDITED: null,
-								FORCED: null,
-								INPUTTED: null,
-								PREVIOUS: null,
 								COLLECTED: 'John',
 							},
 							variableType: 'COLLECTED',
@@ -460,10 +568,6 @@ describe('lunatic-variables-store', () => {
 						{
 							name: 'NOM',
 							values: {
-								EDITED: null,
-								FORCED: null,
-								INPUTTED: null,
-								PREVIOUS: null,
 								COLLECTED: '',
 							},
 							variableType: 'COLLECTED',
@@ -488,5 +592,83 @@ describe('lunatic-variables-store', () => {
 			store.set('NOM', 'Doe');
 			expect(store.get('PRENOM')).toEqual('John');
 		});
+		it('should enable cleaning when disableCleaning = false', () => {
+			const cleaningSpy = vi.spyOn(cleaningModule, 'cleaningBehaviour');
+			LunaticVariablesStore.makeFromSource(
+				{
+					components: [],
+					variables: [
+						{
+							name: 'PRENOM',
+							values: {
+								COLLECTED: 'John',
+							},
+							variableType: 'COLLECTED',
+						},
+						{
+							name: 'NOM',
+							values: {
+								COLLECTED: '',
+							},
+							variableType: 'COLLECTED',
+						},
+					],
+					cleaning: {
+						NOM: {
+							PRENOM: 'false',
+						},
+					},
+				},
+				{
+					COLLECTED: {
+						PRENOM: {
+							COLLECTED: 'Jane',
+						},
+					},
+				},
+				{ current: () => {} },
+				false // enable cleaning
+			);
+			expect(cleaningSpy).toHaveBeenCalled();
+		});
+		it('should disable cleaning when disableCleaning = true', () => {
+			const cleaningSpy = vi.spyOn(cleaningModule, 'cleaningBehaviour');
+			LunaticVariablesStore.makeFromSource(
+				{
+					components: [],
+					variables: [
+						{
+							name: 'PRENOM',
+							values: {
+								COLLECTED: 'John',
+							},
+							variableType: 'COLLECTED',
+						},
+						{
+							name: 'NOM',
+							values: {
+								COLLECTED: '',
+							},
+							variableType: 'COLLECTED',
+						},
+					],
+					cleaning: {
+						NOM: {
+							PRENOM: 'false',
+						},
+					},
+				},
+				{
+					COLLECTED: {
+						PRENOM: {
+							COLLECTED: 'Jane',
+						},
+					},
+				},
+				{ current: () => {} },
+				true // disable cleaning
+			);
+			expect(cleaningSpy).not.toHaveBeenCalled();
+		});
 	});
 });

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

@@ -24,7 +24,7 @@ let interpretCount = 0;
 /** Special variable that will take the current iteration value. */
 const iterationVariableName = 'GLOBAL_ITERATION_INDEX';
 
-type IterationLevel = number[];
+export type IterationLevel = number[];
 export type EventArgs = {
 	change: {
 		/** Name of the changed variable. */
@@ -54,13 +54,14 @@ export class LunaticVariablesStore {
 	public static makeFromSource(
 		source: LunaticSource,
 		data: LunaticData,
-		changeHandler: RefObject<LunaticOptions['onVariableChange']>
+		changeHandler: RefObject<LunaticOptions['onVariableChange']>,
+		disableCleaning?: boolean
 	) {
 		const store = new LunaticVariablesStore();
 		if (!source.variables) {
 			return store;
 		}
-		// Source data (picked from "variables" in the source.json)
+		// Source data (picked from "variables" in the source.json)s
 		const sourceValues: Record<string, unknown> = {};
 		// Starting data for the form (merged with data.json or injected data)
 		const initialValues: Record<string, unknown> = {};
@@ -90,7 +91,9 @@ export class LunaticVariablesStore {
 			}
 		}
 		store.on('change', (e) => changeHandler?.current?.(e.detail));
-		cleaningBehaviour(store, source.cleaning, sourceValues);
+		if (!disableCleaning) {
+			cleaningBehaviour(store, source.cleaning, sourceValues);
+		}
 		resizingBehaviour(store, source.resizing);
 		missingBehaviour(store, source.missingBlock);
 		return store;