@inseefr/lunatic 3.8.1-rc.1 → 3.9.1-rc-react19.0

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

@@ -984,5 +984,111 @@ describe('lunatic-variables-store', () => {
 
 			expect(store.get('GLOBAL_ENFANTS_PRENOMS', [4])).toBe(undefined);
 		});
+
+		it('should compute correctly GLOBAL array variable across calculated variables, even if not intialize', () => {
+			// Given a source with a pairwise component
+			const pairwiseComponent = {
+				id: 'm8ob5u9l',
+				page: '3',
+				symLinks: {
+					LINKS: {
+						'1': '1',
+						'2': '3',
+						'3': '2',
+					},
+				},
+				components: [
+					{
+						id: 'm8ob5u9l-pairwise-dropdown',
+						label: {
+							type: 'VTL|MD',
+							value: '"Qui est " || yAxis || " pour " || xAxis || " ?"',
+						},
+						options: [
+							{
+								label: {
+									type: 'VTL',
+									value: '"Son conjoint, sa conjointe"',
+								},
+								value: '1',
+							},
+							{
+								label: { type: 'VTL', value: '"Sa mère, son père"' },
+								value: '2',
+							},
+							{
+								label: { type: 'VTL', value: '"Sa fille, son fils"' },
+								value: '3',
+							},
+						],
+						response: { name: 'LINKS' },
+						isMandatory: false,
+						componentType: 'Dropdown',
+						conditionFilter: {
+							type: 'VTL',
+							value: '(nvl(xAxis, "") <> "") and (nvl(yAxis, "") <> "")',
+						},
+					},
+				],
+				sourceVariables: {
+					name: 'PRENOM',
+					gender: 'SEXE',
+				},
+				componentType: 'PairwiseLinks',
+				xAxisIterations: { type: 'VTL', value: 'count(PRENOM)' },
+				yAxisIterations: { type: 'VTL', value: 'count(PRENOM)' },
+			} as ComponentDefinitionWithPage;
+
+			// When we create the store
+			const store = LunaticVariablesStore.makeFromSource(
+				{
+					components: [pairwiseComponent],
+					variables: [
+						{
+							name: 'PRENOM',
+							values: { COLLECTED: [] },
+							dimension: 1,
+							variableType: 'COLLECTED',
+							iterationReference: 'm8ob7c76',
+						},
+						{
+							name: 'SEXE',
+							values: { COLLECTED: [] },
+							dimension: 1,
+							variableType: 'COLLECTED',
+							iterationReference: 'm8ob7c76',
+						},
+						{
+							name: 'LINKS',
+							values: { COLLECTED: [[]] },
+							dimension: 2,
+							variableType: 'COLLECTED',
+							iterationReference: 'm8ob7c76',
+						},
+					],
+				},
+				{},
+				{ changeHandler: { current: () => {} } }
+			);
+
+			// When pairwise link is updated
+			store.set('PRENOM', ['Child', 'Dad']);
+			store.set('SEXE', ['1', '1']);
+			store.set('LINKS', [
+				[null, '2'],
+				['3', null],
+			]);
+			store.commit();
+			expect(
+				store.run('"Your children are : " || GLOBAL_ENFANTS_PRENOMS', {
+					iteration: [0],
+				})
+			).toBe('Your children are : null');
+			expect(
+				store.run('"Your children are : " || GLOBAL_ENFANTS_PRENOMS', {
+					iteration: [1],
+				})
+			).toBe('Your children are : Child');
+		});
 	});
 });

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

@@ -540,21 +540,28 @@ export class LunaticVariable {
 		opts: { iteration?: IterationLevel; ignoreIterationOnScalar?: boolean }
 	): boolean {
 		const { iteration, ignoreIterationOnScalar } = opts;
-		if (value === this.getSavedValue(iteration)) {
-			return false;
-		}
-		// Decompose arrays, to only update items that changed
-		if (Array.isArray(value) && !Array.isArray(iteration)) {
-			return this.setValueForArray(value);
-		}
-		// We want to save a value at a specific iteration, but the value is not an array yet
+
+		// We want to save a value at a specific iteration
+		// but the value is not an array yet
+		// we have to initialize the array even if we want to set an `null` or `undefined` value
+		// (if no, issue with getCalculatedAt that check if this.value is an array, it return global updatedValue instead of the iteration one)
 		if (iteration !== undefined && !Array.isArray(this.value)) {
 			// Ignore the iteration since the value is not an array
 			if (ignoreIterationOnScalar) {
 				return this.setValue(value, {});
 			}
+			// we have to set empty array at first before compare the with the SavedValue
 			this.value = [];
 		}
+
+		if (value === this.getSavedValue(iteration)) {
+			return false;
+		}
+		// Decompose arrays, to only update items that changed
+		if (Array.isArray(value) && !Array.isArray(iteration)) {
+			return this.setValueForArray(value);
+		}
+
 		this.value = !Array.isArray(iteration)
 			? value
 			: setAtIndex(this.value, iteration, value);
@@ -680,33 +687,21 @@ export class LunaticVariable {
 	}
 
 	public getUpdatedAt(iteration?: IterationLevel): number {
-		if (this.dimension === 0) {
-			return this.updatedAt.get(undefined) ?? 0;
-		}
 		// The value is an array, do not look at the root updatedAt if an iteration is provided
-		if (Array.isArray(this.value)) {
-			return this.updatedAt.get(iteration?.join('.')) ?? 0;
+		if (iteration !== undefined && Array.isArray(this.value)) {
+			return this.updatedAt.get(iteration.join('.')) ?? 0;
 		}
-		return (
-			this.updatedAt.get(iteration?.join('.')) ??
-			this.updatedAt.get(undefined) ??
-			0
-		);
+		// undefined key is for root level
+		return this.updatedAt.get(undefined) ?? 0;
 	}
 
 	public getCalculatedAt(iteration?: IterationLevel): number {
-		if (this.dimension === 0) {
-			return this.calculatedAt.get(undefined) ?? 0;
+		// The value is an array, do not look at the root calculatedAt if an iteration is provided
+		if (iteration !== undefined && Array.isArray(this.value)) {
+			return this.calculatedAt.get(iteration.join('.')) ?? 0;
 		}
-		// The value is an array, do not look at the root updatedAt if an iteration is provided
-		if (Array.isArray(this.value)) {
-			return this.calculatedAt.get(iteration?.join('.')) ?? 0;
-		}
-		return (
-			this.calculatedAt.get(iteration?.join('.')) ??
-			this.calculatedAt.get(undefined) ??
-			0
-		);
+		// undefined key is for root level
+		return this.calculatedAt.get(undefined) ?? 0;
 	}
 }
 

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

@@ -188,46 +188,54 @@ describe('use-lunatic()', () => {
 
 		describe('with loop', function () {
 			const data = dataFromObject({
-				ETAT: '1',
-				SATISFAIT: '1',
 				T_NHAB: 3,
 				T_PRENOM: ['Quentin', 'Luna', 'Paul'],
-				COMMCOMPO: 'super',
-				T_SEXE: ['1', '2', '1'],
-				T_DATENAIS: [null, null, null],
-				REMARQUES: [null, 'a', 'b'],
-				SUPERQUEST: ['ok', 'ok', null],
-				AUTRESUPERQUEST: ['a', 'c', 'ras'],
-				ENCOREUNEQ: ['wow', 'b', null],
-				COMMENT_QE: null,
-				ETAT_MISSING: null,
-				SATISFAIT_MISSING: null,
-				T_NHAB_MISSING: null,
-				T_PRENOM_MISSING: null,
-				COMMCOMPO_MISSING: null,
-				T_SEXE_MISSING: null,
-				T_DATENAIS_MISSING: [null, 'DK', 'RF'],
-				REMARQUES_MISSING: [null, null, null],
-				SUPERQUEST_MISSING: [null, null, 'DK'],
-				ENCOREUNEQ_MISSING: [null, null, 'RF'],
-				AUTRESUPERQUEST_MISSING: null,
-				COMMENT_QE_MISSING: null,
 			});
 
 			it('should work with loop', async () => {
 				const { result } = renderHook(() =>
 					useLunatic(sourceOverview, data, lunaticConfiguration)
 				);
-				expect(result.current.overview).toMatchSnapshot();
+
+				// 4 sequences, and we loop twice on the second one
+				expect(result.current.overview.length).toBe(5);
+				expect(result.current.overview[0].label).toBe(
+					'I - Habitants du logement'
+				);
+				expect(result.current.overview[0].page).toBe('1');
+				expect(result.current.overview[1].label).toBe(
+					'II - Boucle sur séquence pour  Luna (qui filtre la première itération)'
+				);
+				expect(result.current.overview[1].page).toBe('4.1#2');
+				expect(result.current.overview[2].label).toBe(
+					'II - Boucle sur séquence pour  Paul (qui filtre la première itération)'
+				);
+				expect(result.current.overview[2].page).toBe('4.1#3');
+
+				// 3rd sequence has only one subsequence, and we loop over it
+				expect(result.current.overview[3].children.length).toBe(2);
+				expect(result.current.overview[3].children[0].page).toBe('6.1#2');
+				expect(result.current.overview[3].children[1].page).toBe('6.1#3');
+
+				// It would be nice to test that each label is correct, currently we have issue about expression execution in subsequence in tests only.
 			});
 			it('should handle initialPage', async () => {
 				const { result } = renderHook(() =>
 					useLunatic(sourceOverview, data, {
 						...lunaticConfiguration,
-						initialPage: '10.1#1',
+						initialPage: '6.1#2',
 					})
 				);
-				expect(result.current.overview).toMatchSnapshot();
+
+				// 4 sequences, and we loop twice on the second one
+				expect(result.current.overview.length).toBe(5);
+				expect(result.current.overview[1].reached).toBe(true);
+				expect(result.current.overview[3].children[0].reached).toBe(true);
+				expect(result.current.overview[3].children[1].reached).toBe(false);
+				expect(result.current.overview[4].reached).toBe(false);
+
+				expect(result.current.overview[3].current).toBe(true);
+				expect(result.current.overview[3].children[0].current).toBe(true);
 			});
 		});
 	});