@inseefr/lunatic 0.3.1-experimental → 0.3.2-experimental

package/src/stories/questionnaire/questionnaire.stories.js

@@ -1,6 +1,7 @@
 import React, { useState } from 'react';
 import { storiesOf } from '@storybook/react';
 import Orchestrator from '../utils/orchestrator';
+import OrchestratorSplit from '../utils/orchestrator-split';
 import { titleDecorator } from 'utils/lib';
 import calcVar from './calc-var';
 import logement from './logement';
@@ -10,6 +11,7 @@ import logementSequence from './logement-sequence';
 import dataLogement from './data-logement';
 import simpsons from './simpsons';
 import arithmetic from './arithmetic';
+import arithmeticManagement from './arithmetic-management';
 import updateExternalQuestionnaire from './update-external/questionnaire';
 import updateExternalData from './update-external/data';
 import { positioningOptions, featuresOptions } from '../utils/options';
@@ -35,26 +37,24 @@ def.addWithJSX('Calculated Variables', () => (
 	/>
 ));
 
-def.addWithJSX('Logement', () => (
+def.addWithJSX('Arithmetic', () => (
 	<Orchestrator
 		id="props"
-		source={logement}
-		missing={boolean('Missing', false)}
+		source={arithmetic}
 		features={select('Features', featuresOptions, ['VTL', 'MD'])}
 		positioning={select('Items positioning', positioningOptions, 'DEFAULT')}
 		disabled={boolean('Disabled', false)}
-		focused={boolean('Focused', false)}
-		management={boolean('Management', false)}
 	/>
 ));
 
-def.addWithJSX('Arithmetic', () => (
+def.addWithJSX('Arithmetic - Management', () => (
 	<Orchestrator
 		id="props"
-		source={arithmetic}
+		source={arithmeticManagement}
 		features={select('Features', featuresOptions, ['VTL', 'MD'])}
 		positioning={select('Items positioning', positioningOptions, 'DEFAULT')}
 		disabled={boolean('Disabled', false)}
+		management={boolean('Management', true)}
 	/>
 ));
 
@@ -79,7 +79,7 @@ const paginated = storiesOf('Questionnaire/Paginated', module).addDecorator(
 );
 
 paginated.addWithJSX('Calculated Variables', () => (
-	<Orchestrator
+	<OrchestratorSplit
 		id="props"
 		source={calcVar}
 		missing={boolean('Missing', false)}
@@ -93,7 +93,7 @@ paginated.addWithJSX('Calculated Variables', () => (
 ));
 
 paginated.addWithJSX('Logement', () => (
-	<Orchestrator
+	<OrchestratorSplit
 		id="props"
 		source={logement}
 		data={dataLogement}
@@ -110,11 +110,11 @@ paginated.addWithJSX('Logement', () => (
 ));
 
 paginated.addWithJSX('Logement - Queen', () => (
-	<Orchestrator
+	<OrchestratorSplit
 		id="props"
 		source={logementQueen}
 		data={dataLogement}
-		missing={boolean('Missing', false)}
+		missing={boolean('Missing', true)}
 		activeGoNextForMissing={boolean('Active go next for missing', false)}
 		features={select('Features', featuresOptions, ['VTL', 'MD'])}
 		positioning={select('Items positioning', positioningOptions, 'DEFAULT')}
@@ -126,7 +126,7 @@ paginated.addWithJSX('Logement - Queen', () => (
 ));
 
 paginated.addWithJSX('Logement - Sequence', () => (
-	<Orchestrator
+	<OrchestratorSplit
 		id="props"
 		source={logementSequence}
 		data={dataLogement}
@@ -142,7 +142,7 @@ paginated.addWithJSX('Logement - Sequence', () => (
 ));
 
 paginated.addWithJSX('Logement - S2', () => (
-	<Orchestrator
+	<OrchestratorSplit
 		id="props"
 		source={logementS2}
 		missing={boolean('Missing', false)}
@@ -157,7 +157,7 @@ paginated.addWithJSX('Logement - S2', () => (
 ));
 
 paginated.addWithJSX('Simpsons', () => (
-	<Orchestrator
+	<OrchestratorSplit
 		id="props"
 		source={simpsons}
 		missing={boolean('Missing', false)}

package/src/stories/suggester/data.json

@@ -46,7 +46,10 @@
 					"name": "libelle2",
 					"rules": ["[\\w]+"],
 					"language": "French",
-					"synonyms": { "st": ["saint"] },
+					"synonyms": [
+						{ "source": "saint", "target": ["st"] },
+						{ "source": "oph", "target": ["renaud", "nicolas"] }
+					],
 					"stemmer": false
 				},
 				{ "name": "code" }

package/src/stories/suggester/suggester-workers.stories.js

@@ -53,7 +53,10 @@ const bailleursSociaux = {
 			rules: ['[\\w]+'],
 			language: 'French',
 			stemmer: false,
-			synonyms: { saint: ['st'], sainte: ['ste'] },
+			synonyms: [
+				{ source: 'saint', target: ['st'] },
+				{ source: 'oph', target: ['renaud', 'nicolas'] },
+			],
 		},
 		{ name: 'code' },
 	],

package/src/stories/utils/orchestrator-split.js

@@ -0,0 +1,117 @@
+import React, { useEffect } from 'react';
+import * as lunatic from 'components';
+import './custom-lunatic.scss';
+
+function getStoreInfoRequired() {
+	return {};
+}
+
+const OrchestratorForStories = ({
+	source,
+	suggesters,
+	data = {},
+	management = false,
+	pagination = false,
+	modalForControls = false,
+	features = ['VTL'],
+	bindings: initialBindings,
+	initialPage = '1',
+	getStoreInfo = getStoreInfoRequired,
+	missing = false,
+	shortcut = false,
+	activeGoNextForMissing = false,
+	suggesterFetcher,
+	autoSuggesterLoading,
+	addExternal,
+	...rest
+}) => {
+	const preferences = management
+		? ['COLLECTED', 'FORCED', 'EDITED']
+		: ['COLLECTED'];
+	const savingType = management ? 'EDITED' : 'COLLECTED';
+	const {
+		handleChange,
+		handleExternals,
+		components,
+		bindings,
+		pagination: {
+			goNext,
+			goPrevious,
+			page,
+			setPage,
+			maxPage,
+			isFirstPage,
+			isLastPage,
+			flow,
+		},
+	} = lunatic.useLunaticSplit(source, data, {
+		suggesters,
+		savingType,
+		preferences,
+		features,
+		management,
+		pagination,
+		modalForControls,
+		initialPage,
+		suggesterFetcher,
+		autoSuggesterLoading,
+	});
+
+	useEffect(() => {
+		handleExternals(addExternal);
+	}, [addExternal, handleExternals]);
+
+	const Button = lunatic.Button;
+
+	const missingStrategy = (b) => goNext(null, b);
+
+	return (
+		<div className="container">
+			<div className="components">
+				{components.map((q) => {
+					const { id, componentType } = q;
+					const Component = lunatic[componentType];
+					const { storeName } = q;
+
+					return (
+						<div className="lunatic lunatic-component" key={`component-${id}`}>
+							<Component
+								{...rest}
+								{...q}
+								{...getStoreInfo(storeName)}
+								handleChange={handleChange}
+								preferences={preferences}
+								savingType={savingType}
+								management={management}
+								features={features}
+								bindings={{ ...bindings, ...initialBindings }}
+								currentPage={page}
+								setPage={setPage}
+								flow={flow}
+								pagination={pagination}
+								missing={missing}
+								shortcut={shortcut}
+								missingStrategy={activeGoNextForMissing && missingStrategy}
+							/>
+						</div>
+					);
+				})}
+			</div>
+			{pagination && (
+				<>
+					<div className="pagination">
+						<Button
+							onClick={goPrevious}
+							disabled={isFirstPage}
+							value="Previous"
+						/>
+						<Button onClick={goNext} disabled={isLastPage} value="Next" />
+					</div>
+					<div>{`Page : ${page}/${maxPage}`}</div>
+				</>
+			)}
+		</div>
+	);
+};
+
+export default OrchestratorForStories;

package/src/tests/utils/to-expose/handler/results/res-input-edited.json

@@ -98,7 +98,7 @@
 		"CALCULATED": {
 			"Test": {
 				"expression": "inputOk || \" ok\"",
-				"value": "My input ok",
+				"value": "My new input ok",
 				"bindingDependencies": ["inputOk"]
 			}
 		},

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

@@ -1,59 +1,59 @@
-import {
-	getState,
-	getCollectedState,
-	getCollectedStateByValueType,
-	getBindings,
-} from 'utils/to-expose/state';
-import questionnaire from './questionnaire';
-import * as R from './results';
-
-describe('state', () => {
-	describe('getState', () => {
-		it('should return empty object', () => {
-			expect(getState([])).toEqual({
-				COLLECTED: {},
-				CALCULATED: {},
-				EXTERNAL: {},
-			});
-		});
-		it('should return object', () => {
-			expect(getState(questionnaire)).toEqual(R.state);
-		});
-	});
-	describe('getCollectedState', () => {
-		it('should return empty object', () => {
-			expect(getCollectedState([])).toEqual({});
-		});
-		it('should return object', () => {
-			expect(getCollectedState(questionnaire)).toEqual(R.collectedState);
-		});
-	});
-	describe('getCollectedStateByValueType', () => {
-		it('should return empty object', () => {
-			expect(getCollectedStateByValueType([])('')).toEqual({});
-			expect(getCollectedStateByValueType(questionnaire)('')).toEqual({});
-		});
-		it('should return object', () => {
-			expect(getCollectedStateByValueType(questionnaire)('COLLECTED')).toEqual(
-				R.collectedStateCollected
-			);
-			expect(getCollectedStateByValueType(questionnaire)('FORCED')).toEqual(
-				R.collectedStateForced
-			);
-			expect(
-				getCollectedStateByValueType(questionnaire)('COLLECTED', true)
-			).toEqual(R.collectedStateCollectedWithNull);
-			expect(
-				getCollectedStateByValueType(questionnaire)('FORCED', true)
-			).toEqual(R.collectedStateForcedWithNull);
-		});
-	});
-	describe('getBindings', () => {
-		it('should return empty object', () => {
-			expect(getBindings([])).toEqual({});
-		});
-		it('should return object', () => {
-			expect(getBindings(questionnaire)).toEqual(R.bindingsResults);
-		});
-	});
-});
+import {
+	getState,
+	getCollectedState,
+	getCollectedStateByValueType,
+	getBindings,
+} from 'utils/to-expose/state';
+import questionnaire from './questionnaire';
+import * as R from './results';
+
+describe('state', () => {
+	describe('getState', () => {
+		it('should return empty object', () => {
+			expect(getState([])).toEqual({
+				COLLECTED: {},
+				CALCULATED: {},
+				EXTERNAL: {},
+			});
+		});
+		it('should return object', () => {
+			expect(getState(questionnaire)).toEqual(R.state);
+		});
+	});
+	describe('getCollectedState', () => {
+		it('should return empty object', () => {
+			expect(getCollectedState([])).toEqual({});
+		});
+		it('should return object', () => {
+			expect(getCollectedState(questionnaire)).toEqual(R.collectedState);
+		});
+	});
+	describe('getCollectedStateByValueType', () => {
+		it('should return empty object', () => {
+			expect(getCollectedStateByValueType([])('')).toEqual({});
+			expect(getCollectedStateByValueType(questionnaire)('')).toEqual({});
+		});
+		it('should return object', () => {
+			expect(getCollectedStateByValueType(questionnaire)('COLLECTED')).toEqual(
+				R.collectedStateCollected
+			);
+			expect(getCollectedStateByValueType(questionnaire)('FORCED')).toEqual(
+				R.collectedStateForced
+			);
+			expect(
+				getCollectedStateByValueType(questionnaire)('COLLECTED', true)
+			).toEqual(R.collectedStateCollectedWithNull);
+			expect(
+				getCollectedStateByValueType(questionnaire)('FORCED', true)
+			).toEqual(R.collectedStateForcedWithNull);
+		});
+	});
+	describe('getBindings', () => {
+		it('should return empty object', () => {
+			expect(getBindings([])).toEqual({});
+		});
+		it('should return object', () => {
+			expect(getBindings(questionnaire)).toEqual(R.bindingsResults);
+		});
+	});
+});

package/src/utils/lib/index.js

@@ -18,3 +18,4 @@ export * from './table';
 export * from './tooltip';
 export { isFunction } from './function';
 export { createObjectEvent } from './event';
+export * from './splitting';

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

@@ -221,28 +221,28 @@ const getIterations = ({ component, bindings, featuresWithoutMD }) => {
 export const splitPage = (currentPage = '1', depth) => {
 	const currentPageWithDepth = depth
 		? currentPage
-				.split('.')
+				?.split('.')
 				.slice(0, depth + 1) // scoped
 				.join('.')
 		: currentPage;
 
 	const currentPageWithoutIteration = currentPageWithDepth
-		.split('#')
+		?.split('#')
 		.slice(0, -1)
 		.join('#');
 
 	const currentPageWithoutAnyIteration = currentPageWithDepth
-		.split('.')
+		?.split('.')
 		.map((e) => e.split('#')[0])
 		.join('.');
 
 	const currentRootPage = currentPageWithoutIteration
-		.split('.')
+		?.split('.')
 		.slice(0, -1)
 		.join('.');
 
 	const [currentComponentIndex, currentIteration] = currentPageWithDepth
-		.split('.')
+		?.split('.')
 		.pop()
 		.split('#')
 		.map((c) => parseInt(c, 10));

package/src/utils/lib/splitting.js

@@ -0,0 +1,110 @@
+const getBindingsDependenciesCalculated = (variables) => {
+	if (!variables) return {};
+	return variables.reduce(
+		(acc, { variableType, name, bindingDependencies, shapeFrom }) => {
+			if (variableType === 'CALCULATED')
+				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 getNestedVars =
+	(components = []) =>
+	(variables) => {
+		const variableCalculatedDependencies =
+			getBindingsDependenciesCalculated(variables);
+		const depsVarsTemp = components
+			.reduce((acc, comp) => {
+				const { bindingDependencies, conditionFilter } = comp;
+				var superBind = [];
+				if (Array.isArray(bindingDependencies))
+					superBind = [...superBind, ...bindingDependencies];
+				if (Array.isArray(conditionFilter?.bindingDependencies))
+					superBind = [...superBind, ...conditionFilter.bindingDependencies];
+				return [...acc, ...superBind];
+			}, [])
+			.filter((v, i, a) => a.indexOf(v) === i);
+		return getAllDeps(depsVarsTemp)(variableCalculatedDependencies).filter(
+			(v, i, a) => a.indexOf(v) === i
+		);
+	};
+
+const getUsefullVariablesFromSource = (variables) => (nestedVars) => {
+	if (!variables) return true;
+	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 = [];
+	components.map((c, i) => {
+		const { componentType } = c;
+		// splitting by Sequence or Loop
+		if (componentType === 'Sequence' || componentType === 'Loop') {
+			if (currentComponents.length > 0) split.push(currentComponents);
+			currentComponents = [c];
+		} else {
+			currentComponents.push(c);
+		}
+		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/suggester-workers/commons-tokenizer/create-entity-tokenizer.js

@@ -3,7 +3,8 @@ import { composeFilters, createFilterStopWords } from './filters';
 import filterStemmer from './filters/filter-stemmer';
 import filterLength from './filters/filter-length';
 import filterSynonyms from './filters/filter-synonyms';
-import filterAccentsToLower from './filters/filter-accents-to-lower';
+import filterAccents from './filters/filter-accents';
+import filterToLower from './filters/filter-to-lower';
 import filterDouble from './filters/filter-double';
 
 function createMapFieldsTokenizer(fields, filters) {
@@ -20,9 +21,10 @@ function createFilterTokens(fields, stopWords) {
 	const filterStopWords = createFilterStopWords(stopWords);
 	const getFilters = composeFilters(
 		filterDouble,
-		filterAccentsToLower,
+		filterAccents,
 		filterStemmer,
 		filterSynonyms,
+		filterToLower,
 		filterStopWords,
 		filterLength
 	);

package/src/utils/suggester-workers/commons-tokenizer/filters/{filter-accents-to-lower.js → filter-accents.js}

@@ -1,6 +1,6 @@
 import removeAccents from 'remove-accents';
 
-function filterAccentsToLower(tokens = []) {
+function filterAccents(tokens = []) {
 	return tokens.map(function (token) {
 		if (typeof token === 'string') {
 			return removeAccents(token).toLowerCase();
@@ -9,4 +9,4 @@ function filterAccentsToLower(tokens = []) {
 	});
 }
 
-export default filterAccentsToLower;
+export default filterAccents;

package/src/utils/suggester-workers/commons-tokenizer/filters/{filter-accents-to-lower.spec.js → filter-accents.spec.js}

@@ -1,4 +1,4 @@
-import filterATL from './filter-accents-to-lower';
+import filterATL from './filter-accents';
 
 describe('filter-length', function () {
 	it('maj accent', function () {

package/src/utils/suggester-workers/commons-tokenizer/filters/filter-synonyms.js

@@ -1,4 +1,6 @@
-function filterSynonyms(tokens, { synonyms }) {
+const MAPS_FROM_ARRAY = new Map(); // Pour éviter de recalculer une map à chaque fois
+
+function filterFromObject(tokens, synonyms) {
 	return tokens.reduce(function (prec, token) {
 		if (token in synonyms) {
 			return [...prec, token, ...synonyms[token]];
@@ -7,4 +9,28 @@ function filterSynonyms(tokens, { synonyms }) {
 	}, []);
 }
 
+function buildSynonymsMap(array) {
+	return array.reduce(function (map, { source, target }) {
+		return { ...map, [source]: target };
+	}, {});
+}
+
+function filterFromArray(tokens, synonyms) {
+	if (!MAPS_FROM_ARRAY.has(synonyms)) {
+		MAPS_FROM_ARRAY.set(synonyms, buildSynonymsMap(synonyms));
+	}
+	return filterFromObject(tokens, MAPS_FROM_ARRAY.get(synonyms));
+}
+
+function filterSynonyms(tokens, { synonyms }) {
+	if (Array.isArray(synonyms) && synonyms.length) {
+		return filterFromArray(tokens, synonyms);
+	}
+	if (typeof synonyms === 'object') {
+		return filterFromObject(tokens, synonyms);
+	}
+
+	return tokens;
+}
+
 export default filterSynonyms;

package/src/utils/suggester-workers/commons-tokenizer/filters/filter-to-lower.js

@@ -0,0 +1,10 @@
+function filterToLower(tokens) {
+	return tokens.map(function (token) {
+		if (typeof token === 'string') {
+			return token.toLocaleLowerCase();
+		}
+		return token;
+	});
+}
+
+export default filterToLower;

package/src/utils/suggester-workers/commons-tokenizer/filters/filter-to-lower.spec.js

@@ -0,0 +1,12 @@
+import filterToLower from './filter-to-lower';
+
+describe('filter-to-lower', function () {
+	it('UN', function () {
+		const tokens = ['UN', 'no'];
+		const results = filterToLower(tokens);
+		expect(Array.isArray(results)).toBe(true);
+		expect(results.length).toBe(2);
+		expect(results[0]).toBe('un');
+		expect(results[1]).toBe('no');
+	});
+});

package/src/utils/suggester-workers/commons-tokenizer/index.js

@@ -4,5 +4,5 @@ export { default as prepareStringIndexation } from './prepare-string-indexation'
 export { default as filterStemmer } from './filters/filter-stemmer';
 export { default as filterLength } from './filters/filter-length';
 export { default as filterDouble } from './filters/filter-double';
-export { default as filterAccentsToLower } from './filters/filter-accents-to-lower';
+export { default as filterAccents } from './filters/filter-accents';
 export { default as getRegExpFromPattern } from './get-regexp-from-pattern';