@inseefr/lunatic 0.1.0-hackathon → 0.1.0-v2

package/src/utils/lib/controls/utils.js

@@ -0,0 +1,146 @@
+import { buildLoopBindings } from '../loops';
+import { interpret } from '../../to-expose/interpret';
+import { splitPage } from '..';
+import { getTypeControls } from '../../../components/component-wrapper/controls/validators';
+
+export const getControls = ({
+	page,
+	components,
+	bindings,
+	features,
+	preferences,
+}) =>
+	getControlsFromComponents({
+		page,
+		components,
+		depth: 1,
+		bindings,
+		features,
+		preferences,
+	});
+
+const getControlsFromComponents = ({
+	page,
+	depth,
+	components,
+	bindings,
+	features,
+	preferences,
+}) => {
+	const { currentIteration, currentPageWithoutAnyIteration } = splitPage(
+		page,
+		depth
+	);
+	return components.reduce((acc, component) => {
+		const {
+			controls,
+			componentType,
+			components: loopComponents,
+			page: componentPage,
+			paginatedLoop,
+		} = component;
+		if (componentType === 'Loop') {
+			const { bindingDependencies: bindingDependenciesLoop } = component;
+			const rootLoopBindings = getReducedBindings(
+				bindingDependenciesLoop,
+				bindings
+			);
+			let loopBindings = {};
+			if (paginatedLoop) {
+				loopBindings = buildLoopBindings(currentIteration - 1)(
+					Object.entries(rootLoopBindings)
+				);
+				return [
+					...acc,
+					...getControlsFromComponents({
+						page,
+						components: loopComponents,
+						bindings: loopBindings,
+						features,
+						depth: depth + 1,
+						preferences,
+					}),
+				];
+			} else {
+				const { loopDependencies } = component;
+				const iterations = parseInt(bindings[loopDependencies[0]], 10);
+				const ctrls = [...Array(iterations).keys()].reduce((accIt, i) => {
+					loopBindings = buildLoopBindings(i)(Object.entries(rootLoopBindings));
+					return [
+						...accIt,
+						...getControlsFromComponents({
+							page,
+							components: loopComponents,
+							bindings: loopBindings,
+							features,
+							depth: depth,
+							preferences,
+						}),
+					];
+				}, []);
+				return [...acc, ...ctrls];
+			}
+		}
+		if (currentPageWithoutAnyIteration === componentPage) {
+			if (controls) {
+				const interpretedControls = controls.reduce(
+					(
+						iC,
+						{ id, control, errorMessage, criticality, bindingDependencies }
+					) => {
+						const reducedBindings = getReducedBindings(
+							bindingDependencies,
+							bindings
+						);
+						const interpretedControl =
+							interpret(features)(reducedBindings)(control);
+						if (!interpretedControl)
+							return [...iC, { id, errorMessage, criticality }];
+						return iC;
+					},
+					[]
+				);
+				if (!['InputNumber', 'Datepicker'].includes(componentType))
+					return [...acc, ...interpretedControls];
+				else {
+					const {
+						response: { name },
+					} = component;
+					const value = bindings[name];
+					const typeControls = getTypeControls({
+						...component,
+						value,
+						preferences,
+					});
+
+					if (!typeControls) return [...acc, ...interpretedControls];
+					return [
+						...acc,
+						{ ...typeControls, criticality: 'LOCK' },
+						...interpretedControls,
+					];
+				}
+			}
+			if (['InputNumber', 'Datepicker'].includes(componentType)) {
+				const {
+					response: { name },
+				} = component;
+				const value = bindings[name];
+				const typeControls = getTypeControls({
+					...component,
+					value,
+					preferences,
+				});
+				if (!typeControls) return [...acc];
+				return [...acc, { ...typeControls, criticality: 'LOCK' }];
+			}
+		}
+		return acc;
+	}, []);
+};
+
+const getReducedBindings = (bindingDependencies, bindings) =>
+	(bindingDependencies || []).reduce(
+		(accB, bD) => ({ ...accB, [bD]: bindings[bD] }),
+		{}
+	);

package/src/utils/lib/index.js

@@ -1,19 +1,20 @@
-export { getAlphabet } from './alphabet';
-export * from './array';
-export * from './checkbox';
-export { titleDecorator } from './decorator';
-export * from './env';
-export * from './input-number';
-export * from './label-position';
-export * from './loops';
-export * from './memo-check';
-export * from './missing';
-export * from './options-positioning';
-export * from './pagination';
-export * from './prop-types';
-export * from './responses';
-export { buildStyleObject } from './style';
-export * from './table';
-export * from './tooltip';
-export { isFunction } from './function';
-export { createObjectEvent } from './event';
+export { getAlphabet } from './alphabet';
+export * from './array';
+export * from './checkbox';
+export * from './controls';
+export { titleDecorator } from './decorator';
+export * from './env';
+export * from './input-number';
+export * from './label-position';
+export * from './loops';
+export * from './memo-check';
+export * from './missing';
+export * from './options-positioning';
+export * from './pagination';
+export * from './prop-types';
+export * from './responses';
+export { buildStyleObject } from './style';
+export * from './table';
+export * from './tooltip';
+export { isFunction } from './function';
+export { createObjectEvent } from './event';

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

@@ -50,7 +50,8 @@ export const getPage = ({
 				interpret(featuresWithoutMD)(loopVectorialB)(loopV) !== true ||
 				(flow === FLOW_PREVIOUS &&
 					currentIteration === 1 &&
-					currentComponentIndex === 1)
+					currentComponentIndex === 1 &&
+					page === currentRootPage)
 			)
 				continue;
 			const iterations = getIterations({
@@ -86,7 +87,6 @@ export const getPage = ({
 							page,
 							it,
 							currentIteration,
-							loopComponentIndex: componentIndex,
 							currentComponentIndex,
 							loopComponent,
 						})
@@ -112,7 +112,6 @@ export const getPage = ({
 			const block = filteredComponents.filter(
 				(c) => c.page === page && c.componentType === 'Loop'
 			);
-
 			if (block.length > 0) {
 				const loopIdOfInterest =
 					flow === FLOW_NEXT ? block[0].id : block[block.length - 1].id;
@@ -168,10 +167,14 @@ const hasToBeExcluded = ({
 	page,
 	it,
 	currentIteration,
-	loopComponentIndex,
 	currentComponentIndex,
 	loopComponent,
 }) => {
+	const { page: loopPage, depth } = loopComponent;
+	const { currentComponentIndex: loopComponentIndex } = splitPage(
+		loopPage,
+		depth
+	);
 	if (flow === FLOW_NEXT)
 		return (
 			(currentRootPage === page &&

package/src/utils/lib/responses.js

@@ -1,9 +1,11 @@
 export const getResponseName = (response) => (response && response.name) || '';
 
-export const getResponseByPreference = (preferences) => (response) => {
-	if (!(response && response.values)) return null;
-	return preferences.reduce((acc, p) => {
-		const value = response.values[p];
-		return value !== null ? value : acc;
-	}, null);
-};
+export const getResponseByPreference =
+	(preferences = []) =>
+	(response) => {
+		if (!(response && response.values)) return null;
+		return preferences.reduce((acc, p) => {
+			const value = response.values[p];
+			return value !== null ? value : acc;
+		}, null);
+	};

package/src/utils/lib/tooltip/build-response.js

@@ -1,41 +1,53 @@
-import { buildNewValue } from '../../to-expose/handler';
-import * as C from '../../../constants/value-types';
-
-export const buildMultiTooltipResponse = (options) => (response) => {
-	if (!response || Object.keys(response).length === 0 || !options) return {};
-	const { name, values } = response;
-	const newValues = Object.entries(values).reduce(
-		(acc, [k, v]) =>
-			v === null
-				? { ...acc, [k]: v }
-				: { ...acc, [k]: options.find((o) => o.value === v).label },
-		{}
-	);
-	return { name, values: newValues };
-};
-
-export const buildBooleanTooltipResponse = (response) => {
-	if (!response || Object.keys(response).length === 0) return {};
-	const { name, values } = response;
-	const newValues = Object.entries(values).reduce(
-		(acc, [k, v]) =>
-			v === null ? { ...acc, [k]: v } : { ...acc, [k]: v ? 'Vrai' : 'Faux' },
-		{}
-	);
-	return { name, values: newValues };
-};
-
-/**
- * Assume we use this tool in management mode only
- */
-export const buildLocalResponse = (response, value) => {
-	if (!response || Object.keys(response).length === 0) return {};
-	const { name, values } = response;
-	const newValue = buildNewValue([C.COLLECTED, C.FORCED, C.EDITED])(C.EDITED)(
-		values
-	)(value);
-	return {
-		name,
-		values: { ...values, EDITED: newValue },
-	};
-};
+export const buildLocalResponse = () => {
+	throw new Error('redefine buildLocalResponse if needed');
+};
+
+export const buildMultiTooltipResponse = () => {
+	throw new Error('redefine buildMultiTooltipResponse if needed');
+};
+
+export const buildBooleanTooltipResponse = () => {
+	throw new Error('redefine buildBooleanTooltipResponse if needed');
+};
+
+// import { buildNewValue } from '../../to-expose/handler';
+// import * as C from '../../../constants/value-types';
+
+// export const buildMultiTooltipResponse = (options) => (response) => {
+// 	if (!response || Object.keys(response).length === 0 || !options) return {};
+// 	const { name, values } = response;
+// 	const newValues = Object.entries(values).reduce(
+// 		(acc, [k, v]) =>
+// 			v === null
+// 				? { ...acc, [k]: v }
+// 				: { ...acc, [k]: options.find((o) => o.value === v).label },
+// 		{}
+// 	);
+// 	return { name, values: newValues };
+// };
+
+// export const buildBooleanTooltipResponse = (response) => {
+// 	if (!response || Object.keys(response).length === 0) return {};
+// 	const { name, values } = response;
+// 	const newValues = Object.entries(values).reduce(
+// 		(acc, [k, v]) =>
+// 			v === null ? { ...acc, [k]: v } : { ...acc, [k]: v ? 'Vrai' : 'Faux' },
+// 		{}
+// 	);
+// 	return { name, values: newValues };
+// };
+
+// /**
+//  * Assume we use this tool in management mode only
+//  */
+// export const buildLocalResponse = (response, value) => {
+// 	if (!response || Object.keys(response).length === 0) return {};
+// 	const { name, values } = response;
+// 	const newValue = buildNewValue([C.COLLECTED, C.FORCED, C.EDITED])(C.EDITED)(
+// 		values
+// 	)(value);
+// 	return {
+// 		name,
+// 		values: { ...values, EDITED: newValue },
+// 	};
+// };

package/src/utils/store-tools/auto-load.js

@@ -2,6 +2,7 @@ import openStorage from './open-or-create-store';
 import updateStoreInfo from './create/update-store-info';
 import cleanStorage from './clear-store-data';
 import cleanInfoStorage from './clear-store-info';
+import { createWorker } from '../suggester-workers/create-worker';
 
 const workerPath =
 	process.env.LUNATIC_LOADER_WORKER_PATH ||
@@ -34,7 +35,7 @@ export const loadSuggesters = (suggesterFetcher) => async (suggesters) => {
  * Only with Worker
  */
 function task({ name, fields, stopWords }, version, log = () => null) {
-	const worker = new Worker(workerPath);
+	const worker = createWorker(workerPath);
 	let start = false;
 	let stop = false;
 

package/src/utils/store-tools/create/index.js

@@ -1 +1,2 @@
-export { default } from './create';
+export { default } from './create';
+export { default as updateStoreInfo } from './update-store-info';

package/src/utils/store-tools/create/update-store-info.js

@@ -1,26 +1,26 @@
-import CONSTANTES from '../constantes';
-
-function update(db, storeInfo) {
-	return new Promise(function (resolve, reject) {
-		try {
-			const transaction = db.transaction(
-				CONSTANTES.STORE_INFO_NAME,
-				'readwrite'
-			);
-			const store = transaction.objectStore(CONSTANTES.STORE_INFO_NAME);
-			const request = store.add(storeInfo);
-
-			request.onsuccess = function () {
-				resolve('success');
-			};
-
-			request.onerror = function (e) {
-				reject(e);
-			};
-		} catch (e) {
-			reject(e);
-		}
-	});
-}
-
-export default update;
+import CONSTANTES from '../constantes';
+
+function updateStoreInfo(db, storeInfo) {
+	return new Promise(function (resolve, reject) {
+		try {
+			const transaction = db.transaction(
+				CONSTANTES.STORE_INFO_NAME,
+				'readwrite'
+			);
+			const store = transaction.objectStore(CONSTANTES.STORE_INFO_NAME);
+			const request = store.add(storeInfo);
+
+			request.onsuccess = function () {
+				resolve('success');
+			};
+
+			request.onerror = function (e) {
+				reject(e);
+			};
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+export default updateStoreInfo;

package/src/utils/store-tools/index.js

@@ -1,5 +1,7 @@
-export * as CONSTANTES from './constantes';
-export { default as openOrCreateStore } from './open-or-create-store';
-export { default as clearStoreData } from './clear-store-data';
-export { default as useStoreIndex } from './use-store-index';
-export { default as getStoreCount } from './get-store-count';
+export * as CONSTANTES from './constantes';
+export { default as openOrCreateStore } from './open-or-create-store';
+export { default as clearStoreData } from './clear-store-data';
+export { default as clearStoreInfo } from './clear-store-info';
+export { default as useStoreIndex } from './use-store-index';
+export { default as getStoreCount } from './get-store-count';
+export { default as updateStoreInfo } from './create/update-store-info';

package/src/utils/suggester-workers/append-to-index/create-append-task.js

@@ -1,3 +1,5 @@
+import { createWorker } from '../create-worker';
+
 const workerPath =
 	process.env.LUNATIC_LOADER_WORKER_PATH ||
 	process.env.REACT_APP_LUNATIC_LOADER_WORKER_PATH ||
@@ -8,7 +10,7 @@ const workerPath =
  */
 function task(info, version, log = () => null) {
 	const { name, fields, stopWords } = info;
-	const worker = new Worker(workerPath);
+	const worker = createWorker(workerPath);
 	let start = false;
 	let stop = false;
 

package/src/utils/suggester-workers/commons-tokenizer/create-entity-tokenizer.js

@@ -0,0 +1,56 @@
+import createFieldsTokenizer from './create-fields-tokenizer';
+import { composeFilters, createFilterStopWords } from './filters';
+import filterStemmer from './filters/filter-stemmer';
+import filterLength from './filters/filter-length';
+import filterSynonyms from './filters/filter-synonyms';
+import filterAccents from './filters/filter-accents';
+import filterToLower from './filters/filter-to-lower';
+import filterDouble from './filters/filter-double';
+
+function createMapFieldsTokenizer(fields, filters) {
+	return fields.reduce(function (mapFieldTokenizers, field) {
+		const { name } = field;
+		return {
+			...mapFieldTokenizers,
+			[name]: createFieldsTokenizer(field, filters),
+		};
+	}, {});
+}
+
+function createFilterTokens(fields, stopWords) {
+	const filterStopWords = createFilterStopWords(stopWords);
+	const getFilters = composeFilters(
+		filterDouble,
+		filterAccents,
+		filterStemmer,
+		filterSynonyms,
+		filterToLower,
+		filterStopWords,
+		filterLength
+	);
+	const FIELDS_TOKENIZER_MAP = createMapFieldsTokenizer(
+		fields || [],
+		getFilters
+	);
+
+	return function (field, entity) {
+		const { name } = field;
+		const tokenizeIt = FIELDS_TOKENIZER_MAP[name];
+		if (name in entity) {
+			return tokenizeIt(`${entity[name]}`);
+		}
+		return [];
+	};
+}
+
+function createEntityTokenizer(fields, stopWords) {
+	const tokenizeAll = createFilterTokens(fields, stopWords);
+	return function (entity) {
+		return fields.reduce(function (a, field) {
+			const { name } = field;
+			return { ...a, [name]: tokenizeAll(field, entity) };
+		}, {});
+	};
+}
+
+export default createEntityTokenizer;

package/src/utils/suggester-workers/commons-tokenizer/create-fields-tokenizer.js

@@ -0,0 +1,56 @@
+import prepareStringIndexation from './prepare-string-indexation';
+import softTokenizer from './soft-tokenizer';
+import tokenizer from 'string-tokenizer';
+import getRegExpFromPattern from './get-regexp-from-pattern';
+
+function defaultTokenizeIt(string) {
+	return [prepareStringIndexation(string)];
+}
+
+function toArray(content) {
+	return Array.isArray(content) ? content : [content];
+}
+
+function tokensToArray(tokenized) {
+	return Object.entries(tokenized).reduce(function (a, [k, values]) {
+		if (k.startsWith('pattern')) {
+			return [...a, ...toArray(values)];
+		}
+		return a;
+	}, []);
+}
+
+function createFieldsTokenizer(field, filtersStack) {
+	const {
+		name,
+		rules = [],
+		min,
+		language = 'French',
+		stemmer = true,
+		synonyms = {},
+	} = field;
+	if (rules === 'soft') {
+		return softTokenizer;
+	}
+	if (rules.length) {
+		const tokenRules = rules.reduce(function (rulesMap, pattern, index) {
+			return {
+				...rulesMap,
+				[`pattern${name}${index}`]: getRegExpFromPattern(pattern),
+			};
+		}, {});
+
+		return function (string) {
+			const what = tokenizer().input(string).tokens(tokenRules).resolve();
+			return filtersStack(tokensToArray(what), {
+				min,
+				language,
+				stemmer,
+				synonyms,
+			});
+		};
+	}
+	return defaultTokenizeIt;
+}
+
+export default createFieldsTokenizer;

package/src/utils/suggester-workers/commons-tokenizer/create-filter-stop-words.js

@@ -1,17 +1,17 @@
 import defaultStopWords from './stop-words';
 
 function createFilterStopWords(stops = defaultStopWords) {
-  const mapSW = stops.reduce(function (a, w) {
-    return { ...a, [w]: undefined };
-  }, {});
-  return function filter(tokens) {
-    return tokens.reduce(function (a, t) {
-      if (t in mapSW) {
-        return a;
-      }
-      return [...a, t];
-    }, []);
-  };
+	const mapSW = stops.reduce(function (a, w) {
+		return { ...a, [w]: undefined };
+	}, {});
+	return function filter(tokens) {
+		return tokens.reduce(function (a, t) {
+			if (t in mapSW) {
+				return a;
+			}
+			return [...a, t];
+		}, []);
+	};
 }
 
 export default createFilterStopWords;

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

@@ -0,0 +1,10 @@
+export function composeFilters(...filters) {
+	return filters.reduce(
+		function (next, current) {
+			return (tokens, args) => next(current(tokens, args), args);
+		},
+		(t) => t
+	);
+}
+
+export default composeFilters;

package/src/utils/suggester-workers/commons-tokenizer/filters/create-filter-stop-words.js

@@ -0,0 +1,17 @@
+import defaultStopWords from './stop-words';
+
+function createFilterStopWords(stops = defaultStopWords) {
+	const mapSW = stops.reduce(function (a, w) {
+		return { ...a, [w]: undefined };
+	}, {});
+	return function filter(tokens) {
+		return tokens.reduce(function (a, t) {
+			if (t in mapSW) {
+				return a;
+			}
+			return [...a, t];
+		}, []);
+	};
+}
+
+export default createFilterStopWords;

package/src/utils/suggester-workers/commons-tokenizer/filters/create-filter-stop-words.spec.js

@@ -0,0 +1,14 @@
+import createFilterSW from './create-filter-stop-words';
+
+describe('create-filter-stop-words', function () {
+	it('only last ', function () {
+		const sw = ['un', 'de'];
+		const tokens = ['un', 'de', 'trois'];
+
+		const filter = createFilterSW(sw);
+
+		const results = filter(tokens);
+		expect(Array.isArray(results)).toBe(true);
+		expect(results.length).toBe(1);
+	});
+});

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

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

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

@@ -0,0 +1,12 @@
+import filterATL from './filter-accents';
+
+describe('filter-length', function () {
+	it('maj accent', function () {
+		const tokens = ['UN', 'éà ù'];
+		const results = filterATL(tokens, { min: 3 });
+		expect(Array.isArray(results)).toBe(true);
+		expect(results.length).toBe(2);
+		expect(results[0]).toBe('un');
+		expect(results[1]).toBe('ea u');
+	});
+});