@inseefr/lunatic 0.3.0-experimental → 0.3.0-prisme

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

@@ -1,256 +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,
-	};
-};
+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/lines.js

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

@@ -1,11 +1,11 @@
-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);
-	};
+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 },
+	};
+};