@inseefr/lunatic 0.2.0-experimental → 0.2.0-v2

package/src/utils/to-expose/hooks/filter-components.js

@@ -1,106 +0,0 @@
-import { interpret } from '../interpret';
-import { isDev, buildVectorialBindings } from '../../lib';
-
-let cache = {};
-
-const customFilterPagination = ({ page }, pagination, currentPage) => {
-	return pagination ? currentPage.split('.')[0] === page : true;
-};
-
-const filterComponents = ({ components, updatedVars, features, bindings }) => {
-	const localCache = {};
-	const filtered = components.filter(({ conditionFilter }) => {
-		if (!conditionFilter || !conditionFilter.value) return true;
-		const { bindingDependencies, value } = conditionFilter;
-		if (localCache[value] !== undefined) return localCache[value];
-		if (
-			(!bindingDependencies ||
-				!updatedVars.some((t) => bindingDependencies.includes(t))) &&
-			cache[value] !== undefined
-		)
-			return cache[value];
-		const vectorialBindings = buildVectorialBindings(bindings);
-		const inter = interpret(features)(vectorialBindings)(value);
-		localCache[value] = inter;
-		return inter;
-	});
-	cache = { ...cache, ...localCache };
-	return filtered;
-};
-
-const buildComponents = ({
-	components,
-	management,
-	bindings,
-	features,
-	page,
-	pagination,
-	todo,
-}) => {
-	if (management && !pagination) return components;
-
-	if (management && pagination)
-		return components.filter((c) =>
-			customFilterPagination(c, pagination, page)
-		);
-
-	if (isDev) {
-		console.log('Start filter');
-		var start = new Date().getTime();
-	}
-
-	const updatedVars = Object.keys(todo);
-
-	if (!pagination) {
-		const filtered = filterComponents({
-			components,
-			updatedVars,
-			features,
-			bindings,
-		});
-		if (isDev) console.log(`End filter: ${new Date().getTime() - start} ms`);
-		return filtered;
-	}
-
-	const pageComponents = components.filter((c) =>
-		customFilterPagination(c, pagination, page)
-	);
-
-	const pageComponentsFiltered = filterComponents({
-		components: pageComponents,
-		updatedVars,
-		features,
-		bindings,
-	});
-	if (isDev) console.log(`End filter: ${new Date().getTime() - start}`);
-	return pageComponentsFiltered;
-};
-
-let oldComponents = [];
-let memoryTodo = {};
-
-export const useFilterComponents = ({
-	questionnaire,
-	management,
-	bindings,
-	features,
-	page,
-	pagination,
-	todo,
-}) => {
-	if (Object.keys(todo).length > 0) {
-		memoryTodo = todo;
-		return oldComponents;
-	}
-	const components = buildComponents({
-		components: questionnaire.components,
-		management,
-		bindings,
-		features,
-		page,
-		pagination,
-		todo: memoryTodo,
-	});
-	oldComponents = components;
-	return components;
-};

package/src/utils/to-expose/hooks/index.js

@@ -1 +0,0 @@
-export { default } from './lunatic';

package/src/utils/to-expose/hooks/lunatic.js

@@ -1,191 +0,0 @@
-import { useState, useEffect, useCallback } from 'react';
-import { mergeQuestionnaireAndData } from '../init-questionnaire';
-import { getBindings } from '../state';
-import { updateQuestionnaire } from '../handler';
-import { getPage, FLOW_NEXT, FLOW_PREVIOUS } from '../../lib';
-import { COLLECTED } from '../../../constants';
-import { useFilterComponents } from './filter-components';
-import { loadSuggesters } from '../../store-tools/auto-load';
-
-const useLunatic = (
-	source,
-	data,
-	{
-		savingType = COLLECTED,
-		preferences = [COLLECTED],
-		features = ['VTL'],
-		management = false,
-		pagination = false,
-		initialPage = '1',
-		logFunction = null,
-		autoSuggesterLoading = false,
-		suggesterFetcher,
-		suggesters,
-	}
-) => {
-	const [initPage, setInitPage] = useState(false);
-	const featuresWithoutMD = features.filter((f) => f !== 'MD');
-	const [questionnaire, setQuestionnaire] = useState(() =>
-		mergeQuestionnaireAndData(source)(data || {})
-	);
-	const bindings = getBindings(questionnaire);
-	const [page, setPage] = useState(initialPage);
-
-	const [todo, setTodo] = useState({});
-
-	const components = useFilterComponents({
-		questionnaire,
-		management,
-		bindings,
-		features: featuresWithoutMD,
-		page,
-		pagination,
-		todo,
-	});
-
-	const { suggesters: suggesterStrategy } = source;
-
-	useEffect(() => {
-		const init = async () => {
-			if (
-				autoSuggesterLoading &&
-				typeof suggesters === 'object' &&
-				Object.values(suggesters).length > 0
-			) {
-				// Merge suggester urls & suggester fields contained into lunatic json
-				const s = Object.entries(suggesterStrategy).reduce((acc, [name, d]) => {
-					if (suggesters[name]?.url)
-						return {
-							...acc,
-							[name]: {
-								...d,
-								url: suggesters[name].url,
-								stopWords: suggesters[name].stopWords,
-							},
-						};
-					return acc;
-				}, {});
-				loadSuggesters(suggesterFetcher)(s);
-			}
-		};
-		init();
-	}, [autoSuggesterLoading, suggesterFetcher, suggesters, suggesterStrategy]);
-
-	const [flow, setFlow] = useState(FLOW_NEXT);
-
-	// TODO: dynamic because of filters (kind of last accessible page)
-	const { maxPage } = source;
-
-	const isFirstPage = page === '1';
-	const isLastPage = page === maxPage;
-
-	// First param is the onClick event, useless for us but we have to keep it safe into
-	// function signature to avoid confusing with customBindings
-	const goNext = (_, customBindings) => {
-		if (!isLastPage) {
-			if (flow !== FLOW_NEXT) {
-				setFlow(FLOW_NEXT);
-			}
-			const nextPage = getPage({
-				components: questionnaire.components,
-				bindings: customBindings || bindings,
-				currentPage: page,
-				features: featuresWithoutMD,
-				flow: FLOW_NEXT,
-				management,
-			});
-			setPage(nextPage);
-		}
-	};
-
-	const goPrevious = () => {
-		if (!isFirstPage) {
-			if (flow !== FLOW_PREVIOUS) {
-				setFlow(FLOW_PREVIOUS);
-			}
-			const previousPage = getPage({
-				components: questionnaire.components,
-				bindings,
-				currentPage: page,
-				features: featuresWithoutMD,
-				flow: FLOW_PREVIOUS,
-				management,
-			});
-			setPage(previousPage);
-		}
-	};
-
-	useEffect(() => {
-		if (!initPage && components && components.length === 0)
-			// no component for initialPage, get next page
-			setPage(
-				getPage({
-					components: questionnaire.components,
-					bindings: bindings,
-					currentPage: page,
-					features: featuresWithoutMD,
-					flow: FLOW_NEXT,
-					management,
-				})
-			);
-		else if (!initPage && components && components.length > 0)
-			// initialPage is correct, end of initPage
-			setInitPage(true);
-	}, [
-		initPage,
-		components,
-		questionnaire.components,
-		bindings,
-		page,
-		featuresWithoutMD,
-		management,
-	]);
-
-	const handleChange = useCallback((updatedValue) => {
-		setTodo((t) => ({ ...t, ...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,
-				logFunction
-			)(todo);
-			setQuestionnaire(newQ);
-			setTodo({});
-		}
-	}, [
-		todo,
-		preferences,
-		logFunction,
-		questionnaire,
-		savingType,
-		features,
-		management,
-	]);
-
-	return {
-		questionnaire,
-		handleChange,
-		components,
-		bindings,
-		pagination: {
-			page,
-			setPage,
-			maxPage,
-			goNext,
-			goPrevious,
-			isFirstPage,
-			isLastPage,
-			flow,
-		},
-	};
-};
-
-export default useLunatic;

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

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

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

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

@@ -1,16 +0,0 @@
-import { interpretVTL } from './vtl';
-import { interpretMD } from './md';
-
-export const interpret =
-	(features, logFunction) => (bindings) => (expression) => {
-		if (!expression) return '';
-		if (!Array.isArray(features)) return expression;
-		if (features.includes('VTL')) {
-			const vtl = interpretVTL(bindings)(expression);
-			if (features.includes('MD')) {
-				return interpretMD(vtl)(logFunction);
-			}
-			return vtl;
-		}
-		return expression;
-	};

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

@@ -1,65 +0,0 @@
-import React from 'react';
-import ReactMarkdown from 'react-markdown';
-import ReactTooltip from 'react-tooltip';
-import {
-	EVENT_CLICK,
-	LINK_CATEGORY,
-	TOOLTIP_CATEGORY,
-} from '../../../constants';
-import { createObjectEvent, isFunction } from '../../lib';
-
-const Link = (props) => {
-	const { href, children, title, logFunction } = props;
-	const listener =
-		(link = true) =>
-		() => {
-			if (isFunction(logFunction))
-				logFunction(
-					createObjectEvent(
-						link ? `link-${href}` : `tooltip-${title}`,
-						link ? LINK_CATEGORY : TOOLTIP_CATEGORY,
-						EVENT_CLICK
-					)
-				);
-		};
-	if (href.trim().startsWith('http'))
-		return (
-			<a
-				href={href}
-				target="_blank"
-				rel="noreferrer noopener"
-				onClick={listener()}
-			>
-				{children}
-			</a>
-		);
-	return (
-		<span className="link-md" onPointerUp={listener(false)}>
-			<span
-				data-for={`${title}-tooltip`}
-				data-tip={title}
-				data-multiline
-				className="field-md"
-			>
-				{children}
-			</span>
-			<ReactTooltip
-				id={`${title}-tooltip`}
-				className="tooltip-content"
-				place="bottom"
-				effect="solid"
-				globalEventOff="click"
-			/>
-		</span>
-	);
-};
-
-const renderers = (otherProps) => {
-	return {
-		paragraph: (props) => <p style={{ margin: '0' }}>{props.children}</p>,
-		link: (props) => Link({ ...otherProps, ...props }),
-	};
-};
-
-export const interpretMD = (expression) => (logFunction) =>
-	<ReactMarkdown source={expression} renderers={renderers({ logFunction })} />;

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

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