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

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Kozhin Development
+Copyright (c) 2018 Kozhin Development
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/actions/auth.ts

@@ -0,0 +1,55 @@
+import {goToRoute} from './router';
+
+export const AUTH_INIT = 'AUTH_INIT';
+export const AUTH_INIT_USER = 'AUTH_INIT_USER';
+export const AUTH_SET_DATA = 'AUTH_SET_DATA';
+export const AUTH_ADD_SOCIAL = 'AUTH_ADD_SOCIAL';
+
+export const init = (skipInitialized = false) => (dispatch, getState) => {
+    if (skipInitialized) {
+        const state = getState();
+        if (state.auth && state.auth.isInitialized) {
+            return [];
+        }
+    }
+    return dispatch({
+        type: AUTH_INIT
+    });
+};
+
+export const reInit = () => init();
+
+export const login = (token, redirectPageId: string | boolean = 'root') => (
+    dispatch,
+    getState,
+    {http}
+) => {
+    http.setAccessToken(token);
+    return dispatch({
+        type: AUTH_INIT,
+        redirectPageId: redirectPageId || null
+    });
+};
+
+export const addSocial = social => ({
+    type: AUTH_ADD_SOCIAL,
+    social
+});
+
+export const setUser = user => ({
+    type: AUTH_INIT_USER,
+    user: user || null
+});
+
+export const setData = data => ({
+    type: AUTH_SET_DATA,
+    data
+});
+
+export const logout = (routeId: string | boolean = 'root', routeParams: any = null) => (dispatch, getState, {http}) => {
+    http.removeAccessToken();
+    return dispatch([
+        setUser(null),
+        routeId && goToRoute(routeId, routeParams)
+    ].filter(Boolean));
+};

package/actions/fields.ts

@@ -0,0 +1,5 @@
+export const FIELDS_SET_META = 'FIELDS_SET_META';
+export const setMeta = meta => ({
+  type: FIELDS_SET_META,
+  meta
+});

package/actions/list.ts

@@ -0,0 +1,303 @@
+import {getFormValues, change} from 'redux-form';
+import _get from 'lodash-es/get';
+import _isArray from 'lodash-es/isArray';
+import _isEmpty from 'lodash-es/isEmpty';
+import _orderBy from 'lodash-es/orderBy';
+import _trimStart from 'lodash-es/trimStart';
+import _isFunction from 'lodash-es/isFunction';
+import {filterItems} from '../utils/data';
+
+export interface IList {
+    action?: string,
+    actionMethod?: string,
+    onFetch?: (list: IList, query: object, components: any) => Promise<any>,
+    condition?: (query: object) => any,
+    scope?: string[],
+    total?: number,
+    items?: Array<any>,
+    sourceItems?: Array<any>,
+    isRemote?: boolean,
+    loadMore?: boolean,
+    primaryKey?: string,
+    listId?: string,
+    formId?: string,
+    pageAttribute?: string,
+    pageSizeAttribute?: string,
+    sortAttribute?: string,
+    layoutAttribute?: string,
+    meta?: object,
+    isFetched?: boolean,
+    isLoading?: boolean,
+}
+
+export const LIST_INIT = 'LIST_INIT';
+export const LIST_BEFORE_FETCH = 'LIST_BEFORE_FETCH';
+export const LIST_AFTER_FETCH = 'LIST_AFTER_FETCH';
+export const LIST_ITEM_ADD = 'LIST_ITEM_ADD';
+export const LIST_ITEM_UPDATE = 'LIST_ITEM_UPDATE';
+export const LIST_DESTROY = 'LIST_DESTROY';
+export const LIST_TOGGLE_ITEM = 'LIST_TOGGLE_ITEM';
+export const LIST_TOGGLE_ALL = 'LIST_TOGGLE_ALL';
+export const LIST_SET_LAYOUT = 'LIST_SET_LAYOUT';
+
+//const STORAGE_LAYOUT_KEY_PREFIX = 'listLayout_';
+
+const lazyTimers = {};
+
+const createList = (listId: string, props: any) => ({
+    action: props.action || props.action === '' ? props.action : null,
+    actionMethod: props.actionMethod || 'get',
+    onFetch: props.onFetch,
+    condition: props.condition,
+    scope: props.scope,
+    total: props.total || null,
+    items: null,
+    sourceItems: props.items || null,
+    isRemote: !props.items,
+    loadMore: props._pagination.loadMore,
+    primaryKey: props.primaryKey,
+    listId,
+    formId: _get(props, 'searchForm.formId') || listId,
+    pageAttribute: _get(props, '_pagination.attribute') || null,
+    pageSizeAttribute: _get(props, '_paginationSize.attribute') || null,
+    sortAttribute: _get(props, '_sort.attribute') || null,
+    layoutAttribute: _get(props, '_layout.attribute') || null,
+});
+
+export const httpFetchHandler = (list: IList, query, {http}) => {
+    let url = list.action;
+    if (list.scope) {
+        url +=
+            (url.indexOf('?') !== -1 ? '&' : '?') + 'scope=' + list.scope.join(',');
+    }
+    return http
+        .send(list.actionMethod, url || location.pathname, query)
+        .then(response => response.data);
+};
+
+export const localFetchHandler = (list: IList, query: object) => {
+    query = {...query};
+
+    // Get page
+    const page = query[list.pageAttribute] || null;
+    delete query[list.pageAttribute];
+
+    // Get page size
+    const pageSize = query[list.pageSizeAttribute] || null;
+    delete query[list.pageSizeAttribute];
+
+    // Get sort
+    const sort = query[list.sortAttribute] || null;
+    delete query[list.sortAttribute];
+
+    // Delete layout param
+    delete query[list.layoutAttribute];
+
+    let items = [].concat(list.sourceItems || []);
+
+    // Remove null values from query
+    Object.keys(query).forEach(key => {
+        if (query[key] === null) {
+            delete query[key];
+        }
+    });
+
+    // Filter items
+    if (!_isEmpty(query)) {
+        items = filterItems(
+            items,
+            list.condition
+                ? (_isFunction(list.condition) ? list.condition(query) : list.condition)
+                : query
+        );
+    }
+
+    const total = items.length;
+
+    // Pagination
+    if (page && pageSize) {
+        const startIndex = (page - 1) * pageSize;
+        items = items.slice(startIndex, startIndex + pageSize);
+    }
+
+    // Sort
+    if (sort) {
+        items = _orderBy(
+            items,
+            sort.map(key => _trimStart(key, '-')),
+            sort.map(key => key.indexOf('-') === 0 ? 'desc' : 'asc'),
+        );
+    }
+
+    return {
+        items,
+        total,
+    };
+}
+
+/**
+ * Init list
+ * @param listId
+ * @param props
+ */
+export const listInit = (listId, props) => ({
+    payload: createList(listId, props),
+    type: LIST_INIT,
+});
+
+/*export const initSSR = (listId, props) => (dispatch, getState, {http, clientStorage}) => {
+    const state = getState()
+    const stateList = _get(state, ['list', 'lists', listId]);
+    const list = {
+        ...createList(listId, props, clientStorage),
+        ...stateList
+    };
+    if ((!list.action && list.action !== '') || list.items) {
+        if (!stateList) {
+            return dispatch({
+                ...list,
+                type: LIST_INIT
+            });
+        }
+        return;
+    }
+    const onFetch = list.onFetch || httpFetchHandler;
+    return dispatch(
+        onFetch(list, VALUES, http).then(data => ({
+            ...list,
+            ...data,
+            type: LIST_INIT
+        }))
+    );
+};*/
+
+/**
+ * Update query values and send request
+ * @param listId
+ * @param query
+ */
+export const listFetch = (listId: string, query: object = {}) => (dispatch, getState, components) => {
+    const state = getState();
+    const list = _get(state, ['list', 'lists', listId]) as IList;
+
+    if (!list || (list.isRemote && !list.action && list.action !== '')) {
+        return;
+    }
+
+    const toDispatch = [];
+    const formValues = getFormValues(list.formId)(state) || {};
+    const onFetch = list.onFetch || (list.isRemote ? httpFetchHandler : localFetchHandler);
+
+    // Change query
+    Object.keys(query || {}).forEach(key => {
+        formValues[key] = query[key];
+        toDispatch.push(change(list.formId, key, query[key]));
+    });
+
+    if (list.isRemote) {
+        // Set `Loading...`
+        toDispatch.push({
+            listId,
+            type: LIST_BEFORE_FETCH
+        });
+    }
+
+    // Send request
+    toDispatch.push(
+        Promise.resolve(onFetch(list, formValues, components)).then(data => {
+            // Check list is not destroy
+            if (!getState().list.lists[listId]) {
+                return [];
+            }
+
+            if (_isArray(data)) {
+                data = {
+                    items: data,
+                    total: data.length,
+                    meta: null,
+                };
+            }
+
+            return {
+                items: data.items || [],
+                total: data.total || null,
+                meta: data.meta || null,
+                page: formValues[list.pageAttribute],
+                pageSize: formValues[list.pageSizeAttribute],
+                listId,
+                type: LIST_AFTER_FETCH
+            };
+        })
+    );
+
+    return dispatch(toDispatch);
+};
+
+/**
+ * Lazy update query values and send request
+ * @param listId
+ * @param query
+ */
+export const listLazyFetch = (listId: string, query: object = {}) => dispatch => {
+    if (lazyTimers[listId]) {
+        clearTimeout(lazyTimers[listId]);
+    }
+    lazyTimers[listId] = setTimeout(() => dispatch(listFetch(listId, query)), 200);
+};
+
+/**
+ * Send request with same query
+ * @param listId
+ */
+export const listRefresh = (listId: string) => listFetch(listId);
+
+/**
+ * Destroy list (remove from redux state)
+ * @param listId
+ */
+export const listDestroy = (listId: string) => {
+    if (lazyTimers[listId]) {
+        clearTimeout(lazyTimers[listId]);
+    }
+    return {
+        listId,
+        type: LIST_DESTROY,
+    };
+};
+
+
+export const add = (listId, item) => ({
+    item,
+    listId,
+    type: LIST_ITEM_ADD
+});
+export const update = (listId, item, condition) => ({
+    item,
+    condition,
+    listId,
+    type: LIST_ITEM_UPDATE
+});
+export const toggleItem = (listId, itemId) => ({
+    listId,
+    itemId,
+    type: LIST_TOGGLE_ITEM
+});
+export const toggleAll = listId => ({
+    listId,
+    type: LIST_TOGGLE_ALL
+});
+
+// TODO local storage save?
+/*export const setLayoutName = (listId, layoutName) => (
+    dispatch,
+    getState,
+    {clientStorage}
+) => {
+    clientStorage.set(STORAGE_LAYOUT_KEY_PREFIX + listId, layoutName);
+    return dispatch({
+        listId,
+        layoutName,
+        type: LIST_SET_LAYOUT
+    });
+};
+*/

package/actions/modal.ts

@@ -0,0 +1,33 @@
+export const MODAL_OPEN = '@modal/open';
+export const MODAL_MARK_CLOSING = '@modal/markClosing';
+export const MODAL_CLOSE = '@modal/close';
+
+let idCounter = 0;
+export const openModal = (modal, props: any = {}) => {
+    let id = props ? props.modalId : null;
+    if (!id) {
+        modal._modalId = modal._modalId || 'modal-' + ++idCounter;
+        id = modal._modalId;
+    }
+
+    return {
+        type: MODAL_OPEN,
+        id,
+        modal,
+        group: props.modalGroup || null,
+        props,
+    };
+};
+
+export const modalMarkClosing = (id, group = null) => ({
+    type: MODAL_MARK_CLOSING,
+    id,
+    group,
+});
+
+
+export const closeModal = (id, group = null) => ({
+    type: MODAL_CLOSE,
+    id,
+    group,
+});

package/actions/notifications.ts

@@ -0,0 +1,37 @@
+let ID_COUNTER = 0;
+export const NOTIFICATIONS_SHOW = 'NOTIFICATIONS_SHOW';
+export const NOTIFICATIONS_CLOSING = 'NOTIFICATIONS_CLOSING';
+export const NOTIFICATIONS_CLOSE = 'NOTIFICATIONS_CLOSE';
+
+export interface IShowNotificationParameters {
+    position?: 'top-right' | 'bottom-right' | 'top-left' | 'bottom-left' | string;
+    timeOut?: number;
+}
+
+const showNotificationDefaults: IShowNotificationParameters = {
+    position: 'top-right',
+    timeOut: 10000,
+};
+
+export const showNotification = (message: string, level: ColorName = 'success', params: IShowNotificationParameters = {}) => dispatch => {
+    const {position, timeOut} = {...showNotificationDefaults, ...params} as IShowNotificationParameters;
+    const id = ++ID_COUNTER;
+
+    dispatch({ type: NOTIFICATIONS_SHOW, id, message, level, position});
+
+    if(timeOut > 0){
+        setTimeout(() => dispatch(closeNotification(id)), timeOut);
+    }
+};
+
+export const closeNotification = (id = null) => ({
+    type: NOTIFICATIONS_CLOSE,
+    id
+});
+
+export const setFlashes = flashes =>
+    Object.keys(flashes).map((level: string) => {
+        return []
+            .concat(flashes[level] || [])
+            .map(message => showNotification(message, level));
+    });

package/actions/router.ts

@@ -0,0 +1,111 @@
+import _isArray from 'lodash-es/isArray';
+import _trim from 'lodash-es/trim';
+import {push, replace} from 'connected-react-router';
+
+export const ROUTER_INIT_ROUTES = 'ROUTER_INIT_ROUTES';
+export const ROUTER_SET_PARAMS = 'ROUTER_SET_PARAMS';
+export const ROUTER_ADD_CONFIGS = 'ROUTER_ADD_CONFIGS';
+export const ROUTER_REMOVE_CONFIGS = 'ROUTER_REMOVE_CONFIGS';
+export const ROUTER_SET_DATA = 'ROUTER_SET_DATA';
+
+export interface IFetchConfig {
+    id?: string | number,
+    url: string,
+    key: string,
+    method?: 'get' | 'post' | string,
+    params?: any,
+}
+
+const normalizeConfigs = configs => {
+    if (!configs) {
+        configs = [];
+    }
+    if (!_isArray(configs)) {
+        configs = [configs];
+    }
+    configs.forEach((config, index) => {
+        if (!config.url && !config.id) {
+            throw new Error('id or url is required');
+        }
+        configs[index] = {
+            method: 'get',
+            params: {},
+            ...config
+        };
+    });
+    return configs;
+};
+const defaultFetchHandler = (config, {http}) => {
+    return http
+        .send(config.method, config.url, config.params)
+        .then(result => result.data);
+};
+export const initRoutes = routes => ({
+    type: ROUTER_INIT_ROUTES,
+    routes,
+});
+export const initParams = params => ({
+    type: ROUTER_SET_PARAMS,
+    params
+});
+export const goToRoute = (routeId, params = null, isReplace = false) => (dispatch, getState, {store}) => {
+    if (process.env.PLATFORM === 'mobile') {
+        store.navigationNative.navigate(routeId, params);
+    } else {
+        const getRouteProp = require('../reducers/router').getRouteProp;
+        const buildUrl = require('../reducers/router').buildUrl;
+        const path = getRouteProp(getState(), routeId, 'path');
+        const method = isReplace ? replace : push;
+        return dispatch(method(buildUrl(path, params)));
+    }
+};
+export const goToParent = (level = 1) => (dispatch, getState) => {
+    const getRouteParent = require('../reducers/router').getRouteParent;
+    const getRouteParams = require('../reducers/router').getRouteParams;
+    const state = getState();
+    const params = getRouteParams(state);
+    const parentRoute = getRouteParent(state, level);
+    const parentRouteId = parentRoute ? parentRoute.id : null;
+    const parentRouteParams = parentRoute ? params : null;
+    if (parentRouteId) {
+        return dispatch(goToRoute(parentRouteId, parentRouteParams));
+    }
+};
+export const getConfigId = config => config ? (config.id || _trim(config.url, '/')) : null;
+
+const fetchByConfig = (config, dispatch, components) => {
+    const onFetch = config.onFetch || defaultFetchHandler;
+    onFetch(config, components)
+        .then(data => dispatch({
+            type: ROUTER_SET_DATA,
+            config,
+            data,
+        }));
+}
+
+export const navigationAddConfigs = (configs: IFetchConfig|IFetchConfig[]) => (dispatch, getState, components) => {
+    configs = normalizeConfigs(configs) as IFetchConfig[];
+    if (configs.length > 0) {
+        dispatch({
+            type: ROUTER_ADD_CONFIGS,
+            configs
+        });
+        configs.forEach(config => fetchByConfig(config, dispatch, components));
+    }
+};
+
+export const navigationRefresh = (ids: string[]) => (dispatch, getState, components) => {
+    (getState().router?.configs || [])
+        .filter(config => !ids || ids.includes(config.id))
+        .forEach(config => fetchByConfig(config, dispatch, components));
+};
+
+export const navigationRemoveConfigs = configs => {
+    configs = normalizeConfigs(configs);
+    if (configs.length > 0) {
+        return {
+            type: ROUTER_REMOVE_CONFIGS,
+            configs
+        };
+    }
+};

package/actions/screen.ts

@@ -0,0 +1,28 @@
+export const SCREEN_SET_WIDTH = 'SCREEN_SET_WIDTH';
+export const SCREEN_SET_MEDIA = 'SCREEN_SET_MEDIA';
+
+export const setMedia = media => ({
+    type: SCREEN_SET_MEDIA,
+    media
+});
+
+let timer = null;
+export const setWidth = (width, skipTimeout = false) => dispatch => {
+    if (timer) {
+        clearTimeout(timer);
+    }
+    if (skipTimeout) {
+        return dispatch({
+            type: SCREEN_SET_WIDTH,
+            width
+        });
+    } else {
+        timer = setTimeout(() => {
+            dispatch({
+                type: SCREEN_SET_WIDTH,
+                width
+            });
+        }, 100);
+    }
+    return null;
+};

package/base/Enum.ts

@@ -0,0 +1,28 @@
+export default class Enum {
+    static getLabels() {
+        return {};
+    }
+
+    static getKeys() {
+        return Object.keys(this.getLabels());
+    }
+
+    static getLabel(id) {
+        return this.getLabels()[id] || '';
+    }
+
+    static getCssClasses() {
+        return {};
+    }
+
+    static getCssClass(id) {
+        return this.getCssClasses()[id] || '';
+    }
+
+    static getDropdownItems() {
+        return Object.entries(this.getLabels()).map(([id, label]) => ({
+            label,
+            id
+        }));
+    }
+}