@inseefr/lunatic 0.2.62 → 0.3.0-v2

package/src/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/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/use-lunatic/reducer/reduce-on-init.js

@@ -0,0 +1,183 @@
+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,
+		handleChange,
+		preferences,
+		savingType,
+		management,
+	} = 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,
+			management,
+			savingType,
+		});
+	}
+
+	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,155 @@
+import { useReducer, useEffect, useCallback } from 'react';
+import INITIAL_STATE from './initial-state';
+import * as actions from './actions';
+import reducer from './reducer';
+import { useComponentsFromState, getPageTag, isFirstLastPage } from './commons';
+import { COLLECTED } from 'utils/constants';
+import { loadSuggesters } from '../utils/store-tools/auto-load';
+
+const DEFAULT_DATA = {};
+const DEFAULT_FEATURES = ['VTL', 'MD'];
+const DEFAULT_PREFERENCES = [COLLECTED];
+function nothing() {}
+
+function useLunatic(
+	source,
+	data = DEFAULT_DATA,
+	{
+		features = DEFAULT_FEATURES,
+		preferences = DEFAULT_PREFERENCES,
+		savingType = COLLECTED,
+		onChange = nothing,
+		management = false,
+		initialPage = '1',
+		autoSuggesterLoading = false,
+		suggesters: suggestersConfiguration,
+		suggesterFetcher,
+	}
+) {
+	const [state, dispatch] = useReducer(reducer, INITIAL_STATE);
+	const { pager, waiting, errors } = state;
+	const components = useComponentsFromState(state);
+	const { suggesters } = source;
+
+	useEffect(() => {
+		const init = async () => {
+			if (
+				autoSuggesterLoading &&
+				typeof suggestersConfiguration === 'object' &&
+				Object.values(suggestersConfiguration).length > 0
+			) {
+				const s = suggesters.reduce(function (current, storeInfo) {
+					const { name } = storeInfo;
+					if (!suggestersConfiguration[name]) return current;
+					return {
+						...current,
+						[name]: {
+							...storeInfo,
+							url: suggestersConfiguration[name].url,
+							stopWords: suggestersConfiguration[name].stopWords,
+						},
+					};
+				}, {});
+				dispatch(actions.onSetWaiting(true));
+				const status = await loadSuggesters(suggesterFetcher)(s);
+				dispatch(actions.onSetWaiting(false));
+			}
+		};
+
+		init();
+	}, [
+		autoSuggesterLoading,
+		suggesterFetcher,
+		suggestersConfiguration,
+		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 getState = () => {
+		const { variables } = state;
+		return Object.entries(variables).reduce(
+			(acc, [k, { value }]) => ({ ...acc, [k]: value }),
+			{}
+		);
+	};
+
+	const pageTag = getPageTag(pager);
+	const { isFirstPage, isLastPage } = isFirstLastPage(pager);
+
+	useEffect(
+		function () {
+			dispatch(
+				actions.onInit({
+					source,
+					data,
+					initialPage,
+					features,
+					preferences,
+					savingType,
+					management,
+					handleChange,
+				})
+			);
+		},
+		[
+			source,
+			data,
+			initialPage,
+			features,
+			preferences,
+			savingType,
+			management,
+			handleChange,
+		]
+	);
+
+	return {
+		getComponents,
+		goNextPage,
+		goPreviousPage,
+		getErrors,
+		pageTag,
+		isFirstPage,
+		isLastPage,
+		pager,
+		waiting,
+		getState,
+	};
+}
+
+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,5 @@
+export * from './missing';
+export * from './features';
+export * from './links';
+export * from './variable-status';
+export * from './variable-types';

package/src/utils/constants/links.js

@@ -0,0 +1,2 @@
+export const X_AXIS = 'xAxis';
+export const Y_AXIS = 'yAxis';

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/constants/variable-types.js

@@ -0,0 +1 @@
+export const CALCULATED = 'CALCULATED';

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

@@ -0,0 +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;

package/src/utils/idb-tools/create-db-opener.js

@@ -0,0 +1,43 @@
+import getIDB from './get-idb';
+
+const IDB_REF = getIDB();
+
+function onSuccessDefault(e, resolve) {
+	resolve(e.result);
+}
+
+function onUpgradeNeededDefault() {
+	throw new Error('Upgrade needed hook required!');
+}
+
+function onErrorDefault(e, _, reject) {
+	reject(e.error);
+}
+
+function createDbOpener({
+	onSuccess = onSuccessDefault,
+	onUpgradeNeeded = onUpgradeNeededDefault,
+	onError = onErrorDefault,
+} = {}) {
+	return function (name, version = 1) {
+		return new Promise((resolve, reject) => {
+			if (!IDB_REF) {
+				reject('indexedDb not supported !');
+			}
+			const request = IDB_REF.open(name, version);
+			request.onupgradeneeded = function (e) {
+				onUpgradeNeeded(e, resolve, reject);
+			};
+
+			request.onsuccess = function (e) {
+				onSuccess(e, resolve, reject);
+			};
+
+			request.onerror = function (e) {
+				onError(e, resolve, reject);
+			};
+		});
+	};
+}
+
+export default createDbOpener;

package/src/utils/idb-tools/create-open-db.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-restricted-globals */
+import getIDB from './get-idb';
+
+const IDB_REF = getIDB();
+
+function createOpenDb(onSuccess, onUpgradeNeeded) {
+	return function openStorage(name, version = 1) {
+		return new Promise(function (resolve, reject) {
+			if (!IDB_REF) {
+				reject('indexedDb not supported !');
+			}
+			const request = IDB_REF.open(name, version);
+
+			request.onupgradeneeded = onUpgradeNeeded(resolve, reject);
+
+			request.onsuccess = onSuccess(resolve, reject);
+
+			request.onerror = function (e) {
+				reject(e);
+			};
+		});
+	};
+}
+
+export default createOpenDb;

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

@@ -0,0 +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;

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

@@ -0,0 +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;