@steroidsjs/core 2.3.0-beta.5 → 2.3.0-beta.7

package/components/LocaleComponent.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var React = __importStar(require("react"));
+var intl_messageformat_1 = __importDefault(require("intl-messageformat"));
+var moment_1 = __importDefault(require("moment"));
+var isObject_1 = __importDefault(require("lodash-es/isObject"));
+require("moment/locale/it");
+require("moment/locale/ru");
+/**
+ * Locale Component
+ * Компонент для локализации приложения. Поддерживает конфигурацию языка и временной зоны
+ *
+ * Пример строки: `{__('{count} {count, plural, one{день} few{дня} many{дней}}', {count: 2})}`
+ */
+var LocaleComponent = /** @class */ (function () {
+    function LocaleComponent(components, config) {
+        this.language = config.language || 'en';
+        this.sourceLanguage = config.sourceLanguage || 'ru';
+        this.backendTimeZone = null;
+        this.backendTimeDiff = null; // in microseconds
+        this.translations = {};
+        // Publish to global
+        if (process.env.IS_SSR) {
+            // @ts-ignore
+            global.__ = this.translate.bind(this);
+        }
+        else {
+            window.__ = this.translate.bind(this);
+        }
+    }
+    /**
+     * Получение экземпляра `moment` с учетом временной зоны бекенда
+     * @param date Дата
+     * @param format Формат
+     */
+    LocaleComponent.prototype.moment = function (date, format) {
+        if (date === void 0) { date = undefined; }
+        if (format === void 0) { format = undefined; }
+        if (date && this.backendTimeZone) {
+            if (date.length === 16
+                && moment_1["default"](date, 'YYYY-MM-DD HH:mm').isValid()) {
+                date += ':00';
+            }
+            if (date.length === 19
+                && moment_1["default"](date, 'YYYY-MM-DD HH:mm:ss').isValid()) {
+                date += this.backendTimeZone;
+            }
+        }
+        return moment_1["default"](date, format).locale(this.language);
+    };
+    LocaleComponent.prototype.t = function (message, params) {
+        if (params === void 0) { params = {}; }
+        return this.translate(message, params);
+    };
+    LocaleComponent.prototype.translate = function (message, params) {
+        if (params === void 0) { params = {}; }
+        // Translate
+        var hasTranslate = !!this.translations[message];
+        message = this.translations[message] || message;
+        // Cut react components
+        var components = {};
+        Object.keys(params).map(function (key) {
+            if (isObject_1["default"](params[key])) {
+                components[key] = params[key];
+                params[key] = "!!" + key + "!!";
+            }
+        });
+        // Format message (params, plural, etc..)
+        var language = hasTranslate ? this.language : this.sourceLanguage;
+        var formatter = new intl_messageformat_1["default"](message, language);
+        message = formatter.format(params);
+        // Paste react components
+        message = this._pasteComponents(message, components);
+        return message;
+    };
+    LocaleComponent.prototype._pasteComponents = function (message, components) {
+        if (Object.keys(components).length === 0) {
+            return message;
+        }
+        // Index components
+        var indexedComponents = [];
+        Object.keys(components).map(function (key) {
+            var index = message.indexOf("!!" + key + "!!");
+            if (index !== -1) {
+                indexedComponents.push({
+                    index: index,
+                    component: components[key]
+                });
+            }
+            message = message.replace("!!" + key + "!!", '!!component!!');
+        });
+        indexedComponents.sort(function (a, b) {
+            if (a.index < b.index) {
+                return -1;
+            }
+            if (a.index > b.index) {
+                return 1;
+            }
+            return 0;
+        });
+        // Split text to array, paste components
+        var result = [];
+        var textParts = message.split('!!component!!');
+        for (var i = 0, j = 0; i < textParts.length; i++) {
+            var isComponentAdded = false;
+            if (j === 0
+                && j < indexedComponents.length
+                && indexedComponents[j].index === 0) {
+                result.push(React.createElement("span", { key: "element-" + j }, indexedComponents[j].component));
+                isComponentAdded = true;
+                j++;
+            }
+            result.push(React.createElement("span", { key: "text-" + i }, textParts[i]));
+            if (!isComponentAdded && j < indexedComponents.length) {
+                result.push(React.createElement("span", { key: "element" + j }, indexedComponents[j].component));
+                j++;
+            }
+        }
+        return React.createElement("span", null, result);
+    };
+    return LocaleComponent;
+}());
+exports["default"] = LocaleComponent;

package/components/MetaComponent.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Мета информация о моделе
+ */
+export interface Model {
+    primaryKey?: string;
+    attributes?: (string | ModelAttribute)[];
+}
+export interface ModelAttribute {
+    type?: 'autoTime' | 'boolean' | 'dateTime' | 'date' | 'double' | 'email' | 'enum' | 'file' | 'files' | 'html' | 'integer' | 'money' | 'password' | 'phone' | 'primaryKey' | 'size' | 'string' | 'text' | 'time' | string;
+    jsType?: 'boolean' | 'string' | 'string[]' | 'number' | 'number[]' | string;
+    attribute?: string;
+    label?: string;
+    hint?: string;
+    isRequired?: boolean;
+    isSortable?: boolean;
+    field?: string | any;
+    fieldProps?: Record<string, unknown>;
+    searchField?: string | any;
+    searchFieldProps?: Record<string, unknown>;
+    formatter?: string | any;
+    formatterProps?: Record<string, unknown>;
+    defaultValue?: any;
+    fromStringConverter?: (value: string, type: string, item: any) => any;
+    toStringConverter?: (value: any, type: string, item: any) => string | null;
+}
+/**
+ * Meta Component
+ * Компонент для работы с мета-данными моделей и типами приложения (appType)
+ */
+export default class MetaComponent {
+    defaultPrimaryKey: string;
+    defaultAttributeType: string;
+    models: any;
+    types: any;
+    _components: any;
+    constructor(components: any);
+    setModel(name: string, item: Model): void;
+    getModel(name: string): any;
+    setType(name: any, config: any): void;
+    getType(name: string): any;
+    normalizeName(name: any): any;
+    normalizeModel(inputModel: Model, defaultModel?: Model | any): {
+        primaryKey: any;
+        attributes: any[];
+    };
+    _defaultTypes(): {
+        autoTime: {
+            jsType: string;
+            field: string;
+            formatter: string;
+        };
+        boolean: {
+            jsType: string;
+            field: string;
+            formatter: string;
+        };
+        dateTime: {
+            jsType: string;
+            field: string;
+            formatter: string;
+        };
+        date: {
+            jsType: string;
+            field: string;
+            formatter: string;
+        };
+        double: {
+            jsType: string;
+            field: string;
+        };
+        email: {
+            jsType: string;
+            field: string;
+            fieldProps: {
+                type: string;
+            };
+        };
+        enum: {
+            jsType: string;
+            field: string;
+            formatter: string;
+        };
+        file: {
+            jsType: string;
+            field: string;
+        };
+        files: {
+            jsType: string;
+            field: string;
+            fieldProps: {
+                multiple: boolean;
+            };
+        };
+        html: {
+            jsType: string;
+            field: string;
+        };
+        integer: {
+            jsType: string;
+            field: string;
+        };
+        password: {
+            jsType: string;
+            field: string;
+        };
+        phone: {
+            jsType: string;
+            field: string;
+            fieldProps: {
+                type: string;
+            };
+        };
+        primaryKey: {
+            jsType: string;
+            field: string;
+            fieldProps: {
+                type: string;
+            };
+            searchFieldProps: {
+                type: string;
+            };
+        };
+        string: {
+            jsType: string;
+            field: string;
+        };
+        text: {
+            jsType: string;
+            field: string;
+        };
+        time: {
+            jsType: string;
+            field: string;
+        };
+    };
+}

package/components/MetaComponent.js

@@ -0,0 +1,175 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+/**
+ * Meta Component
+ * Компонент для работы с мета-данными моделей и типами приложения (appType)
+ */
+var MetaComponent = /** @class */ (function () {
+    function MetaComponent(components) {
+        this._components = components;
+        this.models = {};
+        this.types = this._defaultTypes();
+        this.defaultPrimaryKey = 'id';
+        this.defaultAttributeType = 'string';
+    }
+    MetaComponent.prototype.setModel = function (name, item) {
+        name = this.normalizeName(name);
+        item = this.normalizeModel(item);
+        this.models[name] = item;
+    };
+    MetaComponent.prototype.getModel = function (name) {
+        return this.models[name] || null;
+    };
+    MetaComponent.prototype.setType = function (name, config) {
+        this.types[name] = config;
+    };
+    MetaComponent.prototype.getType = function (name) {
+        return this.types[name] || null;
+    };
+    MetaComponent.prototype.normalizeName = function (name) {
+        return name.replace(/\\/g, '.').replace(/^\./, '');
+    };
+    MetaComponent.prototype.normalizeModel = function (inputModel, defaultModel) {
+        var _this = this;
+        if (defaultModel === void 0) { defaultModel = null; }
+        if (!inputModel && !defaultModel) {
+            return null;
+        }
+        inputModel = inputModel || {};
+        defaultModel = defaultModel ? this.normalizeModel(defaultModel) : {};
+        var defaults = {};
+        (defaultModel.attributes || []).forEach(function (item) {
+            if (typeof item !== 'string') {
+                defaults[item.attribute] = item;
+            }
+        });
+        // Normalize attributes config
+        var attributes = [].concat(inputModel.attributes || []).map(function (item) {
+            if (typeof item === 'string') {
+                var parts = item.split(':');
+                item = {
+                    attribute: parts[0],
+                    type: parts[1] || null,
+                    label: parts[2] || null
+                };
+            }
+            return __assign(__assign(__assign({ type: _this.defaultAttributeType, attribute: null, label: null, hint: null, isRequired: false, isSortable: false }, defaults[item.attribute]), _this.getType(item.type || _this.defaultAttributeType)), item);
+        });
+        // Add non-exists default attributes
+        var attributeNames = attributes.map(function (item) { return item.attribute; });
+        (defaultModel.attributes || []).forEach(function (item) {
+            if (typeof item !== 'string' && !attributeNames.includes(item.attribute)) {
+                attributes.push(item);
+            }
+        });
+        return {
+            primaryKey: inputModel.primaryKey || defaultModel.primaryKey || this.defaultPrimaryKey,
+            attributes: attributes
+        };
+    };
+    MetaComponent.prototype._defaultTypes = function () {
+        return {
+            autoTime: {
+                jsType: 'string',
+                field: 'DateTimeField',
+                formatter: 'DateTimeFormatter'
+            },
+            boolean: {
+                jsType: 'boolean',
+                field: 'CheckboxField',
+                formatter: 'BooleanFormatter'
+            },
+            dateTime: {
+                jsType: 'string',
+                field: 'DateTimeField',
+                formatter: 'DateTimeFormatter'
+            },
+            date: {
+                jsType: 'string',
+                field: 'DateField',
+                formatter: 'DateFormatter'
+            },
+            double: {
+                jsType: 'number',
+                field: 'NumberField'
+            },
+            email: {
+                jsType: 'string',
+                field: 'InputField',
+                fieldProps: {
+                    type: 'email'
+                }
+            },
+            "enum": {
+                jsType: 'string',
+                field: 'DropDownField',
+                formatter: 'EnumFormatter'
+            },
+            file: {
+                jsType: 'number',
+                field: 'FileField'
+            },
+            files: {
+                jsType: 'number[]',
+                field: 'FileField',
+                fieldProps: {
+                    multiple: true
+                }
+            },
+            html: {
+                jsType: 'string',
+                field: 'HtmlField'
+            },
+            integer: {
+                jsType: 'number',
+                field: 'NumberField'
+            },
+            password: {
+                jsType: 'string',
+                field: 'PasswordField'
+            },
+            phone: {
+                jsType: 'string',
+                field: 'InputField',
+                fieldProps: {
+                    type: 'phone'
+                }
+            },
+            primaryKey: {
+                jsType: 'number',
+                field: 'InputField',
+                fieldProps: {
+                    type: 'hidden'
+                },
+                searchFieldProps: {
+                    type: 'text'
+                }
+            },
+            string: {
+                jsType: 'string',
+                field: 'InputField'
+            },
+            text: {
+                jsType: 'string',
+                field: 'TextField'
+            },
+            time: {
+                jsType: 'string',
+                field: 'TimeField'
+            }
+        };
+    };
+    return MetaComponent;
+}());
+exports["default"] = MetaComponent;

package/components/MetricsComponent.d.ts

@@ -0,0 +1,39 @@
+declare global {
+    interface Window {
+        ym: any;
+        dataLayer: any;
+        VK: any;
+        fbq: any;
+        _fbq: any;
+    }
+}
+declare type ConfigType = {
+    counters?: {
+        yandexMetrika?: any;
+        googleTagManager?: any;
+        googleAnalytics?: any;
+        vkRetargeting?: any;
+        facebookAnalytics?: any;
+    };
+    enable?: boolean;
+};
+export default class MetricsComponent {
+    _components: any;
+    _prevUrl: string;
+    _isMetricsInitialized: boolean;
+    _config: any;
+    _enable: boolean;
+    _yandexMetrika: any;
+    unsubscribe: () => void;
+    unlisten: () => void;
+    constructor(components: any, config?: ConfigType);
+    _init(): void;
+    setCounters(values: any): void;
+    _setYandexMetrika(value: any): void;
+    _setGoogleTagManager(value: any): void;
+    _setGoogleAnalytics(value: any): void;
+    _setVkRetargeting(value: any): void;
+    _setFacebookAnalytics(value: any): void;
+    _changePageViewHandler(url: any): void;
+}
+export {};

package/components/MetricsComponent.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var upperFirst_1 = __importDefault(require("lodash-es/upperFirst"));
+var isEmpty_1 = __importDefault(require("lodash-es/isEmpty"));
+var auth_1 = require("../reducers/auth");
+var MetricsComponent = /** @class */ (function () {
+    function MetricsComponent(components, config) {
+        if (config === void 0) { config = {}; }
+        this._components = components;
+        this._isMetricsInitialized = false;
+        this._config = config;
+        this._enable = config.enable === undefined
+            ? process.env.APP_ENV === 'prod'
+            : !!config.enable;
+        if (!process.env.IS_SSR) {
+            this._init();
+        }
+    }
+    MetricsComponent.prototype._init = function () {
+        var _this = this;
+        this.unsubscribe = this._components.store.subscribe(function () {
+            var store = _this._components.store;
+            var state = store.getState();
+            if (!auth_1.isInitialized(state)) {
+                return;
+            }
+            _this.unsubscribe();
+            _this.setCounters(_this._config.counters);
+            if (_this._enable && _this._yandexMetrika) {
+                _this.unlisten = store.history.listen(function (_a) {
+                    var pathname = _a.pathname, search = _a.search, hash = _a.hash;
+                    _this._changePageViewHandler(pathname + search + hash);
+                });
+            }
+        });
+    };
+    MetricsComponent.prototype.setCounters = function (values) {
+        var _this = this;
+        if (!this._enable || isEmpty_1["default"](values) || this._isMetricsInitialized) {
+            return;
+        }
+        Object.entries(values).forEach(function (_a) {
+            var counterName = _a[0], counterValue = _a[1];
+            if (counterValue) {
+                _this._isMetricsInitialized = true;
+                _this['_' + counterName] = counterValue;
+                var setter = '_set' + upperFirst_1["default"](counterName);
+                _this[setter](counterValue);
+            }
+        });
+    };
+    MetricsComponent.prototype._setYandexMetrika = function (value) {
+        (function (m, e, t, r, i, k, a) {
+            m[i] = m[i] || function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                (m[i].a = m[i].a || []).push(args);
+            };
+            m[i].l = Date.now();
+            k = e.createElement(t);
+            a = e.getElementsByTagName(t)[0];
+            k.async = 1;
+            k.src = r;
+            a.parentNode.insertBefore(k, a);
+        }(window, document, 'script', 'https://mc.yandex.ru/metrika/tag.js', 'ym'));
+        window.ym(value, 'init', {
+            defer: true,
+            clickmap: true,
+            trackLinks: true,
+            accurateTrackBounce: true,
+            webvisor: true
+        });
+    };
+    MetricsComponent.prototype._setGoogleTagManager = function (value) {
+        (function (w, d, s, l, i) {
+            w[l] = w[l] || [];
+            w[l].push({
+                'gtm.start': new Date().getTime(), event: 'gtm.js'
+            });
+            var f = d.getElementsByTagName(s)[0];
+            var j = d.createElement(s);
+            var dl = l !== 'dataLayer' ? '&l=' + l : '';
+            j.async = true;
+            j.src = 'https://www.googletagmanager.com/gtm.js?id=' + i + dl;
+            f.parentNode.insertBefore(j, f);
+        }(window, document, 'script', 'dataLayer', value));
+    };
+    MetricsComponent.prototype._setGoogleAnalytics = function (value) {
+        var googleLoad = document.createElement('script');
+        googleLoad.async = true;
+        googleLoad.src = "https://www.googletagmanager.com/gtag/js?id=" + value;
+        document.body.appendChild(googleLoad);
+        window.dataLayer = window.dataLayer || [];
+        function gtag() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            window.dataLayer.push(args);
+        }
+        gtag('js', new Date());
+        gtag('config', value);
+    };
+    MetricsComponent.prototype._setVkRetargeting = function (value) {
+        var t = document.createElement('script');
+        t.type = 'text/javascript';
+        t.async = !0;
+        t.src = 'https://vk.com/js/api/openapi.js?168';
+        t.onload = function () {
+            window.VK.Retargeting.Init(value);
+            window.VK.Retargeting.Hit();
+        };
+        document.head.appendChild(t);
+    };
+    MetricsComponent.prototype._setFacebookAnalytics = function (value) {
+        (function (f, b, e, v, n, t, s) {
+            if (f.fbq) {
+                return;
+            }
+            n = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                // eslint-disable-next-line no-unused-expressions
+                n.callMethod ? n.callMethod.apply(n, args) : n.queue.push(args);
+            };
+            f.fbq = n;
+            if (!f._fbq) {
+                f._fbq = n;
+            }
+            n.push = n;
+            n.loaded = !0;
+            n.version = '2.0';
+            n.queue = [];
+            t = b.createElement(e);
+            t.async = !0;
+            t.src = v;
+            s = b.getElementsByTagName(e)[0];
+            s.parentNode.insertBefore(t, s);
+        }(window, document, 'script', 'https://connect.facebook.net/en_US/fbevents.js'));
+        window.fbq('init', value);
+        window.fbq('track', 'PageView');
+    };
+    MetricsComponent.prototype._changePageViewHandler = function (url) {
+        if (this._prevUrl !== url) {
+            window.ym(this._yandexMetrika, 'hit', url);
+            this._prevUrl = url;
+        }
+    };
+    return MetricsComponent;
+}());
+exports["default"] = MetricsComponent;

package/components/ResourceComponent.d.ts

@@ -0,0 +1,32 @@
+declare global {
+    interface Window {
+        grecaptcha: {
+            ready: (...args: any[]) => void;
+            execute: (...args: any[]) => Promise<string>;
+        };
+    }
+}
+/**
+ * Resource Component
+ * Компонент для подгрузки внешних API: Google Maps, Yandex Maps, Twitter, ...
+ */
+export default class ResourceComponent {
+    _callbacks: any;
+    _components: any;
+    googleApiKey: string;
+    googleCaptchaSiteKey: string;
+    language: string;
+    static RESOURCE_GOOGLE_MAP_API: string;
+    static RESOURCE_YANDEX_MAP_API: string;
+    static RESOURCE_TWITTER_WIDGET: string;
+    static RESOURCE_GEETEST_API: string;
+    static RESOURCE_GOOGLE_CAPTCHA: string;
+    constructor(components: any, config: any);
+    loadGoogleCaptcha(): Promise<any>;
+    loadGoogleMapApi(): Promise<any>;
+    loadYandexMap(): Promise<any>;
+    loadTwitterWidget(): Promise<any>;
+    loadGeetest(): Promise<any>;
+    loadScript(url: any, params: any, firstResolver: any): Promise<any>;
+    wait(condition: any, timeout?: number): Promise<unknown>;
+}