@inseefr/lunatic 0.1.13-hackathon → 0.2.0-v2

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

@@ -0,0 +1,50 @@
+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 refreshCalculated(map, { rootExpression, iteration }) {
+		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}`,
+							{ bindings }
+						);
+						console.warn(`root expression : ${rootExpression}`);
+						console.warn(e);
+					}
+				}
+
+				const value = execute(expression, {
+					logging,
+					iteration: shapeFrom ? iteration : undefined,
+				});
+				bindings[name] = value;
+				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,109 @@
+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',
+];
+
+function createCrawl({ executeExpression, iteration }) {
+	/**
+	 *
+	 * @param {*} object
+	 * @param {*} path
+	 * @returns
+	 */
+	function executeAndFillObject(object, path) {
+		const candidate = object[path];
+		return {
+			...object,
+			[path]: executeExpression(candidate, {
+				iteration,
+			}),
+		};
+	}
+
+	/**
+	 *
+	 * @param {*} object
+	 * @param {*} array
+	 * @param {*} path
+	 * @returns
+	 */
+	function crawlArray(object, path) {
+		const [step, ...rest] = path;
+		return object[step].reduce(
+			function (stack, entry) {
+				return {
+					...stack,
+					[step]: [...stack[step], crawl(rest, entry)],
+				};
+			},
+			{ ...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 }) {
+	const crawl = createCrawl({ executeExpression, iteration });
+	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 } = pager;
+
+	return fillAttributes(component, { executeExpression, iteration });
+}
+
+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,32 @@
+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';
+
+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
+);
+
+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-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;

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;

package/src/use-lunatic/commons/is-paginated-loop.js

@@ -0,0 +1,6 @@
+function isPaginatedLoop(component) {
+	const { componentType, paginatedLoop } = component;
+	return componentType === 'Loop' && paginatedLoop;
+}
+
+export default isPaginatedLoop;

package/src/use-lunatic/commons/load-suggesters.js

@@ -0,0 +1,59 @@
+import {
+	openOrCreateStore,
+	clearStoreInfo,
+	clearStoreData,
+	updateStoreInfo,
+} from '../../utils/store-tools';
+import { createAppendTask } from '../../utils/suggester-workers/append-to-index';
+
+async function prepareStore(storeInfo, idbVersion) {
+	const { name } = storeInfo;
+	const db = await openOrCreateStore(name, idbVersion);
+	if (db) {
+		await clearStoreInfo(db);
+		await clearStoreData(db);
+		await updateStoreInfo(db, storeInfo);
+
+		return true;
+	}
+	return false;
+}
+
+async function loadOne(suggester, logging) {
+	const { idbVersion, fetch, ...storeInfo } = suggester;
+	const ready = await prepareStore(storeInfo, idbVersion);
+
+	if (ready) {
+		const data = await fetch();
+		const [launch, terminate] = createAppendTask(
+			storeInfo,
+			idbVersion,
+			logging
+		);
+		await launch(data);
+		terminate();
+	}
+}
+
+async function loadSuggesters(suggesters = []) {
+	try {
+		for (let i = 0; i < suggesters.length; i++) {
+			const suggester = suggesters[i];
+			const { autoLoad } = suggester;
+			function logging(message) {
+				//console.log(name, message);
+			}
+			if (autoLoad) {
+				await loadOne(suggester, logging);
+			}
+		}
+		return true;
+	} catch (e) {
+		console.warn(
+			"Une erreur s'est produite lors de l'initialisation des suggesters."
+		);
+		return false;
+	}
+}
+
+export default loadSuggesters;

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

@@ -0,0 +1,20 @@
+import { useState, useEffect } from 'react';
+import getComponentsFromState from './get-components-from-state';
+import fillComponents from './fill-components';
+
+function useComponentsFromState(state) {
+	const [componentsFilled, setComponentsFilled] = useState([]);
+
+	useEffect(
+		function () {
+			const { pager, pages, isInLoop } = state;
+			const components = getComponentsFromState({ pager, pages, isInLoop });
+			setComponentsFilled(fillComponents(components, state));
+		},
+		[state]
+	);
+
+	return componentsFilled;
+}
+
+export default useComponentsFromState;

package/src/use-lunatic/index.js

@@ -0,0 +1 @@
+export { default } from './use-lunatic';