@inseefr/lunatic 0.3.1-experimental → 0.3.5-experimental

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

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';

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

@@ -43,10 +43,10 @@ export const updateQuestionnaire =
 			{ newVariables: variables, refs: [] }
 		);
 		const { newVariables, refs: r } = varsAndRefs;
-		const newVariablesWithCalculated =
-			valueType === C.COLLECTED
-				? addCalculatedVars(newVariables, updatedValues)(logFunction)
-				: newVariables;
+		const newVariablesWithCalculated = addCalculatedVars(
+			newVariables,
+			updatedValues
+		)(logFunction, preferences);
 		const collectedVars = newVariables[C.COLLECTED];
 		const newComponents = components.map((c) => {
 			if (r.includes(c.id)) return buildFilledComponent(collectedVars)(c);
@@ -92,41 +92,60 @@ export const buildNewValue =
 		return lastValue === value ? null : value;
 	};
 
-const getCollectedAndExternal = (variables) => {
+// Separate methods to avoid perf issue on collect simplest use case
+const getCollectedAndExternal = (preferences) => (variables) => {
 	const { COLLECTED } = variables;
-	const collected = Object.entries(COLLECTED).reduce(
+	if (preferences.length === 1 && preferences[0] === 'COLLECTED')
+		return getCollectedAndExternalSimple(COLLECTED);
+	return getCollectedAndExternalByPreferences(preferences)(COLLECTED);
+};
+
+const getCollectedAndExternalSimple = (variables) => {
+	const collected = Object.entries(variables).reduce(
 		(acc, [k, { values }]) => ({ ...acc, [k]: values.COLLECTED }),
 		{}
 	);
 	return { ...collected, ...variables.EXTERNAL };
 };
 
-const addCalculatedVars = (variables, updatedValues) => (logFunction) => {
-	if (
-		!variables[C.CALCULATED] ||
-		Object.keys(variables[C.CALCULATED]).length === 0
-	)
-		return variables;
+const getCollectedAndExternalByPreferences = (preferences) => (variables) => {
+	const collected = Object.entries(variables).reduce((acc, [k, { values }]) => {
+		const v = preferences.reduce((acc, p) => {
+			const value = values[p];
+			return [null, ''].includes(value) ? acc : value;
+		}, null);
+		return { ...acc, [k]: v };
+	}, {});
+	return { ...collected, ...variables.EXTERNAL };
+};
 
-	if (isDev) {
-		console.log('Start var calculation');
-		var start = new Date().getTime();
-	}
+const addCalculatedVars =
+	(variables, updatedValues) => (logFunction, preferences) => {
+		if (
+			!variables[C.CALCULATED] ||
+			Object.keys(variables[C.CALCULATED]).length === 0
+		)
+			return variables;
+
+		if (isDev) {
+			console.log('Start var calculation');
+			var start = new Date().getTime();
+		}
 
-	const { COLLECTED, EXTERNAL, CALCULATED: calculatedVariables } = variables;
+		const { COLLECTED, EXTERNAL, CALCULATED: calculatedVariables } = variables;
 
-	const updatedVars = Object.keys(updatedValues);
+		const updatedVars = Object.keys(updatedValues);
 
-	const bindings = getCollectedAndExternal(variables);
+		const bindings = getCollectedAndExternal(preferences)(variables);
 
-	const CALCULATED = getCalculatedVariables(calculatedVariables)({
-		bindings,
-		updatedVars,
-		logFunction,
-	});
+		const CALCULATED = getCalculatedVariables(calculatedVariables)({
+			bindings,
+			updatedVars,
+			logFunction,
+		});
 
-	if (isDev)
-		console.log(`End var calculation: ${new Date().getTime() - start} ms`);
+		if (isDev)
+			console.log(`End var calculation: ${new Date().getTime() - start} ms`);
 
-	return { EXTERNAL, COLLECTED, CALCULATED };
-};
+		return { EXTERNAL, COLLECTED, CALCULATED };
+	};

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

@@ -1,106 +1,106 @@
-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;
-};
+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 +1,2 @@
-export { default } from './lunatic';
+export { default as useLunatic } from './lunatic';
+export { default as useLunaticSplit } from './lunatic-split';