@inseefr/lunatic 0.2.63 → 0.3.0-prisme

package/src/components/suggester/state-management/reducer/reduce-on-key-down.js

@@ -0,0 +1,73 @@
+import { BINDED_KEYS } from '../../commons-tools';
+
+function reduceArrowDown(state) {
+	const { options, selectedIndex: prec } = state;
+	if (options.length) {
+		const selectedIndex = Math.min(prec + 1 || 0, options.length - 1);
+		return { ...state, selectedIndex, expended: true, displayLabel: true };
+	}
+	return state;
+}
+
+function reduceArrowUp(state) {
+	const { selectedIndex: prec, options } = state;
+	if (options.length) {
+		const selectedIndex = Math.max(prec - 1 || 0, 0);
+		return { ...state, selectedIndex, expended: true, displayLabel: true };
+	}
+	return state;
+}
+
+function reduceHome(state) {
+	const { options } = state;
+	if (options.length) {
+		return { ...state, selectedIndex: 0, expended: true };
+	}
+	return state;
+}
+
+function reduceEnd(state) {
+	const { options } = state;
+	if (options.length) {
+		return { ...state, selectedIndex: options.length - 1, expended: true };
+	}
+	return state;
+}
+
+function reduceTab(state) {
+	return { ...state, focused: false, expended: false };
+}
+
+function reduceEnter(state) {
+	const { expended } = state;
+	return { ...state, expended: !expended };
+}
+
+function reduceEscape(state) {
+	return { ...state, expended: false };
+}
+
+function reduce(state, action) {
+	const { payload } = action;
+	const { key } = payload;
+	switch (key) {
+		case BINDED_KEYS.ArrowDown:
+			return reduceArrowDown(state);
+		case BINDED_KEYS.ArrowUp:
+			return reduceArrowUp(state);
+		case BINDED_KEYS.Home:
+			return reduceHome(state);
+		case BINDED_KEYS.End:
+			return reduceEnd(state);
+		case BINDED_KEYS.Tab:
+			return reduceTab(state);
+		case BINDED_KEYS.Enter:
+			return reduceEnter(state);
+		case BINDED_KEYS.Escape:
+			return reduceEscape(state);
+		default:
+			return state;
+	}
+}
+
+export default reduce;

package/src/components/suggester/state-management/reducer/reduce-on-unexpected-error.js

@@ -0,0 +1,7 @@
+function reduce(state, action) {
+	const { payload } = action;
+	const { error } = payload;
+	return { ...state, unexpectedError: error };
+}
+
+export default reduce;

package/src/components/suggester/state-management/reducer/reduce-on-update-options.js

@@ -0,0 +1,11 @@
+function reduce(state, action) {
+	const { payload } = action;
+	const { options, search: old } = payload;
+	const { search } = state;
+	if (search === old) {
+		return { ...state, options };
+	}
+	return { ...state, options: [] };
+}
+
+export default reduce;

package/src/components/suggester/state-management/reducer/reducer.js

@@ -0,0 +1,38 @@
+import * as actions from '../actions';
+import reduceOnChangeSearch from './reduce-on-change-search';
+import reduceOnUpdateOptions from './reduce-on-update-options';
+import reduceOnFocus from './reduce-on-focus';
+import reduceOnBlur from './reduce-on-blur';
+import reduceOnClickOption from './reduce-on-click-option';
+import reduceOnKeyDown from './reduce-on-key-down';
+import reduceOnInit from './reduce-on-init';
+import reduceOnError from './reduce-on-error';
+import reduceOnDeleteSearch from './reduce-on-delete-search';
+
+function reduce(state, action) {
+	const { type } = action;
+	switch (type) {
+		case actions.ON_CHANGE_SEARCH:
+			return reduceOnChangeSearch(state, action);
+		case actions.ON_UPDATE_OPTIONS:
+			return reduceOnUpdateOptions(state, action);
+		case actions.ON_FOCUS:
+			return reduceOnFocus(state, action);
+		case actions.ON_BLUR:
+			return reduceOnBlur(state, action);
+		case actions.ON_CLICK_OPTION:
+			return reduceOnClickOption(state, action);
+		case actions.ON_KEY_DOWN:
+			return reduceOnKeyDown(state, action);
+		case actions.ON_INIT:
+			return reduceOnInit(state, action);
+		case actions.ON_ERROR:
+			return reduceOnError(state, action);
+		case actions.ON_DELETE_SEARCH:
+			return reduceOnDeleteSearch(state, action);
+		default:
+			return state;
+	}
+}
+
+export default reduce;

package/src/components/suggester/state-management/suggester-context.js

@@ -0,0 +1,4 @@
+import React from 'react';
+const context = React.createContext([undefined, undefined]);
+
+export default context;

package/src/components/suggester/state-management/use-dispatch.js

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import SuggesterContext from './suggester-context';
+
+function useDispatch() {
+	const context = useContext(SuggesterContext);
+	const dispatch = context[1];
+
+	return dispatch;
+}
+
+export default useDispatch;

package/src/components/suggester/suggester-wrapper.js

@@ -0,0 +1,127 @@
+import React, { useReducer, useEffect } from 'react';
+import PropTypes from 'prop-types';
+import {
+	reducer,
+	INITIAL_STATE,
+	SuggesterContext,
+	actions,
+} from './state-management';
+import { Suggester } from './components';
+import DefaultLabelRenderer from './components/selection/default-label-renderer';
+import { DefaultOptionRenderer } from './components';
+import './default-style.scss';
+
+function getSearch(search, value) {
+	if (search && search.length) {
+		return search;
+	}
+	return value;
+}
+
+function SuggesterWrapper({
+	id,
+	className,
+	version,
+	labelledBy,
+	placeholderList,
+	optionRenderer,
+	onSelect,
+	searching,
+	labelRenderer,
+	disabled,
+	value,
+	focused,
+	response,
+	logFunction,
+}) {
+	const [state, dispatch] = useReducer(reducer, INITIAL_STATE);
+	const { search, selectedIndex, options, expended } = state;
+
+	useEffect(
+		function () {
+			async function doIt() {
+				try {
+					const what = getSearch(search, value);
+					if (what && typeof searching === 'function') {
+						const { results, search: old } = await searching(what);
+						dispatch(actions.onUpdateOptions(results, old));
+					} else {
+						dispatch(actions.onDeleteSearch());
+					}
+				} catch (e) {
+					console.error(e);
+					dispatch(actions.onError('Une erreur est survenue.'));
+				}
+			}
+			doIt();
+		},
+		[search, searching, value]
+	);
+
+	useEffect(
+		function () {
+			if (selectedIndex !== undefined && !expended) {
+				onSelect(options[selectedIndex], selectedIndex);
+			}
+		},
+		[selectedIndex, onSelect, options, expended]
+	);
+
+	useEffect(
+		function () {
+			dispatch(actions.onInit({ id, disabled, value }));
+		},
+		[id, disabled, value]
+	);
+
+	return (
+		<SuggesterContext.Provider value={[state, dispatch]}>
+			<Suggester
+				className={className}
+				placeholderList={placeholderList}
+				version={version}
+				labelledBy={labelledBy}
+				optionRenderer={optionRenderer}
+				labelRenderer={labelRenderer}
+				onSelect={onSelect}
+				value={value}
+				focused={focused}
+				response={response}
+				logFunction={logFunction}
+			/>
+		</SuggesterContext.Provider>
+	);
+}
+
+SuggesterWrapper.propTypes = {
+	id: PropTypes.string,
+	className: PropTypes.string,
+	placeholderList: PropTypes.string,
+	labelledBy: PropTypes.string,
+	optionRenderer: PropTypes.func,
+	labelRenderer: PropTypes.func,
+	onSelect: PropTypes.func,
+	storeInfo: PropTypes.object,
+	value: PropTypes.oneOfType([
+		PropTypes.string,
+		PropTypes.number,
+		PropTypes.bool,
+		PropTypes.object,
+	]),
+	searching: PropTypes.func,
+};
+
+SuggesterWrapper.defaultProps = {
+	id: undefined,
+	className: 'lunatic-suggester-default-style',
+	labelledBy: undefined,
+	placeholderList: 'Veuillez...',
+	optionRenderer: DefaultOptionRenderer,
+	labelRenderer: DefaultLabelRenderer,
+	language: 'French',
+	onSelect: () => null,
+	value: undefined,
+	searching: undefined,
+};
+
+export default SuggesterWrapper;

package/src/components/suggester-loader-widget/index.js

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

package/src/components/suggester-loader-widget/loader-row.js

@@ -0,0 +1,102 @@
+import React, { useEffect, useState, useCallback } from 'react';
+import classnames from 'classnames';
+import {
+	useStoreIndex,
+	getStoreCount,
+	clearStoreData,
+} from '../../utils/store-tools';
+import CrossIcon from '../../utils/icons/cross.icon';
+import LoadIcon from '../../utils/icons/load.icon';
+import Loader from './loader';
+
+function LoaderRow({
+	storeInfo,
+	idbVersion,
+	fetchStore,
+	onRefresh,
+	disabled = false,
+}) {
+	const { name } = storeInfo;
+	const db = useStoreIndex(storeInfo, idbVersion);
+	const [nbEntities, setNbEntities] = useState(undefined);
+	const [start, setStart] = useState(false);
+
+	const post = useCallback(
+		function (_, count) {
+			setNbEntities(count);
+			onRefresh(`Store ${name} loaded.`);
+		},
+		[onRefresh, name]
+	);
+	const clear = useCallback(
+		function () {
+			if (db) {
+				clearStoreData(db);
+				setNbEntities(0);
+			}
+		},
+		[db]
+	);
+
+	useEffect(
+		function () {
+			async function count() {
+				const c = await getStoreCount(db);
+				setNbEntities(c);
+			}
+
+			if (db) {
+				count();
+			}
+		},
+		[db]
+	);
+
+	const handleClick = useCallback(function (p) {
+		if (p === 100) {
+			setStart(false);
+		}
+	}, []);
+
+	return (
+		<div className="widget-row">
+			<div className="store-name">{name}</div>
+			{start ? (
+				<Loader
+					start={true}
+					db={db}
+					store={storeInfo}
+					idVersion={idbVersion}
+					fetch={fetchStore}
+					post={post}
+					handleClick={handleClick}
+				/>
+			) : (
+				<>
+					<div className="stats">
+						{nbEntities > 0 ? `${nbEntities} entities.` : 'Empty store.'}
+					</div>
+
+					<button
+						className={classnames('widget-button', { disabled })}
+						disabled={disabled}
+						onClick={() => setStart(true)}
+						title="Load"
+					>
+						<LoadIcon className="lunatic-suggester-icon" />
+					</button>
+					<button
+						className={classnames('widget-button', { disabled })}
+						disabled={disabled}
+						onClick={clear}
+						title="Clear"
+					>
+						<CrossIcon className="lunatic-suggester-icon" />
+					</button>
+				</>
+			)}
+		</div>
+	);
+}
+
+export default LoaderRow;

package/src/components/suggester-loader-widget/loader.js

@@ -0,0 +1,67 @@
+import React, { useEffect, useState } from 'react';
+import { createAppendTask } from '../../utils/suggester-workers/append-to-index';
+import Progress from './progress';
+import { clearStoreData } from '../../utils/store-tools';
+
+function empty() {}
+
+function Loader({ start, db, store, idbVersion, fetch, post, handleClick }) {
+	const [progress, setProgress] = useState(0);
+	const [entities, setEntities] = useState(undefined);
+
+	useEffect(
+		function () {
+			async function load() {
+				if (typeof fetch === 'function' && start) {
+					const e = await fetch();
+					setEntities(e);
+				}
+			}
+			load();
+		},
+		[fetch, start]
+	);
+
+	function log({ message }) {
+		const { type, percent } = message;
+		if (type === 'bulk-insert/complete') {
+			setProgress(percent);
+		}
+	}
+
+	useEffect(
+		function () {
+			let abort;
+			async function go() {
+				try {
+					if (entities && db && idbVersion && store) {
+						const [startT, abort_] = createAppendTask(store, idbVersion, log);
+						abort = abort_;
+						clearStoreData(db);
+						await startT(entities);
+						post(store.name, entities.length);
+					}
+				} catch (e) {
+					console.warn(e);
+				}
+			}
+
+			go();
+
+			return function () {
+				if (abort) {
+					abort();
+				}
+			};
+		},
+		[store, db, entities, idbVersion, post]
+	);
+
+	return (
+		<Progress percent={progress} display={true} handleClick={handleClick} />
+	);
+}
+
+Loader.defaultProps = { idbVersion: '1', post: empty, handleClick: empty };
+
+export default Loader;

package/src/components/suggester-loader-widget/progress.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import classnames from 'classnames';
+
+function Progress({ display, percent = 0, handleClick = () => null }) {
+	if (display) {
+		return (
+			<div
+				className={classnames('lunatic-suggester-loader-progress', {
+					done: percent === 100,
+				})}
+				onClick={() => handleClick(percent)}
+			>
+				<div className="content">
+					<div
+						className="progress"
+						style={{ width: `${Math.round(percent)}%` }}
+					></div>
+				</div>
+			</div>
+		);
+	}
+	return null;
+}
+
+export default Progress;

package/src/components/suggester-loader-widget/tools/action-tool.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import classnames from 'classnames';
+
+function ActionTool({ children, ariaLabel, className, title, display = true }) {
+	if (display) {
+		return (
+			<div
+				aria-label={ariaLabel}
+				role="button"
+				className={classnames('lunatic-action-tool', className)}
+				title={title}
+			>
+				{children}
+			</div>
+		);
+	}
+	return null;
+}
+
+export default ActionTool;

package/src/components/suggester-loader-widget/tools/index.js

@@ -0,0 +1,2 @@
+export { default as ActionTool } from './action-tool';
+export { default as Tools } from './tools';

package/src/components/suggester-loader-widget/tools/tools.js

@@ -0,0 +1,7 @@
+import React from 'react';
+
+function Tools({ children }) {
+	return <div className="lunatic-widget-tools">{children}</div>;
+}
+
+export default Tools;

package/src/components/suggester-loader-widget/widget-container.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+import classnames from 'classnames';
+
+function WidgetContainer({ children, drag, absolute }, containerEl) {
+	if (absolute) {
+		return ReactDOM.createPortal(
+			<div
+				className={classnames('lunatic-suggester-widget-container', {
+					absolute,
+				})}
+				ref={containerEl}
+			>
+				<div className={classnames('lunatic-suggester-widget', { drag })}>
+					{children}
+				</div>
+			</div>,
+			document.body
+		);
+	}
+	return (
+		<div
+			className={classnames('lunatic-suggester-widget-container', {
+				absolute,
+			})}
+			ref={containerEl}
+		>
+			<div className={classnames('lunatic-suggester-widget', { drag })}>
+				{children}
+			</div>
+		</div>
+	);
+}
+
+export default React.forwardRef(WidgetContainer);

package/src/components/suggester-loader-widget/widget.js

@@ -0,0 +1,123 @@
+import React, { useEffect, useState, useCallback, useRef } from 'react';
+import PropTypes from 'prop-types';
+import classnames from 'classnames';
+import LoaderRow from './loader-row';
+import { Tools, ActionTool } from './tools';
+import { IsNetwork } from '../../utils/components/is-network';
+import WidgetContainer from './widget-container';
+import Dragger from '../../utils/components/dragger';
+import OnDragIcon from '../../utils/icons/on-drag.icon';
+import './widget.scss';
+
+function empty() {}
+
+function SuggesterLoaderWidget({ source, getStoreInfo, onRefresh, absolute }) {
+	const { suggesters } = source;
+	const containerEl = useRef();
+	const { current } = containerEl;
+	const [stores, setStores] = useState(undefined);
+	const [rows, setRows] = useState([]);
+	const [disabled, setDisabled] = useState(false);
+	const [drag, setDrag] = useState(false);
+
+	useEffect(
+		function () {
+			if (suggesters) {
+				const str = suggesters.reduce(function (current, storeInfo) {
+					const { name } = storeInfo;
+
+					return { ...current, [name]: { storeInfo, ...getStoreInfo(name) } };
+				}, {});
+
+				setStores(str);
+			}
+		},
+		[suggesters, getStoreInfo]
+	);
+
+	const notify = useCallback(function (online) {
+		setDisabled(!online);
+	}, []);
+
+	const onDrag = useCallback(
+		function (status) {
+			if (!drag && status) {
+				setDrag(true);
+			} else if (drag && !status) {
+				setDrag(false);
+			}
+		},
+		[drag]
+	);
+
+	useEffect(
+		function () {
+			if (stores) {
+				setRows(
+					Object.entries(stores).map(function ([
+						name,
+						{ storeInfo, idbVersion, fetch: fetchStore },
+					]) {
+						return (
+							<LoaderRow
+								key={name}
+								storeInfo={storeInfo}
+								idbVersion={idbVersion}
+								fetchStore={fetchStore}
+								onRefresh={onRefresh}
+								disabled={disabled}
+							/>
+						);
+					})
+				);
+			}
+		},
+		[stores, disabled, onRefresh]
+	);
+
+	useEffect(
+		function () {
+			if (current && absolute) {
+				current.style.top = '30px';
+				current.style.left = '30px';
+			}
+		},
+		[current, absolute]
+	);
+
+	return (
+		<WidgetContainer ref={containerEl} drag={drag} absolute={absolute}>
+			<Tools>
+				<ActionTool
+					className={classnames('', { drag })}
+					ariaLabel="drag"
+					display={absolute}
+					title="drag"
+				>
+					<Dragger el={current} onDrag={onDrag}>
+						<OnDragIcon className={classnames('on-drag-icon', { drag })} />
+					</Dragger>
+				</ActionTool>
+			</Tools>
+			<IsNetwork
+				className={classnames('suggester-widget-network', { drag })}
+				notify={notify}
+			/>
+			{rows}
+		</WidgetContainer>
+	);
+}
+
+SuggesterLoaderWidget.propTypes = {
+	absolute: PropTypes.bool,
+	source: PropTypes.object.isRequired,
+	getStoreInfo: PropTypes.func.isRequired,
+	onRefresh: PropTypes.func,
+};
+
+SuggesterLoaderWidget.defaultProps = {
+	onRefresh: empty,
+	absolute: false,
+};
+
+export default SuggesterLoaderWidget;