@inseefr/lunatic 0.2.61 → 0.3.1-experimental

package/src/utils/idb-tools/create-db-opener.js

@@ -0,0 +1,43 @@
+import getIDB from './get-idb';
+
+const IDB_REF = getIDB();
+
+function onSuccessDefault(e, resolve) {
+	resolve(e.result);
+}
+
+function onUpgradeNeededDefault() {
+	throw new Error('Upgrade needed hook required!');
+}
+
+function onErrorDefault(e, _, reject) {
+	reject(e.error);
+}
+
+function createDbOpener({
+	onSuccess = onSuccessDefault,
+	onUpgradeNeeded = onUpgradeNeededDefault,
+	onError = onErrorDefault,
+} = {}) {
+	return function (name, version = 1) {
+		return new Promise((resolve, reject) => {
+			if (!IDB_REF) {
+				reject('indexedDb not supported !');
+			}
+			const request = IDB_REF.open(name, version);
+			request.onupgradeneeded = function (e) {
+				onUpgradeNeeded(e, resolve, reject);
+			};
+
+			request.onsuccess = function (e) {
+				onSuccess(e, resolve, reject);
+			};
+
+			request.onerror = function (e) {
+				onError(e, resolve, reject);
+			};
+		});
+	};
+}
+
+export default createDbOpener;

package/src/utils/idb-tools/create-open-db.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-restricted-globals */
+import getIDB from './get-idb';
+
+const IDB_REF = getIDB();
+
+function createOpenDb(onSuccess, onUpgradeNeeded) {
+	return function openStorage(name, version = 1) {
+		return new Promise(function (resolve, reject) {
+			if (!IDB_REF) {
+				reject('indexedDb not supported !');
+			}
+			const request = IDB_REF.open(name, version);
+
+			request.onupgradeneeded = onUpgradeNeeded(resolve, reject);
+
+			request.onsuccess = onSuccess(resolve, reject);
+
+			request.onerror = function (e) {
+				reject(e);
+			};
+		});
+	};
+}
+
+export default createOpenDb;

package/src/utils/idb-tools/get-entity.js

@@ -0,0 +1,15 @@
+function get(db, storeName, id) {
+	return new Promise(function (resolve, reject) {
+		const transaction = db.transaction(storeName, 'readwrite');
+		var store = transaction.objectStore(storeName);
+		const request = store.get(id);
+		transaction.onerror = function () {
+			reject(transaction.error);
+		};
+		request.onsuccess = function () {
+			resolve(request.result);
+		};
+	});
+}
+
+export default get;

package/src/utils/idb-tools/get-idb.js

@@ -0,0 +1,12 @@
+/* eslint-disable no-restricted-globals */
+function getIDB() {
+	const what = self || window;
+	return (
+		what.indexedDB ||
+		what.mozIndexedDB ||
+		what.webkitIndexedDB ||
+		what.msIndexedDB
+	);
+}
+
+export default getIDB;

package/src/utils/idb-tools/idb-bulk-insert.js

@@ -0,0 +1,96 @@
+const BULK_LIMIT = 300;
+
+export const BULK_INSERT_MESSAGES = {
+	bulkInsertComplete: { type: 'bulk-insert/complete' },
+	bulkInsertFinished: { type: 'bulk-insert/finished' },
+	bulkInsertError: { type: 'bulk-insert/error' },
+};
+
+/* */
+const pushTask = (store, transaction) => ([first, ...rest] = []) => {
+	if (first) {
+		const request = store.add(first);
+		request.onsuccess = () => {
+			if (rest.length) {
+				pushTask(store, transaction)(rest);
+			}
+		};
+
+		request.onerror = (e) => {
+			throw e;
+		};
+	}
+};
+
+/* */
+function split(entities, limit = BULK_LIMIT) {
+	return entities.reduce(
+		([f, ...r], n, i) => {
+			return (i + 1) % limit === 0 ? [[n], f, ...r] : [[n, ...f], ...r];
+		},
+		[[]]
+	);
+}
+
+/* */
+const bulkPush = (db, name, hook, resolve, reject, max) => (
+	lot,
+	i = 0,
+	treated = 0
+) => {
+	const [first, ...rest] = lot;
+	try {
+		if (first) {
+			const transaction = db.transaction(name, 'readwrite');
+			const store = transaction.objectStore(name);
+			pushTask(store, transaction)(first);
+			transaction.oncomplete = function () {
+				const nextTreated = treated + first.length;
+				hook({
+					message: {
+						...BULK_INSERT_MESSAGES.bulkInsertComplete,
+						nb: first.length,
+						treated: nextTreated,
+						step: i,
+						max,
+						percent: Math.round((nextTreated / max) * 100),
+					},
+				});
+				bulkPush(
+					db,
+					name,
+					hook,
+					resolve,
+					reject,
+					max
+				)(rest, i + 1, nextTreated);
+			};
+			transaction.onerror = function (e) {
+				hook({ message: BULK_INSERT_MESSAGES.bulkInsertError, error: e });
+				reject(e);
+			};
+		} else {
+			hook({ message: BULK_INSERT_MESSAGES.bulkInsertFinished });
+			resolve('success');
+		}
+	} catch (e) {
+		hook({ message: BULK_INSERT_MESSAGES.bulkInsertError });
+		reject(e);
+	}
+};
+
+/* */
+function bulkInsert(db, store, hook = () => null) {
+	return (entities = []) => {
+		const lots = split(entities, BULK_LIMIT);
+		return new Promise((resolve, reject) => {
+			try {
+				bulkPush(db, store, hook, resolve, reject, entities.length)(lots);
+			} catch (e) {
+				reject(e);
+			}
+		});
+	};
+}
+
+export default bulkInsert;

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

@@ -0,0 +1,10 @@
+export { default as openDb } from './open-db';
+export { default as clearDb } from './clear-store';
+export { default as getIDB } from './get-idb';
+export { default as getEntity } from './get-entity';
+export { default as insertEntity } from './insert-entity';
+export { default as openOnCreateDb } from './open-or-create-db';
+export {
+	default as idbBulkInsert,
+	BULK_INSERT_MESSAGES,
+} from './idb-bulk-insert';

package/src/utils/idb-tools/insert-entity.js

@@ -0,0 +1,15 @@
+function insert(db, storeName, entity) {
+	return new Promise(function (resolve, reject) {
+		const transaction = db.transaction(storeName, 'readwrite');
+		const store = transaction.objectStore(storeName);
+		const request = store.add(entity);
+		request.onsuccess = () => {
+			resolve('success');
+		};
+		request.onerror = (e) => {
+			reject(e);
+		};
+	});
+}
+
+export default insert;

package/src/utils/idb-tools/open-db.js

@@ -0,0 +1,13 @@
+/* eslint-disable no-restricted-globals */
+import createDbOpener from './create-db-opener';
+
+function onUpgradeNeeded(e, _, reject) {
+	e.target.transaction.abort();
+	reject({ message: 'base seems to need an upgrade!' });
+}
+
+function onSuccess(e, resolve) {
+	resolve(e.target.result);
+}
+
+export default createDbOpener({ onUpgradeNeeded, onSuccess });

package/src/utils/idb-tools/open-or-create-db.js

@@ -0,0 +1,34 @@
+/* eslint-disable no-restricted-globals */
+import CONSTANTE from '../store-tools/constantes';
+import createDbOpener from './create-db-opener';
+
+function onUpgradeNeeded(e, resolve, reject) {
+	try {
+		e.target.onsuccess = function () {
+			// Block success event!
+		};
+		const db = e.target.result;
+		const store = db.createObjectStore(CONSTANTE.STORE_DATA_NAME, {
+			keyPath: 'id',
+		});
+		db.createObjectStore(CONSTANTE.STORE_INFO_NAME, {
+			keyPath: 'name',
+		});
+		store.createIndex(CONSTANTE.STORE_INDEX_NAME, 'tokens', {
+			multiEntry: true,
+		});
+
+		const txn = e.target.transaction;
+		txn.oncomplete = function () {
+			resolve(db);
+		};
+	} catch (e) {
+		reject(e);
+	}
+}
+
+function onSuccess(e, resolve) {
+	resolve(e.target.result);
+}
+
+export default createDbOpener({ onUpgradeNeeded, onSuccess });

package/src/utils/lib/alphabet.js

@@ -1 +1 @@
-export const getAlphabet = () => 'abcdefghijklmnopqrstuvwxyz'.split('');
+export const getAlphabet = () => 'abcdefghijklmnopqrstuvwxyz'.split('');

package/src/utils/lib/array.js

@@ -0,0 +1,7 @@
+export const buildNullNestedArray = (array) => {
+	if (!Array.isArray(array)) return [];
+	return array.map((a) => {
+		if (Array.isArray(a)) return buildNullNestedArray(a);
+		return null;
+	});
+};

package/src/utils/lib/checkbox/group.js

@@ -0,0 +1,21 @@
+export const responseToClean = (response) => (preferences) => {
+	if (!preferences || !response.values) return false;
+	const { values } = response;
+	if (!values) return false;
+	const cutedValues = {
+		...values,
+		[preferences[preferences.length - 1]]: null,
+	};
+	return Object.values(cutedValues).filter((v) => v !== null).length === 0;
+};
+
+export const responsesToClean = (responses) => (preferences) => (key) => {
+	if (!preferences || !key) return false;
+	const values = responses.find((r) => r.response.name === key).response.values;
+	if (!values) return false;
+	const cutedValues = {
+		...values,
+		[preferences[preferences.length - 1]]: null,
+	};
+	return Object.values(cutedValues).filter((v) => v !== null).length === 0;
+};

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

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

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

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

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/decorator/index.js

@@ -1 +1 @@
-export { default as titleDecorator } from './title-decorator';
+export { default as titleDecorator } from './title-decorator';

package/src/utils/lib/decorator/title-decorator.js

@@ -1,17 +1,15 @@
-import React, { Component } from 'react';
+import React from 'react';
 
 const titleDecorator = WrappedComponent => {
-	class TitleComponent extends Component {
-		render() {
-			const { title } = this.props;
-			return (
-				<React.Fragment>
-					<h1>{title}</h1>
-					<WrappedComponent />
-				</React.Fragment>
-			);
-		}
-	}
+	const TitleComponent = props => {
+		const { title } = props;
+		return (
+			<>
+				<h1>{title}</h1>
+				<WrappedComponent />
+			</>
+		);
+	};
 	return TitleComponent;
 };
 

package/src/utils/lib/env.js

@@ -0,0 +1,2 @@
+export const isDev =
+	!process.env.NODE_ENV || process.env.NODE_ENV === 'development';

package/src/utils/lib/event.js

@@ -0,0 +1,15 @@
+export const createObjectEvent = (
+	idParadataObject,
+	typeParadataObject,
+	type,
+	responseName,
+	value
+) => {
+	return {
+		idParadataObject,
+		typeParadataObject,
+		type,
+		responseName,
+		value,
+	};
+};

package/src/utils/lib/function.js

@@ -0,0 +1 @@
+export const isFunction = (f) => f && typeof f === 'function';

package/src/utils/lib/index.js

@@ -1,9 +1,20 @@
-export { titleDecorator } from './decorator';
-export * from './prop-types';
-export * from './tooltip';
 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/input-number.js

@@ -0,0 +1,6 @@
+export const isNumberValid = (num, decimals = 0) => {
+	// \\ because of escaping, basic regex has only one \
+	if (num.includes('.') && !decimals) return false;
+	const regex = new RegExp(`^(-)?(0|[1-9]\\d*)(\\.(\\d){0,${decimals}})?$`);
+	return regex.test(num);
+};

package/src/utils/lib/label-position.js

@@ -1,12 +1,12 @@
-export const getLabelPositionClass = position => {
-	switch (position) {
-		case 'TOP':
-			return 'label-top';
-		case 'BOTTOM':
-			return 'label-bottom';
-		case 'RIGHT':
-			return 'label-right';
-		default:
-			return 'label-left';
-	}
-};
+export const getLabelPositionClass = (position) => {
+	switch (position) {
+		case 'LEFT':
+			return 'label-left';
+		case 'BOTTOM':
+			return 'label-bottom';
+		case 'RIGHT':
+			return 'label-right';
+		default:
+			return 'label-top';
+	}
+};

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

@@ -0,0 +1,66 @@
+export const buildBindingsForDeeperComponents = (index) => (bindings) =>
+	bindings
+		? Object.entries(bindings).reduce((_, [name, value]) => {
+				if (Array.isArray(value)) return { ..._, [name]: value[index] };
+				return { ..._, [name]: value };
+		  }, {})
+		: {};
+
+export const buildLoopBindings = (index) => (vars) =>
+	Array.isArray(vars)
+		? vars.reduce((_, [name, value]) => {
+				if (Array.isArray(value)) return { ..._, [name]: value[index] };
+				return { ..._, [name]: value };
+		  }, {})
+		: {};
+
+export const buildLoopMissingResponse = (index) => (missingResponse) => {
+	if ((!index && index !== 0) || !missingResponse) return undefined;
+	const { name, values } = missingResponse;
+	const newValues = Object.entries(values).reduce(
+		(acc, [k, v]) => ({ ...acc, [k]: v[index] }),
+		{}
+	);
+	return { name, values: newValues };
+};
+
+const getDefaultDatasetStructure = (name, value) => ({
+	[name]: { dataStructure: { [name]: {} }, dataPoints: { [name]: value } },
+});
+
+export const buildVectorialBindings = (bindings) =>
+	bindings
+		? Object.entries(bindings).reduce((_, [name, value]) => {
+				if (Array.isArray(value))
+					return {
+						..._,
+						...getDefaultDatasetStructure(name, value),
+					};
+				return { ..._, [name]: value };
+		  }, {})
+		: {};
+
+export const displayLoop = (dependencyList) => (bindings) => {
+	if (!Array.isArray(dependencyList) || !bindings) return false;
+	return !(
+		dependencyList
+			.map((iv) =>
+				Array.isArray(bindings[iv][0])
+					? bindings[iv][0].flat()[0]
+					: bindings[iv][0]
+			)
+			.filter((v) => v).length === 0
+	);
+};
+
+export const displayLoopQuestion = (dependencyList) => (bindings) => {
+	if (!Array.isArray(dependencyList) || !bindings) return false;
+	if (dependencyList.length === 1) return true;
+	return !(
+		dependencyList
+			.map((iv) =>
+				Array.isArray(bindings[iv]) ? bindings[iv].flat()[0] : bindings[iv]
+			)
+			.filter((v) => v).length === 0
+	);
+};

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