@inseefr/lunatic 0.1.0-hackathon → 0.1.0-v2

package/src/utils/to-expose/hooks/lunatic.js

@@ -1,8 +1,8 @@
 import { useState, useEffect, useCallback } from 'react';
 import { mergeQuestionnaireAndData } from '../init-questionnaire';
 import { getBindings } from '../state';
-import { updateQuestionnaire } from '../handler';
-import { getPage, FLOW_NEXT, FLOW_PREVIOUS } from '../../lib';
+import { updateQuestionnaire, updateExternals } from '../handler';
+import { getPage, FLOW_NEXT, FLOW_PREVIOUS, getControls } from '../../lib';
 import { COLLECTED } from '../../../constants';
 import { useFilterComponents } from './filter-components';
 import { loadSuggesters } from '../../store-tools/auto-load';
@@ -16,7 +16,8 @@ const useLunatic = (
 		features = ['VTL'],
 		management = false,
 		pagination = false,
-		initialPage = '1',
+		modalForControls = false,
+		initialPage = '16',
 		logFunction = null,
 		autoSuggesterLoading = false,
 		suggesterFetcher,
@@ -32,6 +33,9 @@ const useLunatic = (
 	const [page, setPage] = useState(initialPage);
 
 	const [todo, setTodo] = useState({});
+	const [todoExternals, setTodoExternals] = useState({});
+
+	const [modalContent, setModalContent] = useState(null);
 
 	const components = useFilterComponents({
 		questionnaire,
@@ -40,7 +44,7 @@ const useLunatic = (
 		features: featuresWithoutMD,
 		page,
 		pagination,
-		todo,
+		todo: { ...todo, ...todoExternals },
 	});
 
 	const { suggesters: suggestersToLoad } = source;
@@ -54,6 +58,7 @@ const useLunatic = (
 			) {
 				const s = suggestersToLoad.reduce(function (current, storeInfo) {
 					const { name } = storeInfo;
+					if (!suggesters[name]) return current;
 					return {
 						...current,
 						[name]: {
@@ -92,7 +97,17 @@ const useLunatic = (
 				flow: FLOW_NEXT,
 				management,
 			});
-			setPage(nextPage);
+			if (modalForControls) {
+				const controls = getControls({
+					page,
+					features: featuresWithoutMD,
+					components,
+					bindings,
+					preferences,
+				});
+				if (controls.length > 0) setModalContent({ page: nextPage, controls });
+				else setPage(nextPage);
+			} else setPage(nextPage);
 		}
 	};
 
@@ -109,7 +124,18 @@ const useLunatic = (
 				flow: FLOW_PREVIOUS,
 				management,
 			});
-			setPage(previousPage);
+			if (modalForControls) {
+				const controls = getControls({
+					page,
+					features: featuresWithoutMD,
+					components,
+					bindings,
+					preferences,
+				});
+				if (controls.length > 0)
+					setModalContent({ page: previousPage, controls });
+				else setPage(previousPage);
+			} else setPage(previousPage);
 		}
 	};
 
@@ -143,6 +169,10 @@ const useLunatic = (
 		setTodo((t) => ({ ...t, ...updatedValue }));
 	}, []);
 
+	const handleExternals = useCallback((externals) => {
+		setTodoExternals((t) => ({ ...t, ...externals }));
+	}, []);
+
 	// Assume we only want to handle source update
 	useEffect(() => {
 		setQuestionnaire(mergeQuestionnaireAndData(source)(data));
@@ -168,10 +198,41 @@ const useLunatic = (
 		management,
 	]);
 
+	useEffect(() => {
+		if (Object.keys(todoExternals).length !== 0) {
+			const newQ = updateExternals(questionnaire)(logFunction)(todoExternals);
+			setQuestionnaire(newQ);
+			setTodoExternals({});
+		}
+	}, [todoExternals, logFunction, questionnaire]);
+
+	const cancelModal = () => {
+		setModalContent(null);
+	};
+
+	const validateModal = () => {
+		setPage(modalContent.page);
+		setModalContent(null);
+	};
+
+	const componentsToDiplay =
+		pagination && modalContent
+			? [
+					{
+						componentType: 'Modal',
+						controls: modalContent.controls,
+						validateModal,
+						cancelModal,
+					},
+					...components,
+			  ]
+			: components;
+
 	return {
 		questionnaire,
 		handleChange,
-		components,
+		handleExternals,
+		components: componentsToDiplay,
 		bindings,
 		pagination: {
 			page,

package/src/utils/to-expose/hooks/use-lunatic/actions.js

@@ -0,0 +1,23 @@
+export const GO_NEXT_PAGE = 'use-lunatic/go-next';
+export const goNextPage = () => ({ type: GO_NEXT_PAGE });
+
+export const GO_PREVIOUS_PAGE = 'use-lunatic/go-previous';
+export const goPreviousPage = () => ({ type: GO_PREVIOUS_PAGE });
+
+export const ON_INIT = 'use-lunatic/on-init';
+export const onInit = ({ data, source, initialPage, features }) => ({
+	type: ON_INIT,
+	payload: { data, source, initialPage, features },
+});
+
+export const HANDLE_CHANGE = 'use-lunatic/handle-change';
+export const handleChange = (response, value, args) => ({
+	type: HANDLE_CHANGE,
+	payload: { response, value, args },
+});
+
+export const ON_SET_WAITING = 'use-lunatic/on-set-waiting';
+export const onSetWaiting = (status) => ({
+	type: ON_SET_WAITING,
+	payload: { status },
+});

package/src/utils/to-expose/hooks/use-lunatic/commons/check-loops.js

@@ -0,0 +1,61 @@
+import isPaginatedLoop from './is-paginated-loop';
+
+function extractSubPages(component, previous = []) {
+	const { components } = component;
+	return components.reduce(function (pages, component) {
+		const { page } = component;
+
+		if (page && pages.indexOf(page) === -1) {
+			return [...pages, page];
+		}
+		return pages;
+	}, previous);
+}
+
+function extractLoop(components) {
+	return components.reduce(
+		function ({ isLoop, subPages, iterations, loopDependencies }, component) {
+			const currentIsLoop = isPaginatedLoop(component);
+			if (currentIsLoop) {
+				return {
+					isLoop: true,
+					subPages: extractSubPages(component, subPages),
+					iterations: iterations || component.iterations,
+					loopDependencies: loopDependencies || component.loopDependencies,
+				};
+			}
+			return { isLoop, subPages, iterations };
+		},
+		{
+			isLoop: false,
+			subPages: undefined,
+			iterations: undefined,
+			loopDependencies: undefined,
+		}
+	);
+}
+
+function checkLoops(pages) {
+	return Object.entries(pages).reduce(function (map, current) {
+		const [number, content] = current;
+		if (number !== 'unpaged') {
+			const { components } = content;
+			const { isLoop, subPages, iterations, loopDependencies } =
+				extractLoop(components);
+
+			return {
+				...map,
+				[number]: {
+					...content,
+					isLoop,
+					subPages,
+					iterations,
+					loopDependencies,
+				},
+			};
+		}
+		return map;
+	}, {});
+}
+
+export default checkLoops;

package/src/utils/to-expose/hooks/use-lunatic/commons/create-map-pages.js

@@ -0,0 +1,69 @@
+import isPaginatedLoop from './is-paginated-loop';
+
+function isUnpaginated(questionnaire) {
+	const { maxPage } = questionnaire;
+	return maxPage === undefined;
+}
+
+/**
+ *
+ * @param {*} component: object
+ * @param {*} page: string
+ * @param {*} map Map<page,{ components: Array<component>, isLoop: boolean, subPages: Array<page> }>
+ * @returns
+ */
+function mergeComponent(component, page, map) {
+	if (!page) {
+		return { ...map, unpaged: [...map.unpaged, component] };
+	}
+	if (page in map) {
+		const current = map[page];
+		const { components } = current;
+		return {
+			...map,
+			[page]: { ...current, components: [...components, component] },
+		};
+	}
+	return { ...map, [page]: { components: [component] } };
+}
+
+function mergeNestedComponents(components, map) {
+	return components.reduce(function (current, component) {
+		const { page } = component;
+		if (page) {
+			return mergeComponent(component, page, current);
+		}
+
+		return current;
+	}, map);
+}
+/**
+ *
+ * @param {*} components
+ * @returns
+ */
+function createPages(questionnaire) {
+	const { components } = questionnaire;
+	if (isUnpaginated(questionnaire)) {
+		return { 1: { components } }; // no page -> one page ;)
+	}
+	const map = components.reduce(
+		function (current, component) {
+			const { components, page } = component;
+			if (isPaginatedLoop(component)) {
+				return mergeComponent(
+					component,
+					page,
+					mergeNestedComponents(components, current)
+				);
+			}
+
+			return mergeComponent(component, page, current);
+		},
+		{ unpaged: [] }
+	);
+
+	return map;
+}
+
+export default createPages;

package/src/utils/to-expose/hooks/use-lunatic/commons/execute-condition-filter.js

@@ -0,0 +1,16 @@
+import getCompatibleVTLExpression from './get-compatible-vtl-expression';
+
+function executeConditionFilter(filter, execute, iteration) {
+	if (filter && typeof execute === 'function') {
+		const { value } = filter;
+
+		function logging(...args) {
+			console.warn(args);
+			console.warn('executeConditionFilter:', filter);
+		}
+		return execute(getCompatibleVTLExpression(value), { iteration, logging });
+	}
+	return undefined;
+}
+
+export default executeConditionFilter;

package/src/utils/to-expose/hooks/use-lunatic/commons/execute-expression/create-execute-expression.js

@@ -0,0 +1,182 @@
+import executeExpression from './execute-expression';
+import getExpressionVariables from './get-expressions-variables';
+import createMemoizer from './create-memoizer';
+import createRefreshCalculated from './create-refresh-calculated';
+
+function validateExpression(expObject) {
+	if (typeof expObject === 'object') {
+		const { type } = expObject;
+		if (type === 'VTL|MD') {
+			return expObject;
+		}
+	}
+	throw new Error(`Non-VTL compatible expression : ${expObject}`);
+}
+
+function getVtlCompatibleValue(value) {
+	if (value === undefined) {
+		return null;
+	}
+	if (Array.isArray(value)) {
+		return {
+			dataStructure: { result: {} },
+			dataPoints: {
+				result: value,
+			},
+		};
+	}
+
+	return value;
+}
+
+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
+	 * @param {*} value
+	 */
+	function updateBindings(name, value) {
+		// update des bindings
+		if (name in bindings) {
+			bindings[name] = value;
+			collectedUpdated.set(name, []);
+		}
+		// enrichissement des variables à rafraîchir
+		const { CalculatedLinked = [] } = variables[name];
+
+		CalculatedLinked.forEach(function (variable) {
+			const { name } = variable;
+			setToRefreshCalculated(name, variable);
+		});
+	}
+
+	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 }) {
+		const value = bindings[name];
+		if (iteration !== undefined && Array.isArray(value)) {
+			if (iteration < value.length) {
+				return value[iteration];
+			}
+			return null;
+		}
+		return getVtlCompatibleValue(value);
+	}
+
+	function fillVariablesValues(map, { iteration }) {
+		return Object.entries(map).reduce(function (sub, [name, _]) {
+			return {
+				...sub,
+				[name]: resolveUseContext(name, { iteration }),
+			};
+		}, {});
+	}
+
+	/**
+	 *
+	 * @param {*} vtlObject
+	 * @param {*} args
+	 * @returns
+	 */
+	function execute(expObject, args) {
+		const { value: expression } = validateExpression(expObject);
+		const { iteration, 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,
+			}),
+			{ rootExpression: expression, iteration }
+		);
+
+		const memoized = getMemoizedValue(expression, vtlBindings);
+
+		if (!memoized) {
+			const result = executeExpression(
+				vtlBindings,
+				expression,
+				features,
+				logging || loggingDefault
+			);
+			memoize(expression, vtlBindings, result);
+
+			return result;
+		}
+		return memoized;
+	}
+
+	return [execute, updateBindings];
+}
+
+export default createExecuteExpression;

package/src/utils/to-expose/hooks/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/utils/to-expose/hooks/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/utils/to-expose/hooks/use-lunatic/commons/execute-expression/execute-expression.js

@@ -0,0 +1,60 @@
+import { interpret } from '@inseefr/trevas';
+
+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 executeVtl(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 loggingDefault(expression, bindings, e) {
+	if (process.env.NODE_ENV === 'development') {
+		console.warn(`VTL error :  ${expression}`, bindings);
+		console.warn(e);
+	}
+}
+
+function executeExpression(
+	vtlBindings,
+	expression,
+	features /* VTL, MD */,
+	logging = loggingDefault
+) {
+	if (expression) {
+		try {
+			if (features.includes('VTL')) {
+				return executeVtl(expression, vtlBindings);
+			}
+			return expression;
+		} catch (e) {
+			// expression en erreur ou simple chaîne de caractère
+			logging(expression, vtlBindings, e);
+			return expression;
+		}
+		// TODO MD only for labels, not for filtering
+	}
+	return '';
+}
+
+export default executeExpression;

package/src/utils/to-expose/hooks/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/utils/to-expose/hooks/use-lunatic/commons/execute-expression/index.js

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