@inseefr/lunatic 0.1.0-hackathon → 0.1.0-v2

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-go-next-page.js

@@ -0,0 +1,129 @@
+import { isOnEmptyPage, validateLoopConditionFilter } from './commons';
+import { getCompatibleVTLExpression } from '../commons';
+
+function getNextPage(state) {
+	const { pager } = state;
+	const { page, maxPage } = pager;
+	const p = Number.parseInt(page);
+	const mp = maxPage;
+	if (p < mp) {
+		return `${p + 1}`;
+	}
+	return `${maxPage}`;
+}
+
+function reduceNextSubPage(state) {
+	const { pager } = state;
+	const { subPage } = pager;
+	return {
+		...state,
+		pager: { ...pager, subPage: subPage + 1 },
+	};
+}
+
+function reduceNextIteration(state) {
+	const { pager } = state;
+	const { iteration } = pager;
+	return {
+		...state,
+		pager: { ...pager, subPage: 0, iteration: iteration + 1 },
+	};
+}
+
+function reduceNextPage(state, { next, iterations }) {
+	const { pager } = state;
+	return {
+		...state,
+		isInLoop: false,
+		pager: {
+			...pager,
+			page: next,
+			iteration: undefined,
+			nbIterations: undefined,
+			subPage: undefined,
+			nbSubPages: undefined,
+		},
+	};
+}
+
+function reduceStartLoop(state, { next, iterations, loopDependencies }) {
+	const { pages, pager, executeExpression } = state;
+	const { subPages } = pages[next];
+
+	if (!validateLoopConditionFilter(state, { next })) {
+		return {
+			...state,
+			pager: {
+				...pager,
+				page: next,
+				subPage: undefined,
+				nbSubPages: undefined,
+				iteration: undefined,
+				nbIterations: undefined,
+			},
+		};
+	}
+	/* 
+	
+	
+	
+	*/
+	const nbIterations = executeExpression(
+		getCompatibleVTLExpression(iterations),
+		{
+			bindingDependencies: loopDependencies,
+			iteration: undefined,
+		}
+	);
+
+	if (Array.isArray(subPages)) {
+		return {
+			...state,
+			isInLoop: true,
+			pager: {
+				...pager,
+				page: next,
+				subPage: 0,
+				nbSubPages: subPages.length,
+				iteration: 0,
+				nbIterations,
+			},
+		};
+	}
+	return state;
+}
+
+function validateChange(state) {
+	if (isOnEmptyPage(state)) {
+		return reduceGoNextPage(state);
+	}
+
+	return state;
+}
+
+function reduceGoNextPage(state) {
+	const { pages, isInLoop, pager } = state;
+	const { iteration, nbIterations, subPage, nbSubPages, page } = pager;
+
+	if (isInLoop && subPage < nbSubPages - 1) {
+		return validateChange(reduceNextSubPage(state));
+	}
+	if (isInLoop && subPage === nbSubPages - 1 && iteration < nbIterations - 1) {
+		return validateChange(reduceNextIteration(state));
+	}
+
+	const next = getNextPage(state);
+	const { isLoop, iterations, loopDependencies } = pages[next];
+	if (next === page) {
+		// TODO on devrait jamais en arriver là !
+	}
+
+	if (isLoop) {
+		return validateChange(
+			reduceStartLoop(state, { next, iterations, loopDependencies })
+		);
+	}
+	return validateChange(reduceNextPage(state, { next }));
+}
+
+export default reduceGoNextPage;

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-go-previous-page.js

@@ -0,0 +1,131 @@
+import { isOnEmptyPage } from './commons';
+import { validateLoopConditionFilter } from './commons';
+import { getCompatibleVTLExpression } from '../commons';
+
+function getPreviousPage(pager) {
+	const { page } = pager;
+	const p = Number.parseInt(page);
+	if (p > 1) {
+		return `${page - 1}`;
+	}
+	return page;
+}
+
+function goStartLoop(state, { previous, iterations, loopDependencies }) {
+	const { pages, pager, executeExpression } = state;
+	const { subPages } = pages[previous];
+
+	if (validateLoopConditionFilter(state, { next: previous })) {
+		return {
+			...state,
+			pager: {
+				...pager,
+				page: previous,
+				subPage: undefined,
+				nbSubPages: undefined,
+				iteration: undefined,
+				nbIterations: undefined,
+			},
+		};
+	}
+
+	if (Array.isArray(subPages)) {
+		const nbIterations = executeExpression(
+			getCompatibleVTLExpression(iterations),
+			{
+				bindingDependencies: loopDependencies,
+			}
+		);
+		return {
+			...state,
+			isInLoop: true,
+			pager: {
+				...pager,
+				page: previous,
+				subPage: subPages.length - 1,
+				nbSubPages: subPages.length,
+				iteration: nbIterations - 1,
+				nbIterations,
+			},
+		};
+	}
+	return state;
+}
+
+function goPreviousSubPage(state) {
+	const { pager } = state;
+	const { subPage } = pager;
+
+	return {
+		...state,
+		pager: { ...pager, subPage: subPage - 1 },
+	};
+}
+
+function goPreviousIteration(state) {
+	const { pager, pages } = state;
+	const { iteration, page } = pager;
+	const { subPages } = pages[page];
+
+	return {
+		...state,
+		pager: { ...pager, subPage: subPages.length - 1, iteration: iteration - 1 },
+	};
+}
+
+function goPreviousPage(state, { previous }) {
+	const { pager } = state;
+	const { page } = pager;
+
+	if (previous !== page) {
+		return {
+			...state,
+			isInLoop: false,
+			pager: {
+				...pager,
+				page: previous,
+				iteration: undefined,
+				nbIterations: undefined,
+				subPage: undefined,
+				nbSubPages: undefined,
+			},
+		};
+	}
+
+	return state;
+}
+
+function validateChange(state) {
+	if (isOnEmptyPage(state)) {
+		return reduceGoPreviousPage(state);
+	}
+
+	return state;
+}
+
+function reduceGoPreviousPage(state) {
+	const { pages, pager, isInLoop } = state;
+	const { iteration, subPage } = pager;
+
+	// dans une boucle et l'itération courante n'est pas finie
+	if (isInLoop && subPage > 0) {
+		return validateChange(goPreviousSubPage(state));
+	}
+	// dans une boucle, l'itération courante est finie mais il reste encore au moins une autre
+	if (isInLoop && subPage === 0 && iteration > 0) {
+		return validateChange(goPreviousIteration(state));
+	}
+
+	const previous = getPreviousPage(pager);
+	const { isLoop, iterations, loopDependencies } = pages[previous];
+	// on rentre dans une boucle
+	if (isLoop) {
+		return validateChange(
+			goStartLoop(state, { previous, loopDependencies, iterations })
+		);
+	}
+	// on change de page
+	return validateChange(goPreviousPage(state, { previous }));
+}
+
+export default reduceGoPreviousPage;

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-handle-change/index.js

@@ -0,0 +1 @@
+export { default } from './reduce-handle-change';

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-handle-change/reduce-handle-change.js

@@ -0,0 +1,69 @@
+import reduceVariablesArray from './reduce-variables-array';
+import reduceVariablesSimple from './reduce-variables-simple';
+
+function isOnSubPage(pager) {
+	const { subPage } = pager;
+	return subPage !== undefined;
+}
+
+function updateVariables(state, action) {
+	const { payload } = action;
+	const { response, value, args = {} } = payload;
+	const { name } = response;
+	const { loop, index, length } = args;
+
+	const { pager, variables } = state;
+	const { nbIterations, iteration } = pager;
+
+	if (loop) {
+		const variablesNext = reduceVariablesArray(variables, {
+			name,
+			value,
+			index,
+			length,
+		});
+		return { ...state, variables: variablesNext };
+	} else if (isOnSubPage(pager)) {
+		const variablesNext = reduceVariablesArray(variables, {
+			name,
+			value,
+			index: iteration,
+			length: nbIterations,
+		});
+
+		return { ...state, variables: variablesNext };
+	} else {
+		const variablesNext = reduceVariablesSimple(variables, { name, value });
+		return { ...state, variables: variablesNext };
+	}
+}
+
+/**
+ * met à jour bindings pour l'exe du VTL (en appelant la fonction fournit par createExecuteExpression)
+ * @param {*} state
+ * @param {*} action
+ * @returns
+ */
+function updateBindings(state, action) {
+	const { payload } = action;
+	const { response } = payload;
+	const { name } = response;
+	const { updateBindings, variables } = state;
+	const { value } = variables[name];
+
+	updateBindings(name, value);
+
+	return state;
+}
+
+/**
+ *
+ * @param {*} state
+ * @param {*} action
+ * @returns
+ */
+function reduceHandleChange(state, action) {
+	return updateBindings(updateVariables(state, action), action);
+}
+
+export default reduceHandleChange;

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-handle-change/reduce-variables-array.js

@@ -0,0 +1,22 @@
+import { resizeArrayVariable } from '../commons';
+
+function reduceVariablesArray(variables, { name, value, index, length }) {
+	if (name in variables) {
+		const variable = variables[name];
+		const { value: previousValue } = variable;
+
+		// validation de la valeur courante : si pas un tableau ou si la taille du tableau a changé
+		let valueNext = resizeArrayVariable([...previousValue], length);
+
+		// value affectation
+		valueNext[index] = value;
+		return {
+			...variables,
+			[name]: { ...variable, value: valueNext },
+		};
+	}
+
+	return variables;
+}
+
+export default reduceVariablesArray;

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-handle-change/reduce-variables-simple.js

@@ -0,0 +1,13 @@
+function reduceVariablesSimple(variables, { name, value }) {
+	if (name in variables) {
+		const variable = variables[name];
+		return {
+			...variables,
+			[name]: { ...variable, value },
+		};
+	}
+
+	return variables;
+}
+
+export default reduceVariablesSimple;

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-on-init.js

@@ -0,0 +1,166 @@
+import {
+	createMapPages,
+	checkLoops,
+	isFirstLastPage,
+	createExecuteExpression,
+} from '../commons';
+
+/* à bouger d'ici */
+
+function getInitalValueFromCollected(variable, data = {}) {
+	const { values, name } = variable;
+	let fromData;
+	if (name in data) {
+		const { COLLECTED, FORCED } = data[name];
+		fromData = COLLECTED || FORCED;
+	}
+	if (values) {
+		const { COLLECTED, FORCED } = values;
+		return fromData || FORCED || COLLECTED;
+	}
+	return undefined;
+}
+
+function getInitialValueFromExternal(variable, data = {}) {
+	const { name } = variable;
+	if (name in data) {
+		return data[name];
+	}
+	return undefined;
+}
+
+function getInitialValue(variable, data = {}) {
+	const { COLLECTED, EXTERNAL, CALCULATED } = data;
+	const { variableType } = variable;
+	switch (variableType) {
+		case 'COLLECTED':
+			return getInitalValueFromCollected(variable, COLLECTED);
+		case 'EXTERNAL':
+			return getInitialValueFromExternal(variable, EXTERNAL);
+		case 'CALCULATED':
+			return getInitialValueFromExternal(variable, CALCULATED);
+		default:
+			return null;
+	}
+}
+
+function appendToArrayMap(map, key, entry) {
+	if (key in map) {
+		return { ...map, [key]: [...map[key], entry] };
+	}
+	return { ...map, [key]: [entry] };
+}
+
+function appendToObjectMap(map, key, object) {
+	if (key in map) {
+		return { ...map, [key]: { ...map[key], ...object } };
+	}
+	return { ...map, [key]: object };
+}
+
+/**
+ *
+ * @param {*} source
+ * @param {*} data
+ * @returns
+ */
+function createVariables(source, data) {
+	const { variables } = source;
+	const [mapVariablesTypes, mapVariables] = variables.reduce(
+		function ([mapType, mapVar], variable) {
+			const { variableType: type, name } = variable;
+
+			return [
+				appendToArrayMap(mapType, type, variable),
+				appendToObjectMap(mapVar, name, {
+					variable,
+					type,
+					value: getInitialValue(variable, data),
+				}),
+			];
+		},
+		[{}, {}]
+	);
+	//
+	const { CALCULATED = [] } = mapVariablesTypes;
+	CALCULATED.forEach(function (calculated) {
+		const { bindingDependencies = [] } = calculated;
+		bindingDependencies.forEach(function (name) {
+			if (name in mapVariables) {
+				const variable = mapVariables[name];
+				const { CalculatedLinked } = variable;
+				if (CalculatedLinked) {
+					CalculatedLinked.push(calculated);
+				} else {
+					variable.CalculatedLinked = [calculated];
+				}
+			}
+		});
+	});
+
+	return mapVariables;
+}
+/* */
+
+function checkInLoop(state) {
+	const { pager, pages, executeExpression } = state;
+	const { page } = pager;
+	if (page in pages) {
+		const { isLoop, subPages, iterations, loopDependencies } = pages[page];
+
+		if (isLoop) {
+			return {
+				...state,
+				pager: {
+					...pager,
+					subPage: 0,
+					nbSubPages: subPages.length,
+					iteration: 0,
+					nbIterations: executeExpression(iterations, {
+						iteration: 0,
+						bindingDependencies: loopDependencies,
+					}),
+				},
+			};
+		}
+	}
+	return state;
+}
+
+function reduceOnInit(state, action) {
+	const { payload } = action;
+	const { source, data, initialPage, features } = payload;
+	if (source && data) {
+		const variables = createVariables(source, data); // map des variables
+		const [executeExpression, updateBindings] = createExecuteExpression(
+			variables,
+			features
+		);
+		const pages = checkLoops(createMapPages(source));
+		const { maxPage } = source;
+		const pager = {
+			page: initialPage,
+			maxPage: Number.parseInt(maxPage) || 1,
+			subPage: undefined,
+			nbSubPages: undefined,
+			iteration: undefined,
+			nbIterations: undefined,
+		};
+		const { isFirstPage, isLastPage } = isFirstLastPage(pager);
+
+		return checkInLoop({
+			...state,
+			variables,
+			pages,
+			isFirstPage,
+			isLastPage,
+			pager,
+			executeExpression,
+			updateBindings,
+		});
+	}
+
+	return state;
+}
+
+export default reduceOnInit;

package/src/utils/to-expose/hooks/use-lunatic/reducer/reduce-on-set-waiting.js

@@ -0,0 +1,7 @@
+function reduceOnSetWaiting(state, action) {
+	const { payload } = action;
+	const { status } = payload;
+	return { ...state, waiting: status };
+}
+
+export default reduceOnSetWaiting;

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

@@ -0,0 +1,26 @@
+import reduceOnInit from './reduce-on-init';
+import reduceGoNextPage from './reduce-go-next-page';
+import reduceGoPreviousPage from './reduce-go-previous-page';
+import reduceHandleChange from './reduce-handle-change';
+import reduceOnSetWaiting from './reduce-on-set-waiting';
+import * as actions from '../actions';
+
+function reducer(state, action) {
+	const { type } = action;
+	switch (type) {
+		case actions.ON_INIT:
+			return reduceOnInit(state, action);
+		case actions.GO_NEXT_PAGE:
+			return reduceGoNextPage(state, action);
+		case actions.GO_PREVIOUS_PAGE:
+			return reduceGoPreviousPage(state, action);
+		case actions.HANDLE_CHANGE:
+			return reduceHandleChange(state, action);
+		case actions.ON_SET_WAITING:
+			return reduceOnSetWaiting(state, action);
+		default:
+			return state;
+	}
+}
+
+export default reducer;

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

@@ -0,0 +1,79 @@
+import { useReducer, useEffect, useCallback } from 'react';
+import INITIAL_STATE from './initial-state';
+import * as actions from './actions';
+import reducer from './reducer';
+import { loadSuggester } from './commons';
+import { useComponentsFromState, getPageTag, isFirstLastPage } from './commons';
+
+function useLunatic({ source, data, initialPage, features }) {
+	const [state, dispatch] = useReducer(reducer, INITIAL_STATE);
+	const { pager, executeExpression, waiting } = state;
+	const components = useComponentsFromState(state);
+	const { suggesters } = source;
+
+	useEffect(
+		function () {
+			async function doIt() {
+				if (suggesters) {
+					dispatch(actions.onSetWaiting(true));
+					const status = await loadSuggester(suggesters);
+					dispatch(actions.onSetWaiting(false));
+				}
+			}
+			doIt();
+		},
+		[suggesters]
+	);
+
+	useEffect(
+		function () {
+			dispatch(actions.onInit({ source, data, initialPage, features }));
+		},
+		[source, data, initialPage, features]
+	);
+
+	const goNextPage = useCallback(
+		function () {
+			dispatch(actions.goNextPage());
+		},
+		[dispatch]
+	);
+
+	const goPreviousPage = useCallback(
+		function () {
+			dispatch(actions.goPreviousPage());
+		},
+		[dispatch]
+	);
+
+	const getComponents = useCallback(
+		function () {
+			return components;
+		},
+		[components]
+	);
+	const handleChange = useCallback(
+		function (response, value, args) {
+			dispatch(actions.handleChange(response, value, args));
+		},
+		[dispatch]
+	);
+
+	const pageTag = getPageTag(pager);
+	const { isFirstPage, isLastPage } = isFirstLastPage(pager);
+
+	return {
+		getComponents,
+		handleChange,
+		goNextPage,
+		goPreviousPage,
+		executeExpression,
+		pageTag,
+		isFirstPage,
+		isLastPage,
+		pager,
+		waiting,
+	};
+}
+
+export default useLunatic;

package/src/utils/to-expose/index.js

@@ -1,11 +1,16 @@
-// updateQuestionnaire is useless since 2.0 optimization efforts
-// export { updateQuestionnaire } from './handler';
-export { mergeQuestionnaireAndData } from './init-questionnaire';
-export {
-	getState,
-	getCollectedState,
-	getCollectedStateByValueType,
-	getBindings,
-} from './state';
-export { interpret } from './interpret';
-export { default as useLunatic } from './hooks';
+// updateQuestionnaire is useless since 2.0 optimization efforts
+// export { updateQuestionnaire } from './handler';
+// export { mergeQuestionnaireAndData } from './init-questionnaire';
+// export {
+// 	getState,
+// 	getCollectedState,
+// 	getCollectedStateByValueType,
+// 	getBindings,
+// } from './state';
+// export { interpret } from './interpret';
+// export * from './hooks';
+export { default as useLunatic } from './hooks';
+
+export const interpret = () => {
+	throw new Error('redefine interpret if needed');
+};