@inseefr/lunatic 0.2.61 → 0.3.1-experimental

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

@@ -0,0 +1,55 @@
+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, missingResponse, components, depth } = c;
+					if (missingResponse) {
+						const miss = { name: missingResponse.name, depth };
+						if (response && response.name)
+							return [..._, { name: response.name, depth }, miss];
+						if (responses || components)
+							return [
+								..._,
+								getInvolvedVariables(responses || components),
+								miss,
+							];
+						return _;
+					}
+					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 (!Number(depth) || depth <= 2) return null;
+	return new Array(depth - 2)
+		.fill(null)
+		.reduce((acc) => new Array(1).fill(acc), null);
+};

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

@@ -0,0 +1,24 @@
+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/missing.js

@@ -0,0 +1,52 @@
+import { buildNullNestedArray } from './array';
+
+export const DK = 'DK';
+export const RF = 'RF';
+
+export const getToClean =
+	(savingType) =>
+	({ response, responses, cells, components }) => {
+		if (response) {
+			const resValues = response.values[savingType];
+			if (resValues !== null) {
+				if (Array.isArray(resValues)) {
+					//handle nested array
+					return { [response.name]: buildNullNestedArray(resValues) };
+				}
+				return { [response.name]: null };
+			}
+			return {};
+		}
+		if (responses || cells || components) {
+			const group = responses || cells || components;
+			return group
+				.flat(Infinity)
+				.reduce((acc, c) => ({ ...acc, ...getToClean(savingType)(c) }), {});
+		}
+		return false;
+	};
+
+export const hasToCleanMissing =
+	(savingType) =>
+	({ response, responses, cells, components }) => {
+		if (response) {
+			const resValues = response.values[savingType];
+			if (resValues !== null) {
+				if (Array.isArray(resValues)) {
+					if (resValues.flat(Infinity).filter((r) => r !== null).length > 0)
+						return true;
+					return false;
+				}
+				return true;
+			}
+			return false;
+		}
+		if (responses || cells || components) {
+			const group = responses || cells || components;
+			return (
+				group.flat(Infinity).filter((c) => hasToCleanMissing(savingType)(c))
+					.length > 0
+			);
+		}
+		return false;
+	};

package/src/utils/lib/pagination/flow.js

@@ -0,0 +1,2 @@
+export const FLOW_NEXT = 'FLOW_NEXT';
+export const FLOW_PREVIOUS = 'FLOW_PREVIOUS';

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

@@ -0,0 +1,2 @@
+export * from './flow';
+export * from './navigation';

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

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

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,
+	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 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 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/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 },
+	};
+};