@inseefr/lunatic 0.3.1-experimental → 0.3.2-v2

package/src/utils/lib/tooltip/content.js

@@ -1,55 +0,0 @@
-import * as C from '../../../constants';
-
-export const buildTooltip = (response) => {
-	if (
-		!response ||
-		!response.values ||
-		Object.keys(response.values).length === 0
-	)
-		return {};
-	const { values } = response;
-	const edited = values[C.EDITED];
-	const forced = values[C.FORCED];
-	const collected = values[C.COLLECTED];
-
-	if (edited === '' && !has(forced) && !has(collected)) return {};
-
-	if (has(edited)) {
-		if (!has(forced))
-			return {
-				content: [
-					{
-						key: 'Brute',
-						value: collected || ' - ',
-					},
-				],
-				imgName: 'editedImg',
-			};
-		return {
-			content: [
-				{
-					key: 'Brute',
-					value: collected || ' - ',
-				},
-				{
-					key: 'Correction automatique',
-					value: forced,
-				},
-			],
-			imgName: 'editedImg',
-		};
-	}
-	if (has(forced))
-		return {
-			content: [
-				{
-					key: 'Brute',
-					value: collected || ' - ',
-				},
-			],
-			imgName: 'forcedImg',
-		};
-	return {};
-};
-
-const has = (status) => ![null, undefined].includes(status);

package/src/utils/lib/tooltip/index.js

@@ -1,6 +0,0 @@
-export { buildTooltip } from './content';
-export {
-	buildLocalResponse,
-	buildMultiTooltipResponse,
-	buildBooleanTooltipResponse,
-} from './build-response';

package/src/utils/to-expose/calculated-variables.js

@@ -1,113 +0,0 @@
-import { interpret } from './interpret';
-import {
-	buildVectorialBindings,
-	buildBindingsForDeeperComponents,
-} from '../lib/loops/bindings';
-import { isFunction } from '../lib';
-import {
-	CALCULATED_VAR_CATEGORY,
-	EVENT_VALUE_CHANGE,
-} from '../../constants/event-types';
-
-export const getCalculatedVariables =
-	(variables) =>
-	({ bindings, updatedVars, logFunction, init = false }) => {
-		let wip = {};
-		return Object.entries(variables).reduce((acc, [name, v]) => {
-			const value = getCalculatedVariable(v, name)(variables)({
-				bindings,
-				wip,
-				updatedVars,
-				logFunction,
-				init,
-			});
-			return {
-				...acc,
-				[name]: value,
-			};
-		}, {});
-	};
-
-const getCalculatedVariable =
-	(v, name) =>
-	(variables) =>
-	({ bindings, wip, updatedVars, logFunction, init }) => {
-		const { bindingDependencies } = v;
-		if (!init && !Array.isArray(bindingDependencies)) return v;
-		if (
-			Array.isArray(updatedVars) &&
-			updatedVars.length > 0 &&
-			Array.isArray(bindingDependencies) &&
-			!updatedVars.some((ai) => bindingDependencies.includes(ai))
-		)
-			return v;
-		const exactBindings = (bindingDependencies || []).reduce((acc, b) => {
-			if (bindings[b] !== undefined) return { ...acc, [b]: bindings[b] };
-			if (wip[b] !== undefined) return { ...acc, [b]: wip[b] };
-			const varToCalc = variables[b];
-			if (!varToCalc) return acc;
-			const newValue = getCalculatedVariable(varToCalc)(variables)({
-				bindings,
-				wip,
-				updatedVars,
-				init,
-			});
-			wip[b] = newValue.value;
-			return { ...acc, [b]: newValue.value };
-		}, {});
-		const { expression, shapeFrom } = v;
-		const value =
-			wip[name] !== undefined
-				? wip[name]
-				: getValue(bindings, exactBindings, expression, shapeFrom);
-		const handleTempMomentValue =
-			value && value._isAMomentObject ? value.format('DD-MM-YYYY') : value;
-
-		if (
-			isFunction(logFunction) &&
-			// Filter only filterResult vars : name.startsWith('FILTER_RESULT_') &&
-			JSON.stringify(value) !== JSON.stringify(variables[name].value)
-		) {
-			logFunction({
-				idParadataObject: `${name}`,
-				typeParadataObject: CALCULATED_VAR_CATEGORY,
-				type: EVENT_VALUE_CHANGE,
-				oldValue: value,
-				newValue: variables[name]?.value,
-			});
-		}
-
-		if (shapeFrom)
-			return {
-				expression,
-				bindingDependencies,
-				value: handleTempMomentValue,
-				shapeFrom,
-			};
-		return {
-			expression,
-			bindingDependencies,
-			value: handleTempMomentValue,
-		};
-	};
-
-const getValue = (bindings, exactBindings, expression, shapeFrom) => {
-	if (!shapeFrom) {
-		const vectorialBindings = buildVectorialBindings(exactBindings);
-		const res = interpret(['VTL'])(vectorialBindings)(expression);
-		return Array.isArray(res) ? res[0] : res;
-	}
-	const shape = bindings[shapeFrom];
-	return buildShape(exactBindings, expression)(shape);
-};
-
-const buildShape = (exactBindings, expression) => (array) =>
-	array.map((a, i) => {
-		const loopBindings = buildBindingsForDeeperComponents(i)(exactBindings);
-		if (Array.isArray(a)) {
-			return buildShape(loopBindings, expression)(a);
-		}
-		const vectorialBindings = buildVectorialBindings(loopBindings);
-		const res = interpret(['VTL'])(vectorialBindings)(expression);
-		return Array.isArray(res) ? res[0] : res;
-	});

package/src/utils/to-expose/handler.js

@@ -1,132 +0,0 @@
-import * as C from '../../constants';
-import { buildFilledComponent } from './init-questionnaire';
-import { supportedPreferences } from '../../constants/supported-preferences';
-import { getCalculatedVariables } from './calculated-variables';
-import { isDev } from '../lib';
-
-export const updateQuestionnaire =
-	(valueType) =>
-	(questionnaire) =>
-	(preferences, logFunction) =>
-	(updatedValues) => {
-		if (
-			!supportedPreferences.includes(valueType) ||
-			preferences.length === 0 ||
-			!updatedValues
-		)
-			return questionnaire;
-		const { variables, components, ...other } = questionnaire;
-		if (!components || components.length === 0) return questionnaire;
-		const varsAndRefs = Object.entries(updatedValues).reduce(
-			(acc, [key, value]) => {
-				const {
-					newVariables: { COLLECTED, ...otherVars },
-					refs,
-				} = acc;
-				const { componentRef, values } = COLLECTED[key];
-				const updated = {
-					componentRef,
-					values: {
-						...values,
-						[valueType]: buildNewValue(preferences)(valueType)(values)(value),
-					},
-				};
-				const newCollected = { ...COLLECTED, [key]: updated };
-				return {
-					newVariables: {
-						...otherVars,
-						COLLECTED: newCollected,
-					},
-					refs: [...refs, componentRef],
-				};
-			},
-			{ newVariables: variables, refs: [] }
-		);
-		const { newVariables, refs: r } = varsAndRefs;
-		const newVariablesWithCalculated =
-			valueType === C.COLLECTED
-				? addCalculatedVars(newVariables, updatedValues)(logFunction)
-				: newVariables;
-		const collectedVars = newVariables[C.COLLECTED];
-		const newComponents = components.map((c) => {
-			if (r.includes(c.id)) return buildFilledComponent(collectedVars)(c);
-			return c;
-		});
-		return {
-			...other,
-			variables: newVariablesWithCalculated,
-			components: newComponents,
-		};
-	};
-
-export const updateExternals =
-	(questionnaire) => (logFunction) => (updatedValues) => {
-		const { variables, ...other } = questionnaire;
-		const { EXTERNAL } = variables;
-		const newVariables = {
-			...variables,
-			EXTERNAL: { ...EXTERNAL, ...updatedValues },
-		};
-
-		const newVariablesWithCalculated = addCalculatedVars(
-			newVariables,
-			updatedValues
-		)(logFunction);
-
-		return {
-			...other,
-			variables: newVariablesWithCalculated,
-		};
-	};
-
-export const buildNewValue =
-	(preferences) => (valueType) => (oldValues) => (value) => {
-		if (preferences.length === 1) return value;
-		const index = preferences.indexOf(valueType);
-		if (index < 1) return value;
-		const valuesByPreference = preferences
-			.slice(0, index)
-			.map((p) => oldValues[p])
-			.filter((v) => v !== null);
-		const lastValue = valuesByPreference[valuesByPreference.length - 1];
-		return lastValue === value ? null : value;
-	};
-
-const getCollectedAndExternal = (variables) => {
-	const { COLLECTED } = variables;
-	const collected = Object.entries(COLLECTED).reduce(
-		(acc, [k, { values }]) => ({ ...acc, [k]: values.COLLECTED }),
-		{}
-	);
-	return { ...collected, ...variables.EXTERNAL };
-};
-
-const addCalculatedVars = (variables, updatedValues) => (logFunction) => {
-	if (
-		!variables[C.CALCULATED] ||
-		Object.keys(variables[C.CALCULATED]).length === 0
-	)
-		return variables;
-
-	if (isDev) {
-		console.log('Start var calculation');
-		var start = new Date().getTime();
-	}
-
-	const { COLLECTED, EXTERNAL, CALCULATED: calculatedVariables } = variables;
-
-	const updatedVars = Object.keys(updatedValues);
-
-	const bindings = getCollectedAndExternal(variables);
-
-	const CALCULATED = getCalculatedVariables(calculatedVariables)({
-		bindings,
-		updatedVars,
-		logFunction,
-	});
-
-	if (isDev)
-		console.log(`End var calculation: ${new Date().getTime() - start} ms`);
-
-	return { EXTERNAL, COLLECTED, CALCULATED };
-};

package/src/utils/to-expose/hooks/filter-components.js

@@ -1,106 +0,0 @@
-import { interpret } from '../interpret';
-import { isDev, buildVectorialBindings } from '../../lib';
-
-let cache = {};
-
-const customFilterPagination = ({ page }, pagination, currentPage) => {
-	return pagination ? currentPage.split('.')[0] === page : true;
-};
-
-const filterComponents = ({ components, updatedVars, features, bindings }) => {
-	const localCache = {};
-	const filtered = components.filter(({ conditionFilter }) => {
-		if (!conditionFilter || !conditionFilter.value) return true;
-		const { bindingDependencies, value } = conditionFilter;
-		if (localCache[value] !== undefined) return localCache[value];
-		if (
-			(!bindingDependencies ||
-				!updatedVars.some((t) => bindingDependencies.includes(t))) &&
-			cache[value] !== undefined
-		)
-			return cache[value];
-		const vectorialBindings = buildVectorialBindings(bindings);
-		const inter = interpret(features)(vectorialBindings)(value);
-		localCache[value] = inter;
-		return inter;
-	});
-	cache = { ...cache, ...localCache };
-	return filtered;
-};
-
-const buildComponents = ({
-	components,
-	management,
-	bindings,
-	features,
-	page,
-	pagination,
-	todo,
-}) => {
-	if (management && !pagination) return components;
-
-	if (management && pagination)
-		return components.filter((c) =>
-			customFilterPagination(c, pagination, page)
-		);
-
-	if (isDev) {
-		console.log('Start filter');
-		var start = new Date().getTime();
-	}
-
-	const updatedVars = Object.keys(todo);
-
-	if (!pagination) {
-		const filtered = filterComponents({
-			components,
-			updatedVars,
-			features,
-			bindings,
-		});
-		if (isDev) console.log(`End filter: ${new Date().getTime() - start} ms`);
-		return filtered;
-	}
-
-	const pageComponents = components.filter((c) =>
-		customFilterPagination(c, pagination, page)
-	);
-
-	const pageComponentsFiltered = filterComponents({
-		components: pageComponents,
-		updatedVars,
-		features,
-		bindings,
-	});
-	if (isDev) console.log(`End filter: ${new Date().getTime() - start}`);
-	return pageComponentsFiltered;
-};
-
-let oldComponents = [];
-let memoryTodo = {};
-
-export const useFilterComponents = ({
-	questionnaire,
-	management,
-	bindings,
-	features,
-	page,
-	pagination,
-	todo,
-}) => {
-	if (Object.keys(todo).length > 0) {
-		memoryTodo = todo;
-		return oldComponents;
-	}
-	const components = buildComponents({
-		components: questionnaire.components,
-		management,
-		bindings,
-		features,
-		page,
-		pagination,
-		todo: memoryTodo,
-	});
-	oldComponents = components;
-	return components;
-};

package/src/utils/to-expose/hooks/index.js

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

package/src/utils/to-expose/hooks/lunatic.js

@@ -1,249 +0,0 @@
-import { useState, useEffect, useCallback } from 'react';
-import { mergeQuestionnaireAndData } from '../init-questionnaire';
-import { getBindings } from '../state';
-import { updateQuestionnaire, updateExternals } from '../handler';
-import { getPage, FLOW_NEXT, FLOW_PREVIOUS, getControls } from '../../lib';
-import { COLLECTED } from '../../../constants';
-import { useFilterComponents } from './filter-components';
-import { loadSuggesters } from '../../store-tools/auto-load';
-
-const useLunatic = (
-	source,
-	data,
-	{
-		savingType = COLLECTED,
-		preferences = [COLLECTED],
-		features = ['VTL'],
-		management = false,
-		pagination = false,
-		modalForControls = false,
-		initialPage = '1',
-		logFunction = null,
-		autoSuggesterLoading = false,
-		suggesterFetcher,
-		suggesters,
-	}
-) => {
-	const [initPage, setInitPage] = useState(false);
-	const featuresWithoutMD = features.filter((f) => f !== 'MD');
-	const [questionnaire, setQuestionnaire] = useState(() =>
-		mergeQuestionnaireAndData(source)(data || {})
-	);
-	const bindings = getBindings(questionnaire);
-	const [page, setPage] = useState(initialPage);
-
-	const [todo, setTodo] = useState({});
-	const [todoExternals, setTodoExternals] = useState({});
-
-	const [modalContent, setModalContent] = useState(null);
-
-	const components = useFilterComponents({
-		questionnaire,
-		management,
-		bindings,
-		features: featuresWithoutMD,
-		page,
-		pagination,
-		todo: { ...todo, ...todoExternals },
-	});
-
-	const { suggesters: suggestersToLoad } = source;
-
-	useEffect(() => {
-		const init = async () => {
-			if (
-				autoSuggesterLoading &&
-				typeof suggesters === 'object' &&
-				Object.values(suggesters).length > 0
-			) {
-				const s = suggestersToLoad.reduce(function (current, storeInfo) {
-					const { name } = storeInfo;
-					if (!suggesters[name]) return current;
-					return {
-						...current,
-						[name]: {
-							...storeInfo,
-							url: suggesters[name].url,
-							stopWords: suggesters[name].stopWords,
-						},
-					};
-				}, {});
-				loadSuggesters(suggesterFetcher)(s);
-			}
-		};
-		init();
-	}, [autoSuggesterLoading, suggesterFetcher, suggesters, suggestersToLoad]);
-
-	const [flow, setFlow] = useState(FLOW_NEXT);
-
-	// TODO: dynamic because of filters (kind of last accessible page)
-	const { maxPage } = source;
-
-	const isFirstPage = page === '1';
-	const isLastPage = page === maxPage;
-
-	// First param is the onClick event, useless for us but we have to keep it safe into
-	// function signature to avoid confusing with customBindings
-	const goNext = (_, customBindings) => {
-		if (!isLastPage) {
-			if (flow !== FLOW_NEXT) {
-				setFlow(FLOW_NEXT);
-			}
-			const nextPage = getPage({
-				components: questionnaire.components,
-				bindings: customBindings || bindings,
-				currentPage: page,
-				featuresWithoutMD,
-				flow: FLOW_NEXT,
-				management,
-			});
-			if (modalForControls) {
-				const controls = getControls({
-					page,
-					features: featuresWithoutMD,
-					components,
-					bindings,
-					preferences,
-				});
-				if (controls.length > 0) setModalContent({ page: nextPage, controls });
-				else setPage(nextPage);
-			} else setPage(nextPage);
-		}
-	};
-
-	const goPrevious = () => {
-		if (!isFirstPage) {
-			if (flow !== FLOW_PREVIOUS) {
-				setFlow(FLOW_PREVIOUS);
-			}
-			const previousPage = getPage({
-				components: questionnaire.components,
-				bindings,
-				currentPage: page,
-				featuresWithoutMD,
-				flow: FLOW_PREVIOUS,
-				management,
-			});
-			if (modalForControls) {
-				const controls = getControls({
-					page,
-					features: featuresWithoutMD,
-					components,
-					bindings,
-					preferences,
-				});
-				if (controls.length > 0)
-					setModalContent({ page: previousPage, controls });
-				else setPage(previousPage);
-			} else setPage(previousPage);
-		}
-	};
-
-	useEffect(() => {
-		if (!initPage && components && components.length === 0)
-			// no component for initialPage, get next page
-			setPage(
-				getPage({
-					components: questionnaire.components,
-					bindings: bindings,
-					currentPage: page,
-					features: featuresWithoutMD,
-					flow: FLOW_NEXT,
-					management,
-				})
-			);
-		else if (!initPage && components && components.length > 0)
-			// initialPage is correct, end of initPage
-			setInitPage(true);
-	}, [
-		initPage,
-		components,
-		questionnaire.components,
-		bindings,
-		page,
-		featuresWithoutMD,
-		management,
-	]);
-
-	const handleChange = useCallback((updatedValue) => {
-		setTodo((t) => ({ ...t, ...updatedValue }));
-	}, []);
-
-	const handleExternals = useCallback((externals) => {
-		setTodoExternals((t) => ({ ...t, ...externals }));
-	}, []);
-
-	// Assume we only want to handle source update
-	useEffect(() => {
-		setQuestionnaire(mergeQuestionnaireAndData(source)(data));
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [source]);
-
-	useEffect(() => {
-		if (Object.keys(todo).length !== 0) {
-			const newQ = updateQuestionnaire(savingType)(questionnaire)(
-				preferences,
-				logFunction
-			)(todo);
-			setQuestionnaire(newQ);
-			setTodo({});
-		}
-	}, [
-		todo,
-		preferences,
-		logFunction,
-		questionnaire,
-		savingType,
-		features,
-		management,
-	]);
-
-	useEffect(() => {
-		if (Object.keys(todoExternals).length !== 0) {
-			const newQ = updateExternals(questionnaire)(logFunction)(todoExternals);
-			setQuestionnaire(newQ);
-			setTodoExternals({});
-		}
-	}, [todoExternals, logFunction, questionnaire]);
-
-	const cancelModal = () => {
-		setModalContent(null);
-	};
-
-	const validateModal = () => {
-		setPage(modalContent.page);
-		setModalContent(null);
-	};
-
-	const componentsToDiplay =
-		pagination && modalContent
-			? [
-					{
-						componentType: 'Modal',
-						controls: modalContent.controls,
-						validateModal,
-						cancelModal,
-					},
-					...components,
-			  ]
-			: components;
-
-	return {
-		questionnaire,
-		handleChange,
-		handleExternals,
-		components: componentsToDiplay,
-		bindings,
-		pagination: {
-			page,
-			maxPage,
-			goNext,
-			goPrevious,
-			isFirstPage,
-			isLastPage,
-			setPage,
-		},
-	};
-};
-
-export default useLunatic;

package/src/utils/to-expose/index.js

@@ -1,11 +0,0 @@
-// updateQuestionnaire is useless since 2.0 optimization efforts
-// export { updateQuestionnaire } from './handler';
-export { mergeQuestionnaireAndData } from './init-questionnaire';
-export {
-	getState,
-	getCollectedState,
-	getCollectedStateByValueType,
-	getBindings,
-} from './state';
-export { interpret } from './interpret';
-export { default as useLunatic } from './hooks';