@inseefr/lunatic 0.3.7-experimental → 0.3.7-v2

package/src/use-lunatic/commons/execute-expression/create-memoizer.js

@@ -0,0 +1,42 @@
+import objectHash from 'object-hash';
+
+function createMemoizer() {
+	const expresionsMap = new Map();
+
+	function refillBindings(bindings) {
+		return Object.entries(bindings).reduce(function (map, [key, value]) {
+			const dataPointsValue = value?.result;
+			if (dataPointsValue) {
+				return { ...map, [key]: dataPointsValue };
+			}
+			return { ...map, [key]: value };
+		}, {});
+	}
+
+	function memoize(expression, bindings, value) {
+		const refill = refillBindings(bindings);
+		const hash = objectHash(refill);
+		let map = expresionsMap.get(expression);
+
+		if (!map) {
+			map = new Map();
+			expresionsMap.set(expression, map);
+		}
+		map.set(hash, value);
+	}
+
+	function getMemoizedValue(expression, bindings) {
+		let map = expresionsMap.get(expression);
+
+		if (map) {
+			const refill = refillBindings(bindings);
+			const hash = objectHash(refill);
+			return map.get(hash);
+		}
+		return undefined;
+	}
+
+	return [memoize, getMemoizedValue];
+}
+
+export default createMemoizer;

package/src/use-lunatic/commons/execute-expression/create-refresh-calculated.js

@@ -0,0 +1,98 @@
+import { CALCULATED, X_AXIS, Y_AXIS } from '../../../utils/constants';
+
+function createRefreshCalculated({ variables, execute, bindings }) {
+	const toRefreshVariables = new Map(); // variables calculées dépendantes d'une variable modifiée.
+
+	// à l'init, on y colle toutes les variables de calcul
+	Object.values(variables).forEach(function ({ variable }) {
+		const { variableType, name } = variable;
+		if (variableType === CALCULATED) {
+			toRefreshVariables.set(name, variable);
+		}
+	});
+
+	function getIteration({ name, iteration, linksIterations }) {
+		if (name === X_AXIS) return linksIterations[0];
+		if (name === Y_AXIS) return linksIterations[1];
+		return iteration;
+	}
+
+	function buildValue({
+		expression,
+		logging,
+		shapeFrom,
+		name,
+		iteration,
+		linksIterations,
+	}) {
+		const value = execute(expression, {
+			logging,
+			iteration: shapeFrom
+				? getIteration({ name, iteration, linksIterations })
+				: undefined,
+		});
+		if (shapeFrom && iteration !== undefined) {
+			if (bindings[name] === undefined) {
+				const shapeVariable = bindings[shapeFrom];
+				const initialValue = shapeVariable.map((_, i) =>
+					execute(expression, {
+						logging,
+						iteration: i,
+					})
+				);
+				bindings[name] = initialValue;
+				return initialValue[iteration];
+			}
+			bindings[name][iteration] = value;
+			return bindings[name][iteration];
+		}
+		bindings[name] = value;
+		return value;
+	}
+
+	function refreshCalculated(
+		map,
+		{ rootExpression, iteration, linksIterations }
+	) {
+		return Object.entries(map).reduce(function (sub, [name, current]) {
+			const { variable, type } = variables[name];
+			if (type === CALCULATED && toRefreshVariables.has(name)) {
+				const { expression, shapeFrom } = variable;
+
+				function logging(expression, bindings, e) {
+					if (process.env.NODE_ENV === 'development') {
+						console.warn(
+							`VTL error when refreshing calculated variable ${name} :  ${expression.value}`,
+							{ bindings }
+						);
+						console.warn(`root expression : ${rootExpression}`);
+						console.warn(e);
+					}
+				}
+
+				const value = buildValue({
+					expression,
+					logging,
+					shapeFrom,
+					name,
+					iteration,
+					linksIterations,
+					bindings,
+				});
+
+				if (type !== CALCULATED || iteration === undefined)
+					toRefreshVariables.delete(name);
+				return { ...sub, [name]: value };
+			}
+			return { ...sub, [name]: current };
+		}, {});
+	}
+
+	function setToRefreshCalculated(name, variable) {
+		toRefreshVariables.set(name, variable);
+	}
+
+	return [refreshCalculated, setToRefreshCalculated];
+}
+
+export default createRefreshCalculated;

package/src/use-lunatic/commons/execute-expression/execute-expression.js

@@ -0,0 +1,69 @@
+import React from 'react';
+import { interpret } from '@inseefr/trevas';
+import MdLabel from '../../../components/commons/components/md-label';
+import { VTL, MD } from '../../../utils/constants';
+
+function isDataSet(result) {
+	return result && typeof result === 'object' && result.dataPoints;
+}
+
+function extractDataSetResult(dataSet) {
+	const { dataPoints } = dataSet;
+	if (dataPoints) {
+		const { result } = dataPoints;
+		return result;
+	}
+	return undefined;
+}
+
+function executeVtlExpression(expression, vtlBindings) {
+	const result = interpret(expression, vtlBindings);
+	if (isDataSet(result)) {
+		return extractDataSetResult(result);
+	}
+	if (result === null) {
+		return null;
+	}
+	if (typeof result === 'object') {
+		return expression;
+	}
+
+	return result;
+}
+
+function executeVTL(expression, vtlBindings, logging) {
+	if (expression) {
+		try {
+			return executeVtlExpression(expression, vtlBindings);
+		} catch (e) {
+			logging(expression, vtlBindings, e);
+			return expression;
+		}
+	}
+	return '';
+}
+
+function loggingDefault(expression, bindings, e) {
+	if (process.env.NODE_ENV === 'development') {
+		console.warn(`VTL error :  ${expression}`, bindings);
+		console.warn(e);
+	}
+}
+
+function executeExpression(
+	vtlBindings,
+	expression,
+	type,
+	features /* VTL, MD */,
+	logging = loggingDefault
+) {
+	if (features.includes(VTL) && type.includes(VTL)) {
+		const vtl = executeVTL(expression, vtlBindings, logging);
+		if (features.includes(MD) && type.includes(MD))
+			return <MdLabel expression={vtl} />;
+		return vtl;
+	}
+	return expression;
+}
+
+export default executeExpression;

package/src/use-lunatic/commons/execute-expression/get-expressions-variables.js

@@ -0,0 +1,22 @@
+import { VtlLexer } from '@inseefr/vtl-2.0-antlr-tools';
+import antlr4 from 'antlr4';
+
+function getExpressionVariables(expression, variables) {
+	try {
+		const chars = new antlr4.InputStream(expression);
+		const lexer = new VtlLexer(chars);
+		return lexer.getAllTokens().reduce(function (array, { start, stop, type }) {
+			if (type === 234) {
+				const token = expression.substr(start, stop - start + 1);
+				if (array.indexOf(token) === -1 && token in variables) {
+					return [...array, token];
+				}
+			}
+			return array;
+		}, []);
+	} catch (e) {
+		return [];
+	}
+}
+
+export default getExpressionVariables;

package/src/use-lunatic/commons/execute-expression/get-safety-expression.js

@@ -0,0 +1,19 @@
+import { VTL } from '../../../utils/constants';
+
+function getSafetyExpression(expression) {
+	if (typeof expression === 'string') {
+		return { value: expression, type: VTL };
+	}
+	// TODO: fix into model and supress this block
+	if (
+		typeof expression === 'object' &&
+		'value' in expression &&
+		!('type' in expression)
+	) {
+		return { ...expression, type: VTL };
+	}
+
+	return expression;
+}
+
+export default getSafetyExpression;

package/src/use-lunatic/commons/execute-expression/index.js

@@ -0,0 +1 @@
+export { default } from './create-execute-expression';

package/src/use-lunatic/commons/fill-components/fill-component-expressions.js

@@ -0,0 +1,129 @@
+const VTL_ATTRIBUTES = [
+	'label',
+	'responses.label',
+	'hierarchy.label',
+	'hierarchy.subSequence.label',
+	'hierarchy.sequence.label',
+	'declarations.label',
+	'controls.control',
+	'controls.errorMessage',
+	'options.label',
+	'lines.min',
+	'lines.max',
+	'iterations',
+	'xAxisIterations',
+	'yAxisIterations',
+	'body.label',
+	'header.label',
+	'conditionFilter',
+];
+
+function createCrawl({ executeExpression, iteration, linksIterations }) {
+	/**
+	 *
+	 * @param {*} object
+	 * @param {*} path
+	 * @returns
+	 */
+	function executeAndFillObject(object, path) {
+		const candidate = object[path];
+		return {
+			...object,
+			[path]: executeExpression(candidate, {
+				iteration,
+				linksIterations,
+			}),
+		};
+	}
+
+	function buildCrawlEntry(entry, path) {
+		return Array.isArray(entry)
+			? entry.map((e) => crawl(path, e))
+			: crawl(path, entry);
+	}
+
+	/**
+	 *
+	 * @param {*} object
+	 * @param {*} array
+	 * @param {*} path
+	 * @returns
+	 */
+	function crawlArray(object, path) {
+		const [step, ...rest] = path;
+		return object[step].reduce(
+			function (stack, entry) {
+				const flattedEntry = buildCrawlEntry(entry, rest);
+				return {
+					...stack,
+					[step]: [...stack[step], flattedEntry],
+				};
+			},
+			{ ...object, [step]: [] }
+		);
+	}
+
+	/**
+	 *
+	 * @param {*} object
+	 * @param {*} path
+	 * @returns
+	 */
+	function crawlObject(object, path) {
+		const [step, ...rest] = path;
+		return { ...object, [step]: crawl(rest, object[step]) };
+	}
+
+	/**
+	 *
+	 * @param {*} path
+	 * @param {*} object
+	 * @returns
+	 */
+	function crawl(path, object) {
+		const [step, ...rest] = path;
+
+		if (step in object && rest.length === 0) {
+			return executeAndFillObject(object, step);
+		} else if (step in object) {
+			if (Array.isArray(object[step])) {
+				return crawlArray(object, path);
+			}
+			return crawlObject(object, path);
+		}
+
+		return object;
+	}
+
+	return crawl;
+}
+
+function fillAttributes(
+	component,
+	{ executeExpression, iteration, linksIterations }
+) {
+	const crawl = createCrawl({ executeExpression, iteration, linksIterations });
+	return VTL_ATTRIBUTES.reduce(
+		function (step, fullStringPath) {
+			const path = fullStringPath.split('.');
+			return {
+				...step,
+				...crawl(path, step, fullStringPath),
+			};
+		},
+		{ ...component }
+	);
+}
+
+function fillComponentExpressions(component, state) {
+	const { pager, executeExpression } = state;
+	const { iteration, linksIterations } = pager;
+
+	return fillAttributes(component, {
+		executeExpression,
+		iteration,
+		linksIterations,
+	});
+}
+
+export default fillComponentExpressions;

package/src/use-lunatic/commons/fill-components/fill-component-value.js

@@ -0,0 +1,8 @@
+import getComponentValue from '../get-component-value';
+
+function fillComponentValue(component, state) {
+	const value = getComponentValue(component, state);
+	return { ...component, value };
+}
+
+export default fillComponentValue;

package/src/use-lunatic/commons/fill-components/fill-components.js

@@ -0,0 +1,34 @@
+import fillComponentExpressions from './fill-component-expressions';
+import fillErrors from './fill-errors';
+import fillFromState from './fill-from-state';
+import fillComponentValue from './fill-component-value';
+import fillPagination from './fill-pagination';
+import fillMissingResponse from './fill-missing-response';
+import fillManagement from './fill-management';
+
+function compose(...fill) {
+	return fill.reduce(
+		function (a, b) {
+			return (cmp, state) => b(a(cmp, state), state);
+		},
+		(c) => c
+	);
+}
+
+const fillComponent = compose(
+	fillErrors,
+	fillFromState,
+	fillComponentExpressions,
+	fillPagination,
+	fillComponentValue,
+	fillMissingResponse,
+	fillManagement
+);
+
+function fillComponents(components, state) {
+	return components.map(function (component) {
+		return fillComponent(component, state);
+	});
+}
+
+export default fillComponents;

package/src/use-lunatic/commons/fill-components/fill-errors.js

@@ -0,0 +1,13 @@
+function fillErrors(component, state) {
+	const { errors } = state;
+	const { id } = component;
+	if (errors) {
+		// TODO only keep criticality info
+		if (id in errors) {
+			return { ...component, error: errors[id] };
+		}
+	}
+	return component;
+}
+
+export default fillErrors;

package/src/use-lunatic/commons/fill-components/fill-from-state.js

@@ -0,0 +1,6 @@
+function fillFromState(component, state) {
+	const { handleChange, executeExpression, preferences } = state;
+	return { ...component, handleChange, executeExpression, preferences };
+}
+
+export default fillFromState;

package/src/use-lunatic/commons/fill-components/fill-management.js

@@ -0,0 +1,9 @@
+function fillManagement(component, state) {
+	const { management } = state;
+	if (management) {
+		return { ...component, management };
+	}
+	return component;
+}
+
+export default fillManagement;

package/src/use-lunatic/commons/fill-components/fill-missing-response.js

@@ -0,0 +1,22 @@
+function fillMissingResponse(component, state) {
+	const { missingResponse } = component;
+	const {
+		variables,
+		pager: { iteration },
+	} = state;
+	if (missingResponse) {
+		const { name } = missingResponse;
+		if (name in variables) {
+			const { value } = variables[name];
+			const missingValue = iteration === undefined ? value : value[iteration];
+			return {
+				...component,
+				missingResponse: { ...missingResponse, value: missingValue },
+			};
+		}
+	}
+
+	return component;
+}
+
+export default fillMissingResponse;

package/src/use-lunatic/commons/fill-components/fill-pagination.js

@@ -0,0 +1,8 @@
+function fillPagination(component, state) {
+	const { pager } = state;
+	const { iteration } = pager;
+
+	return { ...component, iteration };
+}
+
+export default fillPagination;

package/src/use-lunatic/commons/fill-components/index.js

@@ -0,0 +1 @@
+export { default } from './fill-components';

package/src/use-lunatic/commons/get-compatible-vtl-expression.js

@@ -0,0 +1,16 @@
+import { VTL } from '../../utils/constants';
+
+function getCompatibleVTLExpression(expression) {
+	if (typeof expression === 'string') {
+		return { value: expression, type: VTL };
+	}
+	if (typeof expression === 'object') {
+		const { type } = expression;
+		if (type === VTL) {
+			return expression;
+		}
+	}
+	console.warn(`Non-VTL compatible expression : ${expression}`);
+}
+
+export default getCompatibleVTLExpression;

package/src/use-lunatic/commons/get-component-value/get-component-value.js

@@ -0,0 +1,118 @@
+function isInSubPage(state) {
+	const { pager } = state;
+	const { subPage } = pager;
+
+	return subPage !== undefined;
+}
+
+/* */
+function mergeResponse({ map, response, variables }) {
+	const { name } = response;
+	if (name in variables) {
+		return { ...map, [name]: variables[name].value };
+	}
+	return map;
+}
+
+function collecteArrayResponses({ components, variables, map = {} }) {
+	return components.reduce(function (sub, component) {
+		return collecteComponentResponse({
+			component,
+			variables,
+			map: sub,
+		});
+	}, map);
+}
+
+function collectCell({ cell, variables, map }) {
+	const [component, ...rest] = cell;
+	const { componentType } = component;
+	let next = map;
+	if (componentType) {
+		next = {
+			...map,
+			...collecteComponentResponse({ component, variables, map }),
+		};
+	}
+
+	if (rest.length) {
+		return collectCell({ cell: rest, variables, map: next });
+	}
+	return next;
+}
+
+function collectTableResponse({ map, body, variables }) {
+	if (Array.isArray(body)) {
+		return body.reduce(function (sub, cell) {
+			if (Array.isArray(cell)) {
+				return collectCell({ cell, variables, map: sub });
+			}
+			return sub;
+		}, map);
+	}
+	return map;
+}
+
+function collecteComponentResponse({ component, variables, map = {} }) {
+	const { components, response, responses, body } = component;
+
+	if (body) {
+		return collectTableResponse({ map, body, variables });
+	}
+	if (response) {
+		return mergeResponse({ map, response, variables });
+	}
+	if (components) {
+		return collecteArrayResponses({ components, variables, map });
+	}
+	if (responses) {
+		return collecteArrayResponses({ components: responses, variables, map });
+	}
+	return map;
+}
+
+/* */
+
+function checkArrayForSubPage(map, state) {
+	const { pager } = state;
+	const { iteration } = pager;
+
+	return Object.entries(map).reduce(function (sub, [name, value]) {
+		if (value && Array.isArray(value)) {
+			return { ...sub, [name]: value[iteration] };
+		}
+		return { ...sub, [name]: value };
+	}, {});
+}
+
+function checkUseContext(map, state) {
+	if (isInSubPage(state)) {
+		return checkArrayForSubPage(map, state);
+	}
+	return map;
+}
+
+function isSimpleComponent(component) {
+	const { response } = component;
+	return typeof response === 'object';
+}
+
+/* */
+
+function getComponentValue(component, state) {
+	const { variables } = state;
+	/* */
+	const map = checkUseContext(
+		collecteComponentResponse({ component, variables }),
+		state
+	);
+	if (isSimpleComponent(component)) {
+		const { response } = component;
+		const { name } = response;
+
+		return map[name];
+	}
+	return map;
+}
+
+export default getComponentValue;

package/src/use-lunatic/commons/get-component-value/index.js

@@ -0,0 +1 @@
+export { default } from './get-component-value';

package/src/use-lunatic/commons/get-components-from-state.js

@@ -0,0 +1,24 @@
+function getComponentsFromState(state) {
+	const { pager, pages, isInLoop } = state;
+	const { page, subPage } = pager;
+
+	if (page && pages && page in pages) {
+		const current = pages[page];
+		if (isInLoop) {
+			const { subPages } = current;
+			const stepName = subPages[subPage];
+			if (stepName in pages) {
+				const currentSubPage = pages[stepName];
+				const { components } = currentSubPage;
+				return components;
+			}
+		} else {
+			const { components } = current;
+			return components;
+		}
+	}
+
+	return [];
+}
+
+export default getComponentsFromState;

package/src/use-lunatic/commons/get-page-tag.js

@@ -0,0 +1,10 @@
+function getPageTag(pager) {
+	const { page, subPage, iteration } = pager;
+	if (subPage !== undefined && iteration !== undefined) {
+		return `${page}.${subPage + 1}#${iteration + 1}`;
+	}
+
+	return `${page}`;
+}
+
+export default getPageTag;

package/src/use-lunatic/commons/index.js

@@ -0,0 +1,12 @@
+export { default as checkLoops } from './check-loops';
+export { default as createMapPages } from './create-map-pages';
+export { default as isPaginatedLoop } from './is-paginated-loop';
+export { default as getComponentsFromState } from './get-components-from-state';
+export { default as useComponentsFromState } from './use-components-from-state';
+export { default as getPageTag } from './get-page-tag';
+export { default as isFirstLastPage } from './is-First-last-page';
+export { default as createExecuteExpression } from './execute-expression';
+export { default as executeConditionFilter } from './execute-condition-filter';
+export { default as fillComponentExpressions } from './fill-components/fill-component-expressions';
+export { default as loadSuggester } from './load-suggesters';
+export { default as getCompatibleVTLExpression } from './get-compatible-vtl-expression';

package/src/use-lunatic/commons/is-First-last-page.js

@@ -0,0 +1,8 @@
+function isFirstLastPage(pager) {
+	const { page, maxPage } = pager;
+	const isFirstPage = page === '1';
+	const isLastPage = page === maxPage;
+	return { isFirstPage, isLastPage };
+}
+
+export default isFirstLastPage;