@inseefr/lunatic 0.3.3-experimental → 0.3.3-v2

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';

package/src/use-lunatic/initial-state.js

@@ -0,0 +1,32 @@
+import { COLLECTED, VTL } from 'utils/constants';
+
+const INITIAL_STATE = {
+	variables: {}, // map des variables du questionnaires
+	pages: {},
+	isInLoop: false,
+	isFirstPage: false,
+	isLastPage: false,
+	features: [VTL],
+	preferences: [COLLECTED],
+	savingType: COLLECTED,
+	cleaning: {},
+	missingBlock: {},
+	resizing: {},
+	pager: {
+		page: undefined,
+		maxPage: undefined,
+		subPage: undefined,
+		nbSubPages: undefined,
+		iteration: undefined,
+		nbIterations: undefined,
+	},
+	waiting: false,
+	errors: undefined,
+	/* fonctionnalités vtl & md */
+	updateBindings: () => {},
+	executeExpression: () => {},
+	handleChange: () => {},
+	modalForControls: false,
+};
+
+export default INITIAL_STATE;

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);