@inseefr/lunatic 0.3.0-experimental → 0.3.0-prisme

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

@@ -1,30 +1,30 @@
-import tokenizer from 'string-tokenizer';
-
-function toArray(tokens) {
-	if (Array.isArray(tokens)) {
-		return tokens;
-	}
-	return [tokens];
-}
-
-function tokenize(object, pattern = /[\w]+/) {
-	if (typeof object === 'object') {
-		const map = {};
-		Object.entries(object).forEach(function ([key, string]) {
-			if (string.length) {
-				const { tokens } = tokenizer()
-					.input(string)
-					.tokens({ tokens: pattern })
-					.resolve();
-				map[key] = toArray(tokens);
-			} else {
-				map[key] = [];
-			}
-		});
-
-		return map;
-	}
-	return {};
-}
-
-export default tokenize;
+import tokenizer from 'string-tokenizer';
+
+function toArray(tokens) {
+	if (Array.isArray(tokens)) {
+		return tokens;
+	}
+	return [tokens];
+}
+
+function tokenize(object, pattern = /[\w]+/) {
+	if (typeof object === 'object') {
+		const map = {};
+		Object.entries(object).forEach(function ([key, string]) {
+			if (string.length) {
+				const { tokens } = tokenizer()
+					.input(string)
+					.tokens({ tokens: pattern })
+					.resolve();
+				map[key] = toArray(tokens);
+			} else {
+				map[key] = [];
+			}
+		});
+
+		return map;
+	}
+	return {};
+}
+
+export default tokenize;

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

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

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

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

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

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

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

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

@@ -1,2 +1,2 @@
-export { default as queryParserTokenized } from './query-parser-tokenized';
-export { default as queryParserSoft } from './query-parser-soft';
+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

@@ -1,7 +1,7 @@
-import { prepareStringIndexation } from '../../commons-tokenizer';
-
-function queryParserSoft(string) {
-	return [prepareStringIndexation(string, '-')];
-}
-
-export default queryParserSoft;
+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

@@ -1,24 +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!');
-	});
-});
+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

@@ -1,28 +1,34 @@
-import tokenizer from 'string-tokenizer';
-import {
-	filterStemmer,
-	filterLength,
-	filterDouble,
-	getRegExpFromPattern,
-} from '../../commons-tokenizer';
-import { composeFilters } from '../../commons-tokenizer/filters';
-
-const filterTokens = composeFilters(filterDouble, filterStemmer, 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;
+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

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

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

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