@inseefr/lunatic 0.2.62 → 0.3.0-v2

package/src/utils/suggester-workers/find-best-label/tokenize.spec.js

@@ -0,0 +1,19 @@
+import tokenize from './tokenize';
+
+describe('tokenize', function () {
+	it('simple', function () {
+		const results = tokenize({ hello: 'hello world!' });
+		const { hello } = results;
+		expect(Array.isArray(hello)).toEqual(true);
+		expect(hello.length).toEqual(2);
+		expect(hello[0]).toEqual('hello');
+		expect(hello[1]).toEqual('world');
+	});
+
+	it('undefined', function () {
+		const results = tokenize({ hello: '' });
+		const { hello } = results;
+		expect(Array.isArray(hello)).toEqual(true);
+		expect(hello.length).toEqual(0);
+	});
+});

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

@@ -0,0 +1,33 @@
+function finalize(withScore, max = 30) {
+	return withScore
+		.sort(function (a, b) {
+			if (a.score > b.score) {
+				return -1;
+			}
+			if (a.score < b.score) {
+				return 1;
+			}
+			return 0;
+		})
+		.slice(0, max);
+}
+
+function compute(results) {
+	const listOfDocs = Object.values(results);
+	const mapResults = {};
+
+	listOfDocs.forEach(function (docs, i) {
+		docs.forEach(function (doc) {
+			const { id } = doc;
+			if (id in mapResults) {
+				mapResults[id].score++;
+				mapResults[id].step = [i, ...mapResults[id].step];
+			} else {
+				mapResults[id] = { ...doc, score: 1, step: [i] };
+			}
+		});
+	});
+	return finalize(Object.values(mapResults));
+}
+
+export default compute;

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/vtl/dataset-builder.js

@@ -0,0 +1,17 @@
+function getVtlCompatibleValue(value) {
+	if (value === undefined) {
+		return null;
+	}
+	if (Array.isArray(value)) {
+		return {
+			dataStructure: { result: {} },
+			dataPoints: {
+				result: value,
+			},
+		};
+	}
+
+	return value;
+}
+
+export default getVtlCompatibleValue;

package/src/utils/vtl/index.js

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

package/src/components/breadcrumb/breadcrumb.scss

@@ -1,22 +0,0 @@
-@import 'src/components/index.scss';
-
-.breadcrumb-lunatic {
-	width: 100%;
-	height: 40px;
-	box-sizing: border-box;
-	border-radius: 0px;
-	background-color: $main_color;
-	color: white;
-	font-weight: bold;
-	font-size: 130%;
-	padding-left: 10px;
-	display: flex;
-	align-items: center;
-}
-
-.breadcrumb-element-lunatic:before {
-	content: '>';
-	color: white;
-	margin-left: 0.4em;
-	margin-right: 0.4em;
-}

package/src/components/breadcrumb/component.js

@@ -1,29 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { buildStyleObject } from '../../utils/lib';
-import './breadcrumb.scss';
-
-const Breadcrumb = ({ elements, style }) => (
-	<div
-		aria-label={`breadcrumb`}
-		className="breadcrumb-lunatic"
-		style={buildStyleObject(style)}
-	>
-		{elements.map((e, i) => (
-			<React.Fragment key={`breadcrumb-${e.toLowerCase()}`}>
-				{e && (
-					<span className={i !== 0 ? 'breadcrumb-element-lunatic' : undefined}>
-						{e}
-					</span>
-				)}
-			</React.Fragment>
-		))}
-	</div>
-);
-
-Breadcrumb.propTypes = {
-	elements: PropTypes.arrayOf(PropTypes.string).isRequired,
-	style: PropTypes.object,
-};
-
-export default Breadcrumb;

package/src/components/button/component.js

@@ -1,25 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { buildStyleObject } from '../../utils/lib';
-import './button.scss';
-
-const Button = ({ label, value, onClick, disabled, style }) => (
-	<button
-		type="button"
-		aria-label={label || 'button'}
-		className="button-lunatic"
-		style={buildStyleObject(style)}
-		disabled={disabled}
-		onClick={onClick}
-	>
-		{value}
-	</button>
-);
-
-Button.propTypes = {
-	value: PropTypes.string.isRequired,
-	disabled: PropTypes.bool,
-	onClick: PropTypes.func.isRequired,
-};
-
-export default Button;

package/src/components/checkbox/boolean.js

@@ -1,100 +0,0 @@
-import React, { useEffect, useRef } from 'react';
-import PropTypes from 'prop-types';
-import Declarations from '../declarations';
-import { TooltipResponse } from '../tooltip';
-import * as U from '../../utils/lib';
-import * as C from '../../utils/constants';
-import './checkbox.scss';
-
-const CheckboxBoolean = ({
-	id,
-	label,
-	preferences,
-	response,
-	handleChange,
-	disabled,
-	positioning,
-	focused,
-	declarations,
-	tooltip,
-	style,
-}) => {
-	const inputRef = useRef();
-
-	useEffect(() => {
-		if (focused) inputRef.current.focus();
-	}, [focused]);
-
-	const isVertical = positioning === 'VERTICAL';
-	const input = (
-		<input
-			type="checkbox"
-			id={`checkbox-boolean-${id}`}
-			ref={inputRef}
-			title={label ? label : 'empty-label'}
-			className={`checkbox-lunatic${isVertical ? '-no-margin' : ''}`}
-			style={U.buildStyleObject(style)}
-			checked={U.getResponseByPreference(preferences)(response)}
-			disabled={disabled}
-			onChange={e => {
-				handleChange({
-					[U.getResponseName(response)]: e.target.checked,
-				});
-			}}
-		/>
-	);
-	return (
-		<div key={`checkbox-boolean-${id}`} className={`checkbox-modality`}>
-			<Declarations
-				id={id}
-				type={C.BEFORE_QUESTION_TEXT}
-				declarations={declarations}
-			/>
-			{label && <label htmlFor={`checkbox-boolean-${id}`}>{label}</label>}
-			<Declarations
-				id={id}
-				type={C.AFTER_QUESTION_TEXT}
-				declarations={declarations}
-			/>
-			<div className="field-container">
-				<div className={`${tooltip ? 'field-with-tooltip' : 'field'}`}>
-					{isVertical ? <div>{input}</div> : input}
-				</div>
-				{tooltip && (
-					<div className="tooltip">
-						<TooltipResponse id={id} response={response} />
-					</div>
-				)}
-			</div>
-			<Declarations id={id} type={C.DETACHABLE} declarations={declarations} />
-		</div>
-	);
-};
-
-CheckboxBoolean.defaultProps = {
-	label: '',
-	preferences: ['COLLECTED'],
-	response: {},
-	disabled: false,
-	positioning: 'DEFAULT',
-	focused: false,
-	declarations: [],
-	tooltip: false,
-	style: {},
-};
-
-CheckboxBoolean.propTypes = {
-	id: PropTypes.string.isRequired,
-	label: PropTypes.string,
-	preferences: PropTypes.arrayOf(U.valueTypePropTypes),
-	response: U.responsePropTypes,
-	handleChange: PropTypes.func.isRequired,
-	disabled: PropTypes.bool,
-	positioning: PropTypes.oneOf(['DEFAULT', 'HORIZONTAL', 'VERTICAL']),
-	focused: PropTypes.bool,
-	declarations: U.declarationsPropTypes,
-	tooltip: PropTypes.bool,
-	style: PropTypes.object,
-};
-
-export default CheckboxBoolean;

package/src/components/checkbox/group.js

@@ -1,128 +0,0 @@
-import React, { useRef, useEffect } from 'react';
-import PropTypes from 'prop-types';
-import Declarations from '../declarations';
-import { TooltipResponse } from '../tooltip';
-import * as U from '../../utils/lib';
-import * as C from '../../utils/constants';
-import './checkbox.scss';
-
-const CheckboxGroup = ({
-	id,
-	label,
-	preferences,
-	responses,
-	handleChange,
-	disabled,
-	focused,
-	keyboardSelection,
-	positioning,
-	declarations,
-	tooltip,
-	style,
-}) => {
-	const { fieldsetStyle, checkboxStyle } = style;
-	const inputRef = useRef();
-
-	useEffect(() => {
-		if (focused) inputRef.current.focus();
-	}, [focused]);
-
-	return (
-		<React.Fragment>
-			<Declarations
-				id={id}
-				type={C.BEFORE_QUESTION_TEXT}
-				declarations={declarations}
-			/>
-
-			<fieldset
-				key={`checkbox-${id}`}
-				className="checkbox-group"
-				style={U.buildStyleObject(fieldsetStyle)}
-			>
-				<legend>{label}</legend>
-				<Declarations
-					id={id}
-					type={C.AFTER_QUESTION_TEXT}
-					declarations={declarations}
-				/>
-				{responses.map(({ id: modId, label: modLabel, response }, i) => {
-					const checked = U.getResponseByPreference(preferences)(response);
-					return (
-						<div className="field-container" key={`checkbox-${id}-${modId}`}>
-							<div className={`${tooltip ? 'field-with-tooltip' : 'field'}`}>
-								<div
-									className={`checkbox-modality ${U.getItemsPositioningClass(
-										positioning
-									)}`}
-								>
-									<input
-										type="checkbox"
-										id={`checkbox-${id}-${modId}`}
-										ref={inputRef}
-										key={`checkbox-${id}-${modId}`}
-										aria-labelledby={`input-label-${id}-${modId}`}
-										className="checkbox-lunatic"
-										checked={checked}
-										disabled={disabled}
-										onChange={e => {
-											handleChange({
-												[U.getResponseName(response)]: e.target.checked,
-											});
-										}}
-									/>
-									<label
-										htmlFor={`checkbox-${id}-${modId}`}
-										id={`input-label-${id}-${modId}`}
-										style={checked ? U.buildStyleObject(checkboxStyle) : {}}
-									>
-										{keyboardSelection
-											? `${U.getAlphabet()[i].toUpperCase()} - ${modLabel}`
-											: modLabel}
-									</label>
-								</div>
-							</div>
-							{tooltip && (
-								<div className="tooltip">
-									<TooltipResponse id={id} response={response} />
-								</div>
-							)}
-						</div>
-					);
-				})}
-			</fieldset>
-
-			<Declarations id={id} type={C.DETACHABLE} declarations={declarations} />
-		</React.Fragment>
-	);
-};
-
-CheckboxGroup.defaultProps = {
-	label: '',
-	preferences: ['COLLECTED'],
-	responses: [],
-	disabled: false,
-	focused: false,
-	keyboardSelection: false,
-	positioning: 'DEFAULT',
-	declarations: [],
-	tooltip: false,
-	style: { fieldsetStyle: {}, checkboxStyle: {} },
-};
-
-CheckboxGroup.propTypes = {
-	id: PropTypes.string.isRequired,
-	label: PropTypes.string,
-	preferences: PropTypes.arrayOf(U.valueTypePropTypes),
-	response: U.responsePropTypes,
-	handleChange: PropTypes.func.isRequired,
-	disabled: PropTypes.bool,
-	focused: PropTypes.bool,
-	keyboardSelection: PropTypes.bool,
-	positioning: PropTypes.oneOf(['DEFAULT', 'HORIZONTAL', 'VERTICAL']),
-	declarations: U.declarationsPropTypes,
-	tooltip: PropTypes.bool,
-	style: PropTypes.object,
-};
-
-export default CheckboxGroup;