@inseefr/lunatic 3.4.5 → 3.4.6

package/src/use-lunatic/commons/page-tag.ts

@@ -0,0 +1,78 @@
+import type { LunaticReducerState, PageTag } from '../type';
+
+/**
+ * Generate page name from the pager
+ */
+export function getPageTag(pager: LunaticReducerState['pager']): PageTag {
+	const { page, subPage, iteration } = pager;
+	if (subPage !== undefined && iteration !== undefined) {
+		return `${page}.${subPage + 1}#${iteration + 1}`;
+	}
+
+	return `${page}`;
+}
+
+export function getPagerFromPageTag(pageTag: string | number = 1) {
+	if (typeof pageTag === 'number') {
+		return { page: pageTag };
+	}
+	const pattern =
+		/(?<page>\d+)\.?(?<subPagePlusUn>\d+)?#?(?<iterationPlusUn>\d+)?/g;
+	const match = [...(pageTag?.toString().matchAll(pattern) as any)] as
+		| [
+				{
+					groups: {
+						page: string;
+						subPagePlusUn: string;
+						iterationPlusUn: string;
+					};
+				},
+		  ]
+		| [];
+	if (match.length === 0) {
+		return null;
+	}
+	const [
+		{
+			groups: { page, subPagePlusUn, iterationPlusUn },
+		},
+	] = match;
+	if (!subPagePlusUn) {
+		return { page: parseInt(page, 10) };
+	}
+	return {
+		page: parseInt(page, 10),
+		subPage: parseInt(subPagePlusUn, 10) - 1,
+		iteration: parseInt(iterationPlusUn, 10) - 1,
+	};
+}
+
+export function isNewReachedPage(pager: LunaticReducerState['pager']): boolean {
+	const { lastReachedPage } = pager;
+	const pageTag = getPageTag(pager);
+	return pageTagComparator(pageTag, lastReachedPage ?? '0') > 0;
+}
+
+export function getNewReachedPage(
+	pager: LunaticReducerState['pager']
+): PageTag | undefined {
+	return isNewReachedPage(pager) ? getPageTag(pager) : pager.lastReachedPage;
+}
+
+/**
+ * Comparison function for pageTag
+ * - negative if a comes before b
+ * - positive if a comes after b
+ * - 0 if a is the same as b
+ */
+export function pageTagComparator(a: PageTag, b: PageTag) {
+	const pageA = a.split(/\D/).map((v) => parseInt(v, 10));
+	const pageB = b.split(/\D/).map((v) => parseInt(v, 10));
+	// [0, 2, 1] is used to extract the significant part of the pageTag part (start with page, then iteration, then subpage)
+	for (const index of [0, 2, 1]) {
+		if (pageA[index] !== pageB[index]) {
+			return (pageA[index] ?? -1) - (pageB[index] ?? -1);
+		}
+	}
+	return 0;
+}

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

@@ -0,0 +1,47 @@
+import type { LunaticReducerState } from '../type';
+import { getComponentsFromState } from './get-components-from-state';
+import executeConditionFilter from './execute-condition-filter';
+
+export function getPageId({
+	subPage,
+	page,
+}: Pick<LunaticReducerState['pager'], 'page' | 'subPage'>) {
+	if (subPage === undefined) {
+		return page;
+	}
+	return `${page}.${subPage + 1}`;
+}
+
+/**
+ * Converts a page number (3.1.2) to an array of numbers [3, 1, 2]
+ */
+export function pageStringToNumbers(page: string): number[] {
+	return page.split('.').map((v) => parseInt(v, 10));
+}
+
+/**
+ * Check if we are on an empty page
+ * if no components can be displayed on this page (using filter)
+ */
+export function isPageEmpty(state: LunaticReducerState): boolean {
+	const { executeExpression, pager } = state;
+	const { iteration } = pager;
+	const components = getComponentsFromState(state);
+	const visibleComponents = components.filter((component) => {
+		if ('conditionFilter' in component && component.conditionFilter) {
+			return executeConditionFilter(
+				component.conditionFilter,
+				executeExpression,
+				iteration
+			);
+		}
+		return true;
+	});
+
+	// No components are displayable on this page
+	if (visibleComponents.length === 0) {
+		return true;
+	}
+
+	return false;
+}

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

@@ -0,0 +1,73 @@
+import type { LunaticVariablesStore } from '../lunatic-variables-store';
+import type { LunaticSource } from '../../../type';
+import { depth } from '../../../../utils/array';
+
+/**
+ * Cleaning behaviour for the store
+ * When a variable changes, other variables can be reset
+ */
+export function cleaningBehaviour(
+	store: LunaticVariablesStore,
+	cleaning: LunaticSource['cleaning'],
+	// Value used as default when cleaning a variable
+	initialValues: Record<string, unknown> = {}
+) {
+	if (!cleaning) {
+		return;
+	}
+
+	// Create a map to improve performance
+	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
+		if (!cleaningInfo) {
+			return;
+		}
+
+		for (const variableName in cleaningInfo) {
+			try {
+				const skipCleaning = store.run(cleaningInfo[variableName], {
+					iteration,
+				});
+				if (skipCleaning) {
+					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',
+					}
+				);
+			} catch (e) {
+				// If we have an error, skip this cleaning
+				console.error(e);
+			}
+		}
+	});
+}
+
+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));
+}

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

@@ -0,0 +1,36 @@
+import type { LunaticVariablesStore } from '../lunatic-variables-store';
+import type { LunaticSource } from '../../../type';
+
+/**
+ * Add missing behaviour to the store
+ * Missing works as a simplified cleaning that reset a linked variable
+ */
+export function missingBehaviour(
+	store: LunaticVariablesStore,
+	missing: LunaticSource['missingBlock']
+) {
+	if (!missing) {
+		return;
+	}
+
+	// Create a map to improve performance
+	const missingMap = new Map(Object.entries(missing));
+
+	store.on('change', (e) => {
+		// Only clean if a value is set
+		if (e.detail.value === null || e.detail.value === undefined) {
+			return;
+		}
+
+		const linkedVariables = missingMap.get(e.detail.name);
+
+		// The variable does not have missing variable linked
+		if (!linkedVariables) {
+			return;
+		}
+
+		for (const variableName of linkedVariables) {
+			store.set(variableName, null, { iteration: e.detail.iteration });
+		}
+	});
+}

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

@@ -0,0 +1,89 @@
+import type { LunaticVariablesStore } from '../lunatic-variables-store';
+import type { LunaticSource } from '../../../type';
+import { forceInt } from '../../../../utils/number';
+import { resizeArrayVariable } from '../../../reducer/commons';
+import { getExpressionAsString } from '../../../../utils/vtl';
+import { resizeArray } from '../../../../utils/array';
+
+/**
+ * Resizing behaviour for the store
+ * When a variable changes, multiple other variables can change size (size of the array)
+ */
+export function resizingBehaviour(
+	store: LunaticVariablesStore,
+	resizing: LunaticSource['resizing']
+) {
+	if (!resizing) {
+		return;
+	}
+
+	// Create a map to improve performance
+	const resizingMap = new Map(Object.entries(resizing));
+
+	store.on('change', (e) => {
+		// The variable does not have resizing
+		const resizingInfo = resizingMap.get(e.detail.name);
+		if (!resizingInfo) {
+			return;
+		}
+
+		// Pairwise resizing
+		if ('sizeForLinksVariables' in resizingInfo) {
+			resizePairwise(store, resizingInfo, e.detail);
+			if (!('size' in resizingInfo)) {
+				return;
+			}
+		}
+
+		if (!resizingInfo.size) {
+			throw new Error(`Cannot resize ${e.detail.name} missing "size" property`);
+		}
+
+		const newSize = forceInt(store.run(resizingInfo.size));
+		for (const variableName of resizingInfo.variables) {
+			const value = store.get(variableName);
+			if (!Array.isArray(value) || value.length !== newSize) {
+				store.set(variableName, resizeArrayVariable(value, newSize, null), {
+					cause: 'resizing',
+				});
+			}
+		}
+	});
+}
+
+function resizePairwise(
+	store: LunaticVariablesStore,
+	resizingInfo: {
+		sizeForLinksVariables:
+			| [string, string]
+			| { xAxisSize: string; yAxisSize: string };
+		linksVariables: string[];
+	},
+	args: {
+		iteration?: number[];
+	}
+) {
+	// Handle expression being sent as an array or an object (ensure backward compatibility)
+	// Issue : https://github.com/InseeFr/Lunatic/issues/883
+	const sizeExpressions: [string, string] = Array.isArray(
+		resizingInfo.sizeForLinksVariables
+	)
+		? resizingInfo.sizeForLinksVariables
+		: [
+				resizingInfo.sizeForLinksVariables.xAxisSize,
+				resizingInfo.sizeForLinksVariables.yAxisSize,
+			];
+	const [xSize, ySize] = sizeExpressions.map((expression) => {
+		return forceInt(store.run(getExpressionAsString(expression)));
+	});
+	resizingInfo.linksVariables.forEach((variable) => {
+		const value = store.get(variable, args.iteration);
+		const resizedValue = resizeArray(
+			// The value is not an array, force an array
+			Array.isArray(value) ? value.map((i) => resizeArray(i, ySize, null)) : [],
+			xSize,
+			new Array(ySize).fill(null)
+		);
+		store.set(variable, resizedValue);
+	});
+}

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

@@ -0,0 +1,35 @@
+export class VTLExpressionError extends Error {
+	constructor(
+		public readonly expression: string,
+		message: string
+	) {
+		super(`Cannot interpret expression "${expression}" ${message}`);
+	}
+}
+
+export class VTLInterpretationError extends VTLExpressionError {
+	constructor(
+		public readonly expression: string,
+		public readonly bindings: Record<string, unknown>
+	) {
+		super(expression, `with bindings ${JSON.stringify(bindings)}`);
+	}
+}
+
+export class VTLMissingDependency extends VTLExpressionError {
+	constructor(
+		public readonly expression: string,
+		public readonly variableName: string
+	) {
+		super(expression, `unknown variable ${variableName}`);
+	}
+}
+
+export class VTLMissingDependencies extends VTLExpressionError {
+	constructor(
+		public readonly expression: string,
+		public readonly dependencies: string[]
+	) {
+		super(expression, `unknown dependencies ${JSON.stringify(dependencies)}`);
+	}
+}

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

@@ -0,0 +1,73 @@
+import type { LunaticVariablesStore } from './lunatic-variables-store';
+import type { LunaticData, LunaticSource } from '../../type';
+
+export function getQuestionnaireData(
+	store: LunaticVariablesStore,
+	variables: LunaticSource['variables'],
+	withCalculated: boolean = false,
+	variableNames?: string[]
+): LunaticData {
+	const result = {
+		EXTERNAL: {} as Record<string, unknown>,
+		CALCULATED: {} as Record<string, unknown>,
+		COLLECTED: {} as Record<
+			string,
+			{
+				EDITED: unknown;
+				FORCED: unknown;
+				INPUTTED: unknown;
+				PREVIOUS: unknown;
+				COLLECTED: unknown;
+			}
+		>,
+	};
+
+	if (!variables) {
+		return result;
+	}
+
+	// Only return requested variables
+	if (variableNames) {
+		return {
+			...result,
+			COLLECTED: Object.fromEntries(
+				variableNames.map((name) => [
+					name,
+					{
+						EDITED: null,
+						FORCED: null,
+						INPUTTED: null,
+						PREVIOUS: null,
+						COLLECTED: store.get(name),
+					},
+				])
+			),
+		};
+	}
+
+	for (const variable of variables) {
+		// Skip calculated value if necessary
+		if (variable.variableType === 'CALCULATED' && !withCalculated) {
+			continue;
+		}
+
+		if (variable.variableType === 'COLLECTED') {
+			result.COLLECTED[variable.name] = {
+				PREVIOUS: null,
+				FORCED: null,
+				EDITED: null,
+				INPUTTED: null,
+				...variable.values,
+				COLLECTED: store.get(variable.name),
+			};
+		} else {
+			try {
+				result[variable.variableType][variable.name] = store.get(variable.name);
+			} catch {
+				// Error can happen when calculating variable, send null to prevent crashing the mehod
+				result[variable.variableType][variable.name] = null;
+			}
+		}
+	}
+	return result;
+}