@inseefr/lunatic 2.0.0 → 2.0.1-v2

package/src/utils/lib/loops/shared.js

@@ -1,43 +0,0 @@
-import * as C from '../../../constants';
-
-export const getLoopConstructorInitLines = (components) =>
-	Array.isArray(components)
-		? components.reduce(
-				(_, c) =>
-					c.response &&
-					c.response.values[C.COLLECTED] &&
-					c.response.values[C.COLLECTED].length > _
-						? c.response.values[C.COLLECTED].length
-						: _,
-				0
-		  )
-		: 0;
-
-export const getInvolvedVariables = (parentComponents) =>
-	Array.isArray(parentComponents)
-		? parentComponents
-				.reduce((_, c) => {
-					const { response, responses, components, depth } = c;
-					if (response && response.name)
-						return [..._, { name: response.name, depth }];
-					if (responses || components)
-						return [..._, getInvolvedVariables(responses || components)];
-					return _;
-				}, [])
-				.flat()
-		: [];
-
-export const lastLoopChildLineIsEmpty = (bindings) => (involvedVariables) =>
-	bindings && involvedVariables
-		? involvedVariables
-				.map((iv) => iv.name)
-				.filter((iv) => bindings[iv] && bindings[iv][bindings[iv].length - 1])
-				.length === 0
-		: true;
-
-export const buildEmptyValue = (depth) => {
-	if (!depth || depth === 1) return null;
-	return new Array(depth - 1)
-		.fill(null)
-		.reduce((acc) => new Array(1).fill(acc), null);
-};

package/src/utils/lib/memo-check.js

@@ -1,24 +0,0 @@
-import isEqual from 'lodash.isequal';
-
-const VarsHasBeenUpdated = (prevProps, props) => {
-	const { response: oldR, responses: oldRs, cells: oldC } = prevProps;
-	const { response: newR, responses: newRs, cells: newC } = props;
-	if (!newR && !newRs && !newC) return true;
-	return !(
-		(newR && isEqual(oldR, newR)) ||
-		(newRs && isEqual(oldRs, newRs)) ||
-		(newC && isEqual(oldC, newC))
-	);
-};
-export const areEqual = (prevProps, props) => {
-	if (VarsHasBeenUpdated(prevProps, props)) return false;
-	const { bindingDependencies } = props;
-	if (Array.isArray(bindingDependencies) && bindingDependencies.length > 0) {
-		const { bindings: oldB } = prevProps;
-		const { bindings: newB } = props;
-		return !bindingDependencies
-			.map((d) => isEqual(oldB[d], newB[d]))
-			.includes(false);
-	}
-	return true;
-};

package/src/utils/lib/options-positioning.js

@@ -1,9 +0,0 @@
-export const getItemsPositioningClass = positioning => {
-	switch (positioning) {
-		case 'HORIZONTAL':
-			return 'horizontal-options';
-		case 'VERTICAL':
-		default:
-			return '';
-	}
-};

package/src/utils/lib/prop-types/declarations.js

@@ -1,22 +0,0 @@
-import PropTypes from 'prop-types';
-import * as C from '../../../constants';
-
-export default PropTypes.arrayOf(
-	PropTypes.shape({
-		id: PropTypes.string.isRequired,
-		declarationType: PropTypes.oneOf([
-			C.INSTRUCTION,
-			C.COMMENT,
-			C.HELP,
-			C.WARNING,
-			C.MESSAGE_FILTER,
-			C.STATEMENT,
-		]),
-		position: PropTypes.oneOf([
-			C.BEFORE_QUESTION_TEXT,
-			C.AFTER_QUESTION_TEXT,
-			C.DETACHABLE,
-		]),
-		label: PropTypes.string.isRequired,
-	})
-).isRequired;

package/src/utils/lib/prop-types/index.js

@@ -1,5 +0,0 @@
-export { default as declarationsPropTypes } from './declarations';
-export { default as optionsPropTypes } from './options';
-export { default as responsePropTypes } from './response';
-export { default as valueTypePropTypes } from './value-type';
-export { default as linesPropTypes } from './lines';

package/src/utils/lib/prop-types/lines.js

@@ -1,6 +0,0 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.shape({
-	min: PropTypes.number,
-	max: PropTypes.number,
-});

package/src/utils/lib/prop-types/options.js

@@ -1,8 +0,0 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.arrayOf(
-	PropTypes.shape({
-		label: PropTypes.string.isRequired,
-		value: PropTypes.string.isRequired,
-	})
-);

package/src/utils/lib/prop-types/response.js

@@ -1,6 +0,0 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.shape({
-	name: PropTypes.string,
-	values: PropTypes.shape({}),
-});

package/src/utils/lib/prop-types/value-type.js

@@ -1,9 +0,0 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.oneOf([
-	'COLLECTED',
-	'PREVIOUS',
-	'FORCED',
-	'EDITED',
-	'INPUTED',
-]);

package/src/utils/lib/responses.js

@@ -1,9 +0,0 @@
-export const getResponseName = (response) => (response && response.name) || '';
-
-export const getResponseByPreference = (preferences) => (response) => {
-	if (!(response && response.values)) return '';
-	return preferences.reduce((acc, p) => {
-		const value = response.values[p];
-		return value !== null ? value : acc;
-	}, '');
-};

package/src/utils/lib/style.js

@@ -1,10 +0,0 @@
-import camelCase from 'lodash.camelcase';
-
-export const buildStyleObject = obj =>
-	obj
-		? Object.entries(obj).reduce((_, [key, value]) => {
-				if (key.startsWith(':')) _[key] = buildStyleObject(value);
-				else _[camelCase(key)] = value;
-				return _;
-		  }, {})
-		: {};

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

@@ -1 +0,0 @@
-export * from './roster';

package/src/utils/lib/table/roster.js

@@ -1,18 +0,0 @@
-const isResponseEmpty = (response) =>
-	Object.values(response.values).filter((v) => v !== null).length === 0;
-
-export const getRosterInitLines = (cells) =>
-	Array.isArray(cells)
-		? cells
-				.reduce(
-					(_, line) => [
-						..._,
-						line.reduce((__, component) => {
-							if (!component.response || __) return __;
-							return !isResponseEmpty(component.response);
-						}, false),
-					],
-					[]
-				)
-				.filter((b) => b).length
-		: 0;

package/src/utils/lib/tooltip/build-response.js

@@ -1,23 +0,0 @@
-export const buildMultiTooltipResponse = (options) => (response) => {
-	if (!response || Object.keys(response).length === 0 || !options) return {};
-	const { name, values } = response;
-	const newValues = Object.entries(values).reduce(
-		(acc, [k, v]) =>
-			v === null
-				? { ...acc, [k]: v }
-				: { ...acc, [k]: options.find((o) => o.value === v).label },
-		{}
-	);
-	return { name, values: newValues };
-};
-
-export const buildBooleanTooltipResponse = (response) => {
-	if (!response || Object.keys(response).length === 0) return {};
-	const { name, values } = response;
-	const newValues = Object.entries(values).reduce(
-		(acc, [k, v]) =>
-			v === null ? { ...acc, [k]: v } : { ...acc, [k]: v ? 'Vrai' : 'Faux' },
-		{}
-	);
-	return { name, values: newValues };
-};

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

@@ -1,52 +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 (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) => status !== undefined && status !== null;

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

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

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

@@ -1,99 +0,0 @@
-import * as C from '../../constants';
-import { buildFilledComponent } from './init-questionnaire';
-import { supportedPreferences } from '../../constants/supported-preferences';
-import { interpret } from './interpret';
-import { buildVectorialBindings } from '../lib/loops/bindings';
-
-export const updateQuestionnaire = (valueType) => (questionnaire) => (
-	preferences
-) => (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) : 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,
-	};
-};
-
-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 addCalculatedVars = (variables) => {
-	if (
-		!variables[C.CALCULATED] ||
-		Object.keys(variables[C.CALCULATED]).length === 0
-	)
-		return variables;
-	const { COLLECTED, EXTERNAL, CALCULATED } = variables;
-	const collected = Object.entries(COLLECTED).reduce(
-		(acc, [key, { values }]) => ({ ...acc, [key]: values[C.COLLECTED] }),
-		{}
-	);
-	const bindings = buildVectorialBindings({ ...collected, ...EXTERNAL });
-	const calculated = Object.entries(CALCULATED).reduce(
-		(acc, [key, { expression }]) => {
-			// Assume that a calculated variable has a first level scope
-			// If we need to handle deep calculated variables, we have to
-			// update the shape of bindings, grouping vars by type
-			const res = interpret(['VTL'])(bindings)(expression);
-			const value = Array.isArray(res) ? res.join(',') : res;
-			return {
-				...acc,
-				[key]: { expression, value },
-			};
-		},
-		{}
-	);
-	return { EXTERNAL, COLLECTED, CALCULATED: calculated };
-};

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

@@ -1,65 +0,0 @@
-import { useState, useEffect, useCallback } from 'react';
-import { interpret } from './interpret';
-import { mergeQuestionnaireAndData } from './init-questionnaire';
-import { getBindings } from './state';
-import { updateQuestionnaire } from './handler';
-import { COLLECTED } from '../../constants';
-
-const filterComponents = (components, management, bindings, features) => {
-	const filteredComponents = management
-		? components
-		: components.filter(
-				({ conditionFilter }) =>
-					!conditionFilter ||
-					interpret(features)(bindings, true)(conditionFilter) === 'normal'
-		  );
-	return filteredComponents;
-};
-
-const useLunatic = (
-	source,
-	data,
-	{
-		savingType = COLLECTED,
-		preferences = [COLLECTED],
-		features = ['VTL'],
-		management = false,
-	}
-) => {
-	const [questionnaire, setQuestionnaire] = useState(
-		mergeQuestionnaireAndData(source)(data || {})
-	);
-	const [todo, setTodo] = useState({});
-
-	const handleChange = useCallback((updatedValue) => {
-		setTodo(updatedValue);
-	}, []);
-
-	// 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)(
-				todo
-			);
-			setQuestionnaire(newQ);
-			setTodo({});
-		}
-	}, [todo, preferences, questionnaire, savingType, features, management]);
-
-	const bindings = getBindings(questionnaire);
-	const components = filterComponents(
-		questionnaire.components,
-		management,
-		bindings,
-		features
-	);
-
-	return { questionnaire, handleChange, components, bindings };
-};
-
-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, interpretWithEmptyDefault } from './interpret';
-export { default as useLunatic } from './hook';

package/src/utils/to-expose/init-questionnaire.js

@@ -1,114 +0,0 @@
-import * as C from '../../constants';
-import { interpret } from './interpret';
-
-export const mergeQuestionnaireAndData = (questionnaire) => (data) => {
-	if (!questionnaire || !questionnaire.components) return {};
-	if (questionnaire.components.length === 0) return questionnaire;
-	const { components, variables, ...props } = questionnaire;
-
-	const vars = buildVars(data || {})(variables);
-	const filledComponents = buildFilledComponents(vars[C.COLLECTED])(components)(
-		0
-	);
-
-	return { ...props, components: filledComponents, variables: vars };
-};
-
-const buildVars = (data) => (variables) => {
-	if (!Array.isArray(variables)) return {};
-	const { COLLECTED: collectedData } = data;
-	const collected = variables
-		.filter(({ variableType }) => variableType === C.COLLECTED)
-		.reduce((acc, { values, name, componentRef }) => {
-			const d = (collectedData && collectedData[name]) || {};
-			return {
-				...acc,
-				[name]: {
-					componentRef,
-					values: { ...values, ...d },
-				},
-			};
-		}, {});
-	const EXTERNAL = variables
-		.filter(({ variableType }) => variableType === C.EXTERNAL)
-		.reduce((_, v) => ({ ..._, ...initExternalVariable(v)(data) }), {});
-	return {
-		EXTERNAL,
-		COLLECTED: collected,
-		CALCULATED: variables
-			.filter(({ variableType }) => variableType === C.CALCULATED)
-			.reduce(
-				(_, v) => ({
-					..._,
-					...initCalculatedVariable(v)({ ...EXTERNAL, ...collected }),
-				}),
-				{}
-			),
-	};
-};
-
-const buildFilledComponents = (vars) => (components) => (depth) =>
-	components.map((c) => {
-		const component = { depth, ...c };
-		return buildFilledComponent(vars)(component);
-	});
-
-export const buildFilledComponent = (vars) => (component) => {
-	if (component.response) return buildResponseComponent(vars)(component);
-	else if (component.responses) return buildResponsesComponent(vars)(component);
-	else if (component.cells) return buildCellsComponent(vars)(component);
-	else if (component.components)
-		return buildComponentsComponent(vars)(component);
-	return component;
-};
-
-export const buildResponseComponent = (vars) => (c) => ({
-	...c,
-	response: {
-		name: c.response.name,
-		values: vars[c.response.name].values,
-	},
-});
-
-export const buildResponsesComponent = (vars) => (c) => {
-	const { responses, ...rest } = c;
-	const filledResponses = responses.map((r) => buildResponseComponent(vars)(r));
-	return { ...rest, responses: filledResponses };
-};
-
-export const buildCellsComponent = (vars) => (c) => {
-	const { cells, depth, ...rest } = c;
-	const filledCells = cells.map((row) =>
-		buildFilledComponents(vars)(row)(depth)
-	);
-	return { ...rest, depth, cells: filledCells };
-};
-
-export const buildComponentsComponent = (vars) => (component) => {
-	const { components, depth, ...rest } = component;
-	const filledComponents = buildFilledComponents(vars)(components)(depth + 1);
-	return { ...rest, depth, components: filledComponents };
-};
-
-const initExternalVariable = ({ name }) => (data) => ({
-	[name]: (data && data.EXTERNAL && data.EXTERNAL[name]) || null,
-});
-
-const initCalculatedVariable = ({ name, expression }) => (data) => {
-	const bindings = Object.entries(data).reduce(
-		(acc, [key, value]) => ({
-			...acc,
-			[key]:
-				typeof value === 'string' || value === null
-					? value
-					: value.values[C.COLLECTED],
-		}),
-		{}
-	);
-	return {
-		[name]: {
-			expression,
-			value: interpret(['VTL'])(bindings)(expression),
-		},
-	};
-};

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

@@ -1,53 +0,0 @@
-import { interpret as interpretVtl } from '@inseefr/vtl-2.1-engine';
-
-export const interpret = (features) => (bindings, doNotReplaceNullBindings) => (
-	expression
-) => {
-	if (!expression) return '';
-	if (!Array.isArray(features)) return expression;
-	if (features.includes('VTL')) {
-		try {
-			const VTLExpr = interpretVtl(
-				expression,
-				doNotReplaceNullBindings ? bindings : replaceNullBindings(bindings)
-			);
-			if (!VTLExpr) return expression;
-			return VTLExpr;
-		} catch (e) {
-			return expression;
-		}
-	}
-	return expression;
-};
-
-export const interpretWithEmptyDefault = (
-	features,
-	doNotReplaceNullBindings
-) => (bindings, replaceNullBindings) => (expression) => {
-	if (!expression) return '';
-	if (!Array.isArray(features)) return expression;
-	if (features.includes('VTL')) {
-		try {
-			const VTLExpr = interpretVtl(
-				expression,
-				doNotReplaceNullBindings ? bindings : replaceNullBindings(bindings, '')
-			);
-			if (!VTLExpr) return '';
-			return VTLExpr;
-		} catch (e) {
-			return '';
-		}
-	}
-	return '';
-};
-
-export const replaceNullBindings = (bindings, defaultValue) =>
-	bindings
-		? Object.entries(bindings).reduce(
-				(acc, [key, value]) => ({
-					...acc,
-					[key]: value === null ? defaultValue || key : value,
-				}),
-				{}
-		  )
-		: {};

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

@@ -1,58 +0,0 @@
-import * as C from '../../constants';
-
-export const getState = (questionnaire) => {
-	const { variables } = questionnaire;
-	return {
-		[C.CALCULATED]: getCalculatedFromVariables(variables),
-		[C.COLLECTED]: getCollectedState(questionnaire),
-		[C.EXTERNAL]: getExternalFromVariables(variables),
-	};
-};
-
-export const getCollectedState = (questionnaire) => {
-	const { variables } = questionnaire;
-	return (
-		(variables &&
-			variables[C.COLLECTED] &&
-			Object.entries(variables[C.COLLECTED]).reduce(
-				(acc, [name, { values }]) => ({ ...acc, [name]: values }),
-				{}
-			)) ||
-		{}
-	);
-};
-
-const getCalculatedFromVariables = (variables) =>
-	variables && variables[C.CALCULATED]
-		? Object.entries(variables[C.CALCULATED]).reduce(
-				(_, [name, { value }]) => ({ ..._, [name]: value }),
-				{}
-		  )
-		: {};
-
-const getExternalFromVariables = (variables) =>
-	(variables && variables[C.EXTERNAL]) || {};
-
-export const getCollectedStateByValueType = (questionnaire) => (
-	valueType,
-	displayNull
-) =>
-	['PREVIOUS', 'COLLECTED', 'FORCED', 'EDITED', 'INPUTED'].includes(valueType)
-		? Object.entries(getCollectedState(questionnaire)).reduce((_, v) => {
-				if (displayNull || v[1][valueType] !== null)
-					return {
-						..._,
-						[v[0]]: v[1][valueType],
-					};
-				return _;
-		  }, {})
-		: {};
-
-export const getBindings = (questionnaire) => {
-	const { variables } = questionnaire;
-	return {
-		...getCollectedStateByValueType(questionnaire)('COLLECTED', true),
-		...getCalculatedFromVariables(variables),
-		...getExternalFromVariables(variables),
-	};
-};