@inseefr/lunatic 3.4.4 → 3.4.5-rc.0

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

@@ -0,0 +1,99 @@
+import type {
+	LunaticChangesHandler,
+	LunaticComponentDefinition,
+	LunaticState,
+} from '../type';
+import type { ReactNode } from 'react';
+import type { DeepTranslateExpression } from '../commons/fill-components/fill-component-expressions';
+import { isNumber } from '../../utils/number';
+import type { LunaticVariablesStore } from '../commons/variables/lunatic-variables-store';
+
+export type InterpretedOption = {
+	label: ReactNode;
+	value?: string;
+	checked?: boolean;
+	detailLabel?: ReactNode;
+	description?: ReactNode;
+	detailValue?: string | null;
+	onDetailChange?: (value: string) => void;
+	onCheck?: () => void;
+};
+
+/**
+ * Compute options for checkboxes / radios
+ */
+export function getOptionsProp(
+	definition: DeepTranslateExpression<LunaticComponentDefinition>,
+	variables: LunaticVariablesStore,
+	handleChanges: LunaticChangesHandler,
+	pagerIteration: LunaticState['pager']['iteration'],
+	value: unknown
+) {
+	const iteration = isNumber(pagerIteration) ? [pagerIteration] : undefined;
+	//const iteration = pagerIteration ? [pagerIteration] : undefined;
+
+	if (definition.componentType === 'CheckboxGroup') {
+		return definition.responses
+			.filter((response) => {
+				if (!response.conditionFilter) {
+					return true;
+				}
+				return variables.run(response.conditionFilter.value, { iteration });
+			})
+			.map((response) => ({
+				label: response.label,
+				name: response.response.name,
+				id: response.id,
+				checked: !!variables.get(response.response.name, iteration),
+				description: response.description,
+				detailLabel: response.detail?.label,
+				detailValue: response.detail?.response
+					? variables.get(response.detail.response.name, iteration)
+					: undefined,
+				onCheck: (checked: boolean) => {
+					handleChanges([{ name: response.response.name, value: checked }]);
+				},
+				onDetailChange: response.detail?.response
+					? (v: string) => {
+							handleChanges([
+								{ name: response.detail!.response.name, value: v },
+							]);
+						}
+					: undefined,
+			}));
+	}
+
+	if (!('options' in definition)) {
+		return [];
+	}
+
+	return definition.options
+		.filter((option) => {
+			if (!('conditionFilter' in option) || !option.conditionFilter) {
+				return true;
+			}
+			return variables.run(option.conditionFilter.value, { iteration });
+		})
+		.map((option) => ({
+			label: option.label,
+			description: option.description,
+			value: option.value,
+			checked: value === option.value,
+			detailLabel: 'detail' in option ? option.detail?.label : undefined,
+			onCheck: () => {
+				handleChanges([
+					{ name: definition.response.name, value: option.value },
+				]);
+			},
+			detailValue:
+				'detail' in option && option.detail
+					? variables.get(option.detail.response.name, iteration)
+					: null,
+			onDetailChange:
+				'detail' in option && option.detail
+					? (value: string) => {
+							handleChanges([{ name: option.detail!.response.name, value }]);
+						}
+					: null,
+		}));
+}

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

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { getValueProp } from './propValue';
+import type { LunaticComponentDefinition } from '../type';
+import { LunaticVariablesStore } from '../commons/variables/lunatic-variables-store';
+import { times } from '../../utils/array';
+
+describe('fillComponentValue', () => {
+	// Helper to avoid repetition
+	const expectFilledComponent = (
+		component: LunaticComponentDefinition,
+		// Value in the lunatic state
+		values: Record<string, unknown> = {},
+		// Pager iteration
+		iteration?: number
+	) => {
+		return expect(
+			getValueProp(component, {
+				variables: LunaticVariablesStore.makeFromObject(values),
+				pager: {
+					maxPage: 2,
+					page: 1,
+					iteration,
+				},
+			})
+		);
+	};
+
+	describe('response', () => {
+		const component = {
+			response: { name: 'PRENOM' },
+		} as LunaticComponentDefinition<'Input'>;
+
+		it('Should work with simple response', () => {
+			expectFilledComponent(component, { PRENOM: 'John' }).toBe('John');
+			expectFilledComponent(component).toBe(null);
+		});
+
+		it('Should work with simple response as Array', () => {
+			expectFilledComponent(component, { PRENOM: ['John', 'Renaud'] }, 1).toBe(
+				'Renaud'
+			);
+			expectFilledComponent(component, { PRENOM: ['John', 'Renaud'] }, 3).toBe(
+				undefined
+			);
+		});
+	});
+	describe('responses', () => {
+		const component = {
+			responses: times(3, (k) => ({
+				response: { name: `NAME${k}` },
+			})),
+		} as LunaticComponentDefinition<'CheckboxGroup'>;
+
+		it('should work with multiple responses', () => {
+			expectFilledComponent(component).toEqual({
+				NAME0: null,
+				NAME1: null,
+				NAME2: null,
+			});
+			expectFilledComponent(component, { NAME1: true }).toEqual({
+				NAME0: null,
+				NAME1: true,
+				NAME2: null,
+			});
+		});
+	});
+});

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

@@ -0,0 +1,40 @@
+import { isNumber } from '../../utils/number';
+import { hasResponse, hasResponses } from '../commons/component';
+import type { LunaticComponentDefinition, LunaticPager } from '../type';
+import type { LunaticVariablesStore } from '../commons/variables/lunatic-variables-store';
+
+export function getValueProp(
+	component: LunaticComponentDefinition,
+	args: {
+		pager: LunaticPager;
+		variables: LunaticVariablesStore;
+	}
+): unknown {
+	let iteration = isNumber(args.pager.iteration)
+		? [args.pager.iteration]
+		: undefined;
+	if (args.pager.linksIterations) {
+		iteration = args.pager.linksIterations;
+	}
+	if (hasResponses(component)) {
+		return Object.fromEntries(
+			component.responses?.map(({ response }) => [
+				response.name,
+				args.variables.get(response.name, iteration),
+			]) ?? []
+		);
+	}
+	if (hasResponse(component)) {
+		return args.variables.get(component.response.name, iteration);
+	}
+	// For loop, value will be a map of child component values
+	if ('components' in component) {
+		return Object.fromEntries(
+			component.components
+				.map((c) => ('response' in c ? c.response.name : null))
+				.filter((name) => name !== null)
+				.map((name) => [name, args.variables.get(name!)])
+		);
+	}
+	return null;
+}

package/src/use-lunatic/reducer/commons/auto-explore-loop.ts

@@ -0,0 +1,68 @@
+import type { LunaticReducerState } from '../../type';
+import { getPageId, pageStringToNumbers } from '../../commons/page';
+
+/**
+ * Update the pager to enter a loop if the pager is on a loop
+ */
+export function autoExploreLoop(
+	state: LunaticReducerState,
+	direction: 'forward' | 'backward' = 'forward'
+): LunaticReducerState {
+	const newPager = {
+		...state.pager,
+	};
+	const pageId = getPageId(newPager);
+	const page = state.pages[pageId];
+	let hasExploredLoop = false;
+	const isForward = direction === 'forward';
+
+	const goInsideSubpage = (subPages: string[], nbIteration: number) => {
+		// For empty loop jump to the next page
+		if (nbIteration === 0) {
+			newPager.page += isForward ? 1 : -1;
+			hasExploredLoop = true;
+			return;
+		}
+		const maxSubPage = subPages.length;
+		const firstSubPage = pageStringToNumbers(
+			subPages[isForward ? 0 : maxSubPage - 1]
+		);
+		newPager.page = firstSubPage[0];
+		newPager.subPage = firstSubPage[1] - 1; // Subpage starts at 0
+		newPager.nbSubPages = maxSubPage;
+		newPager.nbIterations = nbIteration;
+		newPager.iteration = isForward ? 0 : newPager.nbIterations - 1;
+		hasExploredLoop = true;
+	};
+
+	// The page is a loop
+	if (page.isLoop && page.subPages && page.subPages.length > 0) {
+		goInsideSubpage(
+			page.subPages,
+			state.executeExpression<number>(page.iterations)
+		);
+	}
+
+	// The page contains a roundabout, go to the first iteration if it only has one iteration
+	if (
+		page.components[0].componentType === 'Roundabout' &&
+		page.subPages &&
+		page.subPages.length > 0
+	) {
+		const nbIterations = state.executeExpression<number>(page.iterations);
+		if (nbIterations === 1) {
+			goInsideSubpage(page.subPages, 1);
+		}
+	}
+
+	// No loop were explored, don't mutate the state
+	if (!hasExploredLoop) {
+		return state;
+	}
+
+	return {
+		...state,
+		isInLoop: newPager.nbIterations !== undefined,
+		pager: newPager,
+	};
+}

package/src/use-lunatic/reducer/commons/resize-array-variable.ts

@@ -0,0 +1,28 @@
+/**
+ * Cast the variable into an array and adjust the length if necessary
+ */
+function resizeArrayVariable<T = unknown>(
+	array: unknown,
+	length: number,
+	defaultValue?: T
+): T[] {
+	if (!Array.isArray(array)) {
+		// create the array
+		return new Array(length).fill(defaultValue);
+	} else if (array.length !== length) {
+		// renew array end keep previous values
+		return new Array(length).fill(defaultValue).reduce(function (
+			step,
+			current,
+			index
+		) {
+			if (index < array.length) {
+				return [...step, array[index]];
+			}
+			return [...step, current];
+		}, []);
+	}
+	return array;
+}
+
+export default resizeArrayVariable;

package/src/use-lunatic/reducer/commons/validate-condition-filter.ts

@@ -0,0 +1,21 @@
+import { executeConditionFilter } from '../../commons';
+import type { LunaticReducerState } from '../../type';
+
+function validateLoopConditionFilter(
+	state: Pick<LunaticReducerState, 'pages' | 'executeExpression'>,
+	{ next, iteration }: { next: string; iteration?: number }
+): boolean {
+	const { pages, executeExpression } = state;
+	const { components } = pages[next];
+	const [loop] = components;
+	if (loop && 'conditionFilter' in loop && loop.conditionFilter) {
+		return !!executeConditionFilter(
+			loop.conditionFilter,
+			executeExpression,
+			iteration
+		);
+	}
+	return true;
+}
+
+export { validateLoopConditionFilter };

package/src/use-lunatic/reducer/controls/check-base-control.ts

@@ -0,0 +1,47 @@
+import { type ReactNode } from 'react';
+import type {
+	LunaticControl,
+	LunaticError,
+	LunaticReducerState,
+} from '../../type';
+
+export function checkBaseControl(
+	controlItem: LunaticControl,
+	executeExpression: LunaticReducerState['executeExpression'],
+	pager: LunaticReducerState['pager']
+): LunaticError | undefined {
+	const { iteration, linksIterations } = pager;
+	const { criticality, errorMessage, id, typeOfControl, control } = controlItem;
+
+	// There is no control expression for this control (this is unexpected)
+	if (!control) {
+		return undefined;
+	}
+
+	const result = executeExpression(control, {
+		iteration: linksIterations ?? iteration,
+	});
+
+	try {
+		/**
+		 * Currently, the controls are lifted when the condition is false.
+		 * An evolution is planned on the questionnaire generation side (Eno) to come back to a more coherent logic (i.e. lift the control when the condition is true)
+		 *
+		 * After this change, we have to change the next line to `if (!result) return undefined;`
+		 */
+		if (result) return undefined;
+
+		const label = executeExpression<ReactNode>(errorMessage, {
+			iteration,
+		});
+		return {
+			criticality,
+			errorMessage: label,
+			id,
+			typeOfControl,
+		};
+	} catch {
+		console.warn(`Error on validating control ${control.value}`);
+		return undefined;
+	}
+}

package/src/use-lunatic/reducer/controls/check-roundabout-control.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from 'react';
+import type {
+	LunaticControl,
+	LunaticError,
+	LunaticReducerState,
+} from '../../type';
+
+/**
+ * Pour le Roundabout, le controle doit être validé pour chaque itération
+ * composants l'unité enquêtée.
+ * Itération prend pour valeur le rang de l'unité stat au sein de l'unité enquêté.
+ * Le rondpoint ne peut pas être placé dans une boucle car l'itération est effacée.
+ * TODO intégrer cela dans le cadre de boucle de boucle.
+ */
+export function checkRoundaboutControl(
+	control: LunaticControl,
+	executeExpression: LunaticReducerState['executeExpression']
+): LunaticError | undefined {
+	const { criticality, errorMessage, id, typeOfControl, iterations } = control;
+
+	if (!(typeof iterations === 'number') || iterations <= 0) {
+		return undefined;
+	}
+
+	const errors = Array.from({ length: iterations }, (_, k) => k)
+		// There is an error if the control is evaluated to "true"
+		.filter(
+			(iteration) =>
+				control.control && !executeExpression(control.control, { iteration })
+		)
+		.map((iteration) =>
+			executeExpression<ReactNode>(errorMessage, { iteration })
+		);
+
+	if (errors.length) {
+		return { criticality, errorMessage: errors, id, typeOfControl };
+	}
+
+	return undefined;
+}

package/src/use-lunatic/reducer/overview/overviewOnInit.ts

@@ -0,0 +1,74 @@
+import type {
+	LunaticComponentDefinition,
+	LunaticOverviewItem,
+} from '../../type';
+import type { LunaticSource } from '../../type';
+import type { ItemOf } from '../../../type.utils';
+
+/**
+ * Resolve overview items from component definition
+ */
+function overviewFromComponent(
+	items: LunaticOverviewItem[],
+	component: ItemOf<LunaticSource['components']>,
+	extra: Partial<LunaticOverviewItem> = {}
+): LunaticOverviewItem[] {
+	// For loop we need to explore Subsequence inside the loop
+	if (
+		component.componentType === 'Loop' ||
+		component.componentType === 'Roundabout'
+	) {
+		return overviewFromLoop(items, component);
+	}
+
+	// Only consider Sequence / Subsequence as potential overview item
+	if (
+		(component.componentType === 'Subsequence' ||
+			component.componentType === 'Sequence') &&
+		component.label
+	) {
+		const page = 'page' in component ? component.page : component.goToPage;
+		const parts = page.split('.');
+		items.push({
+			id: component.id,
+			type: component.componentType,
+			pageTag: page,
+			page: parseInt(parts[0], 10),
+			label: component.label,
+			description: component.description,
+			conditionFilter: component.conditionFilter,
+			...extra,
+		});
+	}
+
+	return items;
+}
+
+/**
+ * Resolve subcomponents of a loop
+ */
+function overviewFromLoop(
+	items: LunaticOverviewItem[],
+	component: LunaticComponentDefinition<'Loop' | 'Roundabout'>
+): LunaticOverviewItem[] {
+	// Since we don't know how many iterations we have, skip this component
+	if (!('iterations' in component)) {
+		return items;
+	}
+	for (const child of component.components as LunaticSource['components']) {
+		items = overviewFromComponent(items, child, {
+			iterations: component.iterations,
+		});
+	}
+	return items;
+}
+
+/**
+ * Build a static overview from the state, this overview will be interpreted on page change
+ */
+export function buildOverview(source: LunaticSource): LunaticOverviewItem[] {
+	return source.components.reduce(
+		(acc, c) => overviewFromComponent(acc, c),
+		[] as LunaticOverviewItem[]
+	);
+}

package/src/use-lunatic/reducer/reduce-go-next-page.ts

@@ -0,0 +1,72 @@
+import { getNewReachedPage } from '../commons';
+import { getPageId, isPageEmpty } from '../commons/page';
+import { getNextPager } from '../commons/page-navigation';
+import type { LunaticReducerState } from '../type';
+import { autoExploreLoop } from './commons/auto-explore-loop';
+import { reduceHandleChanges } from './reduce-handle-changes';
+import { ActionKind } from '../actions';
+
+export function reduceGoNextPage(
+	state: LunaticReducerState
+): LunaticReducerState {
+	const { pages, pager } = state;
+	const parentType = pages[pager.page]?.components[0].componentType;
+	const nextPager = getNextPager(pager, parentType);
+	const pageId = getPageId(nextPager);
+
+	if (!pages[pageId]) {
+		throw new Error(`Cannot reach next page ${pageId}`);
+	}
+
+	let newState = { ...state, pager: nextPager };
+
+	// We reached an empty page, move forward
+	if (isPageEmpty(newState)) {
+		return reduceGoNextPage(newState);
+	}
+
+	// If we reached a loop, go inside
+	newState = autoExploreLoop(newState, 'forward');
+
+	// We explored a loop, check if we reached an empty page, move forward
+	if (newState.pager !== nextPager && isPageEmpty(newState)) {
+		return reduceGoNextPage(newState);
+	}
+
+	// We moved up, and we are on a roundabout, update the progress variable
+	if (
+		// We moved up
+		newState.pager.page === newState.previousPager.page &&
+		newState.pager.subPage === undefined &&
+		newState.previousPager.iteration !== undefined &&
+		// We are on a roundabout
+		newState.pages[newState.pager.page].components.length > 0
+	) {
+		// Split the condition to infer variable type
+		const firstComponent = newState.pages[newState.pager.page].components[0];
+		if (firstComponent.componentType === 'Roundabout') {
+			newState = reduceHandleChanges(newState, {
+				type: ActionKind.HANDLE_CHANGES,
+				payload: {
+					responses: [
+						{
+							name: firstComponent.progressVariable,
+							value: 1,
+							iteration: [newState.previousPager.iteration],
+						},
+					],
+				},
+			});
+		}
+	}
+
+	return {
+		...newState,
+		isInLoop: newState.pager.iteration !== undefined,
+		previousPager: state.pager,
+		pager: {
+			...newState.pager,
+			lastReachedPage: getNewReachedPage(newState.pager),
+		},
+	};
+}

package/src/use-lunatic/reducer/reduce-go-previous-page.ts

@@ -0,0 +1,39 @@
+import { getPrevPager } from '../commons/page-navigation';
+import { autoExploreLoop } from './commons/auto-explore-loop';
+import { getPageId, isPageEmpty } from '../commons/page';
+import type { LunaticReducerState } from '../type';
+
+export function reduceGoPreviousPage(
+	state: LunaticReducerState
+): LunaticReducerState {
+	const { pages, pager } = state;
+	const parentType = pages[pager.page]?.components[0].componentType;
+	const prevPager = getPrevPager(pager, parentType);
+	const pageId = getPageId(prevPager);
+	const prevPage = pages[pageId];
+
+	if (!prevPage) {
+		throw new Error(`Cannot reach previous page ${pageId}`);
+	}
+
+	let newState = { ...state, pager: prevPager };
+
+	// We reached an empty page, keep going backward
+	if (isPageEmpty(newState)) {
+		return reduceGoPreviousPage(newState);
+	}
+
+	// If we reached a loop, go to the last iteration / sequence
+	newState = autoExploreLoop(newState, 'backward');
+
+	// We explored a loop, check if we reached an empty page, move backward
+	if (newState.pager !== prevPager && isPageEmpty(newState)) {
+		return reduceGoPreviousPage(newState);
+	}
+
+	return {
+		...newState,
+		previousPager: state.pager,
+		isInLoop: newState.pager.iteration !== undefined,
+	};
+}

package/src/use-lunatic/reducer/reduce-go-to-page.ts

@@ -0,0 +1,69 @@
+import { type ActionGoToPage } from '../actions';
+import { getPageId, isPageEmpty } from '../commons/page';
+import { getPagerFromPageTag } from '../commons/page-tag';
+import type { LunaticReducerState } from '../type';
+import { reduceGoNextPage } from './reduce-go-next-page';
+
+export function reduceGoToPage(
+	state: LunaticReducerState,
+	action: ActionGoToPage
+): LunaticReducerState {
+	// The page contains non digit, extract information from it
+	if (typeof action.payload.page === 'string') {
+		const pager = getPagerFromPageTag(action.payload.page);
+		if (!pager) {
+			console.error(`Cannot reach page "${action.payload.page}", not a number`);
+			return state;
+		}
+		action.payload.iteration = pager.iteration;
+		action.payload.subPage = pager.subPage;
+		action.payload.page = pager.page;
+	}
+
+	const newPager: LunaticReducerState['pager'] = {
+		...state.pager,
+		page: action.payload.page,
+		subPage: action.payload.subPage,
+		iteration: action.payload.iteration,
+		nbIterations: undefined,
+		nbSubPages: undefined,
+	};
+
+	// The page is not reachable
+	const pageId = getPageId(newPager);
+	if (!(pageId in state.pages)) {
+		console.error(`Page "${pageId}" does not exists in this questionnaire`);
+		return state;
+	}
+
+	// Find the number of subPages and iteration
+	const parentPage = state.pages[action.payload.page];
+	if (action.payload.subPage !== undefined && parentPage.iterations) {
+		newPager.nbSubPages = parentPage.subPages?.length;
+		newPager.nbIterations = state.executeExpression<number>(
+			parentPage.iterations
+		);
+	}
+
+	// Prevent an out of bound iteration
+	if (
+		newPager.iteration !== undefined &&
+		newPager.nbIterations !== undefined &&
+		newPager.iteration >= newPager.nbIterations
+	) {
+		newPager.iteration = newPager.nbIterations - 1;
+	}
+
+	// Move forward if the page is empty
+	const newState = {
+		...state,
+		previousPager: state.pager,
+		isInLoop: newPager.nbIterations !== undefined,
+		pager: newPager,
+	};
+	if (isPageEmpty(newState)) {
+		return reduceGoNextPage(newState);
+	}
+
+	return newState;
+}