@inseefr/lunatic 0.2.0-experimental → 0.2.0-v2

package/src/use-lunatic/reducer/reduce-on-init.js

@@ -0,0 +1,174 @@
+import {
+	createMapPages,
+	checkLoops,
+	isFirstLastPage,
+	createExecuteExpression,
+} from '../commons';
+import { COLLECTED } from 'utils/constants';
+
+/* à 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, handleChange, preferences } =
+		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, cleaning = {}, missingBlock = {}, resizing = {} } = 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,
+			cleaning,
+			missingBlock,
+			resizing,
+			variables,
+			pages,
+			isFirstPage,
+			isLastPage,
+			pager,
+			executeExpression,
+			updateBindings,
+			handleChange,
+			preferences: preferences || [COLLECTED],
+		});
+	}
+
+	return state;
+}
+
+export default reduceOnInit;

package/src/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/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/use-lunatic/reducer/validate-controls/create-validate-reducer.js

@@ -0,0 +1,86 @@
+import { getComponentsFromState } from '../../commons';
+
+// export const CRITICALITY = {
+// 	INFO: 'INFO',
+// 	WARN: 'WARN',
+// };
+
+function resolveControl(state, control) {
+	const { executeExpression, pager = {} } = state;
+	const { iteration } = pager;
+	const { criticality, errorMessage, id } = control;
+	const { control: { value = 'true' } = {} } = control;
+	try {
+		const result = executeExpression(value, { iteration });
+		if (!result) {
+			return { criticality, errorMessage, id };
+		}
+		return undefined;
+	} catch (e) {
+		console.log(`Error on validating control ${value}`);
+		return undefined;
+	}
+}
+
+function resolveComponentControls(state, controls) {
+	return controls.reduce(function (errors, control) {
+		const error = resolveControl(state, control);
+		if (error) {
+			return [...errors, error];
+		}
+		return errors;
+	}, []);
+}
+
+function validateComponents(state, components) {
+	// TODO check components in components (Loop, etc...)
+	return components.reduce(function (errors, component) {
+		const { controls, id } = component;
+		if (Array.isArray(controls)) {
+			const componentErrors = resolveComponentControls(state, controls);
+			if (componentErrors.length) {
+				return { ...errors, [id]: componentErrors };
+			}
+		}
+		return errors;
+	}, {});
+}
+
+// function isBlockingErrors(errors) {
+// 	// TODO find criticality WARN
+// 	return false;
+// }
+
+function isErrors(errors) {
+	if (errors) {
+		return Object.keys(errors).length > 0;
+	}
+	return false;
+}
+
+function createValidateReducer(reducer) {
+	// Nothing to init
+	return function (state, action) {
+		const { payload } = action;
+		const { block } = payload;
+		const components = getComponentsFromState(state);
+		const { errors: prec } = state;
+
+		if (block) {
+			return { ...state, errors: undefined };
+		}
+
+		if (prec) {
+			return reducer({ ...state, errors: undefined }, action);
+		}
+
+		const errors = validateComponents(state, components);
+		if (isErrors(errors)) {
+			return { ...state, errors };
+		}
+
+		return reducer({ ...state, errors: undefined }, action);
+	};
+}
+
+export default createValidateReducer;

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

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

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

@@ -0,0 +1,105 @@
+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 nothing() {}
+
+function useLunatic({
+	source,
+	data,
+	initialPage,
+	features,
+	preferences,
+	onChange = nothing,
+}) {
+	const [state, dispatch] = useReducer(reducer, INITIAL_STATE);
+	const { pager, waiting, errors } = 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]
+	);
+
+	const goNextPage = useCallback(
+		function (payload = {}) {
+			dispatch(actions.goNextPage(payload));
+		},
+		[dispatch]
+	);
+
+	const getErrors = useCallback(
+		function () {
+			return errors;
+		},
+		[errors]
+	);
+
+	const goPreviousPage = useCallback(
+		function () {
+			dispatch(actions.goPreviousPage());
+		},
+		[dispatch]
+	);
+
+	const getComponents = useCallback(
+		function () {
+			// validate variables ?
+			return components;
+		},
+		[components]
+	);
+	const handleChange = useCallback(
+		function (response, value, args) {
+			dispatch(actions.handleChange(response, value, args));
+			onChange(response, value, args);
+		},
+		[dispatch, onChange]
+	);
+
+	const pageTag = getPageTag(pager);
+	const { isFirstPage, isLastPage } = isFirstLastPage(pager);
+
+	useEffect(
+		function () {
+			dispatch(
+				actions.onInit({
+					source,
+					data,
+					initialPage,
+					features,
+					preferences,
+					handleChange,
+				})
+			);
+		},
+		[source, data, initialPage, features, preferences, handleChange]
+	);
+
+	return {
+		getComponents,
+		goNextPage,
+		goPreviousPage,
+		getErrors,
+		pageTag,
+		isFirstPage,
+		isLastPage,
+		pager,
+		waiting,
+	};
+}
+
+export default useLunatic;

package/src/utils/constants/features.js

@@ -0,0 +1,3 @@
+export const VTL = 'VTL';
+export const MD = 'MD';
+export const VTL_MD = 'VTL|MD';

package/src/utils/constants/index.js

@@ -0,0 +1,3 @@
+export * from './missing';
+export * from './features';
+export * from './variable-status';

package/src/utils/constants/missing.js

@@ -0,0 +1,2 @@
+export const DK = 'DK';
+export const RF = 'RF';

package/src/utils/constants/variable-status.js

@@ -0,0 +1,5 @@
+export const PREVIOUS = 'PREVIOUS';
+export const COLLECTED = 'COLLECTED';
+export const FORCED = 'FORCED';
+export const EDITED = 'EDITED';
+export const INPUTED = 'INPUTED';

package/src/utils/idb-tools/clear-store.js

@@ -1,16 +1,16 @@
-async function clearStore(db, name) {
-	new Promise(function (resolve, reject) {
-		try {
-			const transaction = db.transaction(name, 'readwrite');
-			transaction.oncomplete = function () {
-				resolve(true);
-			};
-			const store = transaction.objectStore(name);
-			store.clear();
-		} catch (e) {
-			reject(e);
-		}
-	});
-}
-
-export default clearStore;
+async function clearStore(db, name) {
+	new Promise(function (resolve, reject) {
+		try {
+			const transaction = db.transaction(name, 'readwrite');
+			transaction.oncomplete = function () {
+				resolve(true);
+			};
+			const store = transaction.objectStore(name);
+			store.clear();
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+export default clearStore;

package/src/utils/idb-tools/get-entity.js

@@ -1,15 +1,15 @@
-function get(db, storeName, id) {
-	return new Promise(function (resolve, reject) {
-		const transaction = db.transaction(storeName, 'readwrite');
-		var store = transaction.objectStore(storeName);
-		const request = store.get(id);
-		transaction.onerror = function () {
-			reject(transaction.error);
-		};
-		request.onsuccess = function () {
-			resolve(request.result);
-		};
-	});
-}
-
-export default get;
+function get(db, storeName, id) {
+	return new Promise(function (resolve, reject) {
+		const transaction = db.transaction(storeName, 'readwrite');
+		var store = transaction.objectStore(storeName);
+		const request = store.get(id);
+		transaction.onerror = function () {
+			reject(transaction.error);
+		};
+		request.onsuccess = function () {
+			resolve(request.result);
+		};
+	});
+}
+
+export default get;

package/src/utils/idb-tools/get-idb.js

@@ -1,12 +1,12 @@
-/* eslint-disable no-restricted-globals */
-function getIDB() {
-	const what = self || window;
-	return (
-		what.indexedDB ||
-		what.mozIndexedDB ||
-		what.webkitIndexedDB ||
-		what.msIndexedDB
-	);
-}
-
-export default getIDB;
+/* eslint-disable no-restricted-globals */
+function getIDB() {
+	const what = self || window;
+	return (
+		what.indexedDB ||
+		what.mozIndexedDB ||
+		what.webkitIndexedDB ||
+		what.msIndexedDB
+	);
+}
+
+export default getIDB;

package/src/utils/store-tools/auto-load.js

@@ -1,72 +1,74 @@
-import openStorage from './open-or-create-store';
-import updateStoreInfo from './create/update-store-info';
-import cleanStorage from './clear-store-data';
-import cleanInfoStorage from './clear-store-info';
-
-const workerPath =
-	process.env.LUNATIC_LOADER_WORKER_PATH ||
-	process.env.REACT_APP_LUNATIC_LOADER_WORKER_PATH ||
-	'workers/lunatic-loader-worker-0.1.0.js';
-
-export const loadSuggesters = (suggesterFetcher) => async (suggesters) => {
-	Object.entries(suggesters).forEach(async ([name, attrs]) => {
-		const { version } = attrs;
-		const db = await openStorage(name, version);
-		if (db) {
-			await cleanStorage(db);
-			await cleanInfoStorage(db);
-			await updateStoreInfo(db, attrs);
-		}
-	});
-	Object.entries(suggesters).forEach(([name, attrs]) => {
-		const { url, version, fields, stopWords } = attrs;
-		const f = suggesterFetcher || fetch;
-		f(url).then(async (res) => {
-			const data = await res.json();
-			const [launch] = task({ name, fields, stopWords }, version);
-			await launch(data);
-		});
-	});
-};
-
-/**
- * Only with Worker
- */
-function task({ name, fields, stopWords }, version, log = () => null) {
-	const worker = new Worker(workerPath);
-	let start = false;
-	let stop = false;
-
-	function launch(entities, post = () => null) {
-		return new Promise(function (resolve) {
-			start = true;
-			worker.postMessage({
-				name,
-				version,
-				fields,
-				entities,
-				stopWords,
-			});
-			worker.addEventListener('message', function (e) {
-				const { data } = e;
-				if (data === 'success') {
-					if (!stop) {
-						post();
-					}
-					resolve(data);
-				} else {
-					log(data);
-				}
-			});
-		});
-	}
-
-	function terminate() {
-		if (start) {
-			stop = true;
-			worker.terminate();
-		}
-	}
-
-	return [launch, terminate];
-}
+import openStorage from './open-or-create-store';
+import updateStoreInfo from './create/update-store-info';
+import cleanStorage from './clear-store-data';
+import cleanInfoStorage from './clear-store-info';
+import { createWorker } from '../suggester-workers/create-worker';
+
+const workerPath =
+	process.env.LUNATIC_LOADER_WORKER_PATH ||
+	process.env.REACT_APP_LUNATIC_LOADER_WORKER_PATH ||
+	'workers/lunatic-loader-worker-0.1.0.js';
+
+export const loadSuggesters = (suggesterFetcher) => async (suggesters) => {
+	Object.entries(suggesters).forEach(async ([name, attrs]) => {
+		const { version } = attrs;
+		const db = await openStorage(name, version);
+		if (db) {
+			await cleanStorage(db);
+			await cleanInfoStorage(db);
+			await updateStoreInfo(db, attrs);
+		}
+	});
+	Object.entries(suggesters).forEach(([name, attrs]) => {
+		const { url, version, fields, stopWords } = attrs;
+		const f = suggesterFetcher || fetch;
+		f(url).then(async (res) => {
+			const data = await res.json();
+			const [launch, terminate] = task({ name, fields, stopWords }, version);
+			await launch(data);
+			terminate();
+		});
+	});
+};
+
+/**
+ * Only with Worker
+ */
+function task({ name, fields, stopWords }, version, log = () => null) {
+	const worker = createWorker(workerPath);
+	let start = false;
+	let stop = false;
+
+	function launch(entities, post = () => null) {
+		return new Promise(function (resolve) {
+			start = true;
+			worker.postMessage({
+				name,
+				version,
+				fields,
+				entities,
+				stopWords,
+			});
+			worker.addEventListener('message', function (e) {
+				const { data } = e;
+				if (data === 'success') {
+					if (!stop) {
+						post();
+					}
+					resolve(data);
+				} else {
+					log(data);
+				}
+			});
+		});
+	}
+
+	function terminate() {
+		if (start) {
+			stop = true;
+			worker.terminate();
+		}
+	}
+
+	return [launch, terminate];
+}

package/src/utils/store-tools/clear-store-data.js

@@ -1,8 +1,8 @@
-import { clearDb } from '../idb-tools';
-import CONSTANTES from './constantes';
-
-async function clear(db) {
-	await clearDb(db, CONSTANTES.STORE_DATA_NAME);
-}
-
-export default clear;
+import { clearDb } from '../idb-tools';
+import CONSTANTES from './constantes';
+
+async function clear(db) {
+	await clearDb(db, CONSTANTES.STORE_DATA_NAME);
+}
+
+export default clear;