@steroidsjs/core 3.1.8 → 3.1.9

package/src/ui/form/PhoneField/PhoneField.d.ts

@@ -0,0 +1,40 @@
+import { IDropDownFieldItem } from '../DropDownField/DropDownField';
+import { IFieldWrapperInputProps, IFieldWrapperOutputProps } from '../Field/fieldWrapper';
+import { IBaseFieldProps, IInputFieldProps } from '../InputField/InputField';
+export interface ICountryPhoneMask extends IDropDownFieldItem {
+    phoneCode: string;
+    phoneMask?: (string | RegExp)[];
+}
+/**
+ * PhoneField
+ *
+ * Компонент для ввода и форматирования телефонных номеров с поддержкой масок стран.
+ * Автоматически форматирует введенный номер в соответствии с выбранной маской.
+ *
+ */
+interface IPhoneFieldProps extends IFieldWrapperInputProps, IFieldWrapperOutputProps, IBaseFieldProps {
+    /**
+     * Список доступных масок для телефонных номеров разных стран.
+     * Каждая маска определяет формат отображения номера.
+     */
+    phoneMasks: ICountryPhoneMask[];
+    /**
+     * Выбранная страна по умолчанию
+     */
+    initialCountryCode: string;
+}
+export interface IPhoneFieldDropdownProps {
+    onOpen: () => void;
+    onClose: () => void;
+    isOpened: boolean;
+    items: any[];
+    onItemSelect: (id: any) => void;
+    selectedIds: any[];
+    selectedItems: any[];
+    primaryKey: string;
+}
+export interface IPhoneFieldViewProps extends IPhoneFieldProps, IFieldWrapperOutputProps {
+    dropDownProps: IPhoneFieldDropdownProps;
+}
+declare const _default: import("../Field/fieldWrapper").FieldWrapperComponent<IInputFieldProps>;
+export default _default;

package/src/ui/form/PhoneField/PhoneField.js

@@ -0,0 +1,120 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var react_1 = require("@maskito/react");
+var react_2 = require("react");
+var hooks_1 = require("../../../hooks");
+var fieldWrapper_1 = __importDefault(require("../Field/fieldWrapper"));
+function PhoneField(props) {
+    var components = (0, hooks_1.useComponents)();
+    var _a = (0, react_2.useState)(props.initialCountryCode.toUpperCase()), selectedCountryCode = _a[0], setSelectedCountryCode = _a[1];
+    // Data provider
+    var _b = (0, hooks_1.useDataProvider)({
+        items: props.phoneMasks,
+        initialSelectedIds: []
+    }), items = _b.items, sourceItems = _b.sourceItems;
+    // Data select
+    var _c = (0, hooks_1.useDataSelect)({
+        items: items,
+        sourceItems: sourceItems,
+        inputValue: props.input.value,
+        selectedIds: [selectedCountryCode]
+    }), isOpened = _c.isOpened, setIsOpened = _c.setIsOpened, setIsFocused = _c.setIsFocused, setHoveredId = _c.setHoveredId, selectedIds = _c.selectedIds, setSelectedIds = _c.setSelectedIds, selectedItems = _c.selectedItems;
+    var phoneMask = (0, react_2.useMemo)(function () {
+        var _a;
+        return (_a = ((items !== null && items !== void 0 ? items : [])).find(function (countryPhoneMask) { var _a; return countryPhoneMask.id === ((_a = selectedIds[0]) !== null && _a !== void 0 ? _a : props.defaultCountryCode); })) === null || _a === void 0 ? void 0 : _a.phoneMask;
+    }, [items, selectedIds, props.defaultCountryCode]);
+    var maskedInputRef = (0, react_1.useMaskito)({
+        options: {
+            mask: phoneMask
+        }
+    });
+    var _d = (0, hooks_1.useSaveCursorPosition)({
+        inputParams: props.input
+    }), inputRef = _d.inputRef, onChange = _d.onChange, value = _d.value;
+    (0, react_2.useEffect)(function () {
+        if (inputRef.current) {
+            maskedInputRef(inputRef.current);
+        }
+    }, [inputRef, maskedInputRef]);
+    var onOpen = (0, react_2.useCallback)(function () {
+        setIsFocused(true);
+        setIsOpened(true);
+        setHoveredId(null);
+    }, [setHoveredId, setIsFocused, setIsOpened]);
+    var onItemSelect = (0, react_2.useCallback)(function (id) {
+        // If country changed
+        if (selectedCountryCode !== id) {
+            setSelectedIds(id);
+            onChange(null, '');
+            setSelectedCountryCode(id);
+        }
+        setIsOpened(false);
+    }, [setSelectedIds, setIsOpened, onChange, selectedCountryCode]);
+    var onClose = (0, react_2.useCallback)(function () {
+        setIsFocused(false);
+        setIsOpened(false);
+    }, [setIsFocused, setIsOpened]);
+    var onClear = (0, react_2.useCallback)(function () {
+        if (props.onClear) {
+            props.onClear('');
+        }
+        props.input.onChange('');
+    }, [props]);
+    var inputProps = (0, react_2.useMemo)(function () { return (__assign({ name: props.input.name, onInput: onChange, value: value, placeholder: props.placeholder, disabled: props.disabled, type: 'tel' }, props.inputProps)); }, [props.disabled, props.input, props.inputProps, props.placeholder, onChange, value]);
+    var viewProps = (0, react_2.useMemo)(function () { return ({
+        inputRef: inputRef,
+        inputProps: inputProps,
+        size: props.size,
+        errors: props.errors,
+        leadIcon: props.leadIcon,
+        showClear: props.showClear,
+        onClear: onClear,
+        input: props.input,
+        className: props.className,
+        style: props.style,
+        onMouseDown: props.onMouseDown,
+        placeholder: props.placeholder,
+        required: props.required,
+        id: props.id,
+        viewProps: props.viewProps,
+        disabled: props.disabled,
+        dropDownProps: {
+            onOpen: onOpen,
+            onClose: onClose,
+            isOpened: isOpened,
+            items: items,
+            onItemSelect: onItemSelect,
+            selectedIds: selectedIds,
+            selectedItems: selectedItems,
+            primaryKey: 'id'
+        }
+    }); }, [inputProps, inputRef, isOpened, items, onClose,
+        onClear, onItemSelect, onOpen, props.className,
+        props.disabled, props.errors, props.id, props.input, props.leadIcon,
+        props.onMouseDown, props.placeholder, props.required, props.showClear,
+        props.size, props.style, props.viewProps, selectedIds, selectedItems]);
+    // No render for hidden input
+    if (props.type === 'hidden') {
+        return null;
+    }
+    return components.ui.renderView(props.view || 'form.PhoneFieldView', viewProps);
+}
+PhoneField.defaultProps = {
+    disabled: false,
+    required: false
+};
+exports["default"] = (0, fieldWrapper_1["default"])('PhoneField', PhoneField);

package/src/ui/form/WizardForm/WizardForm.d.ts

@@ -0,0 +1,119 @@
+import { ReactNode } from 'react';
+import { IStepsProps, IStepItem } from '../../list/Steps/Steps';
+import { IButtonProps } from '../Button/Button';
+import { IFieldProps } from '../Field/Field';
+import { IFormProps } from '../Form/Form';
+export interface IWizardStepItem extends Partial<IStepItem> {
+    fields?: IFieldProps[];
+    component?: ReactNode;
+    stepLabel?: string;
+}
+/**
+ * WizardForm
+ *
+ * Компонент для создания пошаговой формы. Предоставляет управление и синхронизацию состояния формы,
+ * а также список шагов формы для удобной навигации.
+ * Поля для шагов можно передавать как в виде компонентов, так и в виде объекта с названием поля.
+ * Позволяет выполнять отправку данных формы на сервер с возможностью валидации и перехода к неверно заполненным полям.
+ *
+ */
+export interface IWizardFormProps extends IUiComponent {
+    /**
+     * Идентификатор формы
+     * @example WizardForm
+     */
+    formId: string;
+    /**
+     * Коллекция полей и аттрибутов для каждого шага формы. Можно передавать как компонент, так и объект с полями.
+     * Главное, чтобы внутри шага использовался один из способов.
+     * @example
+     * [
+     *  {
+     *   title: 'Step 1',
+     *   fields: [
+     *     {
+     *       attribute: 'category',
+     *       component: 'DropDownField'
+     *     },
+     *   ],
+     *  },
+     *  {
+     *   title: 'Step 2',
+     *   component: (
+     *      <InputField
+     *        attribute='address'
+     *      />
+     *   )
+     *  }
+     * ]
+     */
+    steps: IWizardStepItem[];
+    /**
+     * Свойства для Form
+     */
+    formProps: Omit<IFormProps, 'formId' | 'fields' | 'useRedux'> & {
+        submitButtonLabel: string;
+    };
+    /**
+     * Обработчик, который вызывается после перехода на следующий шаг формы
+     * @param {number} value
+     * @return {void}
+     */
+    onNextStep?: (nextStep: number) => void;
+    /**
+     * Обработчик, который вызывается после возврата на предыдущий шаг формы
+     * @param {number} value
+     * @return {void}
+     */
+    onPrevStep?: (prevStep: number) => void;
+    /**
+     * Свойства для кнопки возврата
+     */
+    prevStepButtonProps?: IButtonProps;
+    /**
+     * Свойства для кнопки продолжить/отправить
+     */
+    nextStepButtonProps?: IButtonProps;
+    /**
+     * Свойства для Steps
+     */
+    stepsProps?: Pick<IStepsProps, 'stepItems'>;
+    /**
+     * Ориентация списка шагов формы
+     * @example 'horizontal'
+     */
+    stepTitleOrientation?: Orientation;
+    /**
+     * Показывать ли шаги
+     * @example true
+     */
+    showSteps?: boolean;
+}
+export interface IWizardFormViewProps extends Pick<IWizardFormProps, 'prevStepButtonProps' | 'nextStepButtonProps' | 'stepsProps' | 'showSteps'> {
+    currentStep: number;
+    stepTitle: string;
+    stepItems: IStepItem[];
+    renderStep: (header: ReactNode, buttons: ReactNode, viewProps?: IUiComponent) => JSX.Element;
+    isLastStep?: boolean;
+    onPrevStep?: () => void;
+    totalSteps?: number;
+}
+declare function WizardForm(props: IWizardFormProps): import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+declare namespace WizardForm {
+    var defaultProps: {
+        formProps: {
+            label: string;
+        };
+        prevStepButtonProps: {
+            color: string;
+            icon: string;
+            outline: boolean;
+            label: string;
+        };
+        nextStepButtonProps: {
+            label: string;
+        };
+        showSteps: boolean;
+    };
+}
+export default WizardForm;

package/src/ui/form/WizardForm/utils.d.ts

@@ -0,0 +1,12 @@
+import { ReactElement } from 'react';
+import { IWizardStepItem } from './WizardForm';
+export declare const generateFieldStepMap: (arr?: any[]) => any;
+export declare const normalizeSteps: (steps: IWizardStepItem[]) => {
+    id: number;
+    title: string;
+    description: string;
+    subtitle: string;
+    icon: string | number | true | ReactElement<any, string | import("react").JSXElementConstructor<any>> | import("react").ReactFragment;
+    status: string;
+}[];
+export declare const getModifiedSteps: (prevStepsState: any, errorSteps: any, currentStep: number, nextStep: number) => any[];

package/src/ui/format/TimeFormatter/TimeFormatter.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var dayjs_1 = __importDefault(require("dayjs"));
+var hooks_1 = require("../../../hooks");
+var defaultProps = {
+    format: 'HH:mm'
+};
+function TimeFormatter(props) {
+    var components = (0, hooks_1.useComponents)();
+    if (!props.value) {
+        return null;
+    }
+    var time = (0, dayjs_1["default"])(props.value).format(props.format || defaultProps.format);
+    return components.ui.renderView(props.view || 'format.DefaultFormatterView', {
+        value: time
+    });
+}
+exports["default"] = TimeFormatter;

package/src/ui/list/TreeTable/TreeTable.d.ts

@@ -0,0 +1,59 @@
+import { ReactElement } from 'react';
+import { IPreparedTreeItem, ITreeItem } from '../../../hooks/useTree';
+import { ITreeProps } from '../../nav/Tree/Tree';
+import { IColumnViewProps, IGridColumn, IGridProps } from '../Grid/Grid';
+export interface ITreeColumnViewProps extends IColumnViewProps, Pick<ITreeTableProps, 'levelPadding' | 'customIcon'> {
+    item: IPreparedTreeItem;
+}
+/**
+ * TreeTable
+ *
+ * Компонент для представления данных коллекции в виде иерархической структуры.
+ */
+export interface ITreeTableProps extends Omit<IGridProps, 'items' | 'itemsIndexing'>, Pick<ITreeProps, 'alwaysOpened' | 'levelPadding' | 'customIcon' | 'saveInClientStorage' | 'collapseChildItems'> {
+    /**
+     * Элементы коллекции
+     * @example
+     * [
+     *  {
+     *   id: 1,
+     *   name: 'Jane'
+     *  },
+     *  {
+     *   id: 2,
+     *   name: 'John',
+     *   items: [...]
+     *  }
+     * ]
+     */
+    items?: ITreeItem[];
+    /**
+     * Если флаг true, то данные в items переданы только для одной страницы, если false, то данные в items переданы сразу для всех страниц
+     * @example true
+     */
+    isSinglePageItems?: boolean;
+    /**
+     * Кастомная иконка для сворачивания элементов
+     * @example 'arrow'
+     */
+    customIcon?: CustomIcon;
+    /**
+     * Ключ для доступа к вложенным элементам узла
+     * @example 'items'
+     */
+    itemsKey?: string;
+    itemsIndexing?: never;
+}
+export declare const addTreeColumnFieldsToFirstColumn: (columns: IGridColumn[], levelPadding: string | number, customIcon?: string | ReactElement) => IGridColumn[];
+declare function TreeTable(props: ITreeTableProps): JSX.Element;
+declare namespace TreeTable {
+    var defaultProps: {
+        levelPadding: number;
+        alwaysOpened: boolean;
+        saveInClientStorage: boolean;
+        collapseChildItems: boolean;
+        size: string;
+        hasAlternatingColors: boolean;
+    };
+}
+export default TreeTable;

package/src/ui/list/TreeTable/TreeTable.js

@@ -0,0 +1,151 @@
+"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);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.addTreeColumnFieldsToFirstColumn = void 0;
+var jsx_runtime_1 = require("react/jsx-runtime");
+var isString_1 = __importDefault(require("lodash-es/isString"));
+var merge_1 = __importDefault(require("lodash-es/merge"));
+var upperFirst_1 = __importDefault(require("lodash-es/upperFirst"));
+var react_1 = require("react");
+var hooks_1 = require("../../../hooks");
+var useList_1 = __importDefault(require("../../../hooks/useList"));
+var useTree_1 = __importDefault(require("../../../hooks/useTree"));
+var Format_1 = __importDefault(require("../../format/Format"));
+var ControlsColumn_1 = __importDefault(require("../ControlsColumn"));
+var TREE_COLUMN_VIEW_FIELDS = {
+    valueView: 'TreeColumnView',
+    headerClassName: 'TreeColumnHeader'
+};
+var addTreeColumnFieldsToFirstColumn = function (columns, levelPadding, customIcon) {
+    var newColumns = __spreadArray([], columns, true);
+    // Add tree view to the first column
+    (0, merge_1["default"])(newColumns[0], __assign(__assign({}, TREE_COLUMN_VIEW_FIELDS), { levelPadding: levelPadding, customIcon: customIcon }));
+    return newColumns;
+};
+exports.addTreeColumnFieldsToFirstColumn = addTreeColumnFieldsToFirstColumn;
+function TreeTable(props) {
+    var components = (0, hooks_1.useComponents)();
+    var mergedColumns = (0, react_1.useMemo)(function () { return (0, exports.addTreeColumnFieldsToFirstColumn)(props.columns, props.levelPadding, props.customIcon); }, [props.columns, props.customIcon, props.levelPadding]);
+    var _a = (0, useList_1["default"])({
+        listId: props.listId,
+        primaryKey: props.primaryKey,
+        action: props.action,
+        actionMethod: props.actionMethod,
+        pagination: props.pagination,
+        paginationSize: props.paginationSize,
+        infiniteScroll: props.infiniteScroll,
+        sort: props.sort,
+        layout: props.layout,
+        empty: props.empty,
+        searchForm: props.searchForm,
+        autoDestroy: props.autoDestroy,
+        onFetch: props.onFetch,
+        condition: props.condition,
+        addressBar: props.addressBar,
+        scope: props.scope,
+        query: props.query,
+        model: props.model,
+        searchModel: props.searchModel,
+        items: props.items,
+        initialItems: props.initialItems,
+        initialTotal: props.initialTotal,
+        autoFetchOnFormChanges: props.autoFetchOnFormChanges
+    }), list = _a.list, model = _a.model, searchModel = _a.searchModel, paginationPosition = _a.paginationPosition, paginationSizePosition = _a.paginationSizePosition, layoutNamesPosition = _a.layoutNamesPosition, renderList = _a.renderList, renderLoading = _a.renderLoading, renderEmpty = _a.renderEmpty, renderPagination = _a.renderPagination, renderPaginationSize = _a.renderPaginationSize, renderLayoutNames = _a.renderLayoutNames, renderSearchForm = _a.renderSearchForm, renderInfiniteScroll = _a.renderInfiniteScroll, onFetch = _a.onFetch, onSort = _a.onSort, sort = _a.sort;
+    var items = (0, react_1.useMemo)(function () { return (list === null || list === void 0 ? void 0 : list.items) || []; }, [list === null || list === void 0 ? void 0 : list.items]);
+    var treeItems = (0, useTree_1["default"])({
+        items: items,
+        autoOpenLevels: 0,
+        alwaysOpened: props.alwaysOpened,
+        collapseChildItems: props.collapseChildItems,
+        saveInClientStorage: props.saveInClientStorage,
+        clientStorageId: props.listId,
+        isSinglePageItems: props.isSinglePageItems,
+        itemsKey: props.itemsKey
+    }).treeItems;
+    var renderLabel = (0, react_1.useCallback)(function (column) {
+        if (column.headerView) {
+            var HeaderView = column.headerView;
+            return ((0, jsx_runtime_1.jsx)(HeaderView, __assign({}, column, column.headerProps, { listId: props.listId })));
+        }
+        if (column.label || column.label === '') {
+            return column.label;
+        }
+        var attributeMeta = []
+            .concat((model === null || model === void 0 ? void 0 : model.attributes) || [])
+            .concat((searchModel === null || searchModel === void 0 ? void 0 : searchModel.attributes) || [])
+            .find(function (item) { return column.attribute && item.attribute === column.attribute; });
+        return attributeMeta ? attributeMeta.label : (0, upperFirst_1["default"])(column.attribute);
+    }, [model, props.listId, searchModel]);
+    var renderValue = (0, react_1.useCallback)(function (item, column) {
+        // Custom component
+        if (column.valueView) {
+            var isValueViewString = typeof column.valueView === 'string';
+            var ValueView = isValueViewString ? components.ui.getView("list.".concat(column.valueView)) : column.valueView;
+            var viewProps_1 = __assign(__assign(__assign({}, column), column.valueProps), { listId: props.listId, primaryKey: props.primaryKey, item: item, size: props.size });
+            if (isValueViewString) {
+                return components.ui.renderView(ValueView, viewProps_1);
+            }
+            return ((0, jsx_runtime_1.jsx)(ValueView, __assign({}, viewProps_1)));
+        }
+        return ((0, jsx_runtime_1.jsx)(Format_1["default"], __assign({ item: item, model: props.model }, column, (column.formatter || {}))));
+    }, [props.listId, props.model, props.primaryKey]);
+    // Columns
+    var columns = (0, react_1.useMemo)(function () { return []
+        .concat({
+        label: __('№'),
+        valueView: function (_a) {
+            var item = _a.item;
+            return item.index + 1;
+        },
+        visible: false
+    })
+        .concat(mergedColumns)
+        .concat({
+        valueView: ControlsColumn_1["default"],
+        valueProps: {
+            controls: props.controls
+        },
+        visible: !!props.controls
+    })
+        .map(function (column) { return ((0, isString_1["default"])(column) ? {
+        attribute: column
+    } : column); })
+        .filter(function (column) { return column.visible !== false; })
+        .map(function (column) { return (__assign(__assign({}, column), { label: renderLabel(column) })); }); }, [mergedColumns, props.controls, renderLabel]);
+    var viewProps = (0, react_1.useMemo)(function () { return (__assign(__assign({}, props.viewProps), { list: list, paginationPosition: paginationPosition, paginationSizePosition: paginationSizePosition, layoutNamesPosition: layoutNamesPosition, renderList: renderList, renderLoading: renderLoading, renderEmpty: renderEmpty, renderPagination: renderPagination, renderPaginationSize: renderPaginationSize, renderLayoutNames: renderLayoutNames, renderSearchForm: renderSearchForm, renderInfiniteScroll: renderInfiniteScroll, renderValue: renderValue, columns: columns, onFetch: onFetch, onSort: onSort, sort: sort, items: treeItems, searchForm: props.searchForm, listId: props.listId, isLoading: props.isLoading, size: props.size, hasAlternatingColors: props.hasAlternatingColors, className: props.className, primaryKey: props.primaryKey })); }, [treeItems, list, paginationPosition, paginationSizePosition, layoutNamesPosition, renderList, renderLoading, renderEmpty,
+        renderPagination, renderPaginationSize, renderLayoutNames, renderSearchForm, renderInfiniteScroll, renderValue,
+        columns, onFetch, onSort, sort, props.searchForm, props.listId, props.isLoading, props.size, props.hasAlternatingColors,
+        props.className, props.primaryKey, props.viewProps]);
+    return components.ui.renderView(props.view || 'list.GridView', viewProps);
+}
+exports["default"] = TreeTable;
+TreeTable.defaultProps = {
+    levelPadding: 32,
+    alwaysOpened: false,
+    saveInClientStorage: false,
+    collapseChildItems: false,
+    size: 'md',
+    hasAlternatingColors: false
+};

package/tests/actions/auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/tests/actions/auth.test.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var redux_mock_store_1 = __importDefault(require("redux-mock-store"));
+var auth_1 = require("../../src/actions/auth");
+var componentsMock_1 = __importDefault(require("../mocks/componentsMock"));
+var storeMiddlewareMock_1 = __importDefault(require("../mocks/storeMiddlewareMock"));
+var mockStore = (0, redux_mock_store_1["default"])([storeMiddlewareMock_1["default"]]);
+var store = mockStore({});
+describe('auth actions', function () {
+    beforeEach(function () {
+        store.clearActions();
+    });
+    describe('init', function () {
+        it('without skipInitialized', function () {
+            var expectedActions = [{
+                    type: auth_1.AUTH_INIT
+                }];
+            store.dispatch((0, auth_1.init)());
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        it('with skipInitialized', function () {
+            var mockedStore = mockStore({
+                auth: {
+                    isInitialized: true
+                }
+            });
+            var expectedActions = [];
+            mockedStore.dispatch((0, auth_1.init)(true));
+            expect(mockedStore.getActions()).toEqual(expectedActions);
+        });
+    });
+    describe('login', function () {
+        it('without redirectPageId', function () {
+            var token = 'token';
+            var expectedActions = [
+                {
+                    type: auth_1.AUTH_INIT,
+                    redirectPageId: null
+                },
+            ];
+            store.dispatch((0, auth_1.login)(token, false));
+            expect(componentsMock_1["default"].http.onLogin).toHaveBeenCalled();
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        it('with redirectPageId', function () {
+            var redirectPageId = 'foo';
+            var token = 'token';
+            var expectedActions = [
+                {
+                    type: auth_1.AUTH_INIT,
+                    redirectPageId: redirectPageId
+                },
+            ];
+            store.dispatch((0, auth_1.login)(token, redirectPageId));
+            expect(componentsMock_1["default"].http.onLogin).toHaveBeenCalled();
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+    });
+    describe('logout', function () {
+        it('without redirectPageId', function () {
+            var expectedActions = [
+                {
+                    type: auth_1.AUTH_INIT_USER,
+                    user: null
+                },
+            ];
+            store.dispatch((0, auth_1.logout)(false));
+            expect(componentsMock_1["default"].http.onLogout).toHaveBeenCalled();
+            expect(store.getActions()).toEqual(expectedActions);
+        });
+        it('with redirectPageId', function () {
+            var rootPath = 'root-path';
+            var mockedStore = mockStore({
+                router: {
+                    routesMap: {
+                        root: {
+                            path: rootPath
+                        }
+                    }
+                }
+            });
+            var expectedActions = [
+                {
+                    type: auth_1.AUTH_INIT_USER,
+                    user: null
+                },
+                {
+                    type: '@@router/CALL_HISTORY_METHOD',
+                    payload: {
+                        args: [rootPath],
+                        method: 'push'
+                    }
+                },
+            ];
+            mockedStore.dispatch((0, auth_1.logout)());
+            expect(componentsMock_1["default"].http.onLogout).toHaveBeenCalled();
+            expect(mockedStore.getActions()).toEqual(expectedActions);
+        });
+    });
+    describe('setUser', function () {
+        it('with user', function () {
+            var user = {
+                name: 'John'
+            };
+            var expectedAction = {
+                type: auth_1.AUTH_INIT_USER,
+                user: user
+            };
+            expect((0, auth_1.setUser)(user)).toEqual(expectedAction);
+        });
+        it('with null user', function () {
+            var expectedAction = {
+                type: auth_1.AUTH_INIT_USER,
+                user: null
+            };
+            expect((0, auth_1.setUser)(null)).toEqual(expectedAction);
+        });
+    });
+    it('addSocial', function () {
+        var expectedAction = {
+            type: auth_1.AUTH_ADD_SOCIAL,
+            social: 'foo'
+        };
+        expect((0, auth_1.addSocial)('foo')).toEqual(expectedAction);
+    });
+    it('setData', function () {
+        var expectedAction = {
+            type: auth_1.AUTH_SET_DATA,
+            data: 'foo'
+        };
+        expect((0, auth_1.setData)('foo')).toEqual(expectedAction);
+    });
+});

package/tests/actions/fields.test.d.ts

@@ -0,0 +1 @@
+export {};