@inseefr/lunatic 0.1.7 → 0.1.8-experimental

package/src/utils/lib/loops/build-components.js

@@ -0,0 +1,33 @@
+export const buildLoopComponents = (iterations) => (components) => {
+	const toFlat = [...Array(iterations).keys()].map((rowNumber) =>
+		buildFlatten(rowNumber)(components).map((c) => ({ ...c, rowNumber }))
+	);
+	return toFlat.flat();
+};
+
+const buildFlatten = (i) => (parentComponents) =>
+	parentComponents.map((component) => {
+		const { response, responses, components } = component;
+		if (response) return buildFlattenResponse(i)(component);
+		else if (responses)
+			return {
+				...component,
+				responses: responses.map((r) => buildFlattenResponse(i)(r)),
+			};
+		else if (components)
+			return { ...component, components: buildFlatten(i)(components) };
+		else return component;
+	});
+
+const buildFlattenResponse = (i) => (component) => {
+	const { response, ...other } = component;
+	const { name, values } = response;
+	const newValues = Object.entries(values).reduce(
+		(acc, [key, value]) => ({ ...acc, [key]: value ? value[i] : null }),
+		{}
+	);
+	return {
+		...other,
+		response: { name, values: newValues },
+	};
+};

package/src/utils/lib/loops/index.js

@@ -0,0 +1,3 @@
+export * from './bindings';
+export * from './build-components';
+export * from './shared';

package/src/utils/lib/loops/shared.js

@@ -0,0 +1,55 @@
+import * as C from '../../../constants';
+
+export const getLoopConstructorInitLines = (components) =>
+	Array.isArray(components)
+		? components.reduce(
+				(_, c) =>
+					c.response &&
+					c.response.values[C.COLLECTED] &&
+					c.response.values[C.COLLECTED].length > _
+						? c.response.values[C.COLLECTED].length
+						: _,
+				0
+		  )
+		: 0;
+
+export const getInvolvedVariables = (parentComponents) =>
+	Array.isArray(parentComponents)
+		? parentComponents
+				.reduce((_, c) => {
+					const { response, responses, missingResponse, components, depth } = c;
+					if (missingResponse) {
+						const miss = { name: missingResponse.name, depth };
+						if (response && response.name)
+							return [..._, { name: response.name, depth }, miss];
+						if (responses || components)
+							return [
+								..._,
+								getInvolvedVariables(responses || components),
+								miss,
+							];
+						return _;
+					}
+					if (response && response.name)
+						return [..._, { name: response.name, depth }];
+					if (responses || components)
+						return [..._, getInvolvedVariables(responses || components)];
+					return _;
+				}, [])
+				.flat()
+		: [];
+
+export const lastLoopChildLineIsEmpty = (bindings) => (involvedVariables) =>
+	bindings && involvedVariables
+		? involvedVariables
+				.map((iv) => iv.name)
+				.filter((iv) => bindings[iv] && bindings[iv][bindings[iv].length - 1])
+				.length === 0
+		: true;
+
+export const buildEmptyValue = (depth) => {
+	if (!Number(depth) || depth <= 2) return null;
+	return new Array(depth - 2)
+		.fill(null)
+		.reduce((acc) => new Array(1).fill(acc), null);
+};

package/src/utils/lib/memo-check.js

@@ -0,0 +1,24 @@
+import isEqual from 'lodash.isequal';
+
+const VarsHasBeenUpdated = (prevProps, props) => {
+	const { response: oldR, responses: oldRs, cells: oldC } = prevProps;
+	const { response: newR, responses: newRs, cells: newC } = props;
+	if (!newR && !newRs && !newC) return true;
+	return !(
+		(newR && isEqual(oldR, newR)) ||
+		(newRs && isEqual(oldRs, newRs)) ||
+		(newC && isEqual(oldC, newC))
+	);
+};
+export const areEqual = (prevProps, props) => {
+	if (VarsHasBeenUpdated(prevProps, props)) return false;
+	const { bindingDependencies } = props;
+	if (Array.isArray(bindingDependencies) && bindingDependencies.length > 0) {
+		const { bindings: oldB } = prevProps;
+		const { bindings: newB } = props;
+		return !bindingDependencies
+			.map((d) => isEqual(oldB[d], newB[d]))
+			.includes(false);
+	}
+	return true;
+};

package/src/utils/lib/missing.js

@@ -0,0 +1,52 @@
+import { buildNullNestedArray } from './array';
+
+export const DK = 'DK';
+export const RF = 'RF';
+
+export const getToClean =
+	(savingType) =>
+	({ response, responses, cells, components }) => {
+		if (response) {
+			const resValues = response.values[savingType];
+			if (resValues !== null) {
+				if (Array.isArray(resValues)) {
+					//handle nested array
+					return { [response.name]: buildNullNestedArray(resValues) };
+				}
+				return { [response.name]: null };
+			}
+			return {};
+		}
+		if (responses || cells || components) {
+			const group = responses || cells || components;
+			return group
+				.flat(Infinity)
+				.reduce((acc, c) => ({ ...acc, ...getToClean(savingType)(c) }), {});
+		}
+		return false;
+	};
+
+export const hasToCleanMissing =
+	(savingType) =>
+	({ response, responses, cells, components }) => {
+		if (response) {
+			const resValues = response.values[savingType];
+			if (resValues !== null) {
+				if (Array.isArray(resValues)) {
+					if (resValues.flat(Infinity).filter((r) => r !== null).length > 0)
+						return true;
+					return false;
+				}
+				return true;
+			}
+			return false;
+		}
+		if (responses || cells || components) {
+			const group = responses || cells || components;
+			return (
+				group.flat(Infinity).filter((c) => hasToCleanMissing(savingType)(c))
+					.length > 0
+			);
+		}
+		return false;
+	};

package/src/utils/{items-positioning.js → lib/options-positioning.js}

@@ -1,7 +1,7 @@
 export const getItemsPositioningClass = positioning => {
 	switch (positioning) {
 		case 'HORIZONTAL':
-			return 'horizontal-items';
+			return 'horizontal-options';
 		case 'VERTICAL':
 		default:
 			return '';

package/src/utils/lib/pagination/flow.js

@@ -0,0 +1,2 @@
+export const FLOW_NEXT = 'FLOW_NEXT';
+export const FLOW_PREVIOUS = 'FLOW_PREVIOUS';

package/src/utils/lib/pagination/index.js

@@ -0,0 +1,2 @@
+export * from './flow';
+export * from './navigation';

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

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

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

@@ -0,0 +1,108 @@
+import { interpret } from '../../../to-expose/interpret';
+import { FLOW_NEXT, FLOW_PREVIOUS } from '../flow';
+
+export const getPage = ({
+	components,
+	bindings,
+	currentPage,
+	features,
+	depth,
+	flow,
+	management,
+}) => {
+	if (currentPage.includes('#')) {
+		const { currentRootPage, currentComponentIndex, currentIteration } =
+			splitPage(currentPage, depth);
+
+		if (flow === FLOW_NEXT)
+			return `${currentRootPage}.${
+				currentComponentIndex + 1
+			}#${currentIteration}`;
+		if (flow === FLOW_PREVIOUS)
+			return `${currentRootPage}.${
+				currentComponentIndex - 1
+			}#${currentIteration}`;
+		throw new Error(`Unknown flow type: ${flow}`);
+	} else {
+		const newPage = getSimpleNewPage({
+			components,
+			bindings,
+			currentPage,
+			features,
+			flow,
+			management,
+		});
+		return `${parseInt(newPage, 10)}`;
+	}
+};
+
+const getSimpleNewPage = ({
+	components,
+	bindings,
+	currentPage,
+	features,
+	flow,
+	management,
+}) => {
+	const newPage = (
+		flow === FLOW_PREVIOUS ? components.slice().reverse() : components
+	)
+		.filter(({ page }) => {
+			switch (flow) {
+				case FLOW_NEXT:
+					return parseInt(page, 10) > parseInt(currentPage, 10);
+				case FLOW_PREVIOUS:
+					return parseInt(page, 10) < parseInt(currentPage, 10);
+				default:
+					throw new Error('Unknown type');
+			}
+		})
+		.reduce((acc, { conditionFilter, page }) => {
+			if (acc) return acc;
+			if (management) return page;
+			if (
+				!conditionFilter?.value ||
+				interpret(features)(bindings)(conditionFilter.value)
+			)
+				return page;
+			else return null;
+		}, null);
+	return newPage || currentPage;
+};
+
+export const splitPage = (currentPage = '1', depth) => {
+	const currentPageWithDepth = depth
+		? currentPage
+				.split('.')
+				.slice(0, depth + 1) // scoped
+				.join('.')
+		: currentPage;
+
+	const currentPageWithoutIteration = currentPageWithDepth
+		.split('#')
+		.slice(0, -1)
+		.join('#');
+
+	const currentPageWithoutAnyIteration = currentPageWithDepth
+		.split('.')
+		.map((e) => e.split('#')[0])
+		.join('.');
+
+	const currentRootPage = currentPageWithoutIteration
+		.split('.')
+		.slice(0, -1)
+		.join('.');
+
+	const [currentComponentIndex, currentIteration] = currentPageWithDepth
+		.split('.')
+		.pop()
+		.split('#')
+		.map((c) => parseInt(c, 10));
+
+	return {
+		currentRootPage,
+		currentComponentIndex,
+		currentIteration,
+		currentPageWithoutAnyIteration,
+	};
+};

package/src/utils/lib/prop-types/declarations.js

@@ -0,0 +1,22 @@
+import PropTypes from 'prop-types';
+import * as C from '../../../constants';
+
+export default PropTypes.arrayOf(
+	PropTypes.shape({
+		id: PropTypes.string.isRequired,
+		declarationType: PropTypes.oneOf([
+			C.INSTRUCTION,
+			C.COMMENT,
+			C.HELP,
+			C.WARNING,
+			C.MESSAGE_FILTER,
+			C.STATEMENT,
+		]),
+		position: PropTypes.oneOf([
+			C.BEFORE_QUESTION_TEXT,
+			C.AFTER_QUESTION_TEXT,
+			C.DETACHABLE,
+		]),
+		label: PropTypes.string.isRequired,
+	})
+).isRequired;

package/src/utils/lib/prop-types/index.js

@@ -0,0 +1,5 @@
+export { default as declarationsPropTypes } from './declarations';
+export { default as optionsPropTypes } from './options';
+export { default as responsePropTypes } from './response';
+export { default as valueTypePropTypes } from './value-type';
+export { default as linesPropTypes } from './lines';

package/src/utils/lib/prop-types/lines.js

@@ -0,0 +1,6 @@
+import PropTypes from 'prop-types';
+
+export default PropTypes.shape({
+	min: PropTypes.string,
+	max: PropTypes.string,
+});

package/src/utils/lib/prop-types/options.js

@@ -0,0 +1,8 @@
+import PropTypes from 'prop-types';
+
+export default PropTypes.arrayOf(
+	PropTypes.shape({
+		label: PropTypes.string.isRequired,
+		value: PropTypes.string.isRequired,
+	})
+);

package/src/utils/lib/prop-types/response.js

@@ -0,0 +1,6 @@
+import PropTypes from 'prop-types';
+
+export default PropTypes.shape({
+	name: PropTypes.string,
+	values: PropTypes.shape({}),
+});

package/src/utils/lib/prop-types/value-type.js

@@ -0,0 +1,9 @@
+import PropTypes from 'prop-types';
+
+export default PropTypes.oneOf([
+	'COLLECTED',
+	'PREVIOUS',
+	'FORCED',
+	'EDITED',
+	'INPUTED',
+]);

package/src/utils/lib/responses.js

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

package/src/utils/lib/table/index.js

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

package/src/utils/lib/table/roster.js

@@ -0,0 +1,23 @@
+const isResponseEmpty = (response) =>
+	Object.values(response.values).filter((v) => v !== null).length === 0;
+
+export const getRosterInitLines = (cells) =>
+	Array.isArray(cells)
+		? cells
+				.filter(
+					(line) =>
+						line.filter(({ response }) => !response).length !== line.length
+				)
+				.reduce(
+					(_, line) => [
+						..._,
+						line.reduce((__, { response, label }) => {
+							if (label) return true;
+							if (__ || !response) return __;
+							return !isResponseEmpty(response);
+						}, false),
+					],
+					[]
+				)
+				.filter((b) => b).length
+		: 0;

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

@@ -0,0 +1,41 @@
+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/lib/tooltip/content.js

@@ -0,0 +1,55 @@
+import * as C from '../../../constants';
+
+export const buildTooltip = (response) => {
+	if (
+		!response ||
+		!response.values ||
+		Object.keys(response.values).length === 0
+	)
+		return {};
+	const { values } = response;
+	const edited = values[C.EDITED];
+	const forced = values[C.FORCED];
+	const collected = values[C.COLLECTED];
+
+	if (edited === '' && !has(forced) && !has(collected)) return {};
+
+	if (has(edited)) {
+		if (!has(forced))
+			return {
+				content: [
+					{
+						key: 'Brute',
+						value: collected || ' - ',
+					},
+				],
+				imgName: 'editedImg',
+			};
+		return {
+			content: [
+				{
+					key: 'Brute',
+					value: collected || ' - ',
+				},
+				{
+					key: 'Correction automatique',
+					value: forced,
+				},
+			],
+			imgName: 'editedImg',
+		};
+	}
+	if (has(forced))
+		return {
+			content: [
+				{
+					key: 'Brute',
+					value: collected || ' - ',
+				},
+			],
+			imgName: 'forcedImg',
+		};
+	return {};
+};
+
+const has = (status) => ![null, undefined].includes(status);

package/src/utils/lib/tooltip/index.js

@@ -0,0 +1,6 @@
+export { buildTooltip } from './content';
+export {
+	buildLocalResponse,
+	buildMultiTooltipResponse,
+	buildBooleanTooltipResponse,
+} from './build-response';

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

@@ -0,0 +1,72 @@
+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';
+
+const workerPath =
+	process.env.LUNATIC_LOADER_WORKER_PATH ||
+	process.env.REACT_APP_LUNATIC_LOADER_WORKER_PATH ||
+	'workers/lunatic-loader-worker-0.1.0.js';
+
+export const loadSuggesters = (suggesterFetcher) => async (suggesters) => {
+	Object.entries(suggesters).forEach(async ([name, attrs]) => {
+		const { version } = attrs;
+		const db = await openStorage(name, version);
+		if (db) {
+			await cleanStorage(db);
+			await cleanInfoStorage(db);
+			await updateStoreInfo(db, attrs);
+		}
+	});
+	Object.entries(suggesters).forEach(([name, attrs]) => {
+		const { url, version, fields, stopWords } = attrs;
+		const f = suggesterFetcher || fetch;
+		f(url).then(async (res) => {
+			const data = await res.json();
+			const [launch] = task({ name, fields, stopWords }, version);
+			await launch(data);
+		});
+	});
+};
+
+/**
+ * Only with Worker
+ */
+function task({ name, fields, stopWords }, version, log = () => null) {
+	const worker = new Worker(workerPath);
+	let start = false;
+	let stop = false;
+
+	function launch(entities, post = () => null) {
+		return new Promise(function (resolve) {
+			start = true;
+			worker.postMessage({
+				name,
+				version,
+				fields,
+				entities,
+				stopWords,
+			});
+			worker.addEventListener('message', function (e) {
+				const { data } = e;
+				if (data === 'success') {
+					if (!stop) {
+						post();
+					}
+					resolve(data);
+				} else {
+					log(data);
+				}
+			});
+		});
+	}
+
+	function terminate() {
+		if (start) {
+			stop = true;
+			worker.terminate();
+		}
+	}
+
+	return [launch, terminate];
+}

package/src/utils/store-tools/clear-store-data.js

@@ -0,0 +1,8 @@
+import { clearDb } from '../idb-tools';
+import CONSTANTES from './constantes';
+
+async function clear(db) {
+	await clearDb(db, CONSTANTES.STORE_DATA_NAME);
+}
+
+export default clear;

package/src/utils/store-tools/clear-store-info.js

@@ -0,0 +1,8 @@
+import { clearDb } from '../idb-tools';
+import CONSTANTES from './constantes';
+
+async function clear(db) {
+	await clearDb(db, CONSTANTES.STORE_INFO_NAME);
+}
+
+export default clear;

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

@@ -0,0 +1,20 @@
+export const STORE_DATA_NAME = 'store/entities';
+export const STORE_INFO_NAME = 'store/info';
+export const STORE_INDEX_NAME = 'store/entities/index';
+export const STORE_INDEX_PATH = 'searching';
+export const MAX_STRING = String.fromCharCode(65535);
+export const SEARCH_TYPES = {
+	prefix: 'search/prefix',
+	tokens: 'search/tokens',
+};
+
+const CONSTANTES = {
+	STORE_DATA_NAME,
+	STORE_INDEX_NAME,
+	STORE_INDEX_PATH,
+	MAX_STRING,
+	SEARCH_TYPES,
+	STORE_INFO_NAME,
+};
+
+export default CONSTANTES;

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

@@ -0,0 +1,19 @@
+import { clearDb } from '../../idb-tools';
+import CONSTANTES from '../constantes';
+import openOrCreateStore from '../open-or-create-store';
+import updateStoreInfo from './update-store-info';
+
+async function create(storeInfo, idbVersion) {
+	const { name } = storeInfo;
+	try {
+		const db = await openOrCreateStore(name, idbVersion);
+		await clearDb(db, CONSTANTES.STORE_INFO_NAME);
+		await updateStoreInfo(db, storeInfo);
+
+		return db;
+	} catch (e) {
+		throw e;
+	}
+}
+
+export default create;

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

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

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

@@ -0,0 +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;