@inseefr/lunatic 0.2.2-experimental → 0.2.3-prisme

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

@@ -1,164 +1,164 @@
-import * as C from '../../constants';
-import { getCalculatedVariables } from './calculated-variables';
-import { isDev } from '../lib';
-
-const INITIAL_DEPTH = 1;
-
-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)(
-		INITIAL_DEPTH
-	);
-
-	return { ...props, components: filledComponents, variables: vars };
-};
-
-const buildVars = (data) => (variables) => {
-	if (!Array.isArray(variables)) return {};
-
-	if (isDev) {
-		console.log('Start init vars');
-		var start = new Date().getTime();
-	}
-
-	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) }), {});
-	const bindings = Object.entries({ ...collected, ...EXTERNAL }).reduce(
-		(acc, [k, v]) => {
-			if (!v?.values)
-				return {
-					...acc,
-					[k]: v,
-				};
-			return {
-				...acc,
-				[k]: v.values[C.COLLECTED],
-			};
-		},
-		{}
-	);
-
-	const calcVarsAsObj = variables
-		.filter(({ variableType }) => variableType === C.CALCULATED)
-		.reduce((accV, { name, ...rest }) => ({ ...accV, [name]: rest }), {});
-
-	const CALCULATED = getCalculatedVariables(calcVarsAsObj)({
-		bindings,
-		init: true,
-	});
-
-	if (isDev) console.log(`End init vars: ${new Date().getTime() - start} ms`);
-
-	return {
-		EXTERNAL,
-		COLLECTED: collected,
-		CALCULATED,
-	};
-};
-
-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) => {
-	const { missingResponse } = c;
-	const response = {
-		name: c.response.name,
-		values: vars[c.response.name].values,
-	};
-	if (missingResponse)
-		return {
-			...c,
-			response,
-			missingResponse: {
-				name: missingResponse.name,
-				values: vars[missingResponse.name].values,
-			},
-		};
-	return {
-		...c,
-		response,
-	};
-};
-
-export const buildResponsesComponent = (vars) => (c) => {
-	const { responses, missingResponse, ...rest } = c;
-	const filledResponses = responses.map((r) => buildResponseComponent(vars)(r));
-	if (missingResponse)
-		return {
-			...rest,
-			responses: filledResponses,
-			missingResponse: {
-				name: missingResponse.name,
-				values: vars[missingResponse.name].values,
-			},
-		};
-	return { ...rest, responses: filledResponses };
-};
-
-export const buildCellsComponent = (vars) => (c) => {
-	const { cells, depth, missingResponse, ...rest } = c;
-	const filledCells = cells.map((row) =>
-		buildFilledComponents(vars)(row)(depth)
-	);
-	if (missingResponse)
-		return {
-			...rest,
-			cells: filledCells,
-			missingResponse: {
-				name: missingResponse.name,
-				values: vars[missingResponse.name].values,
-			},
-		};
-	return { ...rest, depth, cells: filledCells };
-};
-
-export const buildComponentsComponent = (vars) => (component) => {
-	const { components, depth, missingResponse, ...rest } = component;
-	const filledComponents = buildFilledComponents(vars)(components)(depth + 1);
-	if (missingResponse)
-		return {
-			...rest,
-			components: filledComponents,
-			missingResponse: {
-				name: missingResponse.name,
-				values: vars[missingResponse.name].values,
-			},
-		};
-	return { ...rest, depth, components: filledComponents };
-};
-
-const initExternalVariable =
-	({ name }) =>
-	(data) => ({
-		[name]: (data && data.EXTERNAL && data.EXTERNAL[name]) || null,
-	});
+import * as C from '../../constants';
+import { getCalculatedVariables } from './calculated-variables';
+import { isDev } from '../lib';
+
+const INITIAL_DEPTH = 1;
+
+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)(
+		INITIAL_DEPTH
+	);
+
+	return { ...props, components: filledComponents, variables: vars };
+};
+
+const buildVars = (data) => (variables) => {
+	if (!Array.isArray(variables)) return {};
+
+	if (isDev) {
+		console.log('Start init vars');
+		var start = new Date().getTime();
+	}
+
+	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) }), {});
+	const bindings = Object.entries({ ...collected, ...EXTERNAL }).reduce(
+		(acc, [k, v]) => {
+			if (!v?.values)
+				return {
+					...acc,
+					[k]: v,
+				};
+			return {
+				...acc,
+				[k]: v.values[C.COLLECTED],
+			};
+		},
+		{}
+	);
+
+	const calcVarsAsObj = variables
+		.filter(({ variableType }) => variableType === C.CALCULATED)
+		.reduce((accV, { name, ...rest }) => ({ ...accV, [name]: rest }), {});
+
+	const CALCULATED = getCalculatedVariables(calcVarsAsObj)({
+		bindings,
+		init: true,
+	});
+
+	if (isDev) console.log(`End init vars: ${new Date().getTime() - start} ms`);
+
+	return {
+		EXTERNAL,
+		COLLECTED: collected,
+		CALCULATED,
+	};
+};
+
+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) => {
+	const { missingResponse } = c;
+	const response = {
+		name: c.response.name,
+		values: vars[c.response.name].values,
+	};
+	if (missingResponse)
+		return {
+			...c,
+			response,
+			missingResponse: {
+				name: missingResponse.name,
+				values: vars[missingResponse.name].values,
+			},
+		};
+	return {
+		...c,
+		response,
+	};
+};
+
+export const buildResponsesComponent = (vars) => (c) => {
+	const { responses, missingResponse, ...rest } = c;
+	const filledResponses = responses.map((r) => buildResponseComponent(vars)(r));
+	if (missingResponse)
+		return {
+			...rest,
+			responses: filledResponses,
+			missingResponse: {
+				name: missingResponse.name,
+				values: vars[missingResponse.name].values,
+			},
+		};
+	return { ...rest, responses: filledResponses };
+};
+
+export const buildCellsComponent = (vars) => (c) => {
+	const { cells, depth, missingResponse, ...rest } = c;
+	const filledCells = cells.map((row) =>
+		buildFilledComponents(vars)(row)(depth)
+	);
+	if (missingResponse)
+		return {
+			...rest,
+			cells: filledCells,
+			missingResponse: {
+				name: missingResponse.name,
+				values: vars[missingResponse.name].values,
+			},
+		};
+	return { ...rest, depth, cells: filledCells };
+};
+
+export const buildComponentsComponent = (vars) => (component) => {
+	const { components, depth, missingResponse, ...rest } = component;
+	const filledComponents = buildFilledComponents(vars)(components)(depth + 1);
+	if (missingResponse)
+		return {
+			...rest,
+			components: filledComponents,
+			missingResponse: {
+				name: missingResponse.name,
+				values: vars[missingResponse.name].values,
+			},
+		};
+	return { ...rest, depth, components: filledComponents };
+};
+
+const initExternalVariable =
+	({ name }) =>
+	(data) => ({
+		[name]: (data && data.EXTERNAL && data.EXTERNAL[name]) || null,
+	});

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

@@ -1,18 +1,18 @@
-import { interpret } from '@inseefr/trevas';
-
-const extractDSValue = (v) => {
-	if (v !== null && typeof v === 'object') {
-		const { dataPoints } = v;
-		return Object.values(dataPoints)[0];
-	}
-	return v;
-};
-
-export const interpretVTL = (bindings) => (expression) => {
-	try {
-		const res = interpret(expression, bindings);
-		return extractDSValue(res);
-	} catch (e) {
-		return expression;
-	}
-};
+import { interpret } from '@inseefr/trevas';
+
+const extractDSValue = (v) => {
+	if (v !== null && typeof v === 'object') {
+		const { dataPoints } = v;
+		return Object.values(dataPoints)[0];
+	}
+	return v;
+};
+
+export const interpretVTL = (bindings) => (expression) => {
+	try {
+		const res = interpret(expression, bindings);
+		return extractDSValue(res);
+	} catch (e) {
+		return expression;
+	}
+};

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

@@ -1,58 +1,66 @@
-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),
-	};
-};
+import * as C from '../../constants';
+import { isDev } from '../lib';
+
+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, collectedState) => (valueType, displayNull) =>
+		['PREVIOUS', 'COLLECTED', 'FORCED', 'EDITED', 'INPUTED'].includes(valueType)
+			? Object.entries(
+					collectedState || getCollectedState(questionnaire)
+			  ).reduce((_, v) => {
+					if (displayNull || v[1][valueType] !== null)
+						return {
+							..._,
+							[v[0]]: v[1][valueType],
+						};
+					return _;
+			  }, {})
+			: {};
+
+export const getBindings = (questionnaire) => {
+	if (isDev) {
+		console.log('Get bindings');
+		var start = new Date().getTime();
+	}
+	const { variables } = questionnaire;
+	const bindings = {
+		...getCollectedStateByValueType(questionnaire)('COLLECTED', true),
+		...getCalculatedFromVariables(variables),
+		...getExternalFromVariables(variables),
+	};
+	if (isDev)
+		console.log(`End get bindings: ${new Date().getTime() - start} ms`);
+	return bindings;
+};

package/src/components/missing-wrapper/component.js

@@ -1,120 +0,0 @@
-import React, { useEffect } from 'react';
-import KeyboardEventHandler from 'react-keyboard-event-handler';
-import Button from '../button';
-import * as U from '../../utils/lib';
-import './missing.scss';
-
-const Missing = ({ Component, props }) => {
-	const {
-		dontKnowButton = "Don't know",
-		refusedButton = 'Refused',
-		missingResponse,
-		handleChange,
-		preferences,
-		missingStrategy,
-		missingShortcut = { dontKnow: '', refused: '' },
-		response,
-		responses,
-		cells,
-		components,
-		savingType,
-		bindings,
-		shortcut,
-	} = props;
-
-	const buttonState = U.getResponseByPreference(preferences)(missingResponse);
-
-	useEffect(() => {
-		if (
-			buttonState !== null &&
-			U.hasToCleanMissing(savingType)({
-				response,
-				responses,
-				cells,
-				components,
-			})
-		) {
-			handleChange({ [U.getResponseName(missingResponse)]: null });
-		}
-	}, [
-		buttonState,
-		handleChange,
-		savingType,
-		response,
-		responses,
-		cells,
-		components,
-		missingResponse,
-	]);
-
-	const getVarsToClean = () =>
-		U.getToClean(savingType)({
-			response,
-			responses,
-			cells,
-			components,
-		});
-
-	const onClick = (value) => () => {
-		const isSameValue = buttonState === value;
-		const newValue = isSameValue ? null : value;
-		const toClean = getVarsToClean();
-		if (Object.keys(toClean)) {
-			handleChange(toClean);
-			if (U.isFunction(missingStrategy) && !isSameValue)
-				missingStrategy({ ...bindings, ...toClean });
-		} else {
-			if (U.isFunction(missingStrategy) && !isSameValue)
-				missingStrategy(bindings);
-		}
-		handleChange({ [U.getResponseName(missingResponse)]: newValue });
-	};
-
-	return (
-		<div className="missing-wrapper">
-			<div className="missing-component">
-				<Component {...props} />
-			</div>
-			<div className="missing-buttons">
-				<span
-					className={`missing-button${
-						buttonState === U.DK ? '-active' : ''
-					} missing-button-dk${buttonState === U.DK ? '-active' : ''}`}
-				>
-					<Button
-						label="dont-know-button"
-						value={dontKnowButton}
-						onClick={onClick(U.DK)}
-					/>
-				</span>
-				<span
-					className={`missing-button${
-						buttonState === U.RF ? '-active' : ''
-					} missing-button-rf${buttonState === U.RF ? '-active' : ''}`}
-				>
-					<Button
-						label="refused-button"
-						value={refusedButton}
-						onClick={onClick(U.RF)}
-					/>
-				</span>
-			</div>
-			{shortcut &&
-				missingShortcut &&
-				missingShortcut.dontKnow &&
-				missingShortcut.refused && (
-					<KeyboardEventHandler
-						handleKeys={Object.values(missingShortcut)}
-						onKeyEvent={(key, e) => {
-							e.preventDefault();
-							if (key === missingShortcut.dontKnow) onClick(U.DK)();
-							if (key === missingShortcut.refused) onClick(U.RF)();
-						}}
-						handleFocusableElements
-					/>
-				)}
-		</div>
-	);
-};
-
-export default Missing;

package/src/components/missing-wrapper/wrapper.js

@@ -1,10 +0,0 @@
-import React from 'react';
-import Missing from './component';
-
-const missingWrapper = (Component) => (props) => {
-	const { missing } = props;
-	if (missing) return <Missing Component={Component} props={props} />;
-	return <Component {...props} />;
-};
-
-export default missingWrapper;

package/src/tests/utils/to-expose/hooks/use-lunatic.spec.js

@@ -1,46 +0,0 @@
-import { renderHook, act } from '@testing-library/react-hooks';
-import useLunatic from 'utils/to-expose/hooks/lunatic';
-import source from '../init-questionnaire/questionnaire';
-
-describe('useLunatic', () => {
-	it('with pagination', () => {
-		const { result } = renderHook(() =>
-			useLunatic(source, {}, { features: ['VTL', 'MD'], pagination: true })
-		);
-		const {
-			current: {
-				components,
-				pagination: { page, goNext, goPrevious },
-			},
-		} = result;
-		expect(components.length).toEqual(2);
-		expect(page).toEqual('1');
-
-		act(() => {
-			goNext();
-		});
-
-		expect(components.length).toEqual(2);
-		expect(page).toEqual('1');
-
-		act(() => {
-			goPrevious();
-		});
-
-		expect(components.length).toEqual(2);
-		expect(page).toEqual('1');
-	});
-	it('with custom props', () => {
-		renderHook(() =>
-			useLunatic(
-				source,
-				{},
-				{
-					management: true,
-					savingType: 'EDITED',
-					preferences: ['COLLECTED', 'EDITED'],
-				}
-			)
-		);
-	});
-});