@inseefr/lunatic 0.2.63 → 0.3.0-prisme

package/src/utils/lib/pagination/navigation/shared.js

@@ -0,0 +1,256 @@
+import { interpret } from '../../../to-expose/interpret';
+import { FLOW_NEXT, FLOW_PREVIOUS } from '../flow';
+import {
+	buildVectorialBindings,
+	buildLoopBindings,
+} from '../../loops/bindings';
+
+export const getPage = ({
+	components,
+	bindings,
+	currentPage,
+	featuresWithoutMD,
+	depth,
+	flow,
+	management,
+}) => {
+	const { currentRootPage, currentComponentIndex, currentIteration } =
+		splitPage(currentPage, depth);
+
+	const filteredComponents = (
+		flow === FLOW_PREVIOUS ? components.slice().reverse() : components
+	).filter(({ page }) => {
+		if (flow === FLOW_NEXT && !currentRootPage)
+			return parseInt(page, 10) > parseInt(currentPage, 10);
+		if (flow === FLOW_NEXT && currentRootPage)
+			return parseInt(page, 10) >= parseInt(currentPage, 10);
+		if (flow === FLOW_PREVIOUS && !currentRootPage)
+			return parseInt(page, 10) < parseInt(currentPage, 10);
+		if (flow === FLOW_PREVIOUS && currentRootPage)
+			return parseInt(page, 10) <= parseInt(currentPage, 10);
+		throw new Error('Unknown type');
+	});
+	for (let index = 0; index < filteredComponents.length; index++) {
+		const component = filteredComponents[index];
+		const { id, componentType, page, paginatedLoop } = component;
+
+		// TODO: Handle loop into loop
+		// Easy way: build array with all combinations, but not efficient
+		if (componentType === 'Loop' && paginatedLoop) {
+			const {
+				conditionFilter: { bindingDependencies: loopBD, value: loopV },
+			} = component;
+			const loopB = (loopBD || []).reduce(
+				(acc, b) => ({ ...acc, [b]: bindings[b] }),
+				{}
+			);
+			const loopVectorialB = buildVectorialBindings(loopB);
+			if (
+				management ||
+				interpret(featuresWithoutMD)(loopVectorialB)(loopV) !== true ||
+				(flow === FLOW_PREVIOUS &&
+					currentIteration === 1 &&
+					currentComponentIndex === 1 &&
+					page === currentRootPage)
+			)
+				continue;
+			const iterations = getIterations({
+				component,
+				bindings,
+				featuresWithoutMD,
+			});
+			const { components: loopComponents } = component;
+			const startedIteration = getStartedIteration({
+				currentIteration,
+				currentRootPage,
+				page,
+				flow,
+				iterations,
+			});
+			const iterationsArray = buildIterationsArray({
+				start: flow === FLOW_NEXT ? startedIteration : 0,
+				end: flow === FLOW_NEXT ? iterations - 1 : startedIteration,
+				flow,
+			});
+			const componentIndexArray = buildIterationsArray({
+				start: 0,
+				end: loopComponents.length - 1,
+				flow,
+			});
+			for (const it of iterationsArray.values()) {
+				for (const componentIndex of componentIndexArray.values()) {
+					const loopComponent = loopComponents[componentIndex];
+					if (
+						hasToBeExcluded({
+							flow,
+							currentRootPage,
+							page,
+							it,
+							currentIteration,
+							currentComponentIndex,
+							loopComponent,
+						})
+					)
+						continue;
+					const {
+						conditionFilter: { bindingDependencies: bDLoop, value: vLoop },
+					} = loopComponent;
+					const loopVars = (bDLoop || []).map((b) => {
+						if (bindings[b]) return [b, bindings[b]];
+						return [b, null];
+					});
+					const loopBindings = buildLoopBindings(it)(loopVars);
+
+					// Need vectorial loopBindings instead of loopBindings?
+					const res = interpret(featuresWithoutMD)(loopBindings)(vLoop);
+					if (management || res === true)
+						return `${loopComponent.page}#${it + 1}`;
+				}
+			}
+		} else {
+			// Handle Simple Component + Loop on the same page
+			const block = filteredComponents.filter(
+				(c) => c.page === page && c.componentType === 'Loop'
+			);
+			if (block.length > 0) {
+				const loopIdOfInterest =
+					flow === FLOW_NEXT ? block[0].id : block[block.length - 1].id;
+				const currentComponentIndexInFiltered = filteredComponents.findIndex(
+					(c) => c.id === id
+				);
+				const loopOfInterestIndex = filteredComponents.findIndex(
+					(c) => c.id === loopIdOfInterest
+				);
+				if (
+					(flow === FLOW_NEXT &&
+						!(loopOfInterestIndex <= currentComponentIndexInFiltered)) ||
+					(flow === FLOW_PREVIOUS &&
+						!(loopOfInterestIndex >= currentComponentIndexInFiltered))
+				) {
+					continue;
+				}
+			}
+			const {
+				conditionFilter: { bindingDependencies, value },
+			} = component;
+			const filterBindings = (bindingDependencies || []).reduce(
+				(acc, b) => ({ ...acc, [b]: bindings[b] }),
+				{}
+			);
+			const vectorialBindings = buildVectorialBindings(filterBindings);
+			const res = interpret(featuresWithoutMD)(vectorialBindings)(value);
+			if (management || res === true) return page;
+		}
+	}
+};
+
+const getStartedIteration = ({
+	currentIteration,
+	currentRootPage,
+	page,
+	flow,
+	iterations,
+}) => {
+	if (currentIteration && currentRootPage === page) return currentIteration - 1;
+	if (flow === FLOW_NEXT) return 0;
+	if (flow === FLOW_PREVIOUS) return iterations - 1;
+};
+
+const buildIterationsArray = ({ end, start, flow }) => {
+	const array = [...Array(end - start + 1)].map((_, i) => i + start);
+	return flow === FLOW_PREVIOUS ? array.slice().reverse() : array;
+};
+
+const hasToBeExcluded = ({
+	flow,
+	currentRootPage,
+	page,
+	it,
+	currentIteration,
+	currentComponentIndex,
+	loopComponent,
+}) => {
+	const { page: loopPage, depth } = loopComponent;
+	const { currentComponentIndex: loopComponentIndex } = splitPage(
+		loopPage,
+		depth
+	);
+	if (flow === FLOW_NEXT)
+		return (
+			(currentRootPage === page &&
+				it === currentIteration - 1 &&
+				loopComponentIndex <= currentComponentIndex) ||
+			!loopComponent.page
+		);
+	if (flow === FLOW_PREVIOUS)
+		return (
+			(currentRootPage === page &&
+				it === currentIteration - 1 &&
+				loopComponentIndex >= currentComponentIndex) ||
+			!loopComponent.page
+		);
+	return false;
+};
+
+const getIterations = ({ component, bindings, featuresWithoutMD }) => {
+	const { loopDependencies, iterations: iterationsFormula, lines } = component;
+	const iterationsBindings = loopDependencies.reduce(
+		(acc, b) => ({ ...acc, [b]: bindings[b] }),
+		{}
+	);
+	const iterationsVectorialBindings =
+		buildVectorialBindings(iterationsBindings);
+	if (iterationsFormula) {
+		return parseInt(
+			interpret(featuresWithoutMD)(iterationsVectorialBindings)(
+				iterationsFormula
+			),
+			10
+		);
+	}
+	if (lines) {
+		const { min, max } = lines;
+		const maxRes = parseInt(
+			interpret(featuresWithoutMD)(iterationsVectorialBindings)(max),
+			10
+		);
+		return maxRes || parseInt(min, 10);
+	}
+};
+
+export const splitPage = (currentPage = '1', depth) => {
+	const currentPageWithDepth = depth
+		? currentPage
+				?.split('.')
+				.slice(0, depth + 1) // scoped
+				.join('.')
+		: currentPage;
+
+	const currentPageWithoutIteration = currentPageWithDepth
+		?.split('#')
+		.slice(0, -1)
+		.join('#');
+
+	const currentPageWithoutAnyIteration = currentPageWithDepth
+		?.split('.')
+		.map((e) => e.split('#')[0])
+		.join('.');
+
+	const currentRootPage = currentPageWithoutIteration
+		?.split('.')
+		.slice(0, -1)
+		.join('.');
+
+	const [currentComponentIndex, currentIteration] = currentPageWithDepth
+		?.split('.')
+		.pop()
+		.split('#')
+		.map((c) => parseInt(c, 10));
+
+	return {
+		currentRootPage,
+		currentComponentIndex,
+		currentIteration,
+		currentPageWithoutAnyIteration,
+	};
+};

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

@@ -1,22 +1,22 @@
-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;
+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 +1,5 @@
-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';
+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 +1,6 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.shape({
-	min: PropTypes.number,
-	max: PropTypes.number,
-});
+import PropTypes from 'prop-types';
+
+export default PropTypes.shape({
+	min: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+	max: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+});

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

@@ -1,8 +1,8 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.arrayOf(
-	PropTypes.shape({
-		label: PropTypes.string.isRequired,
-		value: PropTypes.string.isRequired,
-	})
-);
+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,15 +1,6 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.shape({
-	name: PropTypes.string,
-	valueState: PropTypes.arrayOf(
-		PropTypes.shape({
-			valueType: PropTypes.string,
-			value: PropTypes.oneOfType([
-				PropTypes.string,
-				PropTypes.number,
-				PropTypes.bool,
-			]),
-		})
-	),
-});
+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 +1,9 @@
-import PropTypes from 'prop-types';
-
-export default PropTypes.oneOf([
-	'COLLECTED',
-	'PREVIOUS',
-	'FORCED',
-	'EDITED',
-	'INPUTED',
-]);
+import PropTypes from 'prop-types';
+
+export default PropTypes.oneOf([
+	'COLLECTED',
+	'PREVIOUS',
+	'FORCED',
+	'EDITED',
+	'INPUTED',
+]);

package/src/utils/lib/responses.js

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

package/src/utils/lib/splitting.js

@@ -0,0 +1,142 @@
+const getBindingsDependenciesCalculated = (variables) => {
+	if (!variables) return {};
+	return variables.reduce((acc, { name, bindingDependencies, shapeFrom }) => {
+		if (shapeFrom && bindingDependencies)
+			return { ...acc, [name]: [...bindingDependencies, shapeFrom] };
+		if (bindingDependencies) return { ...acc, [name]: bindingDependencies };
+		if (shapeFrom) return { ...acc, [name]: [shapeFrom] };
+		return acc;
+	}, {});
+};
+
+const getAllDeps = (deps) => (variablesCalcDeps) => {
+	if (!deps || !variablesCalcDeps) return [];
+	return deps.reduce((acc, dep) => {
+		const depsOfDep = variablesCalcDeps[dep];
+		if (Array.isArray(depsOfDep)) {
+			return [...acc, dep, ...getAllDeps(depsOfDep)(variablesCalcDeps)];
+		}
+		return [...acc, dep];
+	}, []);
+};
+
+const getNestedVarsInFilterOrControl = (element) => {
+	if (element && Array.isArray(element?.bindingDependencies))
+		return element?.bindingDependencies;
+	return [];
+};
+
+const getNestedVarsInComponent = (component) => {
+	const {
+		componentType,
+		bindingDependencies = [],
+		conditionFilter,
+		controls = [],
+	} = component;
+	var bindings = [
+		...bindingDependencies, // bindingDependencies of Component
+		...getNestedVarsInFilterOrControl(conditionFilter), // bindingDependencies of its conditionFilter
+		...controls.reduce(
+			(acc, c) => [...acc, ...getNestedVarsInFilterOrControl(c)],
+			[]
+		), // bindingDependencies of its controls
+	];
+
+	if (componentType === 'Loop') {
+		const { components, loopDependencies } = component;
+		if (Array.isArray(loopDependencies))
+			bindings = [...bindings, ...loopDependencies];
+		if (Array.isArray(components)) {
+			bindings = components.reduce(
+				(acc, c) => [...acc, ...getNestedVarsInComponent(c)],
+				[...bindings]
+			);
+		}
+	}
+
+	return bindings;
+};
+
+const getNestedVars =
+	(components = []) =>
+	(variables) => {
+		const variableCalculatedDependencies =
+			getBindingsDependenciesCalculated(variables);
+		const depsVarsTemp = components
+			.reduce((acc, c) => {
+				return [...acc, ...getNestedVarsInComponent(c)];
+			}, [])
+			.filter((v, i, a) => a.indexOf(v) === i);
+		return getAllDeps(depsVarsTemp)(variableCalculatedDependencies).filter(
+			(v, i, a) => a.indexOf(v) === i
+		);
+	};
+
+const getUsefullVariablesFromSource = (variables) => (nestedVars) => {
+	return variables.filter(({ variableType, name }) => {
+		if (variableType === 'CALCULATED' && !nestedVars.includes(name))
+			return false;
+		if (variableType === 'COLLECTED' && !nestedVars.includes(name))
+			return false;
+		return true;
+	});
+};
+
+export const getSplitQuestionnaireSource = (source) => {
+	const { components, variables, ...rest } = source;
+	var split = [];
+	var currentComponents = [];
+	var previousPage = null;
+	components.map((c) => {
+		const { componentType, page } = c;
+		// splitting by Sequence or Loop
+		if (
+			(componentType === 'Sequence' || componentType === 'Loop') &&
+			previousPage !== page
+		) {
+			if (currentComponents.length > 0) split.push(currentComponents);
+			currentComponents = [c];
+		} else {
+			currentComponents.push(c);
+		}
+		previousPage = page;
+		return null;
+	});
+	if (currentComponents.length > 0) split.push(currentComponents);
+
+	return split.reduce((prev, currentSource) => {
+		const firstPage = currentSource[0].page;
+		const maxPage = currentSource[currentSource.length - 1].page;
+		const nestedVars = getNestedVars(currentSource)(variables);
+		const newVariables = getUsefullVariablesFromSource(variables)(nestedVars);
+
+		return [
+			...prev,
+			{
+				...rest,
+				variables: newVariables,
+				firstPage,
+				maxPage,
+				components: currentSource,
+			},
+		];
+	}, []);
+};
+
+export const getRootPageInSources = (sources) => {
+	return sources.map((source) => {
+		const { components } = source;
+		return components.reduce((acc, { page }) => {
+			if (page) return [...acc, page];
+			return acc;
+		}, []);
+	});
+};
+
+export const mergeStateData = (oldData, newData) => {
+	return {
+		COLLECTED: { ...oldData.COLLECTED, ...newData.COLLECTED },
+		CALCULATED: { ...oldData.CALCULATED, ...newData.CALCULATED },
+		EXTERNAL: { ...oldData.EXTERNAL, ...newData.EXTERNAL },
+	};
+};

package/src/utils/lib/style.js

@@ -1,10 +1,10 @@
-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 _;
-		  }, {})
-		: {};
+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 +1 @@
-export { getRosterInitLines } from './roster';
+export * from './roster';

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

@@ -1,21 +1,23 @@
-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;
-
-const isResponseEmpty = response =>
-	response.valueState.reduce((_, { value }) => {
-		if (!_) return _;
-		return value === null;
-	}, true);
+const isResponseEmpty = (response) =>
+	Object.values(response.values).filter((v) => v !== null).length === 0;
+
+export const getRosterInitLines = (cells) =>
+	Array.isArray(cells)
+		? cells
+				.filter(
+					(line) =>
+						line.filter(({ response }) => !response).length !== line.length
+				)
+				.reduce(
+					(_, line) => [
+						..._,
+						line.reduce((__, { response, label }) => {
+							if (label) return true;
+							if (__ || !response) return __;
+							return !isResponseEmpty(response);
+						}, false),
+					],
+					[]
+				)
+				.filter((b) => b).length
+		: 0;

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

@@ -1,11 +1,41 @@
-export const buildResponse = options => response => {
-	if (!response || !options) return {};
-	const { name, valueState } = response;
-	const newValueState = valueState.map(({ valueType, value }) =>
-		value === null
-			? { valueType, value }
-			: { valueType, value: options.find(o => o.value === value).label }
-	);
-
-	return { name, valueState: newValueState };
-};
+import { buildNewValue } from '../../to-expose/handler';
+import * as C from '../../../constants/value-types';
+
+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 };
+};
+
+/**
+ * Assume we use this tool in management mode only
+ */
+export const buildLocalResponse = (response, value) => {
+	if (!response || Object.keys(response).length === 0) return {};
+	const { name, values } = response;
+	const newValue = buildNewValue([C.COLLECTED, C.FORCED, C.EDITED])(C.EDITED)(
+		values
+	)(value);
+	return {
+		name,
+		values: { ...values, EDITED: newValue },
+	};
+};