@steroidsjs/core 3.1.7 → 3.1.9

package/tests/reducers/list/getters.test.js

@@ -0,0 +1,227 @@
+"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;
+var list_1 = require("../../../src/reducers/list");
+describe('list reducers', function () {
+    var defaultInitialState = {
+        lists: {},
+        selectedIds: {}
+    };
+    var initialState = __assign({}, defaultInitialState);
+    var getStateWithWrappedLists = function (lists, extraData) {
+        if (lists === void 0) { lists = null; }
+        if (extraData === void 0) { extraData = null; }
+        return ({
+            list: __assign(__assign(__assign({}, initialState), { lists: __assign({}, lists) }), extraData)
+        });
+    };
+    beforeEach(function () {
+        initialState = __assign({}, defaultInitialState);
+    });
+    describe('isListInitialized', function () {
+        it('should return true', function () {
+            var _a;
+            var listId = 'listId';
+            var state = getStateWithWrappedLists((_a = {},
+                _a[listId] = {},
+                _a));
+            var expectedIsListInitialized = true;
+            expect((0, list_1.isListInitialized)(state, listId)).toEqual(expectedIsListInitialized);
+        });
+    });
+    describe('getList', function () {
+        it('should return list', function () {
+            var _a;
+            var listId = 'listId';
+            var listProperties = {
+                formId: 'formId',
+                isRemote: true,
+                loadMore: true,
+                primaryKey: 'key'
+            };
+            var lists = (_a = {},
+                _a[listId] = listProperties,
+                _a);
+            var state = getStateWithWrappedLists(lists);
+            expect((0, list_1.getList)(state, listId)).toEqual(listProperties);
+        });
+        it('should return null', function () {
+            var notExistingListId = 'notExistingListId';
+            var lists = {
+                existingList: {
+                    formId: 'formId',
+                    isRemote: true,
+                    loadMore: true,
+                    items: []
+                }
+            };
+            var state = getStateWithWrappedLists(lists);
+            var emptyList = null;
+            expect((0, list_1.getList)(state, notExistingListId)).toEqual(emptyList);
+        });
+    });
+    describe('getIds', function () {
+        it('should return empty array', function () {
+            var _a;
+            var listId = 'listId';
+            var lists = (_a = {},
+                _a[listId] = {
+                    formId: 'formId',
+                    isRemote: true,
+                    loadMore: true,
+                    items: []
+                },
+                _a);
+            var state = getStateWithWrappedLists(lists);
+            var expectedEmptyIds = [];
+            expect((0, list_1.getIds)(state, listId)).toEqual(expectedEmptyIds);
+        });
+        it('should return items ids', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var primaryKey = 'primaryKey';
+            var itemId = 'itemId';
+            var lists = (_a = {},
+                _a[listId] = {
+                    formId: 'Form',
+                    isRemote: true,
+                    loadMore: true,
+                    primaryKey: primaryKey,
+                    items: [
+                        (_b = {},
+                            _b[primaryKey] = itemId,
+                            _b),
+                    ]
+                },
+                _a);
+            var state = getStateWithWrappedLists(lists);
+            var expectedIds = [itemId];
+            expect((0, list_1.getIds)(state, listId)).toEqual(expectedIds);
+        });
+    });
+    describe('getListItems', function () {
+        var _a;
+        var listId = 'listId';
+        var primaryKey = 'primaryKey';
+        var lists = (_a = {},
+            _a[listId] = {
+                formId: 'formId',
+                isRemote: true,
+                loadMore: true,
+                primaryKey: primaryKey
+            },
+            _a);
+        it('should return empty items', function () {
+            var state = getStateWithWrappedLists(lists);
+            var emptyListItems = null;
+            expect((0, list_1.getListItems)(state, listId)).toEqual(emptyListItems);
+        });
+        it('should return items', function () {
+            var _a;
+            var items = [(_a = {},
+                    _a[primaryKey] = 'itemId',
+                    _a)];
+            lists[listId].items = items;
+            var state = getStateWithWrappedLists(lists);
+            expect((0, list_1.getListItems)(state, listId)).toEqual(items);
+        });
+    });
+    describe('getSelectedIds', function () {
+        it('should return selectedIds', function () {
+            var _a, _b;
+            var selectedIds = ['beautifulItemId', 'terribleItemId', 'shyItemId'];
+            var listId = 'listId';
+            var lists = (_a = {},
+                _a[listId] = {
+                    formId: 'formId',
+                    isRemote: true,
+                    loadMore: true
+                },
+                _a);
+            var state = getStateWithWrappedLists(lists, {
+                selectedIds: (_b = {},
+                    _b[listId] = selectedIds,
+                    _b)
+            });
+            expect((0, list_1.getSelectedIds)(state, listId)).toEqual(selectedIds);
+        });
+        it('should return empty array', function () {
+            var _a, _b;
+            var notExistingListId = 'notExistingListId';
+            var existingListId = 'existingListId';
+            var lists = (_a = {},
+                _a[existingListId] = {
+                    formId: 'formId',
+                    isRemote: true,
+                    loadMore: true
+                },
+                _a);
+            var state = getStateWithWrappedLists(lists, {
+                selectedIds: (_b = {},
+                    _b[existingListId] = ['beautifulItemId'],
+                    _b)
+            });
+            var expectedEmptySelectedIds = [];
+            expect((0, list_1.getSelectedIds)(state, notExistingListId)).toEqual(expectedEmptySelectedIds);
+        });
+    });
+    describe('isSelected', function () {
+        it('default behavior', function () {
+            var _a, _b;
+            var shyItemId = 'shyItemId';
+            var selectedIds = ['terribleItemId', shyItemId];
+            var listId = 'listId';
+            var lists = (_a = {},
+                _a[listId] = {
+                    formId: 'formId',
+                    isRemote: true,
+                    loadMore: true
+                },
+                _a);
+            var state = getStateWithWrappedLists(lists, {
+                selectedIds: (_b = {},
+                    _b[listId] = selectedIds,
+                    _b)
+            });
+            var expectedIsSelected = true;
+            expect((0, list_1.isSelected)(state, listId, shyItemId)).toBe(expectedIsSelected);
+        });
+    });
+    describe('isSelectedAll', function () {
+        it('should return true', function () {
+            var _a, _b, _c;
+            var itemId = 'itemId';
+            var selectedIds = [itemId];
+            var listId = 'listId';
+            var primaryKey = 'primaryKey';
+            var lists = (_a = {},
+                _a[listId] = {
+                    formId: 'formId',
+                    isRemote: true,
+                    loadMore: true,
+                    primaryKey: primaryKey,
+                    items: [(_b = {},
+                            _b[primaryKey] = itemId,
+                            _b)]
+                },
+                _a);
+            var state = getStateWithWrappedLists(lists, {
+                selectedIds: (_c = {},
+                    _c[listId] = selectedIds,
+                    _c)
+            });
+            var expectedIsSelectedAll = true;
+            expect((0, list_1.isSelectedAll)(state, listId)).toEqual(expectedIsSelectedAll);
+        });
+    });
+});

package/tests/reducers/list/reducerMap.test.d.ts

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

package/tests/reducers/list/reducerMap.test.js

@@ -0,0 +1,471 @@
+"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 list_1 = require("../../../src/actions/list");
+var list_2 = __importDefault(require("../../../src/reducers/list"));
+describe('list reducers', function () {
+    var defaultInitialState = {
+        lists: {},
+        selectedIds: {}
+    };
+    var initialState = __assign({}, defaultInitialState);
+    var getStateWithLists = function (listsData, selectedIdsData) {
+        if (listsData === void 0) { listsData = null; }
+        if (selectedIdsData === void 0) { selectedIdsData = null; }
+        return ({
+            lists: __assign({}, listsData),
+            selectedIds: __assign({}, selectedIdsData)
+        });
+    };
+    beforeEach(function () {
+        initialState = __assign({}, defaultInitialState);
+    });
+    describe('default action', function () {
+        it('should return state', function () {
+            var action = {
+                type: 'default'
+            };
+            var expectedState = __assign({}, initialState);
+            expect((0, list_2["default"])(initialState, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_INIT', function () {
+        var _a, _b;
+        var payloadList = 'payloadList';
+        var existingList = 'existingList';
+        var action = {
+            type: list_1.LIST_INIT,
+            total: 0,
+            items: [],
+            payload: {
+                formId: 'formId',
+                listId: payloadList
+            }
+        };
+        var state = getStateWithLists((_a = {},
+            _a[existingList] = {
+                listId: existingList,
+                items: []
+            },
+            _a));
+        var expectedState = __assign(__assign({}, initialState), { lists: (_b = {},
+                _b[payloadList] = __assign({ meta: {}, total: 0, isFetched: false, isLoading: false }, action.payload),
+                _b[existingList] = state.lists[existingList],
+                _b) });
+        it('with total prop', function () {
+            expectedState.lists[payloadList].total = action.total;
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+        it('without total prop', function () {
+            action.total = null;
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_SET_ITEMS', function () {
+        it('default behavior', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var action = {
+                type: list_1.LIST_SET_ITEMS,
+                listId: listId,
+                items: []
+            };
+            var lists = (_a = {
+                    existingList: {
+                        items: []
+                    }
+                },
+                _a[listId] = {
+                    isLoading: true
+                },
+                _a);
+            var state = getStateWithLists(lists);
+            var expectedState = __assign(__assign({}, initialState), { lists: __assign(__assign({}, state.lists), (_b = {}, _b[listId] = __assign(__assign({}, state.lists[listId]), { items: action.items, sourceItems: action.items }), _b)) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_BEFORE_FETCH', function () {
+        it('default behavior', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var action = {
+                type: list_1.LIST_BEFORE_FETCH,
+                listId: listId
+            };
+            var listProperties = {
+                isLoading: false,
+                isRemote: false
+            };
+            var state = getStateWithLists((_a = {},
+                _a[listId] = listProperties,
+                _a));
+            var expectedState = __assign(__assign({}, initialState), { lists: (_b = {},
+                    _b[action.listId] = __assign(__assign({}, listProperties), { isLoading: true }),
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_AFTER_FETCH', function () {
+        it('items match', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var items = [
+                {
+                    primaryKey: 'key'
+                },
+            ];
+            var action = {
+                type: list_1.LIST_AFTER_FETCH,
+                items: items,
+                listId: listId
+            };
+            var listProperties = {
+                isLoading: true,
+                isRemote: false,
+                hasMoreInfiniteScroll: false,
+                items: items
+            };
+            var state = getStateWithLists((_a = {},
+                _a[listId] = listProperties,
+                _a));
+            var expectedState = __assign(__assign({}, state), { lists: (_b = {},
+                    _b[listId] = __assign(__assign(__assign({}, listProperties), action), { isFetched: true, isLoading: false }),
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+        it('with list loadMore and action page', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var action = {
+                type: list_1.LIST_AFTER_FETCH,
+                items: [
+                    {
+                        id: 'item3'
+                    },
+                ],
+                listId: listId,
+                page: 2,
+                pageSize: 1
+            };
+            var listProperties = {
+                isLoading: true,
+                isRemote: false,
+                hasMoreInfiniteScroll: false,
+                items: [
+                    {
+                        id: 'item1'
+                    },
+                    {
+                        id: 'item2'
+                    },
+                ],
+                loadMore: true
+            };
+            var state = getStateWithLists((_a = {},
+                _a[listId] = listProperties,
+                _a));
+            var expectedState = __assign(__assign({}, state), { lists: (_b = {},
+                    _b[listId] = __assign(__assign(__assign({}, listProperties), action), { isFetched: true, isLoading: false, items: [
+                            {
+                                id: 'item1'
+                            },
+                            {
+                                id: 'item3'
+                            },
+                        ] }),
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+        it('list without items', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var items = [
+                {
+                    primaryKey: 'key'
+                },
+            ];
+            var action = {
+                type: list_1.LIST_AFTER_FETCH,
+                items: items,
+                listId: listId
+            };
+            var listProperties = {
+                isLoading: true,
+                isRemote: false,
+                hasMoreInfiniteScroll: false
+            };
+            var state = getStateWithLists((_a = {},
+                _a[listId] = listProperties,
+                _a));
+            var expectedState = __assign(__assign({}, state), { lists: (_b = {},
+                    _b[listId] = __assign(__assign(__assign({}, listProperties), action), { isLoading: false, isFetched: true }),
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_ITEM_ADD', function () {
+        var _a, _b;
+        var listId = 'listId';
+        var existingItem = {
+            id: 'existingItem'
+        };
+        var payloadItem = {
+            id: 'payloadItem'
+        };
+        var action = {
+            type: list_1.LIST_ITEM_ADD,
+            prepend: true,
+            listId: listId,
+            item: payloadItem
+        };
+        var listProperties = {
+            listId: listId,
+            formId: 'formId',
+            items: [existingItem]
+        };
+        var state = getStateWithLists((_a = {},
+            _a[listId] = listProperties,
+            _a));
+        var expectedState = __assign(__assign({}, state), { lists: (_b = {},
+                _b[listId] = __assign(__assign({}, listProperties), { items: [payloadItem, existingItem] }),
+                _b) });
+        it('with prepend true', function () {
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+        it('with prepend false', function () {
+            action.prepend = false;
+            expectedState.lists[listId].items = [existingItem, payloadItem];
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_ITEM_UPDATE', function () {
+        var _a;
+        var listId = 'listId';
+        var getAction = function (condition) { return ({
+            type: list_1.LIST_ITEM_UPDATE,
+            condition: condition,
+            listId: listId,
+            item: {
+                listId: listId
+            }
+        }); };
+        var listProperties = {
+            isLoading: false,
+            isRemote: false,
+            isFetched: false,
+            items: [
+                {
+                    primaryKey: 'key'
+                },
+            ]
+        };
+        var state = getStateWithLists((_a = {},
+            _a[listId] = listProperties,
+            _a));
+        it('condition match', function () {
+            var _a;
+            var action = getAction({
+                primaryKey: 'key'
+            });
+            var expectedState = __assign(__assign({}, state), { lists: (_a = {},
+                    _a[listId] = __assign(__assign({}, listProperties), { items: [
+                            __assign(__assign({}, action.condition), action.item),
+                        ] }),
+                    _a) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+        it('condition not match', function () {
+            var action = getAction({
+                someProp: 'someProp'
+            });
+            var expectedResult = __assign({}, state);
+            expect((0, list_2["default"])(state, action)).toEqual(expectedResult);
+        });
+    });
+    describe('LIST_ITEM_DELETE', function () {
+        it('default behavior', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var matchCondition = {
+                primaryKey: 'key'
+            };
+            var action = {
+                type: list_1.LIST_ITEM_DELETE,
+                listId: listId,
+                condition: matchCondition
+            };
+            var listProperties = {
+                isLoading: false,
+                items: [
+                    matchCondition,
+                ],
+                loadMore: false
+            };
+            var state = getStateWithLists((_a = {},
+                _a[listId] = listProperties,
+                _a));
+            var expectedState = __assign(__assign({}, state), { lists: (_b = {},
+                    _b[listId] = __assign(__assign({}, listProperties), { items: [] }),
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_DESTROY', function () {
+        it('default behavior', function () {
+            var _a;
+            var listId = 'listId';
+            var action = {
+                type: list_1.LIST_DESTROY,
+                listId: listId
+            };
+            var state = getStateWithLists((_a = {},
+                _a[listId] = {
+                    isFetched: true,
+                    items: [],
+                    isLoading: false
+                },
+                _a));
+            var expectedState = __assign({}, initialState);
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_TOGGLE_ITEM', function () {
+        var itemId = 'itemId';
+        var listId = 'listId';
+        var action = {
+            type: list_1.LIST_TOGGLE_ITEM,
+            itemId: itemId,
+            listId: listId
+        };
+        it('with not existing itemId', function () {
+            var _a, _b;
+            var selectedIds = (_a = {},
+                _a[listId] = [],
+                _a);
+            var emptyListData = {};
+            var state = getStateWithLists(emptyListData, selectedIds);
+            var expectedState = __assign(__assign({}, state), { selectedIds: (_b = {},
+                    _b[listId] = [itemId],
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+        it('with existing itemId', function () {
+            var _a, _b;
+            var selectedIds = (_a = {},
+                _a[listId] = [itemId],
+                _a);
+            var emptyListData = {};
+            var state = getStateWithLists(emptyListData, selectedIds);
+            var expectedState = __assign(__assign({}, state), { selectedIds: (_b = {},
+                    _b[listId] = [],
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_TOGGLE_ALL', function () {
+        var listId = 'listId';
+        var primaryKey = 'primaryKey';
+        var action = {
+            type: list_1.LIST_TOGGLE_ALL,
+            listId: listId
+        };
+        it('should return empty array', function () {
+            var _a;
+            var lists = {
+                existingList: {
+                    items: [
+                        (_a = {},
+                            _a[primaryKey] = 'item1',
+                            _a),
+                    ],
+                    primaryKey: primaryKey
+                }
+            };
+            var state = getStateWithLists(lists);
+            var expectedResult = [];
+            expect((0, list_2["default"])(state, action)).toEqual(expectedResult);
+        });
+        it('all ids selected', function () {
+            var _a, _b, _c, _d;
+            var itemId = 'itemId';
+            var lists = (_a = {},
+                _a[listId] = {
+                    items: [
+                        (_b = {},
+                            _b[primaryKey] = itemId,
+                            _b),
+                    ],
+                    primaryKey: primaryKey
+                },
+                _a);
+            var selectedIds = (_c = {},
+                _c[listId] = [itemId],
+                _c);
+            var state = getStateWithLists(lists, selectedIds);
+            var expectedState = __assign(__assign({}, state), { selectedIds: (_d = {},
+                    _d[listId] = [],
+                    _d) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+        it('one id selected', function () {
+            var _a, _b, _c, _d, _e;
+            var item1 = (_a = {},
+                _a[primaryKey] = 'item1',
+                _a);
+            var item2 = (_b = {},
+                _b[primaryKey] = 'item2',
+                _b);
+            var lists = (_c = {},
+                _c[listId] = {
+                    items: [item1, item2],
+                    primaryKey: primaryKey
+                },
+                _c);
+            var selectedIds = (_d = {},
+                _d[listId] = [item1[primaryKey]],
+                _d);
+            var state = getStateWithLists(lists, selectedIds);
+            var expectedState = __assign(__assign({}, state), { selectedIds: (_e = {},
+                    _e[listId] = [item1[primaryKey], item2[primaryKey]],
+                    _e) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+    describe('LIST_SET_LAYOUT', function () {
+        it('default behavior', function () {
+            var _a, _b;
+            var listId = 'listId';
+            var layoutName = 'layoutName';
+            var action = {
+                type: list_1.LIST_SET_LAYOUT,
+                listId: listId,
+                layoutName: layoutName
+            };
+            var listProperties = {
+                items: [],
+                formId: 'formId',
+                listId: listId
+            };
+            var state = getStateWithLists((_a = {},
+                _a[listId] = listProperties,
+                _a));
+            var expectedState = __assign(__assign({}, state), { lists: (_b = {},
+                    _b[listId] = __assign(__assign({}, listProperties), { layoutName: layoutName }),
+                    _b) });
+            expect((0, list_2["default"])(state, action)).toEqual(expectedState);
+        });
+    });
+});

package/tests/reducers/modal.test.d.ts

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