@inseefr/lunatic 0.2.63 → 0.3.0-prisme

package/src/utils/suggester-workers/searching/get-db.js

@@ -0,0 +1,18 @@
+import { openDb } from '../../idb-tools';
+
+let STORES = {};
+
+async function getDb(name, version) {
+	if (name in STORES) {
+		return STORES[name];
+	}
+	try {
+		const store = await openDb(name, version);
+		STORES[name] = store;
+		return store;
+	} catch (e) {
+		throw new Error(`Can't open store ${name} ${version}`);
+	}
+}
+
+export default getDb;

package/src/utils/suggester-workers/searching/index.js

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

package/src/utils/suggester-workers/searching/order/create-alphanumeric-orderer.js

@@ -0,0 +1,20 @@
+function createAlphanumericOrderer(descending = false) {
+	return function ascending(response, order = {}) {
+		const { field } = order;
+
+		if (field && Array.isArray(response)) {
+			return response.sort(function (a, b) {
+				if (field in a.suggestion && field in b.suggestion) {
+					if (a.suggestion[field] > b.suggestion[field]) {
+						return descending ? -1 : 1;
+					} else if (a.suggestion[field] < b.suggestion[field]) {
+						return descending ? 1 : -1;
+					}
+				}
+				return 0;
+			});
+		}
+		return response;
+	};
+}
+export default createAlphanumericOrderer;

package/src/utils/suggester-workers/searching/order/index.js

@@ -0,0 +1,19 @@
+import createAlphanumericOrderer from './create-alphanumeric-orderer';
+
+function identity(response) {
+	return response;
+}
+
+function getOrderingFunction(order = {}) {
+	const { type } = order;
+	switch (type) {
+		case 'ascending':
+			return createAlphanumericOrderer(false);
+		case 'descending':
+			return createAlphanumericOrderer(true);
+		default:
+			return identity;
+	}
+}
+
+export default getOrderingFunction;

package/src/utils/suggester-workers/searching/query-parser/index.js

@@ -0,0 +1,2 @@
+export { default as queryParserTokenized } from './query-parser-tokenized';
+export { default as queryParserSoft } from './query-parser-soft';

package/src/utils/suggester-workers/searching/query-parser/query-parser-soft.js

@@ -0,0 +1,7 @@
+import { prepareStringIndexation } from '../../commons-tokenizer';
+
+function queryParserSoft(string) {
+	return [prepareStringIndexation(string, '-')];
+}
+
+export default queryParserSoft;

package/src/utils/suggester-workers/searching/query-parser/query-parser-soft.spec.js

@@ -0,0 +1,24 @@
+import queryParserSoft from './query-parser-soft';
+
+describe('query-parser-soft', function () {
+	it('empty query', function () {
+		const result = queryParserSoft('');
+		expect(result.length).toBe(1);
+		expect(result).toContain('');
+	});
+	it('to lower case', function () {
+		const result = queryParserSoft('HELLO');
+		expect(result.length).toBe(1);
+		expect(result).toContain('hello');
+	});
+	it('trim accent', function () {
+		const result = queryParserSoft('ïéèû');
+		expect(result.length).toBe(1);
+		expect(result).toContain('ieeu');
+	});
+	it('white spaces', function () {
+		const result = queryParserSoft('HELLO WORLD!');
+		expect(result.length).toBe(1);
+		expect(result).toContain('hello-world!');
+	});
+});

package/src/utils/suggester-workers/searching/query-parser/query-parser-tokenized.js

@@ -0,0 +1,34 @@
+import tokenizer from 'string-tokenizer';
+import {
+	filterStemmer,
+	filterLength,
+	filterDouble,
+	getRegExpFromPattern,
+	filterToLower,
+} from '../../commons-tokenizer';
+import { composeFilters } from '../../commons-tokenizer/filters';
+
+const filterTokens = composeFilters(
+	filterDouble,
+	filterStemmer,
+	filterToLower,
+	filterLength
+);
+
+function toArray(tokens) {
+	if (tokens) {
+		return Array.isArray(tokens) ? tokens : [tokens];
+	}
+	return [];
+}
+
+function queryParserTokenized(query = '', { pattern, ...args } = {}) {
+	const patternForTokens = { tokens: getRegExpFromPattern(pattern) };
+	const { tokens } = tokenizer()
+		.input(query)
+		.tokens(patternForTokens)
+		.resolve();
+	return filterTokens(toArray(tokens), args);
+}
+
+export default queryParserTokenized;

package/src/utils/suggester-workers/searching/resolve-query-parser.js

@@ -0,0 +1,27 @@
+import { queryParserTokenized, queryParserSoft } from './query-parser';
+
+async function resolve(queryParser) {
+	try {
+		const { type } = queryParser;
+		switch (type) {
+			case 'tokenized':
+				const { params } = queryParser;
+				const { language, pattern, min, stemmer } = params;
+				return (query) =>
+					queryParserTokenized(query, {
+						language,
+						pattern,
+						min,
+						stemmer,
+					});
+			case 'soft':
+				return queryParserSoft;
+			default:
+				throw new Error(`Unknown parser type ${type}`);
+		}
+	} catch (e) {
+		throw new Error(e);
+	}
+}
+
+export default resolve;

package/src/utils/suggester-workers/searching/search-in-index.js

@@ -0,0 +1,17 @@
+import { CONSTANTES } from '../../store-tools';
+
+function search(token, index) {
+	const range = IDBKeyRange.bound(token, `${token}${CONSTANTES.MAX_STRING}`);
+	return new Promise(function (resolve, reject) {
+		try {
+			index.getAll(range).onsuccess = function (req) {
+				const results = req.target.result;
+				resolve(results);
+			};
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+export default search;

package/src/utils/suggester-workers/searching/searching.js

@@ -0,0 +1,70 @@
+import getDb from './get-db';
+import { CONSTANTES } from '../../store-tools';
+import { getEntity } from '../../idb-tools';
+import searchInIndex from './search-in-index';
+import resolveQueryParser from './resolve-query-parser';
+import computeScore from './compute-score';
+import getOrderingFunction from './order';
+
+function prepare(response) {
+	return response.map(({ suggestion, tokensMap }) => ({
+		...suggestion,
+		tokensMap,
+	}));
+}
+
+async function searchTokens(tokens, index) {
+	const results = await Promise.all(
+		tokens.map((token) => searchInIndex(token, index))
+	);
+
+	return results.reduce(function (a, step, i) {
+		return { ...a, [tokens[i]]: step };
+	}, {});
+}
+
+function isValideSearch(search) {
+	if (typeof search === 'string' && search.trim().length) {
+		return true;
+	}
+	return false;
+}
+
+function filterSize(response, max) {
+	if (max && max < response.length) {
+		return response.slice(0, max);
+	}
+	return response;
+}
+
+async function searching(search, { name, version = '1' }) {
+	try {
+		if (isValideSearch(search)) {
+			const db = await getDb(name, version);
+			const info = await getEntity(db, CONSTANTES.STORE_INFO_NAME, name);
+			const { queryParser, max, order } = info;
+			const parser = await resolveQueryParser(queryParser);
+			const transaction = db.transaction(
+				CONSTANTES.STORE_DATA_NAME,
+				'readonly'
+			);
+			const store = transaction.objectStore(CONSTANTES.STORE_DATA_NAME);
+			const index = store.index(CONSTANTES.STORE_INDEX_NAME);
+			const tokens = parser(search);
+			const tokensSuggestions = await searchTokens(tokens, index);
+			const response = computeScore(tokensSuggestions);
+			return {
+				results: prepare(
+					getOrderingFunction(order)(filterSize(response, max), order)
+				),
+				search,
+			};
+		}
+		return { results: [], search };
+	} catch (e) {
+		console.error(e);
+		throw e;
+	}
+}
+
+export default searching;

package/src/utils/suggester-workers/searching/searching.worker.js

@@ -0,0 +1,11 @@
+/* eslint-disable no-restricted-globals */
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
+import searching from './searching';
+
+self.onmessage = function (e) {
+	const { search, name, version } = e.data;
+	searching(search, { name, version }).then(function (result) {
+		self.postMessage(result);
+	});
+};

package/src/utils/to-expose/calculated-variables.js

@@ -0,0 +1,113 @@
+import { interpret } from './interpret';
+import {
+	buildVectorialBindings,
+	buildBindingsForDeeperComponents,
+} from '../lib/loops/bindings';
+import { isFunction } from '../lib';
+import {
+	CALCULATED_VAR_CATEGORY,
+	EVENT_VALUE_CHANGE,
+} from '../../constants/event-types';
+
+export const getCalculatedVariables =
+	(variables) =>
+	({ bindings, updatedVars, logFunction, init = false }) => {
+		let wip = {};
+		return Object.entries(variables).reduce((acc, [name, v]) => {
+			const value = getCalculatedVariable(v, name)(variables)({
+				bindings,
+				wip,
+				updatedVars,
+				logFunction,
+				init,
+			});
+			return {
+				...acc,
+				[name]: value,
+			};
+		}, {});
+	};
+
+const getCalculatedVariable =
+	(v, name) =>
+	(variables) =>
+	({ bindings, wip, updatedVars, logFunction, init }) => {
+		const { bindingDependencies } = v;
+		if (!init && !Array.isArray(bindingDependencies)) return v;
+		if (
+			Array.isArray(updatedVars) &&
+			updatedVars.length > 0 &&
+			Array.isArray(bindingDependencies) &&
+			!updatedVars.some((ai) => bindingDependencies.includes(ai))
+		)
+			return v;
+		const exactBindings = (bindingDependencies || []).reduce((acc, b) => {
+			if (bindings[b] !== undefined) return { ...acc, [b]: bindings[b] };
+			if (wip[b] !== undefined) return { ...acc, [b]: wip[b] };
+			const varToCalc = variables[b];
+			if (!varToCalc) return acc;
+			const newValue = getCalculatedVariable(varToCalc)(variables)({
+				bindings,
+				wip,
+				updatedVars,
+				init,
+			});
+			wip[b] = newValue.value;
+			return { ...acc, [b]: newValue.value };
+		}, {});
+		const { expression, shapeFrom } = v;
+		const value =
+			wip[name] !== undefined
+				? wip[name]
+				: getValue(bindings, exactBindings, expression, shapeFrom);
+		const handleTempMomentValue =
+			value && value._isAMomentObject ? value.format('DD-MM-YYYY') : value;
+
+		if (
+			isFunction(logFunction) &&
+			// Filter only filterResult vars : name.startsWith('FILTER_RESULT_') &&
+			JSON.stringify(value) !== JSON.stringify(variables[name].value)
+		) {
+			logFunction({
+				idParadataObject: `${name}`,
+				typeParadataObject: CALCULATED_VAR_CATEGORY,
+				type: EVENT_VALUE_CHANGE,
+				oldValue: value,
+				newValue: variables[name]?.value,
+			});
+		}
+
+		if (shapeFrom)
+			return {
+				expression,
+				bindingDependencies,
+				value: handleTempMomentValue,
+				shapeFrom,
+			};
+		return {
+			expression,
+			bindingDependencies,
+			value: handleTempMomentValue,
+		};
+	};
+
+const getValue = (bindings, exactBindings, expression, shapeFrom) => {
+	if (!shapeFrom) {
+		const vectorialBindings = buildVectorialBindings(exactBindings);
+		const res = interpret(['VTL'])(vectorialBindings)(expression);
+		return Array.isArray(res) ? res[0] : res;
+	}
+	const shape = bindings[shapeFrom];
+	return buildShape(exactBindings, expression)(shape);
+};
+
+const buildShape = (exactBindings, expression) => (array) =>
+	array.map((a, i) => {
+		const loopBindings = buildBindingsForDeeperComponents(i)(exactBindings);
+		if (Array.isArray(a)) {
+			return buildShape(loopBindings, expression)(a);
+		}
+		const vectorialBindings = buildVectorialBindings(loopBindings);
+		const res = interpret(['VTL'])(vectorialBindings)(expression);
+		return Array.isArray(res) ? res[0] : res;
+	});

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

@@ -1,104 +1,149 @@
-export const updateQuestionnaire = valueType => questionnaire => preferences => updatedValue => {
-	if (
-		!['PREVIOUS', 'COLLECTED', 'FORCED', 'EDITED', 'INPUTED'].includes(
-			valueType
-		) ||
-		preferences.length === 0 ||
-		Object.entries(updatedValue).length !== 1
-	)
-		return questionnaire;
-
-	const [name, value] = Object.entries(updatedValue)[0];
-	const components = questionnaire.components.reduce(
-		(_, c) => [..._, updateComponent(valueType)(c)(preferences)(name)(value)],
-		[]
-	);
-	return { ...questionnaire, components };
-};
-
-export const updateComponent = valueType => component => preferences => name => value => {
-	const { response, componentType } = component;
-	if (!isComponentsConcernedByResponse(name)(component)) {
-		return component;
-	} else if (response) {
-		return buildUpdatedResponse(component)(preferences)(valueType)(value);
-	} else if (componentType === 'CheckboxGroup')
-		return buildUpdatedCheckboxGroupResponse(component)(preferences)(valueType)(
-			value
-		)(name);
-	else if (componentType === 'Table')
-		return buildUpdatedTableResponse(component)(preferences)(valueType)(value)(
-			name
-		);
-	else return component;
-};
-
-export const isComponentsConcernedByResponse = responseName => component =>
-	(component.response && component.response.name === responseName) ||
-	(component.responses &&
-		component.responses.filter(
-			o => o.response && o.response.name === responseName
-		).length !== 0) ||
-	(component.cells &&
-		component.cells
-			.reduce((_, line) => {
-				line.forEach(l => {
-					if (l.response && l.response.name) _.push(l.response.name);
-				});
-				return _;
-			}, [])
-			.filter(str => str === responseName).length === 1);
-
-export const buildUpdatedResponse = component => preferences => valueType => value => {
-	let newValue = value;
-	if (preferences.includes(valueType)) {
-		const toCheck = preferences.slice(0, preferences.indexOf(valueType));
-		const lastValue = toCheck.reduce(
-			(_, type) =>
-				component.response.valueState.find(v => v.valueType === type).value ||
-				_,
-			''
-		);
-		if (value === lastValue) newValue = null;
-	}
-	return {
-		...component,
-		response: {
-			...component.response,
-			valueState: component.response.valueState.reduce((__, v) => {
-				if (v.valueType === valueType)
-					return [...__, { ...v, value: newValue }];
-				return [...__, v];
-			}, []),
-		},
-	};
-};
-
-export const buildUpdatedVectorResponse = responses => preferences => valueType => value => name =>
-	responses.reduce((_, cellComponent) => {
-		if (isComponentsConcernedByResponse(name)(cellComponent))
-			_.push(
-				buildUpdatedResponse(cellComponent)(preferences)(valueType)(value)
-			);
-		else _.push(cellComponent);
-		return _;
-	}, []);
-
-export const buildUpdatedCheckboxGroupResponse = component => preferences => valueType => value => name => {
-	const { responses, ...other } = component;
-	const newResponses = buildUpdatedVectorResponse(responses)(preferences)(
-		valueType
-	)(value)(name);
-	return { ...other, responses: newResponses };
-};
-
-export const buildUpdatedTableResponse = component => preferences => valueType => value => name => {
-	const { cells, ...other } = component;
-	const newCells = cells.reduce((_, line) => {
-		_.push(
-			buildUpdatedVectorResponse(line)(preferences)(valueType)(value)(name)
-		);
-		return _;
-	}, []);
-	return { ...other, cells: newCells };
-};
+import * as C from '../../constants';
+import { buildFilledComponent } from './init-questionnaire';
+import { supportedPreferences } from '../../constants/supported-preferences';
+import { getCalculatedVariables } from './calculated-variables';
+import { isDev } from '../lib';
+
+export const updateQuestionnaire =
+	(valueType) =>
+	(questionnaire) =>
+	(preferences, logFunction) =>
+	(updatedValues) => {
+		if (
+			!supportedPreferences.includes(valueType) ||
+			preferences.length === 0 ||
+			!updatedValues
+		)
+			return questionnaire;
+		const { variables, components, ...other } = questionnaire;
+		if (!components || components.length === 0) return questionnaire;
+		const varsAndRefs = Object.entries(updatedValues).reduce(
+			(acc, [key, value]) => {
+				const {
+					newVariables: { COLLECTED, ...otherVars },
+					refs,
+				} = acc;
+				const { componentRef, values } = COLLECTED[key];
+				const updated = {
+					componentRef,
+					values: {
+						...values,
+						[valueType]: buildNewValue(preferences)(valueType)(values)(value),
+					},
+				};
+				const newCollected = { ...COLLECTED, [key]: updated };
+				return {
+					newVariables: {
+						...otherVars,
+						COLLECTED: newCollected,
+					},
+					refs: [...refs, componentRef],
+				};
+			},
+			{ newVariables: variables, refs: [] }
+		);
+		const { newVariables, refs: r } = varsAndRefs;
+		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);
+			return c;
+		});
+		return {
+			...other,
+			variables: newVariablesWithCalculated,
+			components: newComponents,
+		};
+	};
+
+export const updateExternals =
+	(questionnaire) => (logFunction, preferences) => (updatedValues) => {
+		const { variables, ...other } = questionnaire;
+		const { EXTERNAL } = variables;
+		const newVariables = {
+			...variables,
+			EXTERNAL: { ...EXTERNAL, ...updatedValues },
+		};
+
+		const newVariablesWithCalculated = addCalculatedVars(
+			newVariables,
+			updatedValues
+		)(logFunction, preferences);
+		return {
+			...other,
+			variables: newVariablesWithCalculated,
+		};
+	};
+
+export const buildNewValue =
+	(preferences) => (valueType) => (oldValues) => (value) => {
+		if (preferences.length === 1) return value;
+		const index = preferences.indexOf(valueType);
+		if (index < 1) return value;
+		const valuesByPreference = preferences
+			.slice(0, index)
+			.map((p) => oldValues[p])
+			.filter((v) => v !== null);
+		const lastValue = valuesByPreference[valuesByPreference.length - 1];
+		return lastValue === value ? null : value;
+	};
+
+// Separate methods to avoid perf issue on collect simplest use case
+const getCollectedAndExternal = (preferences) => (variables) => {
+	const { COLLECTED, EXTERNAL } = variables;
+	if (preferences.length === 1 && preferences[0] === 'COLLECTED')
+		return { ...getCollectedAndExternalSimple(COLLECTED), ...EXTERNAL };
+	return {
+		...getCollectedAndExternalByPreferences(preferences)(COLLECTED),
+		...EXTERNAL,
+	};
+};
+
+const getCollectedAndExternalSimple = (variables) =>
+	Object.entries(variables).reduce(
+		(acc, [k, { values }]) => ({ ...acc, [k]: values.COLLECTED }),
+		{}
+	);
+
+const getCollectedAndExternalByPreferences = (preferences) => (variables) =>
+	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 };
+	}, {});
+
+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 updatedVars = Object.keys(updatedValues);
+
+		const bindings = getCollectedAndExternal(preferences)(variables);
+
+		const CALCULATED = getCalculatedVariables(calculatedVariables)({
+			bindings,
+			updatedVars,
+			logFunction,
+		});
+
+		if (isDev)
+			console.log(`End var calculation: ${new Date().getTime() - start} ms`);
+
+		return { EXTERNAL, COLLECTED, CALCULATED };
+	};