@steroidsjs/core 2.0.0-rc.7 → 2.0.1-beta.113

package/reducers/list.ts

@@ -0,0 +1,191 @@
+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_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: {}
+};
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case LIST_INIT:
+            return {
+                ...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,
+                    }
+                }
+            };
+
+        case LIST_BEFORE_FETCH:
+            return {
+                ...state,
+                lists: {
+                    ...state.lists,
+                    [action.listId]: {
+                        ...state.lists[action.listId],
+                        isLoading: true
+                    }
+                }
+            };
+
+        case LIST_AFTER_FETCH:
+            let items;
+            const list = state.lists[action.listId];
+            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
+                    }
+                }
+            };
+
+        case LIST_ITEM_ADD:
+            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)
+                        }
+                    }
+                };
+            }
+            break;
+
+        case LIST_ITEM_UPDATE:
+            return {
+                ...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;
+                        })
+                    }
+                }
+            };
+
+        case LIST_DESTROY:
+            delete state.lists[action.listId];
+            return {
+                ...state,
+                lists: {
+                    ...state.lists
+                }
+            };
+
+        case LIST_TOGGLE_ITEM:
+            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)
+                }
+            };
+
+        case LIST_TOGGLE_ALL:
+            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
+                    }
+                };
+            }
+            break;
+
+        case LIST_SET_LAYOUT:
+            return {
+                ...state,
+                lists: {
+                    ...state.lists,
+                    [action.listId]: {
+                        ...state.lists[action.listId],
+                        layoutName: action.layoutName
+                    }
+                }
+            };
+    }
+    return 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) => {
+    return _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)))
+    );
+};

package/reducers/modal.ts

@@ -0,0 +1,79 @@
+import _get from 'lodash-es/get';
+import {MODAL_OPEN, MODAL_CLOSE, MODAL_MARK_CLOSING} from '../actions/modal';
+
+export const MODAL_DEFAULT_GROUP = 'modal';
+
+const initialState = {
+    opened: {}
+};
+
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case MODAL_OPEN:
+            return (() => {
+                const group = action.group || MODAL_DEFAULT_GROUP;
+                const items = _get(state, ['opened', group]) || [];
+                const index = items.findIndex(item => item.id === action.id);
+                if (index !== -1) {
+                    items[index].props = {
+                        ...items[index].props,
+                        ...action.props,
+                    };
+                } else {
+                    items.push({
+                        id: action.id,
+                        modal: action.modal,
+                        props: action.props,
+                        isClosing: false,
+                    });
+                }
+
+                return {
+                    opened: {
+                        ...state.opened,
+                        [group]: [].concat(items),
+                    }
+                };
+            })();
+
+        case MODAL_MARK_CLOSING:
+            return (() => {
+                const group = action.group || MODAL_DEFAULT_GROUP;
+                const items = _get(state, ['opened', group]) || [];
+                const index = items.findIndex(item => item.id === action.id);
+                if (index !== -1) {
+                    items[index] = {
+                        ...items[index],
+                        isClosing: true,
+                    };
+                }
+                return {
+                    opened: {
+                        ...state.opened,
+                        [group]: [].concat(items),
+                    }
+                };
+            })();
+
+        case MODAL_CLOSE:
+            return (() => {
+                const group = action.group || MODAL_DEFAULT_GROUP;
+                const items = _get(state, ['opened', group]) || [];
+                const index = items.findIndex(item => item.id === action.id);
+                if (index !== -1) {
+                    items.splice(index, 1);
+                }
+                return {
+                    opened: {
+                        ...state.opened,
+                        [group]: [].concat(items),
+                    }
+                };
+            })();
+
+        default:
+            return state;
+    }
+};
+
+export const getOpened = (state, group = MODAL_DEFAULT_GROUP) => _get(state, ['modal', 'opened', group]) || null;

package/reducers/notifications.ts

@@ -0,0 +1,39 @@
+import {
+    NOTIFICATIONS_SHOW,
+    NOTIFICATIONS_CLOSING,
+    NOTIFICATIONS_CLOSE
+} from '../actions/notifications';
+
+const initialState = {
+    items: [],
+    position: ''
+};
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case NOTIFICATIONS_SHOW:
+            return {
+                ...state,
+                items: []
+                    .concat(state.items)
+                    .concat([
+                        {
+                            id: action.id,
+                            level: action.level || 'info',
+                            message: action.message,
+                            isClosing: false,
+                            position: action.position
+                        }
+                    ]),
+                position: action.position
+            };
+        case NOTIFICATIONS_CLOSE:
+            return {
+                ...state,
+                items: state.items.filter(item => item.id !== action.id)
+            };
+        default:
+            return state;
+    }
+};
+export const getNotifications = state => state.notifications.items;
+export const getPosition = state => state.notifications.position;

package/reducers/router.ts

@@ -0,0 +1,322 @@
+import * as React from 'react';
+import {parse, compile} from 'path-to-regexp';
+import {matchPath} from 'react-router';
+import * as queryString from 'qs';
+import _get from 'lodash-es/get';
+import _isEmpty from 'lodash-es/isEmpty';
+import _pick from 'lodash-es/pick';
+import _isArray from 'lodash-es/isArray';
+import _isObject from 'lodash-es/isObject';
+import _isFunction from 'lodash-es/isFunction';
+import {
+    ROUTER_INIT_ROUTES,
+    ROUTER_SET_PARAMS,
+    ROUTER_ADD_CONFIGS,
+    ROUTER_REMOVE_CONFIGS,
+    ROUTER_SET_DATA,
+    getConfigId,
+} from '../actions/router';
+
+export interface IRoute {
+    id?: string,
+    title?: string,
+    label?: string,
+    icon?: string,
+    exact?: boolean,
+    strict?: boolean,
+    path?: string,
+    redirectTo?: string,
+    isVisible?: boolean,
+    isNavVisible?: boolean,
+    component?: React.ReactNode,
+    componentProps?: object,
+    roles?: string[],
+    items?: IRoute[],
+    [key: string]: any,
+}
+
+interface IRouterInitialState {
+    location: {
+        pathname: string,
+        search: string,
+        hash: string,
+        query: object,
+    },
+    routesTree: IRoute,
+    routesMap: {[key: string]: IRoute},
+    activeIds: string[],
+    match: {
+        path: string,
+        url: string,
+        isExact: string,
+        params: object,
+    },
+
+    params: object,
+    configs: any,
+    data: object,
+    counters: object,
+}
+
+const initialState = {
+    location: null,
+    routesTree: null,
+    routesMap: null,
+    activeIds: null,
+    currentId: null,
+    match: null,
+
+    params: {},
+    configs: [],
+    data: {},
+    counters: {}
+} as IRouterInitialState;
+
+/**
+ * Generate url for route by path and params
+ * @param path
+ * @param params
+ */
+export const buildUrl = (path, params = null) => {
+    // Get url
+    let url = path;
+    let pathKeys = [];
+    try {
+        pathKeys = parse(path)
+            .slice(1)
+            .map((p: any) => p.name);
+        url = compile(path)({
+            ...params,
+        });
+    } catch (e) {
+        // eslint-disable-line no-empty
+    }
+
+    // Append params, which keys is not included in path keys
+    const queryObj = {};
+    Object.keys(params || {})
+        .filter(key => !pathKeys.includes(key))
+        .forEach(key => {
+            queryObj[key] = params[key];
+        });
+    const query = queryString.stringify(queryObj);
+    if (!_isEmpty(query) && url) {
+        url = url + (url.indexOf('?') !== -1 ? '&' : '?') + query;
+    }
+
+    return url;
+};
+
+/**
+ * Normalize routes tree (convert object structure to items[])
+ */
+const normalizeRoutes = (state, item: IRoute, activeIds: string[], routesMap: object) => {
+    let items = null;
+    if (_isArray(item.items)) {
+        items = item.items.map(subItem => normalizeRoutes(state, subItem, activeIds, routesMap));
+    } else if (_isObject(item.items)) {
+        items = Object.keys(item.items).map(id => normalizeRoutes(state, {...item.items[id], id}, activeIds, routesMap));
+    }
+    const normalizedItem = {
+        ...item,
+        id: item.id,
+        title: item.title || item.title === '' ? item.title : item.label,
+        label: item.label || item.label === '' ? item.label : item.title,
+        icon: item.icon || null,
+        exact: !!item.exact,
+        strict: !!item.strict,
+        path: item.path || '',
+        isVisible: item.isVisible !== false,
+        isNavVisible: item.isNavVisible !== false,
+        component: null, // Do not store component class in redux
+        componentProps: null,
+        roles: item.roles || [],
+        items,
+    };
+
+    routesMap[normalizedItem.id] = normalizedItem;
+    if (checkIsActive(state, normalizedItem)) {
+        activeIds.push(normalizedItem.id);
+    }
+
+    return normalizedItem;
+};
+
+/**
+ * Return true, if item is 'active' - opened current route or it children
+ */
+const checkIsActive = (state, item) => {
+    // Check is active
+    const pathname = location.protocol === 'file:'
+        ? location.hash.replace(/^#/, '')
+        : _get(state, 'location.pathname');
+    const checkActive = (pathname, item) => {
+        const match = matchPath(pathname, _pick(item, ['exact', 'strict', 'path']));
+        return !!(match || (item.items || []).find(sub => checkActive(pathname, sub)));
+    };
+    return checkActive(pathname, item);
+};
+
+/**
+ * Find route in routes tree
+ */
+const findRecursive = (item: IRoute, predicate: string | any, pathItems: IRoute[] | null = null): IRoute | null => {
+    if ((_isFunction(predicate) && predicate(item)) || predicate === item.id) {
+        if (pathItems) {
+            pathItems.push(item);
+        }
+        return item;
+    }
+
+    const finedItem = (item.items || []).find(subItem => findRecursive(subItem, predicate, pathItems)) || null;
+    if (finedItem && pathItems) {
+        pathItems.push(item);
+    }
+    return finedItem;
+};
+
+const getMatch = (currentRoute, state) => {
+    const match = currentRoute
+        ? matchPath(String(state.location.pathname), _pick(currentRoute, ['id', 'exact', 'strict', 'path']))
+        : null;
+
+    return match && {
+        ...match,
+        params: {
+            ...state.location.query,
+            ...match.params,
+        },
+    };
+};
+
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case ROUTER_INIT_ROUTES:
+            const routesMap = {};
+            const activeIds = [];
+            const routesTree = normalizeRoutes(state, action.routes, activeIds, routesMap);
+            const currentRoute = activeIds.length > 0 ? routesMap[activeIds[0]] : null;
+            return {
+                ...state,
+                routesTree,
+                routesMap,
+                activeIds,
+                match: getMatch(currentRoute, state),
+            };
+
+        case '@@router/LOCATION_CHANGE':
+            return (() => {
+                const activeIds = Object.keys(state.routesMap).filter(id => checkIsActive(state, state.routesMap[id]));
+                const currentRoute = activeIds.length > 0 ? state.routesMap[activeIds[0]] : null;
+                return {
+                    ...state,
+                    activeIds,
+                    match: getMatch(currentRoute, state),
+                };
+            })();
+
+        case ROUTER_SET_PARAMS:
+            return {
+                ...state,
+                params: {
+                    ...state.params,
+                    ...state.location.query,
+                    ...action.params
+                }
+            };
+
+        case ROUTER_ADD_CONFIGS:
+            const configs = [].concat(state.configs || []);
+            const counters = {...state.counters};
+            action.configs.forEach(config => {
+                const id = getConfigId(config);
+                if (counters[id]) {
+                    counters[id]++;
+                } else {
+                    counters[id] = 1;
+                    configs.push(config);
+                }
+            });
+            return {
+                ...state,
+                configs,
+                counters
+            };
+
+        case ROUTER_REMOVE_CONFIGS:
+            let configs2 = [].concat(state.configs);
+            const counters2 = {...state.counters};
+            let data = {...state.data};
+            action.configs.forEach(config => {
+                const id = getConfigId(config);
+                if (counters2[id]) {
+                    counters2[id]--;
+                    if (counters2[id] <= 0) {
+                        configs2 = configs2.filter(item => getConfigId(item) !== id);
+                        delete data[id];
+                    }
+                }
+            });
+            return {
+                ...state,
+                data,
+                configs: configs2,
+                counters: counters2
+            };
+
+        case ROUTER_SET_DATA:
+            return {
+                ...state,
+                data: {
+                    ...state.data,
+                    [getConfigId(action.config)]: action.data
+                }
+            };
+    }
+    return state;
+};
+
+/*
+    Changes from version v1 -> v2
+
+    isInitialized -> isRouterInitialized
+    getBreadcrumbs -> getRouteBreadcrumbs
+    getNavItem -> getRoute
+    getNavUrl -> getRoute + buildNavItem
+    getCurrentRoute -> getRoute
+    getCurrentItem -> getRoute
+    getCurrentItemParam -> getRouteProp
+    getNavItems -> getRouteChildren
+    getParentRoute -> getRouteParent
+ */
+
+export const isRouterInitialized = state => !!state.router.routesTree;
+export const getRouterParams = state => _get(state.router, 'params');
+export const getActiveRouteIds = state => _get(state.router, 'activeIds') || null;
+export const getRoutesMap = state => _get(state.router, 'routesMap') || null;
+export const getRouteId = state => _get(state.router, 'activeIds.0') || null;
+export const getRoute = (state, routeId = null) => _get(state.router, ['routesMap', routeId || getRouteId(state)]) || null;
+export const getRouteProp = (state, routeId = null, param) => _get(getRoute(state, routeId), param) || null;
+export const getRouteParams = state => _get(state.router, 'match.params') || null;
+export const getRouteParam = (state, param) => _get(getRouteParams(state), param) || null;
+export const getRouteBreadcrumbs = (state, routeId = null): IRoute[] => {
+    const items = [];
+    findRecursive(state.router.routesTree, routeId, items);
+    return items.reverse().filter(item => item.isVisible !== false && item.isNavVisible !== false);
+};
+export const getRouteChildren = (state, routeId = null) => {
+    const route = getRoute(state, routeId);
+    return route && route.items || null;
+
+};
+export const getRouteParent = (state, routeId = null, level = 1) => {
+    const route = getRoute(state, routeId);
+    const breadcrumbs = route ? getRouteBreadcrumbs(state, route.id) : [];
+    return breadcrumbs.length > level + 1
+        ? breadcrumbs[breadcrumbs.length - (level + 1)]
+        : null;
+};
+export const getNavItems = (state, routeId, level = 1) => {
+    // TODO levels...
+    return getRouteChildren(state, routeId);
+}

package/reducers/screen.ts

@@ -0,0 +1,43 @@
+import {SCREEN_SET_WIDTH, SCREEN_SET_MEDIA} from '../actions/screen';
+
+export const SCREE_PHONE = 'phone';
+export const SCREEN_TABLET = 'tablet';
+export const SCREEN_DESKTOP = 'desktop';
+const initialState = {
+    width: 1280,
+    media: {
+        [SCREE_PHONE]: 320,
+        [SCREEN_TABLET]: 768,
+        [SCREEN_DESKTOP]: 1024
+    }
+};
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case SCREEN_SET_WIDTH:
+            return {
+                ...state,
+                width: action.width
+            };
+        case SCREEN_SET_MEDIA:
+            return {
+                ...state,
+                media: {
+                    ...state.media,
+                    ...action.media
+                }
+            };
+    }
+    return state;
+};
+export const getDeviceType = state => {
+    if (state.screen.width < state.screen.media[SCREEN_TABLET]) {
+        return SCREE_PHONE;
+    }
+    if (state.screen.width < state.screen.media[SCREEN_DESKTOP]) {
+        return SCREEN_TABLET;
+    }
+    return SCREEN_DESKTOP;
+};
+export const isPhone = state => getDeviceType(state) === SCREE_PHONE;
+export const isTablet = state => getDeviceType(state) === SCREEN_TABLET;
+export const isDesktop = state => getDeviceType(state) === SCREEN_DESKTOP;

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "jsx": "react",
+    "experimentalDecorators": true,
+    "esModuleInterop": true
+  }
+}