@inseefr/lunatic 3.12.3 → 3.13.1

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

@@ -7,6 +7,13 @@ import { depth, setAtIndex } from '../../../../utils/array';
 import { castBool } from '../../../../utils/cast';
 import { IterationLevel } from '../models';
 
+type CleaningExpression = {
+	expression: string;
+	shapeFrom?: string;
+	isAggregatorUsed: boolean;
+	shouldCheckAllIterations?: boolean;
+};
+
 /**
  * Implements the cleaning behavior for the variable store.
  * When a variable changes, this function determines which other variables
@@ -130,13 +137,7 @@ function shouldClean(
 		iteration,
 		isResizing,
 	}: {
-		expressions:
-			| string
-			| {
-					expression: string;
-					shapeFrom?: string;
-					isAggregatorUsed: boolean;
-			  }[];
+		expressions: string | CleaningExpression[];
 		iteration?: number[];
 		isResizing: boolean;
 	}
@@ -156,10 +157,21 @@ function shouldClean(
 		expressions = expressions.filter((expr) => expr.isAggregatorUsed);
 	}
 
-	// If expressions have shapeFrom and we're at root level, we need to check each iteration individually
-	if (hasShapeFrom(expressions) && !iteration) {
+	// At least one expression requires to compute on each iteration
+	if (shouldCheckAtAllIterations(expressions)) {
+		const expressionsToCheckAtAllIterations: CleaningExpression[] = [];
+		const expressionsNotToCheckAtAllIterations: CleaningExpression[] = [];
+
+		for (const expression of expressions) {
+			if (expression.shouldCheckAllIterations) {
+				expressionsToCheckAtAllIterations.push(expression);
+			} else {
+				expressionsNotToCheckAtAllIterations.push(expression);
+			}
+		}
+
 		const shapeFromVariable = store.get(
-			expressions[0].shapeFrom as string
+			expressionsToCheckAtAllIterations[0].shapeFrom as string
 		) as Array<unknown>;
 
 		const shouldCleanArray = new Array(shapeFromVariable.length).fill(
@@ -167,27 +179,69 @@ function shouldClean(
 		) as Array<boolean>;
 
 		for (const [iterationIndex] of shouldCleanArray.entries()) {
-			shouldCleanArray[iterationIndex] = shouldClean(store, {
+			shouldCleanArray[iterationIndex] =
+				// check if we need to clean each iteration according to expression
+				shouldCleanAtIteration(store, {
+					expressions: expressionsToCheckAtAllIterations,
+					iteration: [iterationIndex],
+				}) ||
+				shouldCleanAtIteration(store, {
+					expressions: expressionsNotToCheckAtAllIterations,
+					iteration,
+				});
+		}
+		return shouldCleanArray;
+	}
+
+	// If expressions have shapeFrom and we're at root level, we need to check each iteration individually
+	if (expressionsHaveShapeFrom(expressions) && !iteration) {
+		const shapeFrom = findFirstExpressionWithShapeFrom(expressions)?.shapeFrom;
+		const shapeFromVariable = store.get(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] = shouldCleanAtIteration(store, {
 				expressions,
 				iteration: [iterationIndex],
-				isResizing,
-			}) as boolean;
+			});
 		}
 		return shouldCleanArray;
-	} else {
-		// Clean the variable if any condition is false (variable is not visible),
-		for (const expression of expressions) {
-			if (
-				!store.run(expression.expression, {
-					iteration,
-				})
-			)
-				return true;
-		}
+	}
 
-		// All conditions are true, no cleaning needed
-		return false;
+	return shouldCleanAtIteration(store, { expressions, iteration });
+}
+
+function shouldCheckAtAllIterations(expressions: CleaningExpression[]) {
+	return expressions.some(
+		(expression) => expression.shouldCheckAllIterations && expression.shapeFrom
+	);
+}
+
+function shouldCleanAtIteration(
+	store: LunaticVariablesStore,
+	{
+		expressions,
+		iteration,
+	}: {
+		expressions: CleaningExpression[];
+		iteration?: number[];
+	}
+) {
+	// Clean the variable if any condition is false (variable is not visible),
+	for (const expression of expressions) {
+		if (
+			!store.run(expression.expression, {
+				iteration,
+			})
+		)
+			return true;
 	}
+
+	// All conditions are true, no cleaning needed
+	return false;
 }
 
 /**
@@ -205,6 +259,10 @@ function getValueAtIteration(value: unknown, iteration?: number[]) {
 	return getValueAtIteration(value[iteration[0]], iteration.slice(1));
 }
 
+function hasShapeFrom(expression: CleaningExpression) {
+	return expression.shapeFrom !== null && expression.shapeFrom !== undefined;
+}
+
 /**
  * Checks if all expressions in the array have a shapeFrom property
  *
@@ -213,17 +271,18 @@ function getValueAtIteration(value: unknown, iteration?: number[]) {
  *
  * @returns true if all expressions have a non-null shapeFrom property
  */
-function hasShapeFrom(
+function expressionsHaveShapeFrom(
 	expressions: {
 		expression: string;
 		shapeFrom?: string;
 		isAggregatorUsed: boolean;
 	}[]
 ) {
-	return expressions.every(
-		(expression) =>
-			expression.shapeFrom !== null && expression.shapeFrom !== undefined
-	);
+	return expressions.every((expression) => hasShapeFrom(expression));
+}
+
+function findFirstExpressionWithShapeFrom(expressions: CleaningExpression[]) {
+	return expressions.find((expression) => hasShapeFrom(expression));
 }
 
 /**

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

@@ -572,6 +572,91 @@ describe('lunatic-variables-store', () => {
 			variables.set('PRENOM', ['John', 'Jane']);
 			expect(variables.get('AGE')).toEqual([null, null]);
 		});
+		it('should clean but not at every iteration when configured from an iterated source change if there is no shapeFrom provided', () => {
+			// Given
+			variables.set('PRENOM', ['Marc', 'Marc', 'Marc']);
+			variables.set('QCU', 'A');
+			cleaningBehaviour(
+				variables,
+				{
+					PRENOM: {
+						QCU: [
+							{
+								expression: 'false',
+								isAggregatorUsed: false,
+								shouldCheckAllIterations: true,
+							},
+						],
+					},
+				},
+				{ PRENOM: [], QCU: null }
+			);
+
+			// When
+			variables.set('PRENOM', 'Patrick', { iteration: [0] });
+
+			// Then
+			expect(variables.get('QCU')).toEqual(null);
+		});
+		it('should check every iteration when configured from an iterated source change', () => {
+			// Given
+			variables.set('PRENOM', ['Marc', 'Marc', 'Marc']);
+			variables.set('QCU', ['A', 'B', 'B']);
+			cleaningBehaviour(
+				variables,
+				{
+					PRENOM: {
+						QCU: [
+							{
+								expression: 'PRENOM <> "Marc"',
+								shapeFrom: 'PRENOM',
+								isAggregatorUsed: false,
+								shouldCheckAllIterations: true,
+							},
+						],
+					},
+				},
+				{ PRENOM: [], QCU: [null] }
+			);
+
+			// When
+			variables.set('PRENOM', 'Patrick', { iteration: [0] });
+
+			// Then
+			expect(variables.get('QCU')).toEqual(['A', null, null]);
+		});
+		it('should handle simultaneously expressions that should check every iteration and expression that should not ', () => {
+			// Given
+			variables.set('PRENOM', ['Marc', 'Marc', 'Marc']);
+			variables.set('QCU', ['A', 'B', 'B']);
+			cleaningBehaviour(
+				variables,
+				{
+					PRENOM: {
+						QCU: [
+							{
+								expression: 'PRENOM <> ""',
+								shapeFrom: 'PRENOM',
+								isAggregatorUsed: false,
+							},
+							{
+								expression: 'PRENOM <> "Marc"',
+								shapeFrom: 'PRENOM',
+								isAggregatorUsed: false,
+								shouldCheckAllIterations: true,
+							},
+						],
+					},
+				},
+				{ PRENOM: [], QCU: [null] }
+			);
+
+			// When
+			variables.set('PRENOM', '', { iteration: [0] });
+
+			// Then
+			expect(variables.get('QCU')).toEqual([null, null, null]);
+		});
 		it('should clean pairwise in two directions', () => {
 			variables.set('LINKS', [
 				[null, '1', '3'],