@inseefr/lunatic 3.4.21 → 3.5.0-rc.1

package/src/type.source.ts

@@ -272,7 +272,13 @@ export type LunaticSource = {
 	suggesters?: SuggesterDefinition[];
 	cleaning?: {
 		[k: string]: {
-			[k: string]: string;
+			[k: string]:
+				| string
+				| {
+						expression: string;
+						shapeFrom?: string;
+						isAggregatorUsed: boolean;
+				  }[];
 		};
 	};
 	missingBlock?: {

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/lunatic-variables-store.spec.ts

@@ -104,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');
@@ -415,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', () => {

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. */

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

@@ -6,17 +6,18 @@ import {
 	handleChangesAction,
 } from './actions';
 import { getPageTag, isFirstLastPage } from './commons';
+
+import D from '../i18n';
+import { COLLECTED } from '../utils/constants';
+import { createLunaticProvider } from './lunatic-context';
 import type {
+	LunaticSource,
 	LunaticChangesHandler,
 	LunaticData,
 	LunaticOptions,
 	LunaticState,
 	PageTag,
 } from './type';
-import D from '../i18n';
-import { COLLECTED } from '../utils/constants';
-import { createLunaticProvider } from './lunatic-context';
-import type { LunaticSource } from './type';
 import { compileControls as compileControlsLib } from './commons/compile-controls';
 import { useLoopVariables } from './hooks/use-loop-variables';
 import { getQuestionnaireData } from './commons/variables/get-questionnaire-data';

package/src/utils/cast.ts

@@ -0,0 +1,67 @@
+/**
+ * Cast functions that force an unknown type to a specific type
+ */
+
+/**
+ * Force a number (throw if it cannot be converted)
+ */
+export function castNumber(v: unknown): number {
+	if (typeof v === 'number') {
+		return v;
+	}
+	if (typeof v === 'string') {
+		return parseInt(v, 10);
+	}
+	if (Array.isArray(v) && v.length > 0) {
+		return castNumber(v[0]);
+	}
+	throw new Error(`Cannot cast "${v}" to number`);
+}
+
+/**
+ * Force a number, with a default value if an unmanageable type is encountered
+ */
+export const castNumberWithDefault =
+	(initial: number = 0) =>
+	(v: unknown): number => {
+		try {
+			return castNumber(v);
+		} catch {
+			return initial;
+		}
+	};
+
+/**
+ * Force a bool
+ */
+export function castBool(v: unknown): boolean {
+	if (typeof v === 'boolean') {
+		return v;
+	}
+	if (Array.isArray(v) && v.length > 0) {
+		return castBool(v[0]);
+	}
+	if (Array.isArray(v)) {
+		return false;
+	}
+	return Boolean(v);
+}
+
+/**
+ * Force a string
+ */
+export function castString(v: unknown): string {
+	if (typeof v === 'string') {
+		return v;
+	}
+	if (typeof v === 'number') {
+		return v.toString();
+	}
+	if (Array.isArray(v)) {
+		return v.map(castString).join(', ');
+	}
+	if (!v) {
+		return '';
+	}
+	return v.toString();
+}