@steroidsjs/core 2.2.75 → 2.2.78

package/src/components/StoreComponent.ts

@@ -1,197 +0,0 @@
-import {createStore, applyMiddleware, compose} from 'redux';
-import {routerMiddleware, connectRouter} from 'connected-react-router';
-import {
-    createBrowserHistory,
-    createMemoryHistory,
-    createHashHistory,
-} from 'history';
-import _get from 'lodash-es/get';
-import _merge from 'lodash-es/merge';
-import _isPlainObject from 'lodash-es/isPlainObject';
-
-declare global {
-    interface Window {
-        APP_REDUX_PRELOAD_STATES?: any;
-        __REDUX_DEVTOOLS_EXTENSION__?: any;
-    }
-}
-
-interface IStoreComponentConfig {
-    initialState: any,
-    history: any,
-}
-
-/**
- * Store Component
- * Обертка над Redux Store со встроенными middleware (thunk, multi, promise..) и react-router
- */
-export default class StoreComponent {
-    _asyncReducers: any;
-
-    _components: any;
-
-    reducers: any;
-
-    _routerReducer: any;
-
-    history: any;
-
-    navigationNative: any;
-
-    store: any;
-
-    lastAction: string;
-
-    constructor(components, config, lazyInit = false) {
-        this._components = components;
-
-        this.reducers = config.reducers;
-
-        this.history = null;
-        this.store = config.store || null;
-        this.lastAction = null;
-        this._asyncReducers = {};
-
-        this.getState = this.getState.bind(this);
-        this.dispatch = this.dispatch.bind(this);
-        this.subscribe = this.subscribe.bind(this);
-
-        if (!lazyInit) {
-            this.initStore(config);
-        }
-    }
-
-    init(config = {} as IStoreComponentConfig) {
-        this.initStore(config);
-        this.configurate();
-    }
-
-    initStore(config = {} as IStoreComponentConfig) {
-        const initialState = {
-            ...(process.env.IS_WEB
-                ? _merge(...(window.APP_REDUX_PRELOAD_STATES || [{}]))
-                : {}),
-            ...config.initialState,
-        };
-
-        if (window?.APP_REDUX_PRELOAD_STATES) {
-            delete window.APP_REDUX_PRELOAD_STATES;
-        }
-
-        if (process.env.PLATFORM !== 'mobile') {
-            const createHistory: any = process.env.IS_SSR || typeof location === 'undefined'
-                ? createMemoryHistory
-                : location.protocol === 'file:'
-                    ? createHashHistory
-                    : createBrowserHistory;
-            this.history = createHistory({
-                ..._get(initialState, 'config.store.history', {}),
-                ...config.history,
-            });
-
-            // Add '?' for fix connected-react-router
-            if (process.env.IS_SSR && !this.history.location.search) {
-                this.history.location.search = '?';
-            }
-            this._routerReducer = connectRouter(this.history);
-        }
-
-        if (!this.store) {
-            this.store = createStore(
-                this.reducers(
-                    this._routerReducer ? {
-                        router: this._routerReducer,
-                    } : {},
-                ),
-                initialState,
-                compose(
-                    applyMiddleware(({getState}) => next => action => this._prepare(action, next, getState)),
-                    applyMiddleware(routerMiddleware(this.history)),
-                    !process.env.IS_SSR && window.__REDUX_DEVTOOLS_EXTENSION__ && process.env.PLATFORM !== 'mobile'
-                        ? window.__REDUX_DEVTOOLS_EXTENSION__()
-                        : f => f,
-                ),
-            );
-        }
-    }
-
-    configurate() {
-        // Apply configuration
-        const customConfig = this.getState().config || {};
-        const components = this._components;
-        _merge(components.clientStorage, customConfig.clientStorage);
-        _merge(components.html, customConfig.html);
-        _merge(components.http, customConfig.http);
-        _merge(components.locale, customConfig.locale);
-        _merge(components.resource, customConfig.resource);
-        _merge(components.store, customConfig.store);
-        _merge(components.ui, customConfig.ui);
-        _merge(components.widget, customConfig.widget);
-    }
-
-    dispatch(action) {
-        return this.store.dispatch(action);
-    }
-
-    getState() {
-        return this.store.getState();
-    }
-
-    subscribe(handler) {
-        return this.store.subscribe(handler);
-    }
-
-    addReducers(asyncReducers) {
-        this._asyncReducers = {
-            router: this._routerReducer,
-            ...this._asyncReducers,
-            ...asyncReducers,
-        };
-        this.store.replaceReducer(this.reducers(this._asyncReducers));
-    }
-
-    errorHandler(error, action) {
-        throw error;
-    }
-
-    _prepare(action, dispatch, getState) {
-        // Multiple dispatch (redux-multi)
-        if (Array.isArray(action)) {
-            return action
-                .filter(v => v)
-                .map(p => this._prepare(p, dispatch, getState));
-        }
-        // Function wraper (redux-thunk)
-        if (typeof action === 'function') {
-            return action(
-                p => this._prepare(p, dispatch, getState),
-                getState,
-                this._components,
-            );
-        }
-        // Promise, detect errors on rejects
-        // Detect action through instanceof Promise is not working in production mode, then used single detection by type
-        if (
-            typeof action === 'object'
-            && typeof action.then === 'function'
-            && typeof action.catch === 'function'
-        ) {
-            return action
-                .then(payload => this._prepare(payload, dispatch, getState))
-                .catch(e => {
-                    this.errorHandler(e, p => this._prepare(p, dispatch, getState));
-                });
-        }
-        // Default case
-        if (_isPlainObject(action) && action.type) {
-            this.lastAction = action.type;
-
-            try {
-                return dispatch(action);
-            } catch (e) {
-                this.errorHandler(e, p => this._prepare(p, dispatch, getState));
-            }
-        }
-        return action;
-    }
-}

package/src/components/UiComponent.ts

@@ -1,177 +0,0 @@
-import * as React from 'react';
-
-import _isFunction from 'lodash-es/isFunction';
-import _isObject from 'lodash-es/isObject';
-import _isString from 'lodash-es/isString';
-import {ReactNode} from 'react';
-import {IComponents} from '../providers/ComponentsProvider';
-
-/**
- * Ui Component
- * Компонент для подгрузки и конфигурации UI компонентов приложения
- */
-export default class UiComponent {
-    components: IComponents;
-
-    _components: any;
-
-    _models: any;
-
-    icons: { [name: string]: string | number | ReactNode } | any;
-
-    fields: any;
-
-    formatters: any;
-
-    _registeredFields: any;
-
-    _portalElement: HTMLDivElement;
-
-    constructor(components) {
-        this.components = components;
-        this.icons = {};
-        this.fields = {};
-        this.formatters = {};
-        this._components = {};
-        this._models = {};
-        this._registeredFields = {};
-        this._portalElement = null;
-    }
-
-    addViews(components) {
-        this._add('views', components);
-    }
-
-    renderView(Component, props, forceNode = false) {
-        if (_isString(Component)) {
-            Component = this._getComponent('views', Component);
-        }
-        if (!forceNode && _isFunction(Component)) {
-            if (Component.defaultProps) {
-                return Component({...Component.defaultProps, ...props});
-            }
-            return Component(props);
-        }
-        return React.createElement(Component, props);
-    }
-
-    getView(path) {
-        return this._getComponent('views', path);
-    }
-
-    addFields(components) {
-        this._add('fields', components, 'form');
-    }
-
-    getField(path) {
-        return this._getComponent('fields', path);
-    }
-
-    getFieldProps(path, model = null, attribute = null) {
-        return {
-            ...this._getPropsConfig('fields', path),
-            ...this.components.meta.getModel(model)?.attributes?.[attribute],
-        };
-    }
-
-    addFormatters(components) {
-        this._add('formatters', components, 'format');
-    }
-
-    getFormatter(path) {
-        return this._getComponent('formatters', path);
-    }
-
-    getFormatterProps(path) {
-        return this._getPropsConfig('formatters', path);
-    }
-
-    addIcons(icons) {
-        this.icons = icons;
-    }
-
-    getIcon(name) {
-        if (_isFunction(this.icons)) {
-            this.icons = this.icons();
-        }
-        return this.icons?.[name] || null;
-    }
-
-    addModels(models) {
-        this._models = {...this._models, ...models};
-    }
-
-    /*getModel(name) {
-        if (_isString(name)) {
-            name = name.replace(/\\/g, '.').replace(/^\./, '');
-
-            const model = this._models[name] || null;
-            if (!model) {
-                console.warn('Steroids: Not found model meta:', name); // eslint-disable-line no-console
-            }
-            return model;
-        }
-        return name || null;
-    }*/
-
-    registerField(formId, attribute, type) {
-        if (!this._registeredFields[formId]) {
-            this._registeredFields[formId] = {};
-        }
-        this._registeredFields[formId][attribute] = type;
-    }
-
-    getRegisteredFields(formId) {
-        return this._registeredFields[formId] || null;
-    }
-
-    _add(group, items, defaultNamespace = null) {
-        // require.context()
-        if (_isFunction(items) && _isFunction(items.keys)) {
-            items.keys().forEach(fileName => {
-                const matches = fileName.match(/^\.\/(.*\/)?[^\\/]+\/([^\\/]+)\.(js|ts)x?$/);
-                if (matches) {
-                    const path = (matches[1] || '').replace(/\//g, '.') + matches[2];
-                    this._components[group] = this._components[group] || {};
-                    this._components[group][path] = items(fileName).default;
-                }
-            });
-        } else if (_isObject(items)) {
-            // object
-            this._components[group] = this._components[group] || {};
-            Object.keys(items).forEach(key => {
-                const name = key.indexOf('.') === -1 && defaultNamespace
-                    ? `${defaultNamespace}.${key}`
-                    : key;
-                this._components[group][name] = items[key];
-            });
-        } else {
-            throw new Error(`Unsupported ${group} format for add component.`);
-        }
-    }
-
-    _getComponent(group, path) {
-        if (!this._components[group] || !this._components[group][path]) {
-            throw new Error(`Not found '${group}' by path '${path}'.`);
-        }
-
-        // Lazy load component
-        if (_isObject(this._components[group][path]) && this._components[group][path].lazy) {
-            this._components[group][path] = this._components[group][path].lazy();
-        }
-
-        return this._components[group][path];
-    }
-
-    _getPropsConfig(group, path) {
-        return (this[group] && this[group][path]) || null;
-    }
-
-    setPortalElement(element) {
-        this._portalElement = element;
-    }
-
-    getPortalElement() {
-        return this._portalElement;
-    }
-}

package/src/components/WebSocketComponent.ts

@@ -1,232 +0,0 @@
-/**
- * Web Socket Component
- * Компонент, обеспечивающий постоянное web-socket соединение с сервером. Поддерживает подписку на каналы, обработку
- * ответов и токен авторизации
- */
-import {IComponents} from '../providers/ComponentsProvider';
-
-const getStreamName = stream => Array.isArray(stream) ? stream[0] : stream;
-
-export default class WebSocketComponent {
-    wsUrl: string;
-
-    streams: string[] | [string, string|number[]][];
-
-    authHandler: (components: IComponents) => Promise<string>;
-
-    onOpen: (event: any, components: IComponents) => any;
-
-    onClose: (event: any, components: IComponents) => any;
-
-    onMessage: (data: Record<string, unknown>, components: IComponents) => any;
-
-    _components: IComponents;
-
-    _connection: any;
-
-    _tryCount: any;
-
-    _authToken: any;
-
-    REASON_CODE_UNAUTHORIZED: number;
-
-    constructor(components, config) {
-        this.wsUrl = config.wsUrl || null;
-        this.streams = config.streams || ['*'];
-        this.authHandler = config.authHandler || null;
-        this.onOpen = config.onOpen || null;
-        this.onClose = config.onClose || null;
-        this.onMessage = config.onMessage || null;
-
-        this._components = components;
-        this._connection = null;
-        this._tryCount = null;
-        this._authToken = null;
-
-        this._connect = this._connect.bind(this);
-        this._onOpen = this._onOpen.bind(this);
-        this._onMessage = this._onMessage.bind(this);
-        this._onClose = this._onClose.bind(this);
-
-        this.REASON_CODE_UNAUTHORIZED = 4401;
-    }
-
-    open(closePrevious = false) {
-        if (closePrevious) {
-            this.close();
-        }
-        if (!this._connection) {
-            this._connect();
-        }
-    }
-
-    close() {
-        if (this._connection) {
-            this._connection.close();
-            this._connection = null;
-        }
-    }
-
-    subscribeStream(stream, id) {
-        if (id) {
-            this.subscribe([[stream, [id]]]);
-        } else {
-            this.subscribe([stream]);
-        }
-    }
-
-    subscribe(streams) {
-        if (!this._connection) {
-            return;
-        }
-        streams = [].concat(streams);
-
-        // Стримы для подписки
-        const forSubscribe = [];
-        streams.forEach(stream => {
-            // Если стримов нет, то сразу добавляем
-            if (this.streams.length === 0) {
-                this.streams.push(stream);
-                forSubscribe.push(stream);
-                return;
-            }
-
-            const name = getStreamName(stream);
-            // Перебираем текущие стримы
-            this.streams.forEach((clientStream, index, clientStreams) => {
-                // Если текущий стрим и запрашиваемый вида [streamName, [ids...]]
-                // то из запрашиваемых id выбираем те, на которые не подписаны,
-                // формируем новый стрим с нужными id, добавляем с список для дальнейшей подписки
-                if (getStreamName(clientStream) === name && Array.isArray(clientStream)
-                    && Array.isArray(stream)
-                ) {
-                    const idsForSubscribe = stream[1].filter(id => !clientStream.includes(id));
-                    forSubscribe.push([name, idsForSubscribe]);
-                    // К текущим стримам добавлем недостающие id
-                    clientStreams[index][1] = clientStreams[index][1].concat(idsForSubscribe);
-                } else {
-                    forSubscribe.push(stream);
-                }
-            });
-        });
-
-        // Если есть стримы, на которые нужно подписаться, шлем серверу
-        if (forSubscribe.length > 0) {
-            this._connection.send(JSON.stringify({
-                action: 'subscribe',
-                data: forSubscribe,
-            }));
-        }
-    }
-
-    unsubscribeStream(stream, id) {
-        this.unsubscribe(id ? [[stream, [id]]] : [stream]);
-    }
-
-    unsubscribe(streams) {
-        if (!this._connection || this.streams.length === 0) {
-            return;
-        }
-        streams = [].concat(streams);
-
-        // Стримы для отписки
-        const forUnsubscribe = [];
-        this.streams.forEach((clientStream, index, clientStreams) => {
-            const name = getStreamName(clientStream);
-            streams.forEach(stream => {
-                if (getStreamName(stream) === name) {
-                    // Если подписаны на стрим вида 'stream', а запрос на отписку
-                    // виду ['stream', [ids...]], ничего не делаем
-                    if (typeof clientStream === 'string' && Array.isArray(stream)) {
-                        return;
-                    }
-
-                    // Если обычный стрим, добавляем в список для отписки и удаляем из своего списка
-                    if (typeof stream === 'string') {
-                        forUnsubscribe.push(clientStream);
-                        clientStreams.splice(index, 1);
-
-                        // Если стримы вида ['stream', [ids...]], находим из запрашиваемых выбираем ids,
-                        // на которые уже подписаны
-                        // Формируем новый стрим и добавляем в список для дальнейшей отписки
-                        // Удаляем эти ids из текущего списка
-                    } else if (Array.isArray(stream) && Array.isArray(clientStream)) {
-                        const idsForUnsubscribe = stream[1].filter(streamId => clientStream[1].includes(streamId));
-                        forUnsubscribe.push([name, idsForUnsubscribe]);
-                        clientStreams[index][1] = clientStreams[index][1].filter(id => !idsForUnsubscribe.includes(id));
-                        // Если удалили все ids, то удаляем стрим целиком
-                        if (clientStreams[index][1].length === 0) {
-                            clientStreams.splice(index, 1);
-                        }
-                    }
-                }
-            });
-        });
-
-        // Если есть стримы, от которых нужно отписаться, шлем серверу
-        if (forUnsubscribe.length > 0) {
-            this._connection.send(JSON.stringify({
-                action: 'unsubscribe',
-                data: forUnsubscribe,
-            }));
-        }
-    }
-
-    async _connect() {
-        if (!this._authToken) {
-            const token = await this.authHandler(this._components);
-            if (token) {
-                this._authToken = token;
-                this._connect();
-            }
-        } else if (this.streams) {
-            this._connection = new WebSocket(
-                this.wsUrl + '?streams=' + this.streams.join(',') + '&token=' + this._authToken,
-            );
-            this._connection.onopen = this._onOpen;
-            this._connection.onmessage = this._onMessage;
-            this._connection.onclose = this._onClose;
-        }
-    }
-
-    _reConnect() {
-        let delay = 1000;
-        if (this._tryCount > 10) {
-            delay = 2000;
-        }
-        if (this._tryCount > 50) {
-            delay = 5000;
-        }
-        if (this._tryCount > 100) {
-            delay = 15000;
-        }
-
-        this._tryCount += 1;
-        setTimeout(this._connect, delay);
-    }
-
-    _onOpen(event) {
-        this._tryCount = 0;
-
-        if (this.onOpen) {
-            this.onOpen(event, this._components);
-        }
-    }
-
-    _onMessage(message) {
-        if (this.onMessage) {
-            this.onMessage(JSON.parse(message.data), this._components);
-        }
-    }
-
-    _onClose(event) {
-        if (this.onClose) {
-            this.onClose(event, this._components);
-        }
-
-        if (event.code === this.REASON_CODE_UNAUTHORIZED) {
-            this._authToken = null;
-        }
-        this._reConnect();
-    }
-}

package/src/components/social/FacebookProvider.ts

@@ -1,56 +0,0 @@
-export default class FacebookProvider {
-    _components: any;
-
-    clientId: string;
-
-    language: string;
-
-    constructor(components, config) {
-        this._components = components;
-        this.clientId = config.clientId || '';
-        this.language = this._components.locale.language
-            + '_'
-            + this._components.locale.language.toUpperCase();
-    }
-
-    async init() {
-        // @ts-ignore
-        window.fbAsyncInit = () => {
-            // @ts-ignore
-            window.FB.init({
-                version: 'v3.1',
-                appId: this.clientId,
-                xfbml: false,
-                cookie: false,
-            });
-        };
-        return this._components.resource.loadScript(
-            `https://connect.facebook.net/${this.language}/sdk.js`,
-            null,
-            // @ts-ignore
-            () => this._components.resource.wait(() => window.FB),
-        );
-    }
-
-    async start() {
-        return new Promise((resolve, reject) => {
-            // @ts-ignore
-            window.FB.login(
-                response => {
-                    if (response.authResponse) {
-                        resolve({
-                            token: response.authResponse.accessToken,
-                        });
-                    } else {
-                        reject('FB error: ' + response.status);
-                    }
-                },
-                {
-                    scope: 'public_profile,email',
-                    return_scopes: false,
-                    auth_type: '',
-                },
-            );
-        });
-    }
-}