@inseefr/lunatic 3.6.1 → 3.6.3

package/src/components/shared/Checkbox/CheckboxOption.tsx

@@ -18,6 +18,7 @@ export type CheckboxOptionProps = {
 	invalid?: boolean;
 	detailAlwaysDisplayed?: boolean;
 	detailLabel?: ReactNode;
+	detailMaxLength?: number;
 	detailValue?: string | null;
 	onDetailChange?: (value: string) => void;
 };
@@ -32,6 +33,7 @@ function LunaticCheckboxOption({
 	description,
 	detailAlwaysDisplayed,
 	detailLabel,
+	detailMaxLength,
 	detailValue,
 	onDetailChange,
 	codeModality,
@@ -105,6 +107,7 @@ function LunaticCheckboxOption({
 					id="detailId"
 					label={detailLabel ?? 'Précisez :'}
 					value={typeof detailValue === 'string' ? detailValue : ''}
+					maxLength={detailMaxLength}
 					onChange={onDetailChange}
 					disabled={disabled}
 				/>

package/src/components/shared/Radio/RadioOption.tsx

@@ -38,6 +38,7 @@ function LunaticRadioOption({
 	onDetailChange,
 	detailAlwaysDisplayed,
 	detailLabel,
+	detailMaxLength,
 	detailValue,
 	onCheck,
 	onUncheck,
@@ -127,6 +128,7 @@ function LunaticRadioOption({
 					id="detailId"
 					label={detailLabel ?? 'Précisez :'}
 					value={typeof detailValue === 'string' ? detailValue : ''}
+					maxLength={detailMaxLength}
 					onChange={onDetailChange}
 					disabled={disabled}
 				/>

package/src/components/type.ts

@@ -195,8 +195,10 @@ export type ComponentPropsByType = {
 				description?: ReactNode;
 				onCheck: (b: boolean) => void;
 				onDetailChange?: (v: string) => void;
-				detailValue?: string | null;
 				detailLabel?: ReactNode;
+				detailMaxLength?: number;
+				detailValue?: string | null;
+				shouldBeFiltered?: boolean;
 			}[];
 			orientation?: 'horizontal' | 'vertical';
 			detailAlwaysDisplayed?: boolean;
@@ -251,6 +253,7 @@ export type ComponentPropsByType = {
 				description?: ReactNode;
 				label: ReactNode;
 				value: string;
+				shouldBeFiltered?: boolean;
 			}>;
 			response: { name: string };
 			componentType?: 'Dropdown';

package/src/stories/pairwise/source.json

@@ -90,7 +90,10 @@
 				{
 					"componentType": "Dropdown",
 					"id": "dropdown-1",
-					"conditionFilter": { "value": "xAxis <> yAxis", "type": "VTL" },
+					"conditionFilter": {
+						"value": "(nvl(xAxis, \"\") <> \"\") and (nvl(yAxis, \"\") <> \"\")",
+						"type": "VTL"
+					},
 					"label": {
 						"value": "\"Qui est \" || yAxis || \" pour \" || xAxis || \" ?\"",
 						"type": "VTL|MD"

package/src/stories/questionnaires/simpsons/source.json

@@ -2,6 +2,12 @@
 	"$schema": "../../../../lunatic-schema.json",
 	"componentType": "Questionnaire",
 	"variables": [
+		{
+			"variableType": "CALCULATED",
+			"expression": { "type": "VTL", "value": "\"2020\"" },
+			"name": "IGNOREDCALC",
+			"isIgnoredByLunatic": true
+		},
 		{
 			"variableType": "CALCULATED",
 			"expression": { "type": "VTL", "value": "\"2020\"" },

package/src/type.source.ts

@@ -145,6 +145,7 @@ export type ComponentCheckboxGroupDefinition = ComponentDefinitionBase & {
 		id: string;
 		detail?: {
 			label?: VTLExpression;
+			maxLength?: number;
 			response: ResponseDefinition;
 		};
 	}[];
@@ -164,6 +165,7 @@ export type OptionsWithDetail = {
 	description?: VTLExpression;
 	detail?: {
 		label: VTLExpression;
+		maxLength?: number;
 		response: {
 			name: string;
 		};
@@ -255,6 +257,7 @@ export type Variable =
 			variableType: 'CALCULATED';
 			name: string;
 			expression: VTLExpression;
+			isIgnoredByLunatic?: boolean;
 			bindingDependencies?: string[];
 			shapeFrom?: string[] | string;
 			iterationReference?: string;

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

@@ -3,17 +3,21 @@ import type {
 	LunaticVariablesStore,
 } from '../lunatic-variables-store';
 import type { LunaticSource } from '../../../type';
-import { depth } from '../../../../utils/array';
+import { depth, setAtIndex } from '../../../../utils/array';
 import { castBool } from '../../../../utils/cast';
 
 /**
- * Cleaning behaviour for the store
- * When a variable changes, other variables can be reset
+ * Implements the cleaning behavior for the variable store.
+ * When a variable changes, this function determines which other variables
+ * should be reset based on the cleaning rules defined in the source.
+ *
+ * @param store - The variables store that manages all variable values
+ * @param cleaning - Cleaning rules from the Lunatic source
+ * @param sourceValues - Default values from source.json to use when cleaning variables
  */
 export function cleaningBehaviour(
 	store: LunaticVariablesStore,
 	cleaning: LunaticSource['cleaning'],
-	// Value used as default when cleaning a variable, correspoding to value of variable in source.json (not data)
 	sourceValues: Record<string, unknown> = {}
 ) {
 	if (!cleaning) {
@@ -37,31 +41,31 @@ export function cleaningBehaviour(
 		}
 	}
 
-	// Create a map to improve performance
+	// Convert cleaning object to Map for faster lookups
 	const cleaningMap = new Map(Object.entries(cleaning));
 
 	store.on('change', (e) => {
 		const cleaningInfo = cleaningMap.get(e.detail.name);
 		const iteration = e.detail.iteration;
 
-		// The variable does not have cleaning
+		// Skip if the changed variable doesn't have any cleaning rules
 		if (!cleaningInfo) {
 			return;
 		}
 
 		for (const variableName in cleaningInfo) {
 			try {
-				// First: check if variable is already cleaned i.e, value is `null`, empty or list of `null`
+				// Skip if variable is already in a cleaned state
 				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
+				// Determine if the variable needs cleaning based on expressions
 				const shouldCleanResult = shouldClean(store, {
 					expressions: cleaningInfo[variableName],
 					iteration: iteration,
 					isResizing: e.detail.cause === 'resizing',
 				});
 
+				// Handle array variables (where we might need to clean specific indexes)
 				if (Array.isArray(shouldCleanResult)) {
 					cleanArrayVariableAccordingCondition(
 						store,
@@ -71,29 +75,51 @@ export function cleaningBehaviour(
 					);
 					continue;
 				}
+
+				// Clean regular variables if needed
 				if (shouldCleanResult)
 					cleanVariable(store, sourceValues, variableName, iteration);
 			} catch (e) {
-				// If we have an error, skip this cleaning
+				// Log error but continue processing other variables
 				console.error(e);
 			}
 		}
 	});
 }
 
-function isAlreadyCleaned(store: LunaticVariablesStore, variableName: string) {
+/**
+ * Checks if a variable is already in a cleaned state
+ *
+ * @param store - The variables store
+ * @param variableName - Name of the variable to check
+ * @returns true if the variable is null or an array of nulls
+ */
+function isAlreadyCleaned(
+	store: LunaticVariablesStore,
+	variableName: string
+): boolean {
 	const value = store.get(variableName);
 	if (Array.isArray(value)) return value.every((v) => v === null);
-	if (value === null) return true;
+	return value === null;
 }
 
 /**
- * Check if a variable need to be cleaned
+ * Determines if a variable needs to be cleaned based on expressions
+ *
+ * @param store - The variables store
+ * @param options - Configuration options
+ * @param options.expressions - Conditions that determine if cleaning should occur
+ *                             (string for legacy format or array of expression objects)
+ *                             /!\ Expressions comes from conditionFilter so it evaluates to "true"
+ *                             if the variable is visible, meaning we need to clean if the expression
+ *                             is evaluated to false.
+ * @param options.iteration - Current iteration level for the variable
+ * @param options.isResizing - Whether the cleaning is triggered by a resize operation
+ * @returns Boolean or array of booleans indicating if cleaning should occur
  */
 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,
@@ -108,8 +134,8 @@ function shouldClean(
 		iteration?: number[];
 		isResizing: boolean;
 	}
-) {
-	// Legacy cleaning used a simple string
+): boolean | boolean[] {
+	// Handle legacy format where expressions is a single string
 	if (typeof expressions === 'string') {
 		return !castBool(
 			store.run(expressions, {
@@ -118,13 +144,13 @@ function shouldClean(
 		);
 	}
 
-	// New format use tuples { expression, shapeFrom,  isAggregatorUsed }
+	// Handle a new format with expression objects shaped like this { expression, shapeFrom, isAggregatorUsed }
 	if (isResizing) {
-		// If we are resizing a variable, only run expression containing aggregators (count(), sum()...)
+		// During resize operations, only consider expressions with 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 expressions have shapeFrom and we're at root level, we need to check each iteration individually
 	if (hasShapeFrom(expressions) && !iteration) {
 		const shapeFromVariable = store.get(
 			expressions[0].shapeFrom as string
@@ -143,9 +169,8 @@ function shouldClean(
 		}
 		return shouldCleanArray;
 	} else {
-		// if only one expression is false, we have to clean (condition is display condition)
+		// Clean the variable if any condition is false (variable is not visible),
 		for (const expression of expressions) {
-			// Run the expression to check if cleaning should happen
 			if (
 				!store.run(expression.expression, {
 					iteration,
@@ -154,10 +179,16 @@ function shouldClean(
 				return true;
 		}
 
+		// All conditions are true, no cleaning needed
 		return false;
 	}
 }
 
+/**
+ * Recursively retrieves a value at a specific iteration level in a nested structure
+ *
+ * @returns The value at the specified iteration path, or null if not found
+ */
 function getValueAtIteration(value: unknown, iteration?: number[]) {
 	if (!iteration || iteration.length === 0) {
 		return value ?? null;
@@ -169,12 +200,12 @@ function getValueAtIteration(value: unknown, iteration?: number[]) {
 }
 
 /**
- * hasShapeFrom
- * actually, in cleaning modelisation,
- * all expressions have no shapeFrom or have the **same** shapeFrom
- * @param expressions
- * @returns boolean if all expression has shapeFrom
+ * Checks if all expressions in the array have a shapeFrom property
+ *
+ * In the cleaning model, all expressions either have no shapeFrom
+ * or they all have the same shapeFrom value.
  *
+ * @returns true if all expressions have a non-null shapeFrom property
  */
 function hasShapeFrom(
 	expressions: {
@@ -189,6 +220,14 @@ function hasShapeFrom(
 	);
 }
 
+/**
+ * Cleans specific elements in an array variable based on a condition array
+ *
+ * @param store - The variables store
+ * @param sourceValues - Default values from source.json
+ * @param variableName - Name of the array variable to clean
+ * @param shouldClean - Array of booleans indicating which elements should be cleaned
+ */
 function cleanArrayVariableAccordingCondition(
 	store: LunaticVariablesStore,
 	sourceValues: Record<string, unknown>,
@@ -202,10 +241,11 @@ function cleanArrayVariableAccordingCondition(
 }
 
 /**
- * cleanVariable: this function set to null (and not initalValue) the variable at iteration
- * @param store
- * @param variableName
- * @param iteration
+ * Resets a variable to its initial value at a specific iteration level
+ *
+ * This function retrieves the initial value from sourceValues and sets
+ * the variable to that value at the specified iteration. If the variable
+ * is a pairwise variable, it uses a special cleaning method to maintain symmetry.
  */
 function cleanVariable(
 	store: LunaticVariablesStore,
@@ -220,6 +260,9 @@ function cleanVariable(
 			? undefined
 			: iteration?.slice(0, depth(sourceValues[variableName]));
 
+	if (cleanPairwise(store, variableName, variableIteration)) {
+		return;
+	}
 	store.set(
 		variableName,
 		getValueAtIteration(sourceValues[variableName], variableIteration),
@@ -229,3 +272,50 @@ function cleanVariable(
 		}
 	);
 }
+
+/**
+ * Cleans a pairwise variable (2D array) at a specific iteration
+ *
+ * For pairwise variables, cleaning involves setting both the row and column
+ * at the specified index to null, maintaining the symmetry of the matrix.
+ *
+ * @returns true if the variable was a pairwise and was cleaned, false otherwise
+ */
+function cleanPairwise(
+	store: LunaticVariablesStore,
+	variableName: string,
+	iteration?: IterationLevel
+): boolean {
+	// We are not trying to clean a pairwise at a specific index
+	if (!iteration || iteration.length !== 1) {
+		return false;
+	}
+	const variableValue = store.get(variableName);
+
+	// The variable is pairwise if it's a 2D array
+	if (!Array.isArray(variableValue)) {
+		return false;
+	}
+	const variableDepth = depth(variableValue);
+	if (variableDepth !== 2) {
+		return false;
+	}
+
+	// Clean the row and the column corresponding to the index
+	store.set(
+		variableName,
+		variableValue.map((value, k) => {
+			// The value is not an array, this should not happen so we keep the original value
+			if (!Array.isArray(value)) {
+				return value;
+			}
+			// Empty the row corresponding to the index being deleted
+			if (k === iteration[0]) {
+				return value.fill(null);
+			}
+			// Nullify cells in the column corresponding to the index being deleted
+			return setAtIndex(value, iteration, null);
+		})
+	);
+	return true;
+}

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

@@ -40,7 +40,10 @@ export function getQuestionnaireData(
 
 	for (const variable of variables) {
 		// Skip calculated value if necessary
-		if (variable.variableType === 'CALCULATED' && !withCalculated) {
+		if (
+			variable.variableType === 'CALCULATED' &&
+			(variable.isIgnoredByLunatic || !withCalculated)
+		) {
 			continue;
 		}
 

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

@@ -268,7 +268,7 @@ describe('lunatic-variables-store', () => {
 			variables.run('"hello"', { iteration: [0] });
 			variables.run('"hello"', { iteration: [1] });
 			expect(variables.run('"hello"')).toEqual('hello');
-			expect(variables.interpretCount).toBe(3);
+			expect(variables.interpretCount).toBe(1); // only 1 interpretation by the engine since optimisation for primitive value
 		});
 		it('should handle deep refresh', () => {
 			variables.set('LIENS', [
@@ -543,7 +543,7 @@ describe('lunatic-variables-store', () => {
 			variables.set('READY', [true, true, false]);
 			expect(variables.get('PRENOM')).toEqual(['John', 'Jane', null]);
 		});
-		it('should evaluate cleaning for each iteration at root levl', () => {
+		it('should evaluate cleaning for each iteration at root level', () => {
 			variables.set('PRENOM', ['John', 'Jane', 'Marc']);
 			variables.set('AGE', [18, 21, 23]);
 			variables.setCalculated('NB_HAB', 'count(PRENOM)');
@@ -571,6 +571,45 @@ describe('lunatic-variables-store', () => {
 			variables.set('PRENOM', ['John', 'Jane']);
 			expect(variables.get('AGE')).toEqual([null, null]);
 		});
+		it('should clean pairwise in two directions', () => {
+			variables.set('LINKS', [
+				[null, '1', '3'],
+				['1', null, '3'],
+				['2', '2', null],
+			]);
+			variables.set('PRENOM', ['Dad', 'Mom', 'Unknow']);
+			cleaningBehaviour(
+				variables,
+				{
+					PRENOM: {
+						LINKS: [
+							{
+								expression: 'PRENOM <> ""',
+								shapeFrom: 'PRENOM',
+								isAggregatorUsed: true,
+							},
+						],
+					},
+				},
+				{
+					PRENOM: [],
+					LINKS: [],
+				}
+			);
+			variables.set('PRENOM', '', { iteration: [1] });
+			expect(variables.get('PRENOM')).toEqual(['Dad', '', 'Unknow']);
+			expect(variables.get('LINKS')).toEqual([
+				[null, null, '3'],
+				[null, null, null],
+				['2', null, null],
+			]);
+			variables.set('PRENOM', '', { iteration: [0] });
+			expect(variables.get('LINKS')).toEqual([
+				[null, null, null],
+				[null, null, null],
+				[null, null, null],
+			]);
+		});
 	});
 
 	describe('missing', () => {
@@ -657,6 +696,52 @@ describe('lunatic-variables-store', () => {
 			store.commit();
 			expect(store.get('PRENOM')).toEqual('John');
 		});
+
+		it('should handle calculated variables, ignoring them when `isIgnoredByLunatic` is true ', () => {
+			const store = LunaticVariablesStore.makeFromSource(
+				{
+					components: [],
+					variables: [
+						{
+							name: 'calc1',
+							dimension: 0,
+							expression: {
+								type: 'VTL',
+								value: '"calculated value"',
+							},
+							variableType: 'CALCULATED',
+							isIgnoredByLunatic: true,
+						},
+						{
+							name: 'calc2',
+							dimension: 0,
+							expression: {
+								type: 'VTL',
+								value: '"calculated value"',
+							},
+							variableType: 'CALCULATED',
+							isIgnoredByLunatic: false,
+						},
+						{
+							name: 'calc3',
+							dimension: 0,
+							expression: {
+								type: 'VTL',
+								value: '"calculated value"',
+							},
+							variableType: 'CALCULATED',
+						},
+					],
+				},
+				{},
+				{ current: () => {} }
+			);
+
+			expect(store.get('calc1')).toBeNull();
+			expect(store.get('calc2')).toBe('calculated value');
+			expect(store.get('calc3')).toBe('calculated value');
+		});
+
 		it('should enable cleaning when disableCleaning = false', () => {
 			const cleaningSpy = vi.spyOn(cleaningModule, 'cleaningBehaviour');
 			LunaticVariablesStore.makeFromSource(

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

@@ -88,6 +88,7 @@ export class LunaticVariablesStore {
 		for (const variable of source.variables) {
 			switch (variable.variableType) {
 				case 'CALCULATED':
+					if (variable.isIgnoredByLunatic) break;
 					store.setCalculated(variable.name, variable.expression.value, {
 						dependencies: variable.bindingDependencies,
 						iterationDepth: getIterationDepth(variable.name),
@@ -371,9 +372,16 @@ class LunaticVariable {
 
 		// Calculate bindings first to refresh "updatedAt" on calculated dependencies
 		const bindings = this.getDependenciesValues(iteration);
+		const hasNoBinding = Object.keys(bindings).length === 0;
+
+		// A static expression should not be reevaluated
+		if (hasNoBinding && this.value) {
+			return this.value;
+		}
+
 		// A variable without binding is a primitive (string, boolean...)
 		// it yields the same results for every iteration, so we can ignore iteration
-		if (Object.keys(bindings).length === 0) {
+		if (hasNoBinding) {
 			iteration = undefined;
 		}
 		if (this.shapeFrom && !this.isOutdated(iteration)) {

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

@@ -117,6 +117,94 @@ describe('getOptionsProp()', () => {
 				{ name: 'O2', value: false },
 			]);
 		});
+		it('should create detail props correctly for checkboxGroup', () => {
+			const definition = {
+				...checkboxGroupDefinition,
+				responses: [
+					{
+						label: 'Option 1',
+						response: { name: 'O1' },
+						id: 'id1',
+						detail: {
+							label: 'Precize:',
+							response: { name: 'DETAIL' },
+							maxLength: 50,
+						},
+					},
+					{
+						label: 'Option 2',
+						response: { name: 'O2' },
+						id: 'id2',
+						detail: {
+							label: 'Precize:',
+							response: { name: 'DETAILBIS' },
+						},
+					},
+				],
+			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+			variables.set('DETAIL', true);
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger
+			);
+
+			expect(options).toHaveLength(2);
+			expect(options[0].detailLabel).toBe('Precize:');
+			expect(options[1].detailLabel).toBe('Precize:');
+			expect(options[0].detailValue).toBe(true);
+			expect(options[1].detailValue).toBeNull();
+			expect(options[0].detailMaxLength).toBe(50);
+			expect(options[1].detailMaxLength).toBeUndefined();
+		});
+		it('should create detail props correctly for Radiogroup', () => {
+			const definition = {
+				...radioDefinition,
+				options: [
+					{
+						label: 'Option 1',
+						value: 'id1',
+						detail: {
+							label: 'Precize:',
+							response: { name: 'DETAIL' },
+							maxLength: 50,
+						},
+					},
+					{
+						label: 'Option 2',
+						value: 'id2',
+						detail: {
+							label: 'Precize:',
+							response: { name: 'DETAILBIS' },
+						},
+					},
+				],
+			} satisfies DeepTranslateExpression<LunaticComponentDefinition>;
+
+			variables.set('DETAIL', true);
+
+			const options = getOptionsProp(
+				definition,
+				variables,
+				mockChange,
+				undefined,
+				undefined,
+				mockLogger
+			);
+
+			expect(options).toHaveLength(2);
+			expect(options[0].detailLabel).toBe('Precize:');
+			expect(options[1].detailLabel).toBe('Precize:');
+			expect(options[0].detailValue).toBe(true);
+			expect(options[1].detailValue).toBeNull();
+			expect(options[0].detailMaxLength).toBe(50);
+			expect(options[1].detailMaxLength).toBeUndefined();
+		});
 		it('should filter responses (CheckboxGroup) with conditionFilter evaluated to false', () => {
 			const definition = {
 				...checkboxGroupDefinition,