@inseefr/lunatic 0.1.0-hackathon → 0.1.0-v2

package/src/utils/to-expose/hooks/use-lunatic/commons/fill-component-expressions.js

@@ -0,0 +1,113 @@
+const VTL_ATTRIBUTES = [
+	'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];
+
+		if (typeof candidate === 'object') {
+			const { type } = candidate;
+			if (type === 'VTL|MD') {
+				return {
+					...object,
+					[path]: executeExpression(candidate, {
+						iteration,
+					}),
+				};
+			}
+		}
+
+		return object;
+	}
+
+	/**
+	 *
+	 * @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, { executeExpression, iteration }) {
+	return fillAttributes(component, { executeExpression, iteration });
+}
+
+export default fillComponentExpressions;

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

@@ -0,0 +1,31 @@
+import getComponentValue from './get-component-value';
+import fillComponentExpressions from './fill-component-expressions';
+
+function fillComponentValue(component, state) {
+	const value = getComponentValue(component, state);
+	return { ...component, value };
+}
+
+function fillPagination(component, state) {
+	const { pager } = state;
+	const { iteration } = pager;
+
+	return { ...component, iteration };
+}
+
+function fillComponents(components, state) {
+	return components.map(function (component) {
+		const { pager, executeExpression } = state;
+		const { iteration } = pager;
+
+		return fillComponentExpressions(
+			fillPagination(fillComponentValue(component, state), state),
+			{
+				executeExpression,
+				iteration,
+			}
+		);
+	});
+}
+
+export default fillComponents;

package/src/utils/to-expose/hooks/use-lunatic/commons/get-compatible-vtl-expression.js

@@ -0,0 +1,14 @@
+function getCompatibleVTLExpression(expression) {
+	if (typeof expression === 'string') {
+		return { value: expression, type: 'VTL|MD' };
+	}
+	if (typeof expression === 'object') {
+		const { type } = expression;
+		if (expression === 'VTL') {
+			return expression;
+		}
+	}
+	throw new Error(`Non-VTL compatible expression : ${expression}`);
+}
+
+export default getCompatibleVTLExpression;

package/src/utils/to-expose/hooks/use-lunatic/commons/get-component-value/get-component-value.js

@@ -0,0 +1,161 @@
+// function isCheckboxGroup(component) {
+// 	const { componentType } = component;
+// 	return componentType === 'CheckboxGroup';
+// }
+
+// function isLoopComponent(component) {
+// 	const { componentType, lines, iterations } = component;
+// 	if (componentType === 'Loop' && iterations !== undefined) {
+// 		return true;
+// 	}
+// 	if (
+// 		componentType === 'Loop' &&
+// 		typeof lines === 'object' &&
+// 		lines.max !== undefined &&
+// 		lines.min !== undefined
+// 	) {
+// 		return true;
+// 	}
+// 	return false;
+// }
+
+function isInSubPage(state) {
+	const { pager } = state;
+	const { subPage } = pager;
+
+	return subPage !== undefined;
+}
+
+// function getLoopValues(component, variables) {
+// 	const { components } = component;
+// 	return components.reduce(function (map, component) {
+// 		// TODO responses cells
+// 		const { response } = component;
+// 		if (response) {
+// 			const { name } = response;
+// 			if (name) {
+// 				return { ...map, [name]: getCollectedValue(component, variables) };
+// 			}
+// 		}
+// 		return map;
+// 	}, {});
+// }
+
+// function getCheckboxGroupValue(component, variables) {
+// 	const { responses } = component;
+// 	if (typeof responses === 'object') {
+// 		return responses.reduce(function (map, entry) {
+// 			const { response } = entry;
+// 			if (entry) {
+// 				const { name } = response;
+// 				return { ...map, [name]: getCollectedValue({ response }, variables) };
+// 			}
+// 			return map;
+// 		}, {});
+// 	}
+// 	return {};
+// }
+
+// function getCollectedValue(component, variables) {
+// 	const { response } = component;
+
+// 	if (response) {
+// 		const { name } = response;
+// 		if (name in variables) {
+// 			const { value } = variables[name];
+// 			return value;
+// 		}
+// 	}
+
+// 	return undefined;
+// }
+
+// function getSubPageValue(state, component, variables) {
+// 	const value = getCollectedValue(component, variables);
+
+// 	if (value && Array.isArray(value)) {
+// 		const { pager } = state;
+// 		const { iteration } = pager;
+// 		return value[iteration];
+// 	}
+// 	return 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 collecteComponentResponse({ component, variables, map = {} }) {
+	const { components, response, responses } = component;
+	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/utils/to-expose/hooks/use-lunatic/commons/get-component-value/index.js

@@ -0,0 +1 @@
+export { default } from './get-component-value';

package/src/utils/to-expose/hooks/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/utils/to-expose/hooks/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/utils/to-expose/hooks/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-component-expressions';
+export { default as loadSuggester } from './load-suggesters';
+export { default as getCompatibleVTLExpression } from './get-compatible-vtl-expression';

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

@@ -0,0 +1,59 @@
+import {
+	openOrCreateStore,
+	clearStoreInfo,
+	clearStoreData,
+	updateStoreInfo,
+} from '../../../../store-tools';
+import { createAppendTask } from '../../../../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/utils/to-expose/hooks/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/utils/to-expose/hooks/use-lunatic/index.js

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

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

@@ -0,0 +1,22 @@
+const INITIAL_STATE = {
+	variables: {}, // map des variables du questionnaires
+	pages: {},
+	isInLoop: false,
+	isFirstPage: false,
+	isLastPage: false,
+	features: ['VTL'],
+	pager: {
+		page: undefined,
+		maxPage: undefined,
+		subPage: undefined,
+		nbSubPages: undefined,
+		iteration: undefined,
+		nbIterations: undefined,
+	},
+	waiting: false,
+	/* fonctionnalités vtl & md */
+	updateBindings: () => {},
+	executeExpression: () => {},
+};
+
+export default INITIAL_STATE;

package/src/utils/to-expose/hooks/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 { default as validateLoopConditionFilter } from './validate-loop-condition-filter';

package/src/utils/to-expose/hooks/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 !== false) {
+				return [...rest, component];
+			}
+		}
+		return rest;
+	}, []);
+
+	if (!rest.length) {
+		return true;
+	}
+
+	return false;
+}
+
+export default isOnEmptyPage;

package/src/utils/to-expose/hooks/use-lunatic/reducer/commons/resize-array-variable.js

@@ -0,0 +1,26 @@
+/**
+ * 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) {
+	if (!Array.isArray(array)) {
+		// create the array
+		return new Array(length).fill(null);
+	} else if (array.length !== length) {
+		// renew array end keep previous values
+		return new Array(length).fill(null).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/utils/to-expose/hooks/use-lunatic/reducer/commons/validate-loop-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 default validateLoopConditionFilter;

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

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