@inseefr/lunatic 3.13.5-rc.4 → 3.13.5

package/src/stories/questionnaires/SRCV/srcv.stories.tsx

@@ -0,0 +1,23 @@
+import {
+	type Orchestrator,
+	OrchestratorMeta,
+	type OrchestratorStory,
+} from '../../utils/Orchestrator';
+import source from './source.json';
+import interrogation from './data.json';
+import { Meta } from '@storybook/react';
+
+const meta: Meta<typeof Orchestrator> = {
+	title: 'Questionnaires/SRCV',
+	...OrchestratorMeta,
+};
+
+export default meta;
+
+export const Default: OrchestratorStory = {
+	args: {
+		source,
+		data: interrogation.data,
+		initialPage: '179',
+	},
+};

package/src/use-lunatic/commons/compile-controls.spec.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { LunaticReducerState } from '../type';
+import type { ComponentDefinition, InterpretedComponent } from './component';
+import { computeIterations } from './compile-controls';
+
+// Mock de la fonction executeExpression
+const mockExecuteExpression =
+	vi.fn() as unknown as LunaticReducerState['executeExpression'] &
+		ReturnType<typeof vi.fn>;
+
+describe('computeIterations', () => {
+	beforeEach(() => {
+		vi.resetAllMocks();
+	});
+
+	it('should return iterations directly if it is a number', () => {
+		const component = {
+			id: 'test',
+			componentType: 'Loop',
+			iterations: 5,
+		} as InterpretedComponent;
+		expect(computeIterations(component, mockExecuteExpression)).toBe(5);
+	});
+
+	it('should execute VTL expression for iterations if it is an object', () => {
+		const component = {
+			id: 'test',
+			componentType: 'Loop',
+			iterations: { type: 'VTL', value: 'count(ARRAY)' },
+		} as ComponentDefinition;
+		mockExecuteExpression.mockReturnValue(3);
+		expect(computeIterations(component, mockExecuteExpression)).toBe(3);
+		expect(mockExecuteExpression).toHaveBeenCalledWith({
+			type: 'VTL',
+			value: 'count(ARRAY)',
+		});
+	});
+
+	it('should return array length if component has a response with an array value', () => {
+		const component = {
+			id: 'test',
+			componentType: 'Question',
+			response: { name: 'ARRAY' },
+		} as unknown as ComponentDefinition;
+		mockExecuteExpression.mockReturnValue(['a', 'b', 'c', 'd']);
+		expect(computeIterations(component, mockExecuteExpression)).toBe(4);
+		expect(mockExecuteExpression).toHaveBeenCalledWith({
+			type: 'VTL',
+			value: 'ARRAY',
+		});
+	});
+
+	it('should return 0 if response value is not an array', () => {
+		const component: ComponentDefinition = {
+			id: 'test',
+			componentType: 'Question',
+			response: { name: 'VAR' },
+		} as unknown as ComponentDefinition;
+		mockExecuteExpression.mockReturnValue('not an array');
+		expect(computeIterations(component, mockExecuteExpression)).toBe(0);
+	});
+
+	it('should return max iterations of children if component has components', () => {
+		const component: ComponentDefinition = {
+			id: 'parent',
+			componentType: 'Loop',
+			components: [
+				{ id: 'child1', componentType: 'Question', iterations: 2 },
+				{ id: 'child2', componentType: 'Question', iterations: 5 },
+			],
+		} as unknown as ComponentDefinition;
+		expect(computeIterations(component, mockExecuteExpression)).toBe(5);
+	});
+
+	it('should return 0 if no iterations, response, or components are present', () => {
+		const component: ComponentDefinition = {
+			id: 'test',
+			componentType: 'Question',
+		} as unknown as ComponentDefinition;
+		expect(computeIterations(component, mockExecuteExpression)).toBe(0);
+	});
+
+	it('should return 0 if iterations is null or undefined', () => {
+		const component1: ComponentDefinition = {
+			id: 'test1',
+			componentType: 'Loop',
+			iterations: null as unknown as number,
+		} as unknown as ComponentDefinition;
+		const component2: ComponentDefinition = {
+			id: 'test2',
+			componentType: 'Loop',
+			iterations: undefined as unknown as number,
+		} as unknown as ComponentDefinition;
+		expect(computeIterations(component1, mockExecuteExpression)).toBe(0);
+		expect(computeIterations(component2, mockExecuteExpression)).toBe(0);
+	});
+
+	it('should return 0 if all children have no iterations', () => {
+		const component: ComponentDefinition = {
+			id: 'parent',
+			componentType: 'Loop',
+			components: [
+				{ id: 'child1', componentType: 'Question' },
+				{ id: 'child2', componentType: 'Question' },
+			],
+		} as unknown as ComponentDefinition;
+		expect(computeIterations(component, mockExecuteExpression)).toBe(0);
+	});
+
+	it('should prioritize iterations over response if both are present', () => {
+		const component: ComponentDefinition = {
+			id: 'test',
+			componentType: 'Loop',
+			iterations: 3,
+			response: { name: 'ARRAY' },
+		} as unknown as ComponentDefinition;
+		mockExecuteExpression.mockReturnValue(['a', 'b', 'c', 'd', 'e']);
+		expect(computeIterations(component, mockExecuteExpression)).toBe(3);
+		expect(mockExecuteExpression).not.toHaveBeenCalled();
+	});
+
+	it('should prioritize iterations expression over response if both are present', () => {
+		const component: ComponentDefinition = {
+			id: 'test',
+			componentType: 'Loop',
+			iterations: { type: 'VTL', value: 'count(ARRAY)' },
+			response: { name: 'ANOTHER_ARRAY' },
+		} as unknown as ComponentDefinition;
+		mockExecuteExpression.mockReturnValue(7);
+		expect(computeIterations(component, mockExecuteExpression)).toBe(7);
+		expect(mockExecuteExpression).toHaveBeenCalledWith({
+			type: 'VTL',
+			value: 'count(ARRAY)',
+		});
+	});
+});

package/src/use-lunatic/commons/compile-controls.ts

@@ -115,10 +115,14 @@ function checkControls(
 /**
  * Figure out the number of iterations of a component.
  */
-function computeIterations(
+export function computeIterations(
 	component: InterpretedComponent | ComponentDefinition,
 	executeExpression: LunaticReducerState['executeExpression']
 ): number {
+	// iterations is present and it's already computed, return the actual value (case of InterpretedComponent)
+	if ('iterations' in component && typeof component.iterations === 'number')
+		return component.iterations;
+	// iteratons is present and it's an expression, compute it
 	if (
 		'iterations' in component &&
 		component.iterations &&
@@ -127,6 +131,8 @@ function computeIterations(
 	) {
 		return executeExpression<number>(component.iterations);
 	}
+
+	// Fallback to variable collectes by this component, return it's length
 	if ('response' in component) {
 		const value = executeExpression({
 			type: 'VTL',

package/src/utils/getArticulationState.ts

@@ -9,6 +9,7 @@ import { type ReactNode } from 'react';
 import { times } from './array';
 import { forceInt } from './number';
 import { isRoundaboutComponent } from '../use-lunatic/commons/component';
+import { castNumber } from './cast';
 
 export enum ArticulationState {
 	COMPLETED = 1,
@@ -70,13 +71,26 @@ export function getArticulationState(
 	source: LunaticSource & { articulation: Articulation },
 	data: LunaticData
 ): { items: Item[] } {
+	if (!source.articulation) {
+		return {
+			items: [],
+		};
+	}
+
 	const roundabout = findComponentById(
 		source.components,
 		source.articulation.source
 	);
+
+	if (!roundabout) {
+		return {
+			items: [],
+		};
+	}
+
 	const { variables } = reducerInitializer({ source, data });
-	const iterations = forceInt(
-		variables.run(roundabout?.iterations.value ?? '0')
+	const iterations = castNumber(
+		variables.run(roundabout.iterations.value ?? '0')
 	);
 
 	const rows = times(iterations, (k) =>
@@ -86,12 +100,6 @@ export function getArticulationState(
 		}))
 	);
 
-	if (!roundabout) {
-		return {
-			items: [],
-		};
-	}
-
 	return {
 		items: rows.map((row, k) => ({
 			cells: row,