@inseefr/lunatic 0.3.3-experimental → 0.3.3-v2

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

@@ -0,0 +1,188 @@
+import executeExpression from './execute-expression';
+import getSafetyExpression from './get-safety-expression';
+import getExpressionVariables from './get-expressions-variables';
+import createMemoizer from './create-memoizer';
+import createRefreshCalculated from './create-refresh-calculated';
+import getVtlCompatibleValue from '../../../utils/vtl';
+import { VTL, VTL_MD, X_AXIS, Y_AXIS } from '../../../utils/constants';
+
+function validateExpression(expObject) {
+	if (typeof expObject === 'object') {
+		const { type } = expObject;
+		if (type === VTL || type === VTL_MD) {
+			return expObject;
+		}
+	}
+	if (typeof expObject === 'string') return { value: expObject, type: VTL };
+	throw new Error(`Non-VTL compatible expression : ${expObject}`);
+}
+
+function createBindings(variables) {
+	return Object.entries(variables).reduce(function (
+		bindings,
+		[name, { value }]
+	) {
+		return { ...bindings, [name]: value };
+	},
+	{});
+}
+
+/**
+ *
+ * @param {*} variables
+ * @returns
+ */
+function createExecuteExpression(variables, features) {
+	// on aimerait map d'expression, avec les bindings
+	const bindings = createBindings(variables);
+	const tokensMap = new Map();
+	const collectedUpdated = new Map();
+	const [memoize, getMemoizedValue] = createMemoizer();
+	const [refreshCalculated, setToRefreshCalculated] = createRefreshCalculated({
+		variables,
+		execute,
+		bindings,
+	});
+
+	/**
+	 *
+	 * @param {*} name
+	 */
+	function pushToLazy(name) {
+		const { CalculatedLinked = [] } = variables[name];
+
+		CalculatedLinked.forEach(function (variable) {
+			const { name } = variable;
+			setToRefreshCalculated(name, variable);
+		});
+	}
+
+	/**
+	 *
+	 * @param {*} name
+	 * @param {*} value
+	 */
+	function updateBindings(name, value) {
+		// update des bindings
+		if (name in bindings) {
+			bindings[name] = value;
+			collectedUpdated.set(name, []);
+		}
+		pushToLazy(name);
+	}
+
+	function getVariablesAndCach(expression) {
+		if (tokensMap.has(expression)) {
+			return tokensMap.get(expression);
+		}
+		const tokens = getExpressionVariables(expression, variables);
+		tokensMap.set(expression, tokens);
+		return tokens;
+	}
+
+	/**/
+	function collecteVariables(dependencies) {
+		if (Array.isArray(dependencies)) {
+			return dependencies.reduce(function (map, name) {
+				if (name in variables) {
+					const data = variables[name];
+					const { variable, type } = data;
+					if (!(name in map)) {
+						if (type === 'CALCULATED') {
+							const { expression } = variable;
+							const subDependencies = getVariablesAndCach(expression);
+
+							return {
+								...map,
+								[name]: { ...variable },
+								...collecteVariables(subDependencies),
+							};
+						}
+
+						return { ...map, [name]: { ...variable } };
+					}
+				} else {
+					throw new Error(`Unknown variable ${name}`);
+				}
+				return map;
+			}, {});
+		}
+		return {};
+	}
+
+	function resolveUseContext(name, { iteration, linksIterations }) {
+		const value = bindings[name];
+		if ([X_AXIS, Y_AXIS].includes(name) && linksIterations !== undefined) {
+			pushToLazy(name);
+			const [x, y] = linksIterations;
+			if (Array.isArray(value) && x < value.length) {
+				return value[name === X_AXIS ? x : y];
+			}
+			return null;
+		}
+		if (iteration !== undefined && Array.isArray(value)) {
+			pushToLazy(name);
+			if (iteration < value.length) {
+				return value[iteration];
+			}
+			return null;
+		}
+		return getVtlCompatibleValue(value);
+	}
+
+	function fillVariablesValues(map, { iteration, linksIterations }) {
+		return Object.entries(map).reduce(function (sub, [name, _]) {
+			return {
+				...sub,
+				[name]: resolveUseContext(name, { iteration, linksIterations }),
+			};
+		}, {});
+	}
+
+	/**
+	 *
+	 * @param {*} vtlObject
+	 * @param {*} args
+	 * @returns
+	 */
+	function execute(expObject, args = {}) {
+		const { value: expression, type } = validateExpression(
+			getSafetyExpression(expObject)
+		);
+		const { iteration, linksIterations, logging } = args;
+		const bindingDependencies = getVariablesAndCach(expression);
+
+		function loggingDefault(_, bindings, e) {
+			if (process.env.NODE_ENV === 'development') {
+				console.warn(`VTL error :  ${expression}`, { ...args }, { bindings });
+				console.warn(e);
+			}
+		}
+		const vtlBindings = refreshCalculated(
+			fillVariablesValues(collecteVariables(bindingDependencies), {
+				iteration,
+				linksIterations,
+			}),
+			{ rootExpression: expression, iteration, linksIterations }
+		);
+
+		const memoized = getMemoizedValue(expression, vtlBindings);
+		if (memoized === undefined) {
+			const result = executeExpression(
+				vtlBindings,
+				expression,
+				type,
+				features,
+				logging || loggingDefault
+			);
+			memoize(expression, vtlBindings, result);
+
+			return result;
+		}
+		return memoized;
+	}
+
+	return [execute, updateBindings];
+}
+
+export default createExecuteExpression;

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;
+		}
+	}
+	throw new Error(`Non-VTL compatible expression : ${expression}`);
+}
+
+export default getCompatibleVTLExpression;