@inseefr/lunatic 0.2.0-v2 → 0.2.1-prisme

package/src/stories/switch/SwitchMaterialUI.js

@@ -1,35 +0,0 @@
-import React, { useCallback } from 'react';
-import Switch from '@mui/material/Switch';
-import Stack from '@mui/material/Stack';
-import Typography from '@mui/material/Typography';
-
-function SwitchMaterialUI({
-	checked,
-	disabled,
-	handleChange,
-	statusLabel,
-	labelId,
-}) {
-	const onClick = useCallback(
-		function () {
-			handleChange(!checked);
-		},
-		[checked, handleChange]
-	);
-
-	const { true: trueStatus, false: falseStatue } = statusLabel;
-	return (
-		<Stack direction="row" spacing={1} alignItems="center">
-			<Typography>{falseStatue}</Typography>
-			<Switch
-				checked={checked}
-				onClick={onClick}
-				disabled={disabled}
-				inputProps={{ 'aria-labelledby': labelId, 'aria-checked': checked }}
-			/>
-			<Typography>{trueStatus}</Typography>
-		</Stack>
-	);
-}
-
-export default SwitchMaterialUI;

package/src/stories/switch/switch.js

@@ -1,72 +0,0 @@
-import React, { useState } from 'react';
-import { storiesOf } from '@storybook/react';
-import { withReadme } from 'storybook-readme';
-import Orchestrator from '../utils/orchestrator';
-import readme from './README.md';
-import { titleDecorator } from '../utils';
-import data from './data';
-import dataForced from './data-forced';
-import { boolean, select, object } from '@storybook/addon-knobs/react';
-import { positioningOptions, featuresOptions } from '../utils/options';
-import { SwitchMui } from '../custom-mui';
-
-const stories = storiesOf('switch', module)
-	.addDecorator(withReadme(readme))
-	.addDecorator((Component) => {
-		const WrappedComponent = titleDecorator(Component);
-		return <WrappedComponent title="<CheckboxBoolean />" />;
-	});
-
-stories.addWithJSX('Default', () => <Orchestrator source={data} />);
-
-stories.addWithJSX('Props', () => (
-	<Orchestrator
-		source={data}
-		positioning={select('Items positioning', positioningOptions, 'DEFAULT')}
-		features={select('Features', featuresOptions, ['VTL', 'MD'])}
-		missing={boolean('Missing', false)}
-		bindings={object('Bindings', { test: 'test' })}
-		disabled={boolean('Disabled', false)}
-		focused={boolean('Focused', false)}
-		management={boolean('Management', false)}
-	/>
-));
-
-stories.addWithJSX('External update', () => {
-	const Fake = () => {
-		const [up, setUp] = useState(false);
-		return (
-			<>
-				<button
-					type="button"
-					onClick={() => {
-						setUp(true);
-					}}
-					disabled={up}
-				>
-					Force external update
-				</button>
-
-				<Orchestrator id="default" source={up ? dataForced : data} />
-			</>
-		);
-	};
-	return <Fake />;
-});
-
-stories.addWithJSX('Custom Switch', function () {
-	const custom = { Switch: SwitchMui };
-	return (
-		<Orchestrator
-			source={data}
-			positioning={select('Items positioning', positioningOptions, 'DEFAULT')}
-			features={select('Features', featuresOptions, ['VTL', 'MD'])}
-			missing={boolean('Missing', false)}
-			bindings={object('Bindings', { test: 'test' })}
-			disabled={boolean('Disabled', false)}
-			focused={boolean('Focused', false)}
-			management={boolean('Management', false)}
-			custom={custom}
-		/>
-	);
-});

package/src/stories/utils/default-arg-types.js

@@ -1,29 +0,0 @@
-const fields = [
-	'source',
-	'id',
-	'pagination',
-	'data',
-	'management',
-	'modalForControls',
-	'features',
-	'initialPage',
-	'getStoreInfo',
-	'missing',
-	'shortcut',
-	'activeGoNextForMissing',
-	'filterDescription',
-];
-
-const defaultArgTypes = fields.reduce(
-	(acc, f) => ({
-		...acc,
-		[f]: {
-			table: {
-				disable: true,
-			},
-		},
-	}),
-	{}
-);
-
-export default defaultArgTypes;

package/src/stories/utils/waiting/index.js

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

package/src/stories/utils/waiting/waiting.js

@@ -1,21 +0,0 @@
-import React from 'react';
-import './waiting.scss';
-import preloader from './preloader.svg';
-
-function Waiting({ status, children }) {
-	if (status) {
-		return (
-			<div className="waiting">
-				<img src={preloader} alt="loading" />
-				<div className="content">{children}</div>
-			</div>
-		);
-	}
-	return null;
-}
-
-Waiting.defaultProps = {
-	status: false,
-};
-
-export default React.memo(Waiting);

package/src/tests/sample.spec.js

@@ -1,5 +0,0 @@
-describe('sample', () => {
-	it('add fake test to avoid test script bug', () => {
-		expect(true).toBeTruthy();
-	});
-});

package/src/use-lunatic/actions.js

@@ -1,32 +0,0 @@
-export const GO_NEXT_PAGE = 'use-lunatic/go-next';
-export const goNextPage = ({ block }) => ({
-	type: GO_NEXT_PAGE,
-	payload: { block },
-});
-
-export const GO_PREVIOUS_PAGE = 'use-lunatic/go-previous';
-export const goPreviousPage = () => ({ type: GO_PREVIOUS_PAGE });
-
-export const ON_INIT = 'use-lunatic/on-init';
-export const onInit = ({
-	data,
-	source,
-	initialPage,
-	features,
-	handleChange,
-}) => ({
-	type: ON_INIT,
-	payload: { data, source, initialPage, features, handleChange },
-});
-
-export const HANDLE_CHANGE = 'use-lunatic/handle-change';
-export const handleChange = (response, value, args) => ({
-	type: HANDLE_CHANGE,
-	payload: { response, value, args },
-});
-
-export const ON_SET_WAITING = 'use-lunatic/on-set-waiting';
-export const onSetWaiting = (status) => ({
-	type: ON_SET_WAITING,
-	payload: { status },
-});

package/src/use-lunatic/commons/check-loops.js

@@ -1,61 +0,0 @@
-import isPaginatedLoop from './is-paginated-loop';
-
-function extractSubPages(component, previous = []) {
-	const { components } = component;
-	return components.reduce(function (pages, component) {
-		const { page } = component;
-
-		if (page && pages.indexOf(page) === -1) {
-			return [...pages, page];
-		}
-		return pages;
-	}, previous);
-}
-
-function extractLoop(components) {
-	return components.reduce(
-		function ({ isLoop, subPages, iterations, loopDependencies }, component) {
-			const currentIsLoop = isPaginatedLoop(component);
-			if (currentIsLoop) {
-				return {
-					isLoop: true,
-					subPages: extractSubPages(component, subPages),
-					iterations: iterations || component.iterations,
-					loopDependencies: loopDependencies || component.loopDependencies,
-				};
-			}
-			return { isLoop, subPages, iterations };
-		},
-		{
-			isLoop: false,
-			subPages: undefined,
-			iterations: undefined,
-			loopDependencies: undefined,
-		}
-	);
-}
-
-function checkLoops(pages) {
-	return Object.entries(pages).reduce(function (map, current) {
-		const [number, content] = current;
-		if (number !== 'unpaged') {
-			const { components } = content;
-			const { isLoop, subPages, iterations, loopDependencies } =
-				extractLoop(components);
-
-			return {
-				...map,
-				[number]: {
-					...content,
-					isLoop,
-					subPages,
-					iterations,
-					loopDependencies,
-				},
-			};
-		}
-		return map;
-	}, {});
-}
-
-export default checkLoops;

package/src/use-lunatic/commons/create-map-pages.js

@@ -1,69 +0,0 @@
-import isPaginatedLoop from './is-paginated-loop';
-
-function isUnpaginated(questionnaire) {
-	const { maxPage } = questionnaire;
-	return maxPage === undefined;
-}
-
-/**
- *
- * @param {*} component: object
- * @param {*} page: string
- * @param {*} map Map<page,{ components: Array<component>, isLoop: boolean, subPages: Array<page> }>
- * @returns
- */
-function mergeComponent(component, page, map) {
-	if (!page) {
-		return { ...map, unpaged: [...map.unpaged, component] };
-	}
-	if (page in map) {
-		const current = map[page];
-		const { components } = current;
-		return {
-			...map,
-			[page]: { ...current, components: [...components, component] },
-		};
-	}
-	return { ...map, [page]: { components: [component] } };
-}
-
-function mergeNestedComponents(components, map) {
-	return components.reduce(function (current, component) {
-		const { page } = component;
-		if (page) {
-			return mergeComponent(component, page, current);
-		}
-
-		return current;
-	}, map);
-}
-/**
- *
- * @param {*} components
- * @returns
- */
-function createPages(questionnaire) {
-	const { components } = questionnaire;
-	if (isUnpaginated(questionnaire)) {
-		return { 1: { components } }; // no page -> one page ;)
-	}
-	const map = components.reduce(
-		function (current, component) {
-			const { components, page } = component;
-			if (isPaginatedLoop(component)) {
-				return mergeComponent(
-					component,
-					page,
-					mergeNestedComponents(components, current)
-				);
-			}
-
-			return mergeComponent(component, page, current);
-		},
-		{ unpaged: [] }
-	);
-
-	return map;
-}
-
-export default createPages;

package/src/use-lunatic/commons/execute-condition-filter.js

@@ -1,16 +0,0 @@
-import getCompatibleVTLExpression from './get-compatible-vtl-expression';
-
-function executeConditionFilter(filter, execute, iteration) {
-	if (filter && typeof execute === 'function') {
-		const { value } = filter;
-
-		function logging(...args) {
-			console.warn(args);
-			console.warn('executeConditionFilter:', filter);
-		}
-		return execute(getCompatibleVTLExpression(value), { iteration, logging });
-	}
-	return undefined;
-}
-
-export default executeConditionFilter;

package/src/use-lunatic/commons/execute-expression/create-execute-expression.js

@@ -1,194 +0,0 @@
-import executeExpression from './execute-expression';
-import getSafetyExpression from './get-safety-expression';
-import getExpressionVariables from './get-expressions-variables';
-import createMemoizer from './create-memoizer';
-import createRefreshCalculated from './create-refresh-calculated';
-import { VTL, VTL_MD } from 'utils/constants';
-
-function validateExpression(expObject) {
-	if (typeof expObject === 'object') {
-		const { type } = expObject;
-		if (type === VTL || type === VTL_MD) {
-			return expObject;
-		}
-	}
-	throw new Error(`Non-VTL compatible expression : ${expObject}`);
-}
-
-function getVtlCompatibleValue(value) {
-	if (value === undefined) {
-		return null;
-	}
-	if (Array.isArray(value)) {
-		return {
-			dataStructure: { result: {} },
-			dataPoints: {
-				result: value,
-			},
-		};
-	}
-
-	return value;
-}
-
-function createBindings(variables) {
-	return Object.entries(variables).reduce(function (
-		bindings,
-		[name, { value }]
-	) {
-		return { ...bindings, [name]: value };
-	},
-	{});
-}
-
-/**
- *
- * @param {*} variables
- * @returns
- */
-function createExecuteExpression(variables, features) {
-	// on aimerait map d'expression, avec les bindings
-	const bindings = createBindings(variables);
-	const tokensMap = new Map();
-	const collectedUpdated = new Map();
-	const [memoize, getMemoizedValue] = createMemoizer();
-	const [refreshCalculated, setToRefreshCalculated] = createRefreshCalculated({
-		variables,
-		execute,
-		bindings,
-	});
-
-	/**
-	 *
-	 * @param {*} name
-	 */
-	function pushToLazy(name) {
-		const { CalculatedLinked = [] } = variables[name];
-
-		CalculatedLinked.forEach(function (variable) {
-			const { name } = variable;
-			setToRefreshCalculated(name, variable);
-		});
-	}
-
-	/**
-	 *
-	 * @param {*} name
-	 * @param {*} value
-	 */
-	function updateBindings(name, value) {
-		// update des bindings
-		if (name in bindings) {
-			bindings[name] = value;
-			collectedUpdated.set(name, []);
-		}
-		pushToLazy(name);
-	}
-
-	function getVariablesAndCach(expression) {
-		if (tokensMap.has(expression)) {
-			return tokensMap.get(expression);
-		}
-		const tokens = getExpressionVariables(expression, variables);
-		tokensMap.set(expression, tokens);
-		return tokens;
-	}
-
-	/**/
-	function collecteVariables(dependencies) {
-		if (Array.isArray(dependencies)) {
-			return dependencies.reduce(function (map, name) {
-				if (name in variables) {
-					const data = variables[name];
-					const { variable, type } = data;
-					if (!(name in map)) {
-						if (type === 'CALCULATED') {
-							const { expression } = variable;
-							const subDependencies = getVariablesAndCach(expression);
-
-							return {
-								...map,
-								[name]: { ...variable },
-								...collecteVariables(subDependencies),
-							};
-						}
-
-						return { ...map, [name]: { ...variable } };
-					}
-				} else {
-					throw new Error(`Unknown variable ${name}`);
-				}
-				return map;
-			}, {});
-		}
-		return {};
-	}
-
-	function resolveUseContext(name, { iteration }) {
-		const value = bindings[name];
-		if (iteration !== undefined && Array.isArray(value)) {
-			pushToLazy(name);
-			if (iteration < value.length) {
-				return value[iteration];
-			}
-			return null;
-		}
-		return getVtlCompatibleValue(value);
-	}
-
-	function fillVariablesValues(map, { iteration }) {
-		return Object.entries(map).reduce(function (sub, [name, _]) {
-			return {
-				...sub,
-				[name]: resolveUseContext(name, { iteration }),
-			};
-		}, {});
-	}
-
-	/**
-	 *
-	 * @param {*} vtlObject
-	 * @param {*} args
-	 * @returns
-	 */
-	function execute(expObject, args = {}) {
-		const { value: expression, type } = validateExpression(
-			getSafetyExpression(expObject)
-		);
-		const { iteration, logging } = args;
-		const bindingDependencies = getVariablesAndCach(expression);
-
-		function loggingDefault(_, bindings, e) {
-			if (process.env.NODE_ENV === 'development') {
-				console.warn(`VTL error :  ${expression}`, { ...args }, { bindings });
-				console.warn(e);
-			}
-		}
-
-		const vtlBindings = refreshCalculated(
-			fillVariablesValues(collecteVariables(bindingDependencies), {
-				iteration,
-			}),
-			{ rootExpression: expression, iteration }
-		);
-
-		const memoized = getMemoizedValue(expression, vtlBindings);
-		if (memoized === undefined) {
-			const result = executeExpression(
-				vtlBindings,
-				expression,
-				type,
-				features,
-				logging || loggingDefault
-			);
-			memoize(expression, vtlBindings, result);
-
-			return result;
-		}
-		return memoized;
-	}
-
-	return [execute, updateBindings];
-}
-
-export default createExecuteExpression;

package/src/use-lunatic/commons/execute-expression/create-memoizer.js

@@ -1,42 +0,0 @@
-import objectHash from 'object-hash';
-
-function createMemoizer() {
-	const expresionsMap = new Map();
-
-	function refillBindings(bindings) {
-		return Object.entries(bindings).reduce(function (map, [key, value]) {
-			const dataPointsValue = value?.result;
-			if (dataPointsValue) {
-				return { ...map, [key]: dataPointsValue };
-			}
-			return { ...map, [key]: value };
-		}, {});
-	}
-
-	function memoize(expression, bindings, value) {
-		const refill = refillBindings(bindings);
-		const hash = objectHash(refill);
-		let map = expresionsMap.get(expression);
-
-		if (!map) {
-			map = new Map();
-			expresionsMap.set(expression, map);
-		}
-		map.set(hash, value);
-	}
-
-	function getMemoizedValue(expression, bindings) {
-		let map = expresionsMap.get(expression);
-
-		if (map) {
-			const refill = refillBindings(bindings);
-			const hash = objectHash(refill);
-			return map.get(hash);
-		}
-		return undefined;
-	}
-
-	return [memoize, getMemoizedValue];
-}
-
-export default createMemoizer;

package/src/use-lunatic/commons/execute-expression/create-refresh-calculated.js

@@ -1,50 +0,0 @@
-function createRefreshCalculated({ variables, execute, bindings }) {
-	const toRefreshVariables = new Map(); // variables calculées dépendantes d'une variable modifiée.
-
-	// à l'init, on y colle toutes les variables de calcul
-	Object.values(variables).forEach(function ({ variable }) {
-		const { variableType, name } = variable;
-		if (variableType === 'CALCULATED') {
-			toRefreshVariables.set(name, variable);
-		}
-	});
-
-	function refreshCalculated(map, { rootExpression, iteration }) {
-		return Object.entries(map).reduce(function (sub, [name, current]) {
-			const { variable, type } = variables[name];
-
-			if (type === 'CALCULATED' && toRefreshVariables.has(name)) {
-				const { expression, shapeFrom } = variable;
-
-				function logging(expression, bindings, e) {
-					if (process.env.NODE_ENV === 'development') {
-						console.warn(
-							`VTL error when refreshing calculated variable ${name} :  ${expression}`,
-							{ bindings }
-						);
-						console.warn(`root expression : ${rootExpression}`);
-						console.warn(e);
-					}
-				}
-
-				const value = execute(expression, {
-					logging,
-					iteration: shapeFrom ? iteration : undefined,
-				});
-				bindings[name] = value;
-				toRefreshVariables.delete(name);
-
-				return { ...sub, [name]: value };
-			}
-			return { ...sub, [name]: current };
-		}, {});
-	}
-
-	function setToRefreshCalculated(name, variable) {
-		toRefreshVariables.set(name, variable);
-	}
-
-	return [refreshCalculated, setToRefreshCalculated];
-}
-
-export default createRefreshCalculated;

package/src/use-lunatic/commons/execute-expression/execute-expression.js

@@ -1,69 +0,0 @@
-import React from 'react';
-import { interpret } from '@inseefr/trevas';
-import MdLabel from 'components/commons/components/md-label';
-import { VTL, MD } from 'utils/constants';
-
-function isDataSet(result) {
-	return result && typeof result === 'object' && result.dataPoints;
-}
-
-function extractDataSetResult(dataSet) {
-	const { dataPoints } = dataSet;
-	if (dataPoints) {
-		const { result } = dataPoints;
-		return result;
-	}
-	return undefined;
-}
-
-function executeVtlExpression(expression, vtlBindings) {
-	const result = interpret(expression, vtlBindings);
-	if (isDataSet(result)) {
-		return extractDataSetResult(result);
-	}
-	if (result === null) {
-		return null;
-	}
-	if (typeof result === 'object') {
-		return expression;
-	}
-
-	return result;
-}
-
-function executeVTL(expression, vtlBindings, logging) {
-	if (expression) {
-		try {
-			return executeVtlExpression(expression, vtlBindings);
-		} catch (e) {
-			logging(expression, vtlBindings, e);
-			return expression;
-		}
-	}
-	return '';
-}
-
-function loggingDefault(expression, bindings, e) {
-	if (process.env.NODE_ENV === 'development') {
-		console.warn(`VTL error :  ${expression}`, bindings);
-		console.warn(e);
-	}
-}
-
-function executeExpression(
-	vtlBindings,
-	expression,
-	type,
-	features /* VTL, MD */,
-	logging = loggingDefault
-) {
-	if (features.includes(VTL) && type.includes(VTL)) {
-		const vtl = executeVTL(expression, vtlBindings, logging);
-		if (features.includes(MD) && type.includes(MD))
-			return <MdLabel expression={vtl} />;
-		return vtl;
-	}
-	return expression;
-}
-
-export default executeExpression;