@steroidsjs/core 2.0.0-rc.6 → 2.0.1-beta.112

package/src/ui/nav/Tree/demo/level-tree.tsx

@@ -1,44 +0,0 @@
-import * as React from 'react';
-import Tree from '../Tree'
-
-export default () => (
-    <>
-        <Tree
-            level={3}
-            items={[
-                {
-                    id: 1,
-                    label: 'label 1',
-                    items: [
-                        {
-                            id: 2,
-                            label: 'label 2.1',
-                            items: [
-                                {
-                                    id: 3,
-                                    label: 'label 3',
-                                    items: [
-                                        {
-                                            id: 4,
-                                            label: 'label 4',
-                                            items: [
-                                                {
-                                                    id: 5,
-                                                    label: 'label 5'
-                                                }
-                                            ]
-                                        },
-                                    ],
-                                }
-                            ],
-                        },
-                        {
-                            id: 2.2,
-                            label: 'label 2.2',
-                        }
-                    ],
-                },
-            ]}
-        />
-    </>
-);

package/src/ui/nav/Tree/index.ts

@@ -1,2 +0,0 @@
-import Tree from './Tree';
-export default Tree;

package/src/ui/nav/index.ts

@@ -1,5 +0,0 @@
-import Nav from './Nav';
-import Router from './Router';
-import Link from './Link';
-import Breadcrumbs from './Breadcrumbs';
-export { Nav, Router, Link, Breadcrumbs };

package/src/utils/collection.ts

@@ -1,14 +0,0 @@
-import _isArray from 'lodash-es/isArray';
-
-// eslint-disable-next-line import/prefer-default-export
-export const indexBy = (collection, key) => {
-    if (!_isArray(collection)) {
-        return collection;
-    }
-
-    const result = {};
-    (collection || []).forEach(item => {
-        result[item[key]] = item;
-    });
-    return result;
-};

package/src/utils/data.ts

@@ -1,160 +0,0 @@
-import _uniqBy from 'lodash-es/uniqBy';
-import _isString from 'lodash-es/isString';
-import _isArray from 'lodash-es/isArray';
-import _some from 'lodash-es/some';
-import _has from 'lodash-es/has';
-import _isObject from 'lodash-es/isObject';
-import _isInteger from 'lodash-es/isInteger';
-import _isFunction from 'lodash-es/isFunction';
-import _every from 'lodash-es/every';
-
-/**
- * Normalize items for save to state. Support enum class or normal items list.
- * @param {array|object} items
- * @returns {*}
- */
-export const normalizeItems = (items) => {
-    // Array
-    if (_isArray(items)) {
-        // List of strings/numbers
-        if (_some(items, item => _isString(item) || _isInteger(item))) {
-            return items.map(item => {
-                if (_isString(item) || _isInteger(item)) {
-                    return {
-                        id: item,
-                        label: item,
-                    };
-                }
-                return item;
-            });
-        }
-        // Labels as ids
-        if (_some(items, item => !_has(item, 'id'))) {
-            return _uniqBy(
-                items.map(item => ({
-                    id: item.label,
-                    ...item,
-                })),
-                'label',
-            );
-        }
-        return items;
-    }
-    // Enum
-    if (_isObject(items) && _isFunction(items.getLabels)) {
-        const labels = items.getLabels();
-        return Object.keys(labels).map(id => ({
-            id,
-            label: labels[id],
-        }));
-    }
-    return [];
-};
-
-export const checkCondition = (item, condition) => {
-    if (_isObject(condition) && !_isArray(condition)) {
-        return _every(Object.keys(condition), key => {
-            const value = condition[key];
-            const operator = _isString(value) ? 'like' : '=';
-            return checkCondition(item, [operator, key, value]);
-        });
-    }
-    if (_isArray(condition) && condition.length > 1) {
-        const operator = condition[0].toLowerCase();
-
-        // ['not', {role: 'admin'}]
-        if (operator.indexOf('not') === 0) {
-            const newOperator = operator.replace(/^not\s+/, '');
-            return !checkCondition(item, [newOperator].concat(condition.slice(1)));
-        }
-
-        const key = condition[1];
-        const value = condition[2];
-        switch (operator) {
-            case '=': // ['=', 'age', 18]
-                return item[key] === value;
-
-            case '>': // ['>', 'age', 18]
-                return item[key] > value;
-
-            case '>=': // ['>=', 'age', 18]
-            case '=>':
-                return item[key] >= value;
-
-            case '<': // ['<', 'age', 18]
-                return item[key] < value;
-
-            case '<=': // ['<=', 'age', 18]
-            case '=<':
-                return item[key] <= value;
-
-            case 'and': // ['and', {isActive: true}, ['=', 'name', 'Ivan']]
-            case '&&':
-                return _every(condition.slice(1), subCondition => checkCondition(item, subCondition));
-
-            case 'or': // ['or', {isAdmin: true}, ['=', 'name', 'Ivan']]
-            case '||':
-                return _some(condition.slice(1), subCondition => checkCondition(item, subCondition));
-
-            case 'like': // ['like', 'name', 'alex']
-                return _isString(item[key]) && item[key].toLowerCase().indexOf(value.toLowerCase()) !== -1;
-
-            case 'between': // ['between', 'size', 5, 10]
-                return condition[2] <= value && value <= condition[3];
-
-            case 'in': // ['in', 'ids', [5, 6, 10]]
-                return _isArray(item[key]) && item[key].includes(value);
-
-            default:
-                throw Error('Wrong operator: ' + operator);
-        }
-    }
-    if (_isFunction(condition)) {
-        return !!condition(item);
-    }
-
-    return true;
-};
-
-export const filterItems = (items: Array<any>, condition: any) => items.filter(item => checkCondition(item, condition));
-
-const shouldUpdateSingle = (a, b) => {
-    if (_isFunction(a) && _isFunction(b)) {
-        return false;
-    }
-    return a !== b;
-};
-
-export const shouldUpdate = (objA, objB, deepPaths = null) => {
-    if (_isObject(objA) && _isObject(objB)) {
-        const keysA = Object.keys(objA);
-        const keysB = Object.keys(objB);
-        if (keysA.length !== keysB.length) {
-            return true;
-        }
-
-        // Convert deep paths to array of arrays
-        if (deepPaths) {
-            deepPaths = deepPaths.map(p => _isString(p) ? p.split('.') : p);
-        }
-
-        for (let i = 0; i < keysA.length; i += 1) {
-            const key = keysA[i];
-            let deepPath = null;
-            if (deepPaths) {
-                deepPath = deepPaths.find(p => p[0] === key) || null;
-            }
-
-            const hasChanges = deepPath
-                ? shouldUpdate(objA[key], objB[key], deepPath)
-                : shouldUpdateSingle(objA[key], objB[key]);
-            if (hasChanges) {
-                console.log(0, 'shouldUpdate changed key:', key, objA[key], objB[key]);
-                return true;
-            }
-        }
-        return false;
-    }
-
-    return shouldUpdateSingle(objA, objB);
-};

package/src/utils/form.ts

@@ -1,205 +0,0 @@
-import _isPlainObject from 'lodash-es/isPlainObject';
-import _isArray from 'lodash-es/isArray';
-import _isEqual from 'lodash-es/isEqual';
-import _get from 'lodash-es/get';
-import {useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState} from 'react';
-import {useEffectOnce, useLifecycles, useUpdate} from 'react-use';
-import useDispatch from '../hooks/useDispatch';
-import {useSelector} from '../hooks';
-import {FormContext} from '../ui/form/Form/Form';
-import {formChange, formInitialize, formSetErrors} from '../actions/form';
-import {reducerItem} from '../reducers/form';
-
-export const setInWithPath = (state: any, value: any, path: string[], pathIndex = 0) => {
-    if (pathIndex >= path.length) {
-        return value;
-    }
-
-    const first = path[pathIndex];
-    const firstState = state && (Array.isArray(state) ? state[Number(first)] : state[first]);
-    const next = setInWithPath(firstState, value, path, pathIndex + 1);
-
-    if (!state) {
-        if (Number.isNaN(first)) {
-            return { [first]: next };
-        }
-        const initialized = [];
-        initialized[parseInt(first, 10)] = next;
-        return initialized;
-    }
-
-    if (Array.isArray(state)) {
-        const copy = [].concat(state);
-        copy[parseInt(first, 10)] = next;
-        return copy;
-    }
-
-    return {
-        ...state,
-        [first]: next,
-    };
-};
-
-export const normalizeLayout = layout => (typeof layout === 'object' ? layout : {layout});
-
-export const mergeLayoutProp = (layout1, layout2) => {
-    layout1 = layout1 ? normalizeLayout(layout1) : null;
-    layout2 = layout2 ? normalizeLayout(layout2) : null;
-    return layout1 || layout2 ? {...layout1, ...layout2} : null;
-};
-
-export const cleanEmptyObject = object => {
-    // if all properties are null substitute the object with null
-    if (!Object.values(object).some(x => x)) {
-        return null;
-    }
-
-    Object.keys(object).forEach(key => {
-        if (_isPlainObject(object[key])) {
-            object[key] = cleanEmptyObject(object[key]);
-        }
-
-        if (_isArray(object[key])) {
-            const array = object[key];
-
-            array.forEach((value, index) => {
-                if (_isPlainObject(value)) {
-                    array[index] = cleanEmptyObject(value);
-                }
-            });
-
-            if (!object[key].some(x => Boolean(x))) {
-                object[key] = [];
-            }
-        }
-    });
-
-    return object;
-};
-
-// Form state providers
-export const providers = {
-    // Redux
-    redux: {
-        useForm: (formId, initialValues) => {
-            const dispatch = useDispatch(); // eslint-disable-line react-hooks/rules-of-hooks
-            useEffectOnce(() => { // eslint-disable-line react-hooks/rules-of-hooks
-                dispatch(formInitialize(formId, initialValues));
-            });
-            return {
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                ...useSelector(state => _get(state, ['form', formId])),
-                setErrors: useCallback(
-                    errors => dispatch(formSetErrors(formId, errors)),
-                    [dispatch, formId],
-                ),
-                reducer: null,
-                setState: null,
-                dispatch,
-            };
-        },
-        useField: (formId, name, isList) => {
-            const dispatch = useDispatch(); // eslint-disable-line react-hooks/rules-of-hooks
-            return {
-                ...useSelector(state => {
-                    const error = _get(state, ['form', formId, 'errors'].concat(name.split('.')));
-                    const value = _get(state, ['form', formId, 'values'].concat(name.split('.')));
-                    return {
-                        error,
-                        value: isList ? value?.length || 0 : value,
-                    };
-                }),
-                setValue: useCallback(
-                    value => dispatch(formChange(formId, name, value)),
-                    [dispatch, formId, name],
-                ),
-            };
-        },
-        useDispatch: () => useDispatch(),
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        select: (formId, selector) => useSelector(state => selector(_get(state, ['form', formId]))),
-    },
-
-    // React reducer
-    reducer: {
-        useForm: (formId, initialValues) => {
-            const initialState = reducerItem({}, formInitialize(formId, initialValues));
-            const [state, dispatch] = useReducer(reducerItem, initialState);
-
-            const subscribersRef = useRef([]);
-            useEffect(() => {
-                subscribersRef.current.forEach(callback => callback(state));
-            }, [state]);
-            const reducer = useMemo(() => ({
-                dispatch,
-                select: selector => {
-                    // eslint-disable-next-line react-hooks/rules-of-hooks
-                    const forceUpdate = useUpdate();
-
-                    // eslint-disable-next-line react-hooks/rules-of-hooks
-                    const valueRef = useRef(selector.call(null, state));
-
-                    // eslint-disable-next-line react-hooks/rules-of-hooks
-                    const callback = useCallback((newSstate) => {
-                        const newValue2 = selector.call(null, newSstate);
-                        if (!_isEqual(valueRef.current, newValue2)) {
-                            valueRef.current = newValue2;
-                            forceUpdate();
-                        }
-                    }, []); // eslint-disable-line react-hooks/exhaustive-deps
-                    // eslint-disable-next-line react-hooks/rules-of-hooks
-                    useLifecycles(
-                        () => subscribersRef.current.push(callback),
-                        () => {
-                            const index = subscribersRef.current.indexOf(callback);
-                            if (index !== -1) {
-                                subscribersRef.current.splice(index, 1);
-                            }
-                        },
-                    );
-
-                    return valueRef.current;
-                },
-            }), []); // eslint-disable-line react-hooks/exhaustive-deps
-
-            return {
-                ...state,
-                setErrors: useCallback(
-                    errors => dispatch(formSetErrors(formId, errors)),
-                    [dispatch, formId],
-                ),
-                reducer,
-                setState: null,
-                dispatch,
-            };
-        },
-        useField: (formId, name, isList) => {
-            const {reducer} = useContext(FormContext); // eslint-disable-line react-hooks/rules-of-hooks
-            const value = reducer.select(state => _get(state, 'values.' + name));
-
-            return {
-                error: reducer.select(state => _get(state, 'errors.' + name)),
-                value: isList ? value?.length || 0 : value,
-                setValue: useCallback(
-                    newValue => reducer.dispatch(formChange(formId, name, newValue)),
-                    [reducer, formId, name],
-                ),
-            };
-        },
-        useDispatch: () => useContext(FormContext).reducer.dispatch,
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        select: (formId, selector) => useContext(FormContext).reducer.select(selector),
-    },
-
-    // Local component state
-    state: {
-        useField: (initialValue) => {
-            const [value, setValue] = useState(initialValue); // eslint-disable-line react-hooks/rules-of-hooks
-            return {
-                error: null,
-                value,
-                setValue,
-            };
-        },
-    },
-};

package/src/utils/query.ts

@@ -1,50 +0,0 @@
-import queryString from 'query-string';
-import _get from 'lodash-es/get';
-import _isObject from 'lodash-es/isObject';
-import _isString from 'lodash-es/isString';
-import _toInteger from 'lodash-es/toInteger';
-import _groupBy from 'lodash-es/groupBy';
-import _cloneDeep from 'lodash-es/cloneDeep';
-import {replace} from 'connected-react-router';
-import {Model} from '../components/MetaComponent';
-
-export const queryConfig = (config, defaultConfig = null) => {
-    config = _isObject(config) ? config : {};
-    defaultConfig = defaultConfig ? queryConfig(defaultConfig) : {};
-
-    config = _cloneDeep({
-        useHash: false,
-        attributes: [],
-        ...config,
-    });
-
-    const defaults = _groupBy(defaultConfig.attributes, 'attribute');
-    Object.keys(defaults).forEach(attribute => {
-        if (!config.attributes.find(item => item === attribute || item.attribute === attribute)) {
-            config.attributes.push(attribute);
-        }
-    });
-
-    // Normalize attributes
-    config.attributes = config.attributes
-        .map(item => {
-            if (_isString(item)) {
-                item = {attribute: item};
-            }
-
-            item = {
-                type: 'string', // string, string[], number, number[], boolean, boolean[]
-                attribute: null,
-                defaultValue: null,
-                toFormConverter: null,
-                toQueryConverter: null,
-                ..._get(defaults, [item.attribute, 0]),
-                ...item,
-            };
-
-            return item;
-        })
-        .filter(item => !!item.attribute);
-
-    return config;
-};

package/src/utils/text.ts

@@ -1,84 +0,0 @@
-import _orderBy from 'lodash-es/orderBy';
-
-const stringToWords = str => {
-    let words = [];
-    String(str).split(' ').forEach(strItem => {
-        words = words.concat(strItem.match(/^[^\p{Lu}]+/u));
-        words = words.concat(strItem.match(/[\p{Lu}][^\p{Lu}]*/gu));
-        words.push(' ');
-    });
-    words.pop();
-    return words.filter(Boolean);
-};
-
-// eslint-disable-next-line import/prefer-default-export
-export const smartSearch = (query, sourceItems) => {
-    if (!query) {
-        return sourceItems;
-    }
-    const queryCharacters = query.split('');
-    // Match
-    let items = sourceItems.filter(item => {
-        const id = item.id;
-        const words = stringToWords(item.label || '');
-        if (words.length === 0 || !id) {
-            return false;
-        }
-        let word = null;
-        let highlighted = [['', false]];
-        let index = 0;
-        let wordIndex = 0;
-        let wordChar = null;
-        let wordCharIndex = 0;
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            const char = queryCharacters[index];
-            if (!char) {
-                highlighted.push([
-                    word.substr(wordCharIndex) + words.slice(wordIndex + 1).join(''),
-                    false,
-                ]);
-                break;
-            }
-            word = words[wordIndex];
-            wordChar = (word && word.split('')[wordCharIndex]) || '';
-            if (!word) {
-                highlighted = [];
-                break;
-            }
-            const isMatch = !char.match(/[\p{Lu}]/u)
-                ? wordChar.toLowerCase() === char.toLowerCase()
-                : wordChar === char;
-            if (isMatch) {
-                index += 1;
-                wordCharIndex += 1;
-                highlighted[highlighted.length - 1][0] += wordChar;
-                highlighted[highlighted.length - 1][1] = true;
-            } else {
-                highlighted.push([word.substr(wordCharIndex), false]);
-                highlighted.push(['', false]);
-                wordIndex += 1;
-                wordCharIndex = 0;
-            }
-        }
-        highlighted = highlighted.filter(highlightedItem => !!highlightedItem[0]);
-        if (highlighted.findIndex(highlightedItem => highlightedItem[1]) !== -1) {
-            item.labelHighlighted = highlighted;
-            return true;
-        }
-        return false;
-    });
-    items = _orderBy(
-        items,
-        item => {
-            // Fined first word is priority
-            if (item.labelHighlighted) {
-                return item.labelHighlighted.findIndex(i => i[1]);
-            }
-            return Infinity;
-        },
-        'asc',
-    );
-
-    return items;
-};