@steroidsjs/core 2.2.18 → 2.2.21

package/src/providers/SsrProvider.tsx

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import {PropsWithChildren} from 'react';
+import {StaticRouterContext} from 'react-router';
+
+export interface IPreloadedData {
+    [configId: string]: any
+}
+
+export interface ISsr {
+    history?: {
+        initialEntries: string[],
+    },
+    staticContext?: StaticRouterContext,
+    preloadedData?: IPreloadedData,
+}
+
+export const SsrProviderContext = React.createContext<ISsr>(null);
+
+export interface ISsrProviderProps extends ISsr, PropsWithChildren<any> {}
+
+export default function SsrProvider(props: ISsrProviderProps): JSX.Element {
+    return (
+        <SsrProviderContext.Provider value={{
+            history: props.history,
+            staticContext: props.staticContext,
+            preloadedData: props.preloadedData,
+        }}
+        >
+            {props.children}
+        </SsrProviderContext.Provider>
+    );
+}

package/src/providers/index.ts

@@ -0,0 +1,9 @@
+import ScreenProvider from './ScreenProvider';
+import ComponentsProvider from './ComponentsProvider';
+import SsrProvider from './SsrProvider';
+
+export {
+    SsrProvider,
+    ScreenProvider,
+    ComponentsProvider,
+};

package/src/reducers/auth.test.ts

@@ -0,0 +1,240 @@
+import {
+    AUTH_INIT,
+    AUTH_INIT_USER,
+    AUTH_SET_DATA,
+    AUTH_ADD_SOCIAL,
+} from '../actions/auth';
+import auth from './auth';
+
+describe('auth reducer', () => {
+    const initialState = {
+        isInitialized: false,
+        initializeCounter: 0,
+        redirectPageId: null,
+        user: null,
+        data: null,
+    };
+
+    describe('AUTH_INIT', () => {
+        it('without redirectPageId', () => {
+            const action = {
+                type: AUTH_INIT,
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                initializeCounter: initialState.initializeCounter + 1,
+                redirectPageId: null,
+            });
+        });
+
+        it('with redirectPageId', () => {
+            const action = {
+                type: AUTH_INIT,
+                redirectPageId: 'root',
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                initializeCounter: initialState.initializeCounter + 1,
+                redirectPageId: action.redirectPageId,
+            });
+        });
+    });
+
+    describe('AUTH_INIT_USER', () => {
+        it('without user', () => {
+            const action = {
+                type: AUTH_INIT_USER,
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                isInitialized: true,
+                user: undefined,
+            });
+        });
+
+        it('with null user', () => {
+            const action = {
+                type: AUTH_INIT_USER,
+                user: null,
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                isInitialized: true,
+                user: null,
+            });
+        });
+
+        it('with user', () => {
+            const action = {
+                type: AUTH_INIT_USER,
+                user: {
+                    id: 1,
+                    name: 'Ivan',
+                },
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                isInitialized: true,
+                user: action.user,
+            });
+        });
+    });
+
+    describe('AUTH_SET_DATA', () => {
+        it('without data', () => {
+            const action = {
+                type: AUTH_SET_DATA,
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                data: {},
+            });
+        });
+
+        it('with null data', () => {
+            const action = {
+                type: AUTH_SET_DATA,
+                user: null,
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                data: {},
+            });
+        });
+
+        it('with data', () => {
+            const action = {
+                type: AUTH_SET_DATA,
+                data: {
+                    title: 'data',
+                    value: 42,
+                },
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                data: action.data,
+            });
+        });
+
+        it('with merge data', () => {
+            const newInitialState = {
+                ...initialState,
+                data: {
+                    value: 10,
+                    name: 'test',
+                },
+            };
+
+            const action = {
+                type: AUTH_SET_DATA,
+                data: {
+                    title: 'data',
+                    value: 42,
+                },
+            };
+
+            expect(auth(newInitialState, action)).toEqual({
+                ...newInitialState,
+                data: {
+                    title: 'data',
+                    value: 42,
+                    name: 'test',
+                },
+            });
+        });
+    });
+
+    describe('AUTH_ADD_SOCIAL', () => {
+        it('without social', () => {
+            const action = {
+                type: AUTH_ADD_SOCIAL,
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                user: {
+                    socials: [],
+                },
+            });
+        });
+
+        it('with null social', () => {
+            const action = {
+                type: AUTH_ADD_SOCIAL,
+                social: null,
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                user: {
+                    socials: [],
+                },
+            });
+        });
+
+        it('with social', () => {
+            const action = {
+                type: AUTH_ADD_SOCIAL,
+                social: [
+                    {
+                        title: 'social',
+                        value: 42,
+                    },
+                ],
+            };
+
+            expect(auth(initialState, action)).toEqual({
+                ...initialState,
+                user: {
+                    socials: action.social,
+                },
+            });
+        });
+
+        it('with merge social', () => {
+            const newInitalState = {
+                ...initialState,
+                user: {
+                    socials: [{
+                        title: 'test',
+                        value: 10,
+                    }],
+                },
+            };
+
+            const action = {
+                type: AUTH_ADD_SOCIAL,
+                social: [{
+                    title: 'social',
+                    value: 42,
+                }],
+            };
+
+            expect(auth(newInitalState, action)).toEqual({
+                ...newInitalState,
+                user: {
+                    ...newInitalState.user,
+                    socials: [
+                        {
+                            title: 'test',
+                            value: 10,
+                        },
+                        {
+                            title: 'social',
+                            value: 42,
+                        },
+
+                    ],
+                },
+            });
+        });
+    });
+});

package/src/reducers/auth.ts

@@ -0,0 +1,56 @@
+import _merge from 'lodash-es/merge';
+import {
+    AUTH_INIT,
+    AUTH_INIT_USER,
+    AUTH_SET_DATA,
+    AUTH_ADD_SOCIAL,
+} from '../actions/auth';
+
+const initialState = {
+    isInitialized: false,
+    initializeCounter: 0,
+    redirectPageId: null,
+    user: null,
+    data: null,
+};
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case AUTH_INIT:
+            return {
+                ...state,
+                initializeCounter: state.initializeCounter + 1,
+                redirectPageId: action.redirectPageId || null,
+            };
+        case AUTH_INIT_USER:
+            return {
+                ...state,
+                isInitialized: true,
+                user: action.user,
+            };
+        case AUTH_SET_DATA:
+            return {
+                ...state,
+                data: _merge({}, state.data, action.data),
+            };
+        case AUTH_ADD_SOCIAL:
+            return {
+                ...state,
+                user: {
+                    ...state.user,
+                    socials: [
+                        ...(state.user?.socials || []),
+                        ...(action.social || []),
+                    ],
+                },
+            };
+        default:
+            return state;
+    }
+};
+export const isInitialized = state => state.auth.isInitialized;
+export const getInitializeCounter = state => state.auth.initializeCounter;
+export const isAuthorized = state => !!state.auth.user;
+export const getUser = state => state.auth.user;
+export const getUserId = state => (state.auth.user && state.auth.user.id) || null;
+export const getUserRole = state => (state.auth.user && state.auth.user.role) || null;
+export const getData = state => state.auth.data;

package/src/reducers/fields.ts

@@ -0,0 +1,42 @@
+import _isString from 'lodash-es/isString';
+import _get from 'lodash-es/get';
+import {FIELDS_SET_META} from '../actions/fields';
+
+const initialState = {
+    props: {},
+    meta: null,
+};
+const normalizeName = name => name.replace(/\\/g, '.').replace(/^\./, '');
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case FIELDS_SET_META:
+            Object.keys(action.meta).forEach(name => {
+                action.meta[name].className = name;
+            });
+            return {
+                ...state,
+                meta: {
+                    ...state.meta,
+                    ...action.meta,
+                },
+            };
+        default:
+            return state;
+    }
+};
+
+export const isMetaFetched = state => _get(state, ['fields', 'meta']) !== null;
+export const getEnumLabels = (state, name) => _get(state, ['fields', 'meta', name, 'labels']) || null;
+const warnings = {};
+export const getModel = (state, name) => {
+    if (_isString(name)) {
+        name = normalizeName(name);
+        const meta = _get(state, ['fields', 'meta', name]) || null;
+        if (!meta && isMetaFetched(state) && !warnings[name]) {
+            warnings[name] = true;
+            console.warn('Steroids: Not found model meta:', name); // eslint-disable-line no-console
+        }
+        return meta;
+    }
+    return name || null;
+};

package/src/reducers/form.ts

@@ -0,0 +1,97 @@
+import _get from 'lodash-es/get';
+import _isEqual from 'lodash-es/isEqual';
+import _cloneDeep from 'lodash-es/cloneDeep';
+import _isObject from 'lodash-es/isObject';
+import {set as _set, delete as _delete} from 'dot-prop-immutable';
+
+import {
+    FORM_INITIALIZE,
+    FORM_CHANGE,
+    FORM_SET_ERRORS,
+    FORM_SUBMIT,
+    FORM_RESET,
+    FORM_ARRAY_ADD,
+    FORM_ARRAY_REMOVE,
+} from '../actions/form';
+
+/**
+ * Редьюрес для одной формы. Используется как для Redux, так и для React Reducer
+ * @param state
+ * @param action
+ */
+export function reducerItem(state, action) {
+    if (!state && action.type !== FORM_INITIALIZE) {
+        state = reducerItem(state, {
+            type: FORM_INITIALIZE,
+            formId: action.formId,
+        });
+    }
+
+    switch (action.type) {
+        case FORM_INITIALIZE:
+            return {
+                errors: {},
+                isInvalid: false,
+                isSubmitting: false,
+                ...state,
+                values: state?.values || _cloneDeep(action.values || {}),
+                initialValues: action.values || state?.values || null,
+            };
+
+        case FORM_CHANGE:
+            if (_isObject(action.nameOrObject)) {
+                const newValues = {
+                    ...state.values,
+                    ...action.nameOrObject,
+                };
+                if (!_isEqual(state.values, newValues)) {
+                    return {
+                        ...state,
+                        values: {
+                            ...state.values,
+                            ...action.nameOrObject,
+                        },
+                    };
+                }
+                return state;
+            }
+            return _set(state, 'values.' + action.nameOrObject, action.value);
+
+        case FORM_SET_ERRORS:
+            return _set(state, 'errors', action.errors);
+
+        case FORM_SUBMIT:
+            return _set(state, 'submitCounter', (state.submitCounter || 0) + 1);
+
+        case FORM_RESET:
+            return {
+                ...state,
+                values: _cloneDeep(state.initialValues || {}),
+            };
+
+        case FORM_ARRAY_ADD:
+            // eslint-disable-next-line no-case-declarations
+            const newValue = [].concat(_get(state, 'values.' + action.name) || []);
+            for (let i = 0; i < action.rowsCount; i += 1) {
+                newValue.push(_cloneDeep(action.initialValues || {}));
+            }
+            return _set(state, 'values.' + action.name, newValue);
+
+        case FORM_ARRAY_REMOVE:
+            return _delete(state, 'values.' + action.name + '.' + action.index);
+
+        default:
+            return state;
+    }
+}
+
+const initialState = {};
+export default (state = initialState, action) => {
+    if (action.formId) {
+        return _set(state, action.formId, reducerItem(state[action.formId], action));
+    }
+    return state;
+};
+
+export const formSelector = (state, formId, selector) => selector(state.form?.[formId] || {});
+export const getFormValues = (state, formId) => state.form?.[formId]?.values || null;

package/src/reducers/index.ts

@@ -0,0 +1,24 @@
+import {combineReducers} from 'redux';
+import auth from './auth';
+import fields from './fields';
+import form from './form';
+import list from './list';
+import notifications from './notifications';
+import modal from './modal';
+import router from './router';
+import screen from './screen';
+
+export {
+    form, auth, fields, list, notifications, modal, router, screen,
+};
+export default asyncReducers => combineReducers({
+    form,
+    auth,
+    fields,
+    list,
+    notifications,
+    modal,
+    screen,
+    ...asyncReducers,
+    router: (state, action) => router(asyncReducers.router ? asyncReducers.router(state, action) : {}, action),
+});

package/src/reducers/list.ts

@@ -0,0 +1,196 @@
+import _get from 'lodash-es/get';
+import _isMatch from 'lodash-es/isMatch';
+import _every from 'lodash-es/every';
+import _extend from 'lodash-es/extend';
+import {
+    LIST_INIT,
+    LIST_SET_ITEMS,
+    LIST_BEFORE_FETCH,
+    LIST_AFTER_FETCH,
+    LIST_ITEM_ADD,
+    LIST_ITEM_UPDATE,
+    LIST_DESTROY,
+    LIST_TOGGLE_ITEM,
+    LIST_TOGGLE_ALL,
+    LIST_SET_LAYOUT,
+} from '../actions/list';
+
+const initialState = {
+    lists: {},
+    selectedIds: {},
+};
+
+const reducerMap = {
+    [LIST_INIT]: (state, action) => ({
+        ...state,
+        lists: {
+            ...state.lists,
+            [action.payload.listId]: {
+                meta: {},
+                total: action.payload.total || (action.payload.items ? action.payload.items.length : 0),
+                isFetched: !!action.payload.items,
+                isLoading: false,
+                ...action.payload,
+            },
+        },
+    }),
+    [LIST_SET_ITEMS]: (state, action) => ({
+        ...state,
+        lists: {
+            ...state.lists,
+            [action.listId]: {
+                ...state.lists[action.listId],
+                items: action.items,
+            },
+        },
+    }),
+    [LIST_BEFORE_FETCH]: (state, action) => ({
+        ...state,
+        lists: {
+            ...state.lists,
+            [action.listId]: {
+                ...state.lists[action.listId],
+                isLoading: true,
+            },
+        },
+    }),
+    [LIST_AFTER_FETCH]: (state, action) => {
+        let items;
+        const list = state.lists[action.listId];
+        if (list.items === action.items) {
+            // No changes
+            items = list.items;
+        } else if (list && list.items && list.loadMore && action.page > 1) {
+            items = [].concat(list.items);
+            action.items.forEach((entry, i) => {
+                const index = (action.page - 1) * action.pageSize + i;
+                items[index] = entry;
+            });
+        } else {
+            items = [].concat(action.items);
+        }
+        return {
+            ...state,
+            lists: {
+                ...state.lists,
+                [action.listId]: {
+                    ...list,
+                    ...action,
+                    items,
+                    isFetched: true,
+                    isLoading: false,
+                },
+            },
+        };
+    },
+    [LIST_ITEM_ADD]: (state, action) => {
+        if (state.lists[action.listId]) {
+            return {
+                ...state,
+                lists: {
+                    ...state.lists,
+                    [action.listId]: {
+                        ...state.lists[action.listId],
+                        items: action.prepend
+                            ? []
+                                .concat(action.item)
+                                .concat(state.lists[action.listId].items)
+                            : []
+                                .concat(state.lists[action.listId].items)
+                                .concat(action.item),
+                    },
+                },
+            };
+        }
+        return [];
+    },
+    [LIST_ITEM_UPDATE]: (state, action) => ({
+        ...state,
+        lists: {
+            ...state.lists,
+            [action.listId]: {
+                ...state.lists[action.listId],
+                items: state.lists[action.listId].items.map(item => {
+                    if (_isMatch(item, action.condition)) {
+                        item = _extend({}, item, action.item);
+                    }
+                    return item;
+                }),
+            },
+        },
+    }),
+    [LIST_DESTROY]: (state, action) => {
+        delete state.lists[action.listId];
+        return {
+            ...state,
+            lists: {
+                ...state.lists,
+            },
+        };
+    },
+    [LIST_TOGGLE_ITEM]: (state, action) => {
+        const selectedIds = _get(state, ['selectedIds', action.listId]) || [];
+        const index = selectedIds.indexOf(action.itemId);
+        if (index === -1) {
+            selectedIds.push(action.itemId);
+        } else {
+            selectedIds.splice(index, 1);
+        }
+        return {
+            ...state,
+            selectedIds: {
+                ...state.selectedIds,
+                [action.listId]: [].concat(selectedIds),
+            },
+        };
+    },
+    [LIST_TOGGLE_ALL]: (state, action) => {
+        const list4 = state.lists[action.listId];
+        if (list4) {
+            const ids = list4.items.map(item => item[list4.primaryKey]) || [];
+            const isAll = state.selectedIds[action.listId]
+                && _every(ids.map(id => state.selectedIds[action.listId].includes(id)));
+            return {
+                ...state,
+                selectedIds: {
+                    ...state.selectedIds,
+                    [action.listId]: isAll ? [] : ids,
+                },
+            };
+        }
+        return [];
+    },
+    [LIST_SET_LAYOUT]: (state, action) => ({
+        ...state,
+        lists: {
+            ...state.lists,
+            [action.listId]: {
+                ...state.lists[action.listId],
+                layoutName: action.layoutName,
+            },
+        },
+    }),
+};
+
+export default (state = initialState, action) => reducerMap[action.type]
+    ? reducerMap[action.type](state, action)
+    : state;
+
+export const isListInitialized = (state, listId) => !!_get(state, ['list', 'lists', listId]);
+export const getList = (state, listId) => _get(state, ['list', 'lists', listId]) || null;
+export const getIds = (state, listId) => {
+    const list = getList(state, listId);
+    return (
+        (list && list.items && list.items.map(item => item[list.primaryKey])) || []
+    );
+};
+export const getListItems = (state, listId) => _get(state, ['list', 'lists', listId, 'items']);
+export const getCheckedIds = (state, listId) => _get(state, ['list', 'selectedIds', listId]) || [];
+export const isChecked = (state, listId, itemId) => getCheckedIds(state, listId).includes(itemId);
+export const isCheckedAll = (state, listId) => {
+    const selectedIds = getCheckedIds(state, listId);
+    return (
+        selectedIds.length > 0
+        && _every(getIds(state, listId).map(id => selectedIds.includes(id)))
+    );
+};