@inseefr/lunatic 0.2.62 → 0.3.0-v2

package/src/use-lunatic/reducer/commons/Insee.code-workspace

@@ -0,0 +1,47 @@
+{
+  "folders": [
+	{
+		"path": "..\\..\\..\\..\\..\\spark-hadoop"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\rdf\\SPARQL-React"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\VTL-Lab-UI"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\vtl-editor"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\test-vtl"
+	},
+	{
+		"path": "..\\..\\..\\.."
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\Wilco"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\oidc-js-examples"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\deploy\\vtl-deploy"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\Lunatic-mui"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\Trevas-JS"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\GF-Pilot-client"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\SEP-Pilot-client"
+	},
+	{
+		"path": "..\\..\\..\\..\\..\\Statistics-Contextualized"
+	}
+],
+  "settings": {}
+}

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

@@ -0,0 +1,3 @@
+export { default as isOnEmptyPage } from './is-empty-on-empty-page';
+export { default as resizeArrayVariable } from './resize-array-variable';
+export * from './validate-condition-filter';

package/src/use-lunatic/reducer/commons/is-empty-on-empty-page.js

@@ -0,0 +1,29 @@
+import { getComponentsFromState, executeConditionFilter } from '../../commons';
+
+function isOnEmptyPage(state) {
+	const { executeExpression, pager } = state;
+	const { iteration } = pager;
+	const components = getComponentsFromState(state);
+	const rest = components.reduce(function (rest, component) {
+		const { conditionFilter } = component;
+		if (conditionFilter) {
+			const result = executeConditionFilter(
+				conditionFilter,
+				executeExpression,
+				iteration
+			);
+			if (result === true) {
+				return [...rest, component];
+			}
+		}
+		return rest;
+	}, []);
+
+	if (!rest.length) {
+		return true;
+	}
+
+	return false;
+}
+
+export default isOnEmptyPage;

package/src/use-lunatic/reducer/commons/resize-array-variable.js

@@ -0,0 +1,28 @@
+/**
+ * certaines variables du questionnaire sont de type tableau.
+ * Il faut alors vérifier qu'elles le sont véritablement.
+ * Il faut aussi vérifier quelles sont de la taille adéquate.
+ * @param {*} array
+ * @param {*} length
+ * @returns le tableau à la taille correcte.
+ */
+function resizeArrayVariable(array, length, defaultValue) {
+	if (!Array.isArray(array)) {
+		// create the array
+		return new Array(length).fill(defaultValue);
+	} else if (array.length !== length) {
+		// renew array end keep previous values
+		return new Array(length)
+			.fill(defaultValue)
+			.reduce(function (step, current, index) {
+				if (index < array.length) {
+					return [...step, array[index]];
+				}
+				return [...step, current];
+			}, []);
+	}
+	// do nothing
+	return array;
+}
+
+export default resizeArrayVariable;

package/src/use-lunatic/reducer/commons/validate-condition-filter.js

@@ -0,0 +1,20 @@
+import { executeConditionFilter } from '../../commons';
+
+function validateLoopConditionFilter(state, { next, iteration }) {
+	const { pages, executeExpression } = state;
+	const { components } = pages[next];
+	const [loop] = components;
+	if (loop) {
+		const { conditionFilter } = loop;
+		if (conditionFilter) {
+			return executeConditionFilter(
+				conditionFilter,
+				executeExpression,
+				iteration
+			);
+		}
+	}
+	return true;
+}
+
+export { validateLoopConditionFilter };

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

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

package/src/use-lunatic/reducer/reduce-go-next-page.js

@@ -0,0 +1,135 @@
+import { isOnEmptyPage, validateLoopConditionFilter } from './commons';
+import { getCompatibleVTLExpression } from '../commons';
+import { createValidateReducer } from './validate-controls';
+
+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 },
+		errors: undefined,
+	};
+}
+
+function reduceNextIteration(state) {
+	const { pager } = state;
+	const { iteration } = pager;
+	return {
+		...state,
+		pager: { ...pager, subPage: 0, iteration: iteration + 1 },
+		errors: undefined,
+	};
+}
+
+function reduceNextPage(state, { next, iterations }) {
+	const { pager } = state;
+	return {
+		...state,
+		isInLoop: false,
+		pager: {
+			...pager,
+			page: next,
+			iteration: undefined,
+			nbIterations: undefined,
+			subPage: undefined,
+			nbSubPages: undefined,
+		},
+		errors: 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,
+			},
+			errors: 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,
+			},
+			errors: undefined,
+		};
+	}
+	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 createValidateReducer(reduceGoNextPage);

package/src/use-lunatic/reducer/reduce-go-previous-page.js

@@ -0,0 +1,133 @@
+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];
+
+	//TODO: check if loop components are all filtered
+
+	// 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/use-lunatic/reducer/reduce-handle-change/index.js

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

package/src/use-lunatic/reducer/reduce-handle-change/reduce-cleaning.js

@@ -0,0 +1,44 @@
+import { getCompatibleVTLExpression } from '../../commons';
+
+function reduceCleaning(state, action) {
+	const { payload } = action;
+	const { response } = payload;
+	const { executeExpression, cleaning, updateBindings, variables, pager } =
+		state;
+	const { iteration } = pager;
+	if (response) {
+		const { name } = response;
+		if (name in cleaning) {
+			const expressions = cleaning[name];
+			const delta = Object.entries(expressions).reduce(function (
+				step,
+				[key, expression]
+			) {
+				const isCleaning = executeExpression(
+					getCompatibleVTLExpression(expression),
+					{ iteration }
+				);
+				if (!isCleaning && key in variables) {
+					const variableRoot = variables[key];
+					const { variable } = variableRoot;
+					const initialValue = variable?.values?.COLLECTED || null;
+					updateBindings(key, initialValue);
+					return { ...step, [key]: { ...variableRoot, value: initialValue } };
+				}
+				return step;
+			},
+			{});
+
+			return {
+				...state,
+				variables: {
+					...variables,
+					...delta,
+				},
+			};
+		}
+	}
+	return state;
+}
+
+export default reduceCleaning;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-handle-change.js

@@ -0,0 +1,89 @@
+import reduceVariablesArray from './reduce-variables-array';
+import reduceVariablesSimple from './reduce-variables-simple';
+import reduceCleaning from './reduce-cleaning';
+import reduceMissing from './reduce-missing';
+import reduceResizing from './reduce-resizing';
+import reduceLinksVariable from './reduce-links-variable';
+
+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, linksIterations } = args;
+
+	const { pager, variables } = state;
+	const { nbIterations, iteration } = pager;
+
+	if (linksIterations !== undefined) {
+		const variablesNext = reduceLinksVariable(variables, {
+			name,
+			value,
+			linksIterations,
+		});
+		return { ...state, variables: variablesNext };
+	} else 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 reduceResizing(
+		reduceMissing(
+			reduceCleaning(
+				updateBindings(updateVariables(state, action), action),
+				action
+			),
+			action
+		),
+		action
+	);
+}
+
+export default reduceHandleChange;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-links-variable.js

@@ -0,0 +1,18 @@
+function reduceLinksVariable(variables, { name, value, linksIterations }) {
+	if (name in variables) {
+		const variable = variables[name];
+		const { value: v } = variable;
+		const [x, y] = linksIterations;
+		if (v[x][y] !== undefined) {
+			v[x][y] = value;
+			return {
+				...variables,
+				[name]: { ...variable, value: v },
+			};
+		}
+		return variables;
+	}
+	return variables;
+}
+
+export default reduceLinksVariable;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-missing.js

@@ -0,0 +1,47 @@
+import reduceCleaning from './reduce-cleaning';
+
+function buildMissingValue(state, oldValue) {
+	const {
+		pager: { iteration },
+	} = state;
+	// Root question
+	if (iteration === undefined) return null;
+	// Loop question
+	const newValue = [...oldValue];
+	newValue[iteration] = null;
+	return newValue;
+}
+
+function reduceMissing(state, action) {
+	const {
+		payload: {
+			response: { name },
+		},
+	} = action;
+	const { missingBlock } = state;
+	if (name in missingBlock) {
+		const { variables, updateBindings } = state;
+		const toClean = missingBlock[name];
+		const delta = toClean.reduce((acc, variableName) => {
+			const { value, ...rest } = variables[variableName];
+			updateBindings(variableName, null);
+			const newValue = buildMissingValue(state, value);
+			return { ...acc, [variableName]: { ...rest, value: newValue } };
+		}, {});
+		const newStateAfterMissing = {
+			...state,
+			variables: { ...variables, ...delta },
+		};
+		// If missing clean variable which is also into cleaning case,
+		// we have to handle theses cleanings
+		// To check: do we have with this trick or triggering handle change action?
+		const newStateAfterCleaning = toClean.reduce(
+			(acc, v) => reduceCleaning(acc, { payload: { response: { name: v } } }),
+			newStateAfterMissing
+		);
+		return newStateAfterCleaning;
+	}
+	return state;
+}
+
+export default reduceMissing;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-resizing.js

@@ -0,0 +1,91 @@
+import { getCompatibleVTLExpression } from '../../commons';
+import { resizeArrayVariable } from '../commons';
+
+function reduceResizingVariables({
+	size,
+	variableArray,
+	variables,
+	executeExpression,
+	updateBindings,
+}) {
+	if (size !== undefined) {
+		const sizeValue = executeExpression(getCompatibleVTLExpression(size));
+		return variableArray.reduce((acc, v) => {
+			const { value } = variables[v];
+			const newValue = resizeArrayVariable(value, sizeValue, null);
+			updateBindings(v, newValue);
+			return {
+				...acc,
+				[v]: { ...variables[v], value: newValue },
+			};
+		}, {});
+	}
+	return {};
+}
+
+function reduceResizingLinksVariables({
+	sizeForLinksVariables,
+	linksVariables,
+	variables,
+	executeExpression,
+	updateBindings,
+}) {
+	if (Array.isArray(sizeForLinksVariables)) {
+		const [xSize, ySize] = sizeForLinksVariables.map((s) => {
+			return executeExpression(getCompatibleVTLExpression(s));
+		});
+		return linksVariables.reduce((acc, v) => {
+			const { value } = variables[v];
+			const newValue = resizeArrayVariable(
+				value.map((i) => resizeArrayVariable(i, ySize, null)),
+				xSize,
+				new Array(ySize).fill(null)
+			);
+			updateBindings(v, newValue);
+			return {
+				...acc,
+				[v]: { ...variables[v], value: newValue },
+			};
+		}, {});
+	}
+	return {};
+}
+
+function reduceResizing(state, action) {
+	const {
+		payload: {
+			response: { name },
+		},
+	} = action;
+	const { resizing, variables, updateBindings } = state;
+	if (name in resizing) {
+		const {
+			size,
+			variables: variableArray,
+			sizeForLinksVariables,
+			linksVariables,
+		} = resizing[name];
+		const { executeExpression } = state;
+		const newLinksVariables = reduceResizingLinksVariables({
+			sizeForLinksVariables,
+			linksVariables,
+			variables,
+			executeExpression,
+			updateBindings,
+		});
+		const newVariables = reduceResizingVariables({
+			size,
+			variableArray,
+			variables,
+			executeExpression,
+			updateBindings,
+		});
+		return {
+			...state,
+			variables: { ...variables, ...newLinksVariables, ...newVariables },
+		};
+	}
+	return state;
+}
+
+export default reduceResizing;