@steroidsjs/core 3.1.7 → 3.1.9

package/tests/helpers/customRenderHook.js

@@ -0,0 +1,31 @@
+"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;
+exports.renderHook = void 0;
+// eslint-disable-next-line import/no-extraneous-dependencies
+var react_1 = require("@testing-library/react");
+var mockApplication_1 = __importDefault(require("../mocks/mockApplication"));
+var customRenderHook = function (hook, config, options) {
+    var Wrapper = function (_a) {
+        var children = _a.children;
+        return (0, mockApplication_1["default"])({
+            children: children,
+            config: config
+        });
+    };
+    return (0, react_1.renderHook)(hook, __assign({ wrapper: Wrapper }, options));
+};
+exports.renderHook = customRenderHook;

package/tests/helpers/getElementByClassName.d.ts

@@ -0,0 +1 @@
+export declare const getElementByClassName: (container: HTMLElement, className: string, elementIndex?: number) => Element;

package/tests/helpers/getElementByClassName.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+exports.getElementByClassName = void 0;
+var getElementByClassName = function (container, className, elementIndex) {
+    if (elementIndex === void 0) { elementIndex = 0; }
+    return container.getElementsByClassName(className)[elementIndex];
+};
+exports.getElementByClassName = getElementByClassName;

package/tests/helpers/getElementByTag.d.ts

@@ -0,0 +1 @@
+export declare const getElementByTag: (container: HTMLElement, tag: string, elementIndex?: number) => Element;

package/tests/helpers/getElementByTag.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+exports.getElementByTag = void 0;
+var getElementByTag = function (container, tag, elementIndex) {
+    if (elementIndex === void 0) { elementIndex = 0; }
+    return container.getElementsByTagName(tag)[elementIndex];
+};
+exports.getElementByTag = getElementByTag;

package/tests/helpers/index.d.ts

@@ -0,0 +1,7 @@
+import { FormWrapper } from './FormWrapper';
+import { JSXWrapper } from './JSXWrapper';
+import { render } from './customRender';
+import { renderHook } from './customRenderHook';
+import { getElementByClassName } from './getElementByClassName';
+import { getElementByTag } from './getElementByTag';
+export { getElementByClassName, JSXWrapper, FormWrapper, getElementByTag, render, renderHook, };

package/tests/helpers/index.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.renderHook = exports.render = exports.getElementByTag = exports.FormWrapper = exports.JSXWrapper = exports.getElementByClassName = void 0;
+var FormWrapper_1 = require("./FormWrapper");
+exports.FormWrapper = FormWrapper_1.FormWrapper;
+var JSXWrapper_1 = require("./JSXWrapper");
+exports.JSXWrapper = JSXWrapper_1.JSXWrapper;
+var customRender_1 = require("./customRender");
+exports.render = customRender_1.render;
+var customRenderHook_1 = require("./customRenderHook");
+exports.renderHook = customRenderHook_1.renderHook;
+var getElementByClassName_1 = require("./getElementByClassName");
+exports.getElementByClassName = getElementByClassName_1.getElementByClassName;
+var getElementByTag_1 = require("./getElementByTag");
+exports.getElementByTag = getElementByTag_1.getElementByTag;

package/tests/hooks/useAbsolutePositioning.test.d.ts

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

package/tests/hooks/useAbsolutePositioning.test.js

@@ -0,0 +1,70 @@
+"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 react_1 = require("@testing-library/react");
+var hooks_1 = require("../../src/hooks");
+var useAbsolutePositioning_1 = require("../../src/hooks/useAbsolutePositioning");
+describe('useAbsolutePositioning hook', function () {
+    var expectedComponentExist = true;
+    var expectedComponentVisible = true;
+    var expectedComponentNotVisible = false;
+    var expectedComponentNotExist = false;
+    var defaultProps = {
+        position: useAbsolutePositioning_1.Position.TOP,
+        gap: 5,
+        componentDestroyDelay: 100,
+        visible: true,
+        onVisibleChange: jest.fn()
+    };
+    it('should return correct position', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, hooks_1.useAbsolutePositioning)(defaultProps); }).result;
+        expect(result.current.position).toEqual(defaultProps.position);
+    });
+    it('should initialize with the correct visibility state', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, hooks_1.useAbsolutePositioning)(defaultProps); }).result;
+        expect(result.current.isComponentExist).toBe(expectedComponentExist);
+        expect(result.current.isComponentVisible).toBe(expectedComponentNotVisible);
+        (0, react_1.waitFor)(function () {
+            expect(result.current.isComponentVisible).toEqual(expectedComponentVisible);
+        });
+    });
+    it('should toggle visibility correctly when `onShow` handler is called', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, hooks_1.useAbsolutePositioning)(__assign(__assign({}, defaultProps), { visible: false })); }).result;
+        expect(result.current.isComponentVisible).toBe(expectedComponentNotVisible);
+        expect(result.current.onShow).toBeInstanceOf(Function);
+        (0, react_1.act)(function () {
+            result.current.onShow();
+        });
+        (0, react_1.waitFor)(function () {
+            expect(result.current.isComponentVisible).toEqual(expectedComponentVisible);
+        });
+    });
+    it('should toggle visibility correctly when `onHide` handler is called', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, hooks_1.useAbsolutePositioning)(defaultProps); }).result;
+        expect(result.current.onHide).toBeInstanceOf(Function);
+        (0, react_1.act)(function () {
+            result.current.onHide();
+        });
+        expect(result.current.isComponentVisible).toBe(expectedComponentNotVisible);
+        (0, react_1.waitFor)(function () {
+            expect(result.current.isComponentExist).toBe(expectedComponentNotExist);
+        });
+    });
+    it('should call onVisibleChange callback then isComponentVisible has changed', function () {
+        var result = (0, react_1.renderHook)(function () { return (0, hooks_1.useAbsolutePositioning)(defaultProps); }).result;
+        (0, react_1.act)(function () {
+            result.current.onHide();
+        });
+        expect(defaultProps.onVisibleChange).toHaveBeenCalledWith(expectedComponentNotVisible);
+    });
+});

package/tests/hooks/useAddressBar.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/tests/hooks/useAddressBar.test.js

@@ -0,0 +1,418 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+require("@testing-library/jest-dom");
+var connectedReactRouter = __importStar(require("connected-react-router"));
+var react_redux_1 = require("react-redux");
+var redux_mock_store_1 = __importDefault(require("redux-mock-store"));
+var hooks_1 = require("../../src/hooks");
+var useAddressBar_1 = require("../../src/hooks/useAddressBar");
+var helpers_1 = require("../helpers");
+var storeMiddlewareMock_1 = __importDefault(require("../mocks/storeMiddlewareMock"));
+var ITEM_STUB = null;
+var WITH_HASH = true;
+var WITHOUT_HASH = false;
+describe('defaultFromStringConverter function', function () {
+    it('should convert from string correctly', function () {
+        var testCases = [
+            {
+                value: '123',
+                type: 'number',
+                expectedValue: 123
+            },
+            {
+                value: 'true',
+                type: 'boolean',
+                expectedValue: true
+            },
+            {
+                value: '1_2_3',
+                type: 'number[]',
+                expectedValue: [1, 2, 3]
+            },
+            {
+                value: '1,2,3',
+                type: 'number[]',
+                expectedValue: [0]
+            },
+            {
+                value: 'a_b_c',
+                type: 'string[]',
+                expectedValue: ['a', 'b', 'c']
+            },
+            {
+                value: undefined,
+                type: 'string',
+                expectedValue: null
+            },
+            {
+                value: 123,
+                type: 'unknown',
+                expectedValue: '123'
+            },
+            {
+                value: '',
+                type: 'unknown',
+                expectedValue: null
+            },
+        ];
+        testCases.forEach(function (_a) {
+            var value = _a.value, type = _a.type, expectedValue = _a.expectedValue;
+            var convertedValue = (0, useAddressBar_1.defaultFromStringConverter)(value, type, ITEM_STUB);
+            expect(convertedValue).toEqual(expectedValue);
+        });
+    });
+});
+describe('defaultToStringConverter', function () {
+    it('should convert to string correctly', function () {
+        var testCases = [
+            {
+                value: 'hello',
+                type: 'string',
+                expectedValue: 'hello'
+            },
+            {
+                value: '',
+                type: 'string',
+                expectedValue: null
+            },
+            {
+                value: null,
+                type: 'string',
+                expectedValue: null
+            },
+            {
+                value: 42,
+                type: 'number',
+                expectedValue: '42'
+            },
+            {
+                value: null,
+                type: 'number',
+                expectedValue: null
+            },
+            {
+                value: true,
+                type: 'boolean',
+                expectedValue: '1'
+            },
+            {
+                value: false,
+                type: 'boolean',
+                expectedValue: null
+            },
+            {
+                value: ['one', 'two', 'three'],
+                type: 'string[]',
+                expectedValue: 'one_two_three'
+            },
+            {
+                value: [],
+                type: 'string[]',
+                expectedValue: ''
+            },
+            {
+                value: null,
+                type: 'string[]',
+                expectedValue: null
+            },
+        ];
+        testCases.forEach(function (_a) {
+            var value = _a.value, type = _a.type, expectedValue = _a.expectedValue;
+            var convertedValue = (0, useAddressBar_1.defaultToStringConverter)(value, type, ITEM_STUB);
+            expect(convertedValue).toEqual(expectedValue);
+        });
+    });
+});
+describe('queryRestore', function () {
+    var mockLocation = {
+        search: '',
+        hash: ''
+    };
+    var mockModel = {
+        primaryKey: 'id',
+        attributes: [
+            'id',
+            'name',
+            {
+                attribute: 'isActive',
+                fromStringConverter: useAddressBar_1.defaultFromStringConverter,
+                jsType: 'boolean'
+            },
+        ]
+    };
+    it('should restore attributes from query parameters', function () {
+        var expectedResult = {
+            id: '1',
+            name: 'John',
+            isActive: true
+        };
+        mockLocation.search = '?id=1&name=John&isActive=true';
+        var result = (0, useAddressBar_1.queryRestore)(mockModel, mockLocation, WITHOUT_HASH);
+        expect(result).toEqual(expectedResult);
+    });
+    it('should restore attributes from hash parameters', function () {
+        var expectedResult = {
+            id: '2',
+            name: 'Jane'
+        };
+        mockLocation.hash = '#id=2&name=Jane&isActive=false';
+        var result = (0, useAddressBar_1.queryRestore)(mockModel, mockLocation, WITH_HASH);
+        expect(result).toEqual(expectedResult);
+    });
+    it('should can use custom converter for attributes', function () {
+        var expectedResult = {
+            isActive: true
+        };
+        mockLocation.search = '?isActive=1';
+        var customModel = {
+            attributes: [{
+                    attribute: 'isActive',
+                    fromStringConverter: function (value) { return value === '1'; },
+                    jsType: 'boolean'
+                }]
+        };
+        var result = (0, useAddressBar_1.queryRestore)(customModel, mockLocation, WITHOUT_HASH);
+        expect(result).toEqual(expectedResult);
+    });
+});
+jest.mock('connected-react-router', function () { return (__assign({ __esModule: true }, jest.requireActual('connected-react-router'))); });
+var replaceSpy = jest.spyOn(connectedReactRouter, 'replace');
+describe('queryReplace', function () {
+    var mockModel = {
+        primaryKey: 'id',
+        attributes: [
+            'id',
+            'name',
+            {
+                attribute: 'isActive',
+                toStringConverter: useAddressBar_1.defaultToStringConverter,
+                jsType: 'boolean'
+            },
+        ]
+    };
+    var mockLocation = {
+        pathname: '/example',
+        search: '',
+        hash: ''
+    };
+    var mockValues = {
+        id: 123,
+        name: 'John',
+        isActive: true
+    };
+    beforeEach(function () {
+        mockLocation.search = '';
+        mockLocation.hash = '';
+        jest.clearAllMocks();
+    });
+    afterAll(function () {
+        jest.restoreAllMocks();
+    });
+    it('should replace query parameters with the given values', function () {
+        var expectedQuery = '/example?id=123&name=John&isActive=1';
+        (0, useAddressBar_1.queryReplace)(mockModel, mockLocation, mockValues, WITHOUT_HASH);
+        expect(replaceSpy).toHaveBeenCalledWith(expectedQuery);
+    });
+    it('should replace hash parameters with the given values', function () {
+        var expectedQuery = '#id=123&name=John&isActive=1';
+        var expectedResult = [];
+        var result = (0, useAddressBar_1.queryReplace)(mockModel, mockLocation, mockValues, WITH_HASH);
+        expect(mockLocation.hash).toBe(expectedQuery);
+        expect(result).toEqual(expectedResult);
+    });
+    it('should not replace parameters with the same values', function () {
+        mockLocation.search = '?id=123&name=John&isActive=1';
+        (0, useAddressBar_1.queryReplace)(mockModel, mockLocation, mockValues, WITHOUT_HASH);
+        expect(replaceSpy).not.toHaveBeenCalled();
+    });
+    it('should not include parameters with falsy values', function () {
+        var defaultValues = {
+            id: null,
+            name: 'John',
+            isActive: null
+        };
+        var expectedQuery = '/example?name=John';
+        (0, useAddressBar_1.queryReplace)(mockModel, mockLocation, defaultValues, WITHOUT_HASH);
+        expect(replaceSpy).toHaveBeenCalledWith(expectedQuery);
+    });
+    it('should can use custom converter for attributes', function () {
+        var customModel = {
+            attributes: [{
+                    attribute: 'isActive',
+                    toStringConverter: function (value) { return (value ? 'active' : 'inactive'); },
+                    jsType: 'boolean'
+                }]
+        };
+        var localValues = {
+            isActive: true
+        };
+        var expectedQuery = '/example?isActive=active';
+        (0, useAddressBar_1.queryReplace)(customModel, mockLocation, localValues, WITHOUT_HASH);
+        expect(replaceSpy).toHaveBeenCalledWith(expectedQuery);
+    });
+});
+jest.mock('react-redux', function () { return (__assign(__assign({ __esModule: true }, jest.requireActual('react-redux')), { useSelector: jest.fn() })); });
+var mockedUseSelector = react_redux_1.useSelector;
+var implementMockedUseSelectorWithStore = function (store) { return mockedUseSelector.mockImplementationOnce(function (callback) { return callback(store); }); };
+describe('useAddressBar Hook', function () {
+    var dispatch = jest.fn();
+    var observerMiddleware = function () { return function (next) { return function (action) {
+        if (dispatch) {
+            dispatch(action);
+        }
+        return next(action);
+    }; }; };
+    var mockStore = (0, redux_mock_store_1["default"])([observerMiddleware, storeMiddlewareMock_1["default"]]);
+    var mockedRouterStateWithoutSearch = {
+        router: {
+            location: {
+                pathname: '/documents',
+                search: '',
+                hash: '',
+                key: 'key',
+                query: {}
+            }
+        }
+    };
+    var mockedRouterStateWithSearch = {
+        router: {
+            location: {
+                pathname: '/documents',
+                search: '?page=1&pageSize=50',
+                hash: '',
+                key: 'key'
+            }
+        }
+    };
+    var configWithDisabledProp = {
+        enable: false
+    };
+    var configWithEnabledProp = {
+        enable: true
+    };
+    beforeEach(function () { return jest.clearAllMocks(); });
+    afterAll(function () { return jest.restoreAllMocks(); });
+    it('should set initial query to null if config is disabled', function () {
+        var store = mockStore(__assign({}, mockedRouterStateWithoutSearch));
+        implementMockedUseSelectorWithStore(mockedRouterStateWithoutSearch);
+        var result = (0, helpers_1.renderHook)(function () { return (0, hooks_1.useAddressBar)(configWithDisabledProp); }, {
+            store: {
+                store: store
+            }
+        }).result;
+        expect(result.current.initialQuery).toBeNull();
+        expect(result.current.updateQuery).toBeInstanceOf(Function);
+    });
+    it('should not dispatch the replace query if this query already exist in location', function () {
+        var store = mockStore(__assign({}, mockedRouterStateWithSearch));
+        implementMockedUseSelectorWithStore(mockedRouterStateWithSearch);
+        var _a = (0, helpers_1.renderHook)(function () { return (0, hooks_1.useAddressBar)(configWithEnabledProp); }, {
+            store: {
+                store: store
+            }
+        }), result = _a.result, rerender = _a.rerender;
+        result.current.updateQuery({
+            layout: null,
+            page: 1,
+            pageSize: 50,
+            sort: null
+        });
+        var expectedNormalizedValues = {
+            page: 1,
+            pageSize: 50
+        };
+        expect(dispatch).toHaveBeenCalledWith([]);
+        rerender();
+        expect(result.current.initialQuery).toEqual(expectedNormalizedValues);
+    });
+    it('should dispatch the replace query if query is not equal to query from location', function () {
+        var store = mockStore(__assign({}, mockedRouterStateWithSearch));
+        implementMockedUseSelectorWithStore(mockedRouterStateWithSearch);
+        var expectedAction = {
+            type: '@@router/CALL_HISTORY_METHOD',
+            payload: {
+                method: 'replace',
+                args: ['/documents?page=2&pageSize=50']
+            }
+        };
+        var _a = (0, helpers_1.renderHook)(function () { return (0, hooks_1.useAddressBar)(configWithEnabledProp); }, {
+            store: {
+                store: store
+            }
+        }), result = _a.result, rerender = _a.rerender;
+        result.current.updateQuery({
+            layout: null,
+            page: 2,
+            pageSize: 50,
+            sort: null
+        });
+        var expectedNormalizedValues = {
+            page: 2,
+            pageSize: 50
+        };
+        expect(dispatch).toHaveBeenCalledWith(expectedAction);
+        rerender();
+        expect(result.current.initialQuery).toEqual(expectedNormalizedValues);
+    });
+    it('should restore query using model attributes', function () {
+        var store = mockStore(__assign({}, mockedRouterStateWithSearch));
+        implementMockedUseSelectorWithStore(mockedRouterStateWithSearch);
+        var mockedProps = {
+            enable: true,
+            model: {
+                primaryKey: 'page',
+                attributes: [
+                    'page',
+                    'pageSize',
+                ]
+            }
+        };
+        var expectedRestoredQuery = {
+            page: '1',
+            pageSize: '50'
+        };
+        var result = (0, helpers_1.renderHook)(function () { return (0, hooks_1.useAddressBar)(mockedProps); }, {
+            store: {
+                store: store
+            }
+        }).result;
+        expect(result.current.initialQuery).toEqual(expectedRestoredQuery);
+    });
+});

package/tests/hooks/useApplication.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';