├── .eslintignore
├── .gitignore
├── .browserslistrc
├── .travis.yml
├── tests
    ├── fixtures
    │   ├── types.js
    │   ├── container.js
    │   ├── actions.js
    │   └── reducer.js
    ├── helper.js
    ├── types.js
    ├── reset.js
    ├── container.jsx
    ├── reducer.js
    └── actions.js
├── .eslintrc
├── appveyor.yml
├── gulpfile.js
├── .babelrc
├── .editorconfig
├── .nycrc
├── docs
    ├── types.md
    ├── install.md
    ├── container.md
    ├── use.md
    ├── actions.md
    ├── reducer.md
    └── options.md
├── package.json
├── README.md
└── src
    └── index.js


/.eslintignore:
--------------------------------------------------------------------------------
1 | lib
2 | coverage
3 | node_modules
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | lib
3 | !lib/.gitkeep
4 | node_modules
5 | coverage
6 | .nyc_output
7 | 


--------------------------------------------------------------------------------
/.browserslistrc:
--------------------------------------------------------------------------------
1 | # Browsers that we support
2 | 
3 | > 1%
4 | Last 2 versions
5 | IE 10 # sorry
6 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "8"
4 |   - "9"
5 |   - "10"
6 | script:
7 |   - npm test
8 |   - npm run report
9 | 


--------------------------------------------------------------------------------
/tests/fixtures/types.js:
--------------------------------------------------------------------------------
1 | export const POST_TITLE = '@@post/TITLE';
2 | export const POST_BODY = '@@post/BODY';
3 | export const POST_SUBMIT = '@@post/SUBMIT';
4 | 


--------------------------------------------------------------------------------
/.eslintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "parser": "babel-eslint",
 3 |   "extends": "airbnb",
 4 |   "env": {
 5 |     "browser": true,
 6 |     "node": true,
 7 |     "mocha": true
 8 |   },
 9 |   "rules": {
10 |     "react/destructuring-assignment": 0
11 |   }
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | environment:
 2 |   matrix:
 3 |     - nodejs_version: "8"
 4 | install:
 5 |   - ps: Install-Product node $env:nodejs_version
 6 |   - npm install
 7 | test_script:
 8 |   - node --version
 9 |   - npm --version
10 |   - npm test
11 | build: off
12 | 


--------------------------------------------------------------------------------
/gulpfile.js:
--------------------------------------------------------------------------------
1 | const gulp = require('gulp');
2 | const babel = require('gulp-babel');
3 | const cleanDest = require('gulp-clean-dest');
4 | 
5 | gulp.task('default', () => gulp.src(['./src/index.js'])
6 |   .pipe(cleanDest('lib'))
7 |   .pipe(babel())
8 |   .pipe(gulp.dest('lib')));
9 | 


--------------------------------------------------------------------------------
/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "presets": [
 3 |     "@babel/preset-env",
 4 |     "@babel/preset-react"
 5 |   ],
 6 |   "plugins": [
 7 |     "@babel/plugin-proposal-class-properties",
 8 |     "@babel/plugin-proposal-object-rest-spread",
 9 |     "@babel/plugin-syntax-dynamic-import"
10 |   ]
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/fixtures/container.js:
--------------------------------------------------------------------------------
 1 | import { connect } from 'react-redux';
 2 | import * as actions from './actions';
 3 | 
 4 | export const POST = '@@post/POST';
 5 | 
 6 | const mapStateToProps = state => state[POST];
 7 | const mapDispatchToProps = { ...actions };
 8 | 
 9 | export default connect(mapStateToProps, mapDispatchToProps);
10 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | # EditorConfig is awesome: http://EditorConfig.org
 2 | 
 3 | # top-most EditorConfig file
 4 | root = true
 5 | 
 6 | # Unix-style newlines with a newline ending every file
 7 | [*]
 8 | end_of_line = lf
 9 | insert_final_newline = true
10 | 
11 | # Set default charse
12 | charset = utf-8
13 | 
14 | # 2 space indentation
15 | indent_style = space
16 | indent_size = 2
17 | 


--------------------------------------------------------------------------------
/tests/fixtures/actions.js:
--------------------------------------------------------------------------------
 1 | import {
 2 |   POST_TITLE,
 3 |   POST_BODY,
 4 |   POST_SUBMIT,
 5 | } from './types';
 6 | 
 7 | export const titleAction = title => ({
 8 |   type: POST_TITLE,
 9 |   title,
10 | });
11 | 
12 | export const bodyAction = body => ({
13 |   type: POST_BODY,
14 |   body,
15 | });
16 | 
17 | export const submitAction = () => ({
18 |   type: POST_SUBMIT,
19 | });
20 | 


--------------------------------------------------------------------------------
/tests/fixtures/reducer.js:
--------------------------------------------------------------------------------
 1 | import { POST_TITLE, POST_BODY } from './types';
 2 | 
 3 | export const defaultState = {
 4 |   title: '',
 5 |   body: '',
 6 | };
 7 | 
 8 | export default (state = defaultState, action) => {
 9 |   switch (action.type) {
10 |     case POST_TITLE:
11 |     case POST_BODY:
12 |       return { ...state, ...action };
13 |     default:
14 |       return state;
15 |   }
16 | };
17 | 


--------------------------------------------------------------------------------
/.nycrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extension": [".js",".jsx"],
 3 |   "require": ["./tests/helper.js"],
 4 |   "exclude": [
 5 |     "node_modules",
 6 |     "lib",
 7 |     "coverage",
 8 |     "tests",
 9 |     "gulpfile.js"
10 |   ],
11 |   "check-coverage": true,
12 |   "per-file": false,
13 |   "statements": 100,
14 |   "branches": 98,
15 |   "functions": 100,
16 |   "lines": 100,
17 |   "reporter": [
18 |     "lcov",
19 |     "text",
20 |     "text-summary",
21 |     "html"
22 |   ],
23 |   "all": true
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/helper.js:
--------------------------------------------------------------------------------
 1 | require('@babel/register');
 2 | 
 3 | const { configure } = require('enzyme');
 4 | const Adapter = require('enzyme-adapter-react-16');
 5 | 
 6 | configure({ adapter: new Adapter() });
 7 | 
 8 | const { JSDOM } = require('jsdom');
 9 | 
10 | const exposedProperties = ['window', 'navigator', 'document'];
11 | 
12 | const { window } = new JSDOM('', { url: 'http://localhost' });
13 | global.document = window.document;
14 | global.window = window;
15 | Object.keys(document.defaultView).forEach((property) => {
16 |   if (typeof global[property] === 'undefined') {
17 |     exposedProperties.push(property);
18 |     global[property] = document.defaultView[property];
19 |   }
20 | });
21 | 
22 | global.navigator = {
23 |   userAgent: 'node.js',
24 | };
25 | 
26 | global.localStorage = {
27 |   setItem() {},
28 | };
29 | 
30 | global.documentRef = document;
31 | 


--------------------------------------------------------------------------------
/tests/types.js:
--------------------------------------------------------------------------------
 1 | import { expect } from 'chai';
 2 | import RL from '../src';
 3 | import * as types from './fixtures/types';
 4 | 
 5 | const rl = new RL('post');
 6 | 
 7 | rl.addAction('title', { title: '' });
 8 | rl.addAction('body', { body: '' });
 9 | rl.addAction('submit');
10 | 
11 | const { types: rlTypes } = rl.flush();
12 | 
13 | describe('Testing types', () => {
14 |   describe('Redux', () => {
15 |     it('should test POST_TITLE', () => {
16 |       expect(types.POST_TITLE).to.be.equal('@@post/TITLE');
17 |     });
18 | 
19 |     it('should test POST_BODY', () => {
20 |       expect(types.POST_BODY).to.be.equal('@@post/BODY');
21 |     });
22 | 
23 |     it('should test POST_SUBMIT', () => {
24 |       expect(types.POST_SUBMIT).to.be.equal('@@post/SUBMIT');
25 |     });
26 |   });
27 | 
28 |   describe('Redux Lazy', () => {
29 |     it('should test POST_TITLE', () => {
30 |       expect(rlTypes.POST_TITLE).to.be.equal('@@post/TITLE');
31 |     });
32 | 
33 |     it('should test POST_BODY', () => {
34 |       expect(rlTypes.POST_BODY).to.be.equal('@@post/BODY');
35 |     });
36 | 
37 |     it('should test POST_SUBMIT', () => {
38 |       expect(rlTypes.POST_SUBMIT).to.be.equal('@@post/SUBMIT');
39 |     });
40 | 
41 |     it('should test type with camelCase to underscore', () => {
42 |       const newRl = new RL('newPost');
43 |       newRl.addAction('newTitle', { title: '' });
44 |       const { types: newRlTypes } = newRl.flush();
45 | 
46 |       expect(newRlTypes.NEW_POST_NEW_TITLE).to.be.equal('@@newPost/NEW_TITLE');
47 |     });
48 |   });
49 | });
50 | 


--------------------------------------------------------------------------------
/docs/types.md:
--------------------------------------------------------------------------------
 1 | # Types
 2 | 
 3 | ## If you use redux you need to create [types](https://redux.js.org/basics/actions):
 4 | 
 5 | ```javascript
 6 | export const POST_TITLE = '@@post/TITLE';
 7 | export const POST_BODY = '@@post/BODY';
 8 | export const POST_SUBMIT = '@@post/SUBMIT';
 9 | ```
10 | 
11 | ## Redux Lazy
12 | 
13 | With Redux Lazy you don't need to make it manually.
14 | Create **rl.js** file inside of your module and put code like this:
15 | 
16 | ```javascript
17 | import RL from 'redux-lazy';
18 | 
19 | const rl = new RL('post');
20 | 
21 | rl.addAction('title', { title: '' });
22 | rl.addAction('body', { body: '' });
23 | rl.addAction('submit');
24 | 
25 | export default rl;
26 | ```
27 | How to add actions see [docs](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md).
28 | 
29 | Then import **rl** where you need it:
30 | 
31 | ```javascript
32 | import rl from './rl';
33 | 
34 | const { types } = rl;
35 | ```
36 | 
37 | ## Testing
38 | 
39 | ```javascript
40 | import { expect } from 'chai';
41 | import rl from '../src/rl';
42 | 
43 | const { types } = rl.flush();
44 | 
45 | describe('Testing types', () => {
46 |   it('should test POST_TITLE', () => {
47 |     expect(types.POST_TITLE).to.be.equal('@@post/TITLE');
48 |   });
49 | 
50 |   it('should test POST_BODY', () => {
51 |     expect(types.POST_BODY).to.be.equal('@@post/BODY');
52 |   });
53 | 
54 |   it('should test POST_SUBMIT', () => {
55 |     expect(types.POST_SUBMIT).to.be.equal('@@post/SUBMIT');
56 |   });  
57 | });
58 | 
59 | ```
60 | 
61 | ## Documentation
62 | 
63 |  * [Install](https://github.com/evheniy/redux-lazy/blob/master/docs/install.md)
64 |  * [How to use](https://github.com/evheniy/redux-lazy/blob/master/docs/use.md)
65 |  * [Actions](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md)
66 |  * [Reducer](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md)
67 |  * [Container](https://github.com/evheniy/redux-lazy/blob/master/docs/container.md)
68 |  * [Options](https://github.com/evheniy/redux-lazy/blob/master/docs/options.md)
69 | 
70 | 
71 | [More examples](https://github.com/evheniy/redux-lazy/blob/master/tests/types.js)
72 | 


--------------------------------------------------------------------------------
/docs/install.md:
--------------------------------------------------------------------------------
 1 | # Install
 2 | 
 3 | ## How to install
 4 | 
 5 |      npm i -S redux-lazy
 6 |      
 7 | Or
 8 | 
 9 |     yarn add redux-lazy
10 |     
11 | ## How to use
12 | 
13 | To work with Redux Lazy you need to make only 3 steps:
14 | 
15 | ### 1. Import redux-lazy
16 | 
17 | ```javascript
18 | import RL from 'redux-lazy';
19 | ```
20 | 
21 | ### 2. Create a instance
22 | 
23 | ```javascript
24 | const rl = new RL('post');
25 | ```
26 | 
27 | ### 3. Add actions
28 | 
29 | ```javascript
30 | rl.addAction('title', { title: '' });
31 | rl.addAction('body', { body: '' });
32 | ```
33 | After that you can flush all code for working with redux:
34 | 
35 | ```javascript
36 | const {
37 |   nameSpace,
38 |   types,
39 |   actions,
40 |   defaultState,
41 |   reducer,
42 |   mapStateToProps,
43 |   mapDispatchToProps,
44 |   Container,
45 | } = rl.flush();
46 | ```
47 | 
48 | You can export each type and action:
49 | 
50 | ```javascript
51 | const {
52 |   nameSpace,
53 |   types,
54 |   actions,
55 |   ...
56 | } = rl.flush();
57 | 
58 | const { titleAction, bodyAction } = actions;
59 | const { POST_TITLE, POST_BODY } = types;
60 | 
61 | export default rl;
62 | 
63 | export {
64 |   nameSpace,
65 |   titleAction,
66 |   bodyAction,
67 |   POST_TITLE,
68 |   POST_BODY,
69 | };
70 | ```
71 | This will help you to avoid magic in code.
72 | 
73 | ## Default state
74 | 
75 | When you add action to Redux Lazy you can set payload.
76 | Payload from all actions creates default state.
77 | 
78 | If you need to customize it you can set default state:
79 | 
80 | ```javascript
81 |   const defaultState = { title: 'title', body: 'body' };
82 |   const rl = new RL('post', defaultState);
83 | ```
84 | 
85 | ## Documentation
86 | 
87 |  * [How to use](https://github.com/evheniy/redux-lazy/blob/master/docs/use.md)
88 |  * [Types](https://github.com/evheniy/redux-lazy/blob/master/docs/types.md)
89 |  * [Actions](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md)
90 |  * [Reducer](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md)
91 |  * [Container](https://github.com/evheniy/redux-lazy/blob/master/docs/container.md)
92 |  * [Options](https://github.com/evheniy/redux-lazy/blob/master/docs/options.md)
93 |    
94 | [More examples](https://github.com/evheniy/redux-lazy/blob/master/tests/)
95 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "redux-lazy",
 3 |   "version": "0.6.1",
 4 |   "description": "redux-lazy",
 5 |   "main": "lib/index.js",
 6 |   "files": [
 7 |     "lib"
 8 |   ],
 9 |   "scripts": {
10 |     "test": "npm-run-all test:*",
11 |     "test:security": "nsp check",
12 |     "test:lint": "eslint . --ext .js,.jsx",
13 |     "test:coverage": "cross-env NODE_ENV=test nyc mocha tests/*.{js,jsx}",
14 |     "report": "cat ./coverage/lcov.info | coveralls",
15 |     "build": "cross-env NODE_ENV=production gulp",
16 |     "precommit": "npm t",
17 |     "prepush": "npm t",
18 |     "release": "npm run build && npm publish"
19 |   },
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "git+https://github.com/evheniy/redux-lazy.git"
23 |   },
24 |   "keywords": [
25 |     "redux",
26 |     "react",
27 |     "lazy",
28 |     "action",
29 |     "creator",
30 |     "types",
31 |     "reduce",
32 |     "container"
33 |   ],
34 |   "author": "Evheniy Bystrov",
35 |   "license": "MIT",
36 |   "bugs": {
37 |     "url": "https://github.com/evheniy/redux-lazy/issues"
38 |   },
39 |   "homepage": "https://github.com/evheniy/redux-lazy#readme",
40 |   "peerDependencies": {
41 |     "react-redux": "^5.0.7",
42 |     "redux": "^4.0.0"
43 |   },
44 |   "devDependencies": {
45 |     "@babel/core": "^7.1.2",
46 |     "@babel/plugin-proposal-class-properties": "^7.1.0",
47 |     "@babel/plugin-proposal-object-rest-spread": "^7.0.0",
48 |     "@babel/plugin-syntax-dynamic-import": "^7.0.0",
49 |     "@babel/preset-env": "^7.1.0",
50 |     "@babel/preset-react": "^7.0.0",
51 |     "@babel/register": "^7.0.0",
52 |     "babel-eslint": "^10.0.1",
53 |     "chai": "^4.2.0",
54 |     "coveralls": "^3.0.2",
55 |     "enzyme": "^3.7.0",
56 |     "enzyme-adapter-react-16": "^1.6.0",
57 |     "eslint": "^5.6.1",
58 |     "eslint-config-airbnb": "^17.1.0",
59 |     "eslint-plugin-import": "^2.14.0",
60 |     "eslint-plugin-jsx-a11y": "^6.1.2",
61 |     "eslint-plugin-react": "^7.11.1",
62 |     "gulp": "^4.0.0",
63 |     "gulp-babel": "^8.0.0",
64 |     "gulp-clean-dest": "^0.2.0",
65 |     "gulp-react": "^3.1.0",
66 |     "husky": "^1.1.1",
67 |     "jsdom": "^12.2.0",
68 |     "mocha": "^5.2.0",
69 |     "npm-run-all": "^4.1.3",
70 |     "nsp": "^3.2.1",
71 |     "nyc": "^13.1.0",
72 |     "react": "^16.5.2",
73 |     "react-dom": "^16.5.2",
74 |     "react-redux": "^5.0.7",
75 |     "redux": "^4.0.0",
76 |     "redux-mock-store": "^1.5.3",
77 |     "sinon": "^6.3.5"
78 |   },
79 |   "dependencies": {
80 |     "cross-env": "^5.2.0"
81 |   }
82 | }
83 | 


--------------------------------------------------------------------------------
/docs/container.md:
--------------------------------------------------------------------------------
 1 | # Container
 2 | 
 3 | To get state from store and put it to React components you should use **[react-redux](https://github.com/reduxjs/react-redux)** library.
 4 | It has **[connect](https://github.com/reduxjs/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)** - high order component (HOC) to get part of store and put it to component.
 5 | 
 6 | ## Redux
 7 | 
 8 | ```javascript
 9 | import { connect } from 'react-redux';
10 | import * as actions from './actions';
11 | 
12 | export const POST = '@@post/POST';
13 | 
14 | const mapStateToProps = state => state[POST];
15 | const mapDispatchToProps = { ...actions };
16 | 
17 | export default connect(mapStateToProps, mapDispatchToProps);
18 | ```
19 | 
20 | Here we have 3 main points:
21 | 
22 |  * We need to create constant (POST) - it's useful for working with **[combineReducers](https://redux.js.org/basics/reducers#splitting-reducers)** and making selectors for **[mapStateToProps](https://github.com/reduxjs/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)**.
23 |  * We need to create selector and put it to **[mapStateToProps](https://github.com/reduxjs/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)**.
24 |  * We need to create **[mapDispatchToProps](https://github.com/reduxjs/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)**.
25 | 
26 | After that we can use **connect** to wrap React component and put part of state using **selectors**.
27 | 
28 | ## Redux Lazy
29 | 
30 | With Redux Lazy you don't need to make it manually.
31 | Create **rl.js** file inside of your module and put code like this:
32 | 
33 | ```javascript
34 | import RL from 'redux-lazy';
35 | 
36 | const rl = new RL('post');
37 | 
38 | rl.addAction('title', { title: '' });
39 | rl.addAction('body', { body: '' });
40 | rl.addAction('submit');
41 | 
42 | export default rl;
43 | ```
44 | 
45 | Then import **rl** where you need it:
46 | 
47 | ```javascript
48 | import rl from './rl';
49 | 
50 | const {
51 |   nameSpace,
52 |   Container,
53 |   mapStateToProps,
54 |   mapDispatchToProps,
55 | } = rl;
56 | ```
57 | 
58 | We can use **nameSpace** for selectors.
59 | 
60 | 
61 | ## Documentation
62 | 
63 |  * [Install](https://github.com/evheniy/redux-lazy/blob/master/docs/install.md)
64 |  * [How to use](https://github.com/evheniy/redux-lazy/blob/master/docs/use.md)
65 |  * [Types](https://github.com/evheniy/redux-lazy/blob/master/docs/types.md)
66 |  * [Actions](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md)
67 |  * [Reducer](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md)
68 |  * [Options](https://github.com/evheniy/redux-lazy/blob/master/docs/options.md)
69 | 
70 | [More examples](https://github.com/evheniy/redux-lazy/blob/master/tests/container.jsx)
71 | 


--------------------------------------------------------------------------------
/docs/use.md:
--------------------------------------------------------------------------------
  1 | # How to use
  2 | 
  3 | ## Form
  4 | 
  5 | If you need to submit form:
  6 | 
  7 | ### Redux
  8 | 
  9 | Action:
 10 | ```javascript
 11 | export const MODULE_SUBMIT = '@@module/SUBMIT';
 12 | 
 13 | export const submitAction = () => ({
 14 |   type: MODULE_SUBMIT,
 15 | });
 16 | ```
 17 | React:
 18 | ```html
 19 | <form onSubmit={(event) => {
 20 |     event.preventDefault();
 21 |     props.submitAction();
 22 | }}>
 23 | ```
 24 | 
 25 | ### Redux Lazy
 26 | 
 27 | Action:
 28 | ```javascript
 29 | rl.addFormAction('submit');
 30 | ```
 31 | React:
 32 | ```html
 33 | <form onSubmit={props.submitAction}>
 34 | ```
 35 | 
 36 | ## Form Element
 37 | 
 38 | If you need to get value from form input (textarea or < input type="text" />):
 39 | 
 40 | ### Redux
 41 | 
 42 | Action:
 43 | ```javascript
 44 | export const MODULE_TITLE = '@@module/TITLE';
 45 | 
 46 | export const titleAction = (title) => ({
 47 |   type: MODULE_SUBMIT,
 48 |   title,
 49 | });
 50 | ```
 51 | React:
 52 | ```html
 53 | <input
 54 |   type="text"
 55 |   onChange={event => props.titleAction(event.target.value)}
 56 |   value={props.title}
 57 | />
 58 | ```
 59 | 
 60 | ### Redux Lazy
 61 | 
 62 | Action:
 63 | ```javascript
 64 | rl.addFormElementAction('title', 'defaultValue');
 65 | ```
 66 | React:
 67 | ```html
 68 | <input
 69 |   type="text"
 70 |   onChange={props.titleAction}
 71 |   value={props.title}
 72 | />
 73 | ```
 74 | 
 75 | ## Event
 76 | 
 77 | If you need to get event, for example button click:
 78 | 
 79 | ```javascript
 80 | rl.addEventAction('event');
 81 | ```
 82 | React:
 83 | ```html
 84 | <button onClick={props.eventAction} />
 85 | ```
 86 | 
 87 | 
 88 | ## Action with parameter
 89 | 
 90 | You can emulate redux action:
 91 | 
 92 | ```javascript
 93 | rl.addParamAction('title', 'defaultValue');
 94 | 
 95 | const { actions } = rl.flush();
 96 | ```
 97 | And you will have action:
 98 | 
 99 | ```javascript
100 | actions.titleActions('text');
101 | ```
102 | Result:
103 | 
104 | ```javascript
105 | {
106 |   type: types.POST_TITLE,
107 |   title: 'text',
108 | }
109 | ```
110 | 
111 | Or with default value:
112 | 
113 | ```javascript
114 | actions.titleActions();
115 | ```
116 | Result:
117 | 
118 | ```javascript
119 | {
120 |   type: types.POST_TITLE,
121 |   title: 'defaultValue',
122 | }
123 | ```
124 | 
125 | ## Action with parameters
126 | 
127 | If you need to update more than one parameter:
128 | 
129 | 
130 | ```javascript
131 | rl.addParamsAction('clear', { title: 'defaultTitleValue', body: 'defaultBodyValue' });
132 | 
133 | const { actions } = rl.flush();
134 | ```
135 | 
136 | And you will have action:
137 | 
138 | ```javascript
139 | actions.clearActions('title', 'body');
140 | ```
141 | Result:
142 | 
143 | ```javascript
144 | {
145 |   type: types.POST_TITLE,
146 |   title: 'title',
147 |   body: 'body',
148 | }
149 | ```
150 | 
151 | Or with default value:
152 | 
153 | ```javascript
154 | actions.clearActions();
155 | ```
156 | Result:
157 | 
158 | ```javascript
159 | {
160 |   type: types.POST_TITLE,
161 |   title: 'defaultTitleValue',
162 |   body: 'defaultBodyValue',
163 | }
164 | ```
165 | 
166 | ## Documentation
167 | 
168 |  * [Install](https://github.com/evheniy/redux-lazy/blob/master/docs/install.md)
169 |  * [Types](https://github.com/evheniy/redux-lazy/blob/master/docs/types.md)
170 |  * [Actions](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md)
171 |  * [Reducer](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md)
172 |  * [Container](https://github.com/evheniy/redux-lazy/blob/master/docs/container.md)
173 |  * [Options](https://github.com/evheniy/redux-lazy/blob/master/docs/options.md)
174 | 


--------------------------------------------------------------------------------
/tests/reset.js:
--------------------------------------------------------------------------------
  1 | import { expect } from 'chai';
  2 | 
  3 | import RL from '../src';
  4 | 
  5 | describe('Testing reset actions', () => {
  6 |   it('should test without default state', () => {
  7 |     const rl = new RL('post');
  8 | 
  9 |     rl.addParamAction('test', 'test');
 10 |     rl.addResetAction();
 11 | 
 12 |     const { types, actions } = rl.flush();
 13 | 
 14 |     expect(!!actions.resetAction).to.be.equal(true);
 15 | 
 16 |     const action = actions.resetAction();
 17 | 
 18 |     expect(action).to.be.a('object');
 19 | 
 20 |     expect(action.type).to.be.equal(types.POST_RESET);
 21 |     expect(action.test).to.be.equal('test');
 22 | 
 23 |     expect(action).to.be.eql({
 24 |       test: 'test',
 25 |       type: types.POST_RESET,
 26 |     });
 27 |   });
 28 | 
 29 |   it('should test with default state', () => {
 30 |     const defaultState = { value: 1 };
 31 | 
 32 |     const rl = new RL('post', defaultState);
 33 | 
 34 |     rl.addParamAction('test', 'test');
 35 |     rl.addResetAction();
 36 | 
 37 |     const { types, actions } = rl.flush();
 38 | 
 39 |     expect(!!actions.resetAction).to.be.equal(true);
 40 | 
 41 |     const action = actions.resetAction();
 42 | 
 43 |     expect(action).to.be.a('object');
 44 | 
 45 |     expect(action.type).to.be.equal(types.POST_RESET);
 46 |     expect(action.value).to.be.equal(1);
 47 |     expect(action.test).to.be.equal('test');
 48 | 
 49 |     expect(action).to.be.eql({
 50 |       test: 'test',
 51 |       value: 1,
 52 |       type: types.POST_RESET,
 53 |     });
 54 |   });
 55 | 
 56 |   it('should test custom name', () => {
 57 |     const rl = new RL('post');
 58 | 
 59 |     rl.addParamAction('test', 'test');
 60 |     rl.addResetAction('clear');
 61 | 
 62 |     const { types, actions } = rl.flush();
 63 | 
 64 |     expect(!!actions.resetAction).to.be.equal(false);
 65 |     expect(!!actions.clearAction).to.be.equal(true);
 66 | 
 67 |     const action = actions.clearAction();
 68 | 
 69 |     expect(action).to.be.a('object');
 70 | 
 71 |     expect(action.type).to.be.equal(types.POST_CLEAR);
 72 |     expect(action.test).to.be.equal('test');
 73 | 
 74 |     expect(action).to.be.eql({
 75 |       test: 'test',
 76 |       type: types.POST_CLEAR,
 77 |     });
 78 |   });
 79 | 
 80 |   it('should test exactly option', () => {
 81 |     const rl = new RL('post');
 82 | 
 83 |     rl.addParamAction('test', 'test');
 84 |     rl.addResetAction('clear', true);
 85 | 
 86 |     const { types, actions } = rl.flush();
 87 | 
 88 |     expect(!!actions.resetAction).to.be.equal(false);
 89 |     expect(!!actions.clearAction).to.be.equal(true);
 90 | 
 91 |     const action = actions.clearAction();
 92 | 
 93 |     expect(action).to.be.a('object');
 94 | 
 95 |     expect(action.type).to.be.equal(types.POST_CLEAR);
 96 | 
 97 |     expect(action).to.be.eql({
 98 |       type: types.POST_CLEAR,
 99 |     });
100 |   });
101 | 
102 |   it('should test exactly option with default state', () => {
103 |     const defaultState = { value: 1 };
104 | 
105 |     const rl = new RL('post', defaultState);
106 | 
107 |     rl.addParamAction('test', 'test');
108 |     rl.addResetAction('clear', true);
109 | 
110 |     const { types, actions } = rl.flush();
111 | 
112 |     expect(!!actions.resetAction).to.be.equal(false);
113 |     expect(!!actions.clearAction).to.be.equal(true);
114 | 
115 |     const action = actions.clearAction();
116 | 
117 |     expect(action).to.be.a('object');
118 | 
119 |     expect(action.type).to.be.equal(types.POST_CLEAR);
120 |     expect(action.value).to.be.equal(1);
121 | 
122 |     expect(action).to.be.eql({
123 |       value: 1,
124 |       type: types.POST_CLEAR,
125 |     });
126 |   });
127 | });
128 | 


--------------------------------------------------------------------------------
/tests/container.jsx:
--------------------------------------------------------------------------------
  1 | import React from 'react';
  2 | import { mount } from 'enzyme';
  3 | import { expect } from 'chai';
  4 | import { spy } from 'sinon';
  5 | import configureMockStore from 'redux-mock-store';
  6 | import { Provider } from 'react-redux';
  7 | 
  8 | import PostContainer, { POST } from './fixtures/container';
  9 | 
 10 | import RL from '../src';
 11 | 
 12 | const rl = new RL('post');
 13 | 
 14 | rl.addAction('title', { title: '' });
 15 | rl.addAction('body', { body: '' });
 16 | rl.addAction('submit');
 17 | 
 18 | const {
 19 |   actions: rlActions,
 20 |   nameSpace,
 21 |   Container: RLPostContainer,
 22 |   mapStateToProps,
 23 |   mapDispatchToProps,
 24 | } = rl.flush();
 25 | 
 26 | describe('Testing container', () => {
 27 |   describe('Redux', () => {
 28 |     it('should test nameSpace', () => {
 29 |       expect(POST).to.be.equal('@@post/POST');
 30 |     });
 31 | 
 32 |     it('should test container', () => {
 33 |       const Component = spy(() => null);
 34 |       const Container = PostContainer(Component);
 35 | 
 36 |       const title = 'title';
 37 |       const body = 'body';
 38 | 
 39 |       const mockStore = configureMockStore([]);
 40 |       const store = mockStore({
 41 |         [POST]: {
 42 |           title,
 43 |           body,
 44 |         },
 45 |       });
 46 | 
 47 |       const wrapper = mount(
 48 |         <Provider store={store}>
 49 |           <Container />
 50 |         </Provider>,
 51 |       );
 52 | 
 53 |       expect(wrapper.find(Component)).to.have.length(1);
 54 | 
 55 |       const props = wrapper.find(Component).props();
 56 | 
 57 |       expect(props.title).to.be.equal(title);
 58 |       expect(props.body).to.be.equal(body);
 59 |       expect(props.titleAction).to.be.a('function');
 60 |       expect(props.bodyAction).to.be.a('function');
 61 |       expect(props.submitAction).to.be.a('function');
 62 |     });
 63 |   });
 64 | 
 65 |   describe('Redux Lazy', () => {
 66 |     it('should test nameSpace', () => {
 67 |       expect(nameSpace).to.be.equal('@@post/POST');
 68 |       expect(nameSpace).to.be.equal(POST);
 69 |     });
 70 | 
 71 |     it('should test container', () => {
 72 |       const Component = spy(() => null);
 73 |       const Container = RLPostContainer(Component);
 74 | 
 75 |       const title = 'title';
 76 |       const body = 'body';
 77 | 
 78 |       const mockStore = configureMockStore([]);
 79 |       const store = mockStore({
 80 |         [nameSpace]: {
 81 |           title,
 82 |           body,
 83 |         },
 84 |       });
 85 | 
 86 |       const wrapper = mount(
 87 |         <Provider store={store}>
 88 |           <Container />
 89 |         </Provider>,
 90 |       );
 91 | 
 92 |       expect(wrapper.find(Component)).to.have.length(1);
 93 | 
 94 |       const props = wrapper.find(Component).props();
 95 | 
 96 |       expect(props.title).to.be.equal(title);
 97 |       expect(props.body).to.be.equal(body);
 98 |       expect(props.titleAction).to.be.a('function');
 99 |       expect(props.bodyAction).to.be.a('function');
100 |       expect(props.submitAction).to.be.a('function');
101 |     });
102 | 
103 |     it('should test mapStateToProps', () => {
104 |       const title = 'title';
105 |       const body = 'body';
106 | 
107 |       const state = {
108 |         [nameSpace]: {
109 |           title,
110 |           body,
111 |         },
112 |       };
113 | 
114 |       const props = mapStateToProps(state);
115 | 
116 |       expect(props).to.be.eql({ title, body });
117 |     });
118 | 
119 |     it('should test mapDispatchToProps', () => {
120 |       expect(mapDispatchToProps).to.be.a('object');
121 | 
122 |       expect(mapDispatchToProps).to.be.eql(rlActions);
123 | 
124 |       expect(mapDispatchToProps.titleAction).to.be.a('function');
125 |       expect(mapDispatchToProps.bodyAction).to.be.a('function');
126 |       expect(mapDispatchToProps.submitAction).to.be.a('function');
127 |     });
128 |   });
129 | });
130 | 


--------------------------------------------------------------------------------
/docs/actions.md:
--------------------------------------------------------------------------------
  1 | # Actions
  2 | 
  3 | **[Action creators](https://redux.js.org/basics/actions#action-creators)** are exactly that—functions that create actions. 
  4 | It's easy to conflate the terms “action” and “action creator”, so do your best to use the proper term.
  5 | 
  6 | ## Redux
  7 | 
  8 | To update redux state you need to create action creator for each action type.
  9 | 
 10 | 
 11 | ```javascript
 12 | import {
 13 |   POST_TITLE,
 14 |   POST_BODY,
 15 |   POST_SUBMIT,
 16 | } from './types';
 17 | 
 18 | export const titleAction = title => ({
 19 |   type: POST_TITLE,
 20 |   title,
 21 | });
 22 | 
 23 | export const bodyAction = body => ({
 24 |   type: POST_BODY,
 25 |   body,
 26 | });
 27 | 
 28 | export const submitAction = () => ({
 29 |   type: POST_SUBMIT,
 30 | });
 31 | 
 32 | ```
 33 | 
 34 | ## Redux Lazy
 35 | 
 36 | With Redux Lazy you don't need to make it manually.
 37 | Create **rl.js** file inside of your module and put code like this:
 38 | 
 39 | ```javascript
 40 | import RL from 'redux-lazy';
 41 | 
 42 | const rl = new RL('post');
 43 | 
 44 | rl.addAction('title', { title: '' });
 45 | rl.addAction('body', { body: '' });
 46 | rl.addAction('submit');
 47 | 
 48 | export default rl;
 49 | ```
 50 | 
 51 | Then import **rl** where you need it:
 52 | 
 53 | ```javascript
 54 | import rl from './rl';
 55 | 
 56 | const { actions } = rl;
 57 | ```
 58 | 
 59 | ## Default parameters
 60 | 
 61 | When you create action you can set payload.
 62 | It will be a part of default state:
 63 | 
 64 | 
 65 | ```javascript
 66 | rl.addAction('title', { title: 'title' });
 67 | ```
 68 | 
 69 | Or
 70 | 
 71 | ```javascript
 72 | const title = 'title';
 73 | 
 74 | rl.addAction('title', { title });
 75 | ```
 76 | 
 77 | And to run:
 78 | 
 79 | ```javascript
 80 | import rl from '../src/rl'
 81 | 
 82 | const { actions } = rl.flush();
 83 | 
 84 | const action = actions.titleAction();
 85 | ```
 86 | 
 87 | It will return:
 88 | 
 89 | 
 90 | ```javascript
 91 | {
 92 |   type: types.POST_TITLE,
 93 |   payload: {
 94 |     title: 'title',
 95 |   },
 96 | }
 97 | ```
 98 | 
 99 | How to set default state see [docs](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md).
100 | 
101 | ## Testing
102 | 
103 | ```javascript
104 | import { expect } from 'chai';
105 | import rl from '../src/rl'
106 | 
107 | const { types, actions } = rl.flush();
108 | 
109 | describe('Testing actions', () => {
110 |   it('should test titleAction', () => {
111 |     const title = 'title';
112 | 
113 |     const action = actions.titleAction({ title });
114 | 
115 |     expect(action).to.be.a('object');
116 | 
117 |     expect(action.type).to.be.equal(types.POST_TITLE);
118 |     expect(action.payload.title).to.be.equal(title);
119 |   });
120 | 
121 |   it('should test bodyAction', () => {
122 |     const body = 'body';
123 | 
124 |     const action = actions.bodyAction({ body });
125 | 
126 |     expect(action).to.be.a('object');
127 | 
128 |     expect(action.type).to.be.equal(types.POST_BODY);
129 |     expect(action.payload.body).to.be.equal(body);
130 |   });
131 | 
132 |   it('should test submitAction', () => {
133 |     const action = actions.submitAction();
134 | 
135 |     expect(action).to.be.a('object');
136 | 
137 |     expect(action.type).to.be.equal(types.POST_SUBMIT);
138 |   });
139 | });
140 | 
141 | ```
142 | 
143 | ## Documentation
144 | 
145 |  * [Install](https://github.com/evheniy/redux-lazy/blob/master/docs/install.md)
146 |  * [How to use](https://github.com/evheniy/redux-lazy/blob/master/docs/use.md)
147 |  * [Types](https://github.com/evheniy/redux-lazy/blob/master/docs/types.md)
148 |  * [Reducer](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md)
149 |  * [Container](https://github.com/evheniy/redux-lazy/blob/master/docs/container.md)
150 |  * [Options](https://github.com/evheniy/redux-lazy/blob/master/docs/options.md)
151 | 
152 | [More examples](https://github.com/evheniy/redux-lazy/blob/master/tests/actions.js)
153 | 


--------------------------------------------------------------------------------
/docs/reducer.md:
--------------------------------------------------------------------------------
  1 | # Reducer
  2 | 
  3 | **[Reducers](https://redux.js.org/basics/reducers)** specify how the application's state changes in response to [actions](https://redux.js.org/basics/actions) sent to the store. 
  4 | Remember that actions only describe *what happened*, but don't describe how the application's state changes.
  5 | 
  6 | ## Redux
  7 | 
  8 | To change redux state you need to create reducer:
  9 | 
 10 | ```javascript
 11 | import { POST_TITLE, POST_BODY } from './types';
 12 | 
 13 | export const defaultState = {
 14 |   title: '',
 15 |   body: '',
 16 | };
 17 | 
 18 | export default (state = defaultState, action) => {
 19 |   switch (action.type) {
 20 |     case POST_TITLE:
 21 |     case POST_BODY:
 22 |       return { ...state, ...action };
 23 |     default:
 24 |       return state;
 25 |   }
 26 | };
 27 | ```
 28 | 
 29 | ## Redux Lazy
 30 | 
 31 | With Redux Lazy you don't need to make it manually.
 32 | Create **rl.js** file inside of your module and put code like this:
 33 | 
 34 | ```javascript
 35 | import RL from 'redux-lazy';
 36 | 
 37 | const rl = new RL('post');
 38 | 
 39 | rl.addAction('title', { title: '' });
 40 | rl.addAction('body', { body: '' });
 41 | rl.addAction('submit');
 42 | 
 43 | export default rl;
 44 | ```
 45 | 
 46 | Then import **rl** where you need it:
 47 | 
 48 | ```javascript
 49 | import rl from './rl';
 50 | 
 51 | const { reducer } = rl;
 52 | ```
 53 | 
 54 | ## Default state
 55 | 
 56 | When you create Redux Lazy instance you can set default state as the second parameter
 57 | 
 58 | ```javascript
 59 | const defaultState = { title: 'title', body: 'body' };
 60 | const rl = new RL('post', defaultState);
 61 | const { defaultState: newRlDefaultState } = rl.flush();
 62 | ```
 63 | 
 64 | ## Testing
 65 | 
 66 | ```javascript
 67 | import { expect } from 'chai';
 68 | import RL from '../src';
 69 | import * as types from './fixtures/types';
 70 | import reducer from './fixtures/reducer';
 71 | 
 72 | const rl = new RL('post');
 73 | 
 74 | rl.addAction('title', { title: '' });
 75 | rl.addAction('body', { body: '' });
 76 | rl.addAction('submit');
 77 | 
 78 | const {
 79 |   types,
 80 |   reducer,
 81 |   defaultState: rlDefaultState,
 82 | } = rl.flush();
 83 | 
 84 | describe('Testing reducer', () => {
 85 |   const defaultState = {
 86 |     title: '',
 87 |     body: '',
 88 |   };
 89 | 
 90 |   it('should test RL default state', () => {
 91 |     expect(rlDefaultState).to.be.eql(defaultState);
 92 |   });
 93 | 
 94 |   it('should test RL new default state', () => {
 95 |     const newDefaultState = { title: 'title', body: 'body' };
 96 |     const newRl = new RL('post', newDefaultState);
 97 |     const { defaultState: newRlDefaultState } = newRl.flush();
 98 | 
 99 |     expect(newRlDefaultState).to.be.not.eql(defaultState);
100 |     expect(newRlDefaultState).to.be.eql(newDefaultState);
101 |   });
102 | 
103 |   it('should test default state', () => {
104 |     const state = reducer(undefined, { type: 'test' });
105 | 
106 |     expect(state).to.be.eql(defaultState);
107 |   });
108 | 
109 |   it('should test POST_TITLE action', () => {
110 |     const title = 'title';
111 | 
112 |     const state = reducer(undefined, { type: types.POST_TITLE, payload: { title } });
113 | 
114 |     expect(state.title).to.be.equal(title);
115 |   });
116 | 
117 |   it('should test POST_BODY action', () => {
118 |     const body = 'body';
119 | 
120 |     const state = reducer(undefined, { type: types.POST_BODY, payload: { body } });
121 | 
122 |     expect(state.body).to.be.equal(body);
123 |   });
124 | 
125 |   it('should test default state with value', () => {
126 |     const state = reducer({ test: true }, { type: 'test' });
127 | 
128 |     expect(state.test).to.be.equal(true);
129 |   });
130 | });
131 | ```
132 | 
133 | ## Documentation
134 | 
135 |  * [Install](https://github.com/evheniy/redux-lazy/blob/master/docs/install.md)
136 |  * [How to use](https://github.com/evheniy/redux-lazy/blob/master/docs/use.md)
137 |  * [Types](https://github.com/evheniy/redux-lazy/blob/master/docs/types.md)
138 |  * [Actions](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md)
139 |  * [Container](https://github.com/evheniy/redux-lazy/blob/master/docs/container.md)
140 |  * [Options](https://github.com/evheniy/redux-lazy/blob/master/docs/options.md)
141 | 
142 | [More examples](https://github.com/evheniy/redux-lazy/blob/master/tests/reducer.js)
143 | 
144 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # redux-lazy
 2 | 
 3 | Generating constants, action types, action creators, reducers and containers for you.
 4 | 
 5 | [![NPM](https://nodei.co/npm/redux-lazy.png)](https://npmjs.org/package/redux-lazy)
 6 | 
 7 | [![npm version](https://badge.fury.io/js/redux-lazy.svg)](https://badge.fury.io/js/redux-lazy)
 8 | [![Build Status](https://travis-ci.org/evheniy/redux-lazy.svg?branch=master)](https://travis-ci.org/evheniy/redux-lazy)
 9 | [![Coverage Status](https://coveralls.io/repos/github/evheniy/redux-lazy/badge.svg?branch=master)](https://coveralls.io/github/evheniy/redux-lazy?branch=master)
10 | [![Linux Build](https://img.shields.io/travis/evheniy/redux-lazy/master.svg?label=linux)](https://travis-ci.org/evheniy/)
11 | [![Windows Build](https://img.shields.io/appveyor/ci/evheniy/redux-lazy/master.svg?label=windows)](https://ci.appveyor.com/project/evheniy/redux-lazy)
12 | 
13 | [![Dependency Status](https://david-dm.org/evheniy/redux-lazy.svg)](https://david-dm.org/evheniy/redux-lazy)
14 | [![devDependency Status](https://david-dm.org/evheniy/redux-lazy/dev-status.svg)](https://david-dm.org/evheniy/redux-lazy#info=devDependencies)
15 | [![peerDependencies Status](https://david-dm.org/evheniy/redux-lazy/peer-status.svg)](https://david-dm.org/evheniy/redux-lazy?type=peer)
16 | 
17 | [![NSP Status](https://img.shields.io/badge/NSP%20status-no%20vulnerabilities-green.svg)](https://travis-ci.org/evheniy/redux-lazy)
18 | [![Known Vulnerabilities](https://snyk.io/test/github/evheniy/redux-lazy/badge.svg)](https://snyk.io/test/github/evheniy/redux-lazy)
19 | [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/evheniy/redux-lazy/master/LICENSE)
20 | [![GitHub stars](https://img.shields.io/github/stars/evheniy/redux-lazy.svg)](https://github.com/evheniy/redux-lazy/stargazers)
21 | [![GitHub forks](https://img.shields.io/github/forks/evheniy/redux-lazy.svg)](https://github.com/evheniy/redux-lazy/network)
22 | [![GitHub issues](https://img.shields.io/github/issues/evheniy/redux-lazy.svg)](https://github.com/evheniy/redux-lazy/issues)
23 | [![Twitter](https://img.shields.io/twitter/url/https/github.com/evheniy/redux-lazy.svg?style=social)](https://twitter.com/intent/tweet?text=Wow:&url=%5Bobject%20Object%5D)
24 | 
25 | 
26 | ## How to install
27 | 
28 |      npm i -S redux-lazy
29 | 
30 | ## How to use
31 | 
32 | ```javascript
33 | import RL from 'redux-lazy';
34 | 
35 | const rl = new RL('post');
36 | 
37 | rl.addAction('title', { title: '' });
38 | 
39 | const {
40 |   nameSpace,
41 |   types,
42 |   actions,
43 |   defaultState,
44 |   reducer,
45 |   mapStateToProps,
46 |   mapDispatchToProps,
47 |   Container,
48 | } = rl.flush();
49 | ```
50 | 
51 | ### React example
52 | 
53 | ```javascript
54 | import React from 'react';
55 | import RL from 'redux-lazy';
56 | 
57 | const rl = new RL('post');
58 | 
59 | rl.addFormAction('submit');
60 | rl.addFormElementAction('title');
61 | 
62 | const { Container, reducer } = rl.flush();
63 | 
64 | const FormComponent = props => (
65 |   <form onSubmit={props.submitAction}>
66 |     <input
67 |       type="text"
68 |       value={props.title}
69 |       onChange={props.titleAction}
70 |     />
71 |   </form>
72 | );
73 | 
74 | export default Container(FormComponent);
75 | 
76 | export { reducer };
77 | ```
78 | 
79 | Just add reducer to redux and this example should work.
80 | 
81 | ## Articles
82 | 
83 | **React — redux for lazy developers:**
84 |  * [Part 1](https://hackernoon.com/react-redux-for-lazy-developers-b551f16a456f)
85 |  * [Part 2](https://hackernoon.com/react-redux-for-lazy-developers-part-2-d0c60123592f)
86 |  * [Part 3](https://medium.com/@evheniybystrov/react-redux-for-lazy-developers-part-3-319b639a22c3)
87 | 
88 | **[React/Redux development on steroids](https://medium.com/@evheniybystrov/react-redux-development-on-steroids-95dfed7e7a85)**
89 | 
90 | ## Documentation
91 | 
92 |  * [Install](https://github.com/evheniy/redux-lazy/blob/master/docs/install.md)
93 |  * [How to use](https://github.com/evheniy/redux-lazy/blob/master/docs/use.md)
94 |  * [Types](https://github.com/evheniy/redux-lazy/blob/master/docs/types.md)
95 |  * [Actions](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md)
96 |  * [Reducer](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md)
97 |  * [Container](https://github.com/evheniy/redux-lazy/blob/master/docs/container.md)
98 |  * [Options](https://github.com/evheniy/redux-lazy/blob/master/docs/options.md)
99 | 


--------------------------------------------------------------------------------
/tests/reducer.js:
--------------------------------------------------------------------------------
  1 | import { expect } from 'chai';
  2 | import RL from '../src';
  3 | import * as types from './fixtures/types';
  4 | import reducer from './fixtures/reducer';
  5 | 
  6 | const rl = new RL('post');
  7 | 
  8 | rl.addAction('title', { title: '' });
  9 | rl.addAction('body', { body: '' });
 10 | rl.addAction('submit');
 11 | 
 12 | const {
 13 |   types: rlTypes,
 14 |   reducer: rlReducer,
 15 |   defaultState: rlDefaultState,
 16 | } = rl.flush();
 17 | 
 18 | describe('Testing reducer', () => {
 19 |   const defaultState = {
 20 |     title: '',
 21 |     body: '',
 22 |   };
 23 | 
 24 |   describe('Redux', () => {
 25 |     it('should test default state', () => {
 26 |       const state = reducer(undefined, { type: 'test' });
 27 | 
 28 |       expect(state).to.be.eql(defaultState);
 29 |     });
 30 | 
 31 |     it('should test POST_TITLE action', () => {
 32 |       const title = 'title';
 33 | 
 34 |       const state = reducer(undefined, { type: types.POST_TITLE, title });
 35 | 
 36 |       expect(state.title).to.be.equal(title);
 37 |     });
 38 | 
 39 |     it('should test POST_BODY action', () => {
 40 |       const body = 'body';
 41 | 
 42 |       const state = reducer(undefined, { type: types.POST_BODY, body });
 43 | 
 44 |       expect(state.body).to.be.equal(body);
 45 |     });
 46 | 
 47 |     it('should test default state with value', () => {
 48 |       const state = reducer({ test: true }, { type: 'test' });
 49 | 
 50 |       expect(state.test).to.be.equal(true);
 51 |     });
 52 |   });
 53 | 
 54 |   describe('Redux Lazy', () => {
 55 |     it('should test RL default state', () => {
 56 |       expect(rlDefaultState).to.be.eql(defaultState);
 57 |     });
 58 | 
 59 |     it('should test RL new default state', () => {
 60 |       const newDefaultState = { title: 'title', body: 'body' };
 61 |       const newRl = new RL('post', newDefaultState);
 62 |       const { defaultState: newRlDefaultState } = newRl.flush();
 63 | 
 64 |       expect(newRlDefaultState).to.be.not.eql(defaultState);
 65 |       expect(newRlDefaultState).to.be.eql(newDefaultState);
 66 |     });
 67 | 
 68 |     it('should test default state', () => {
 69 |       const state = rlReducer(undefined, { type: 'test' });
 70 | 
 71 |       expect(state).to.be.eql(defaultState);
 72 |     });
 73 | 
 74 |     it('should test POST_TITLE action', () => {
 75 |       const title = 'title';
 76 | 
 77 |       const state = rlReducer(undefined, { type: rlTypes.POST_TITLE, payload: { title } });
 78 | 
 79 |       expect(state.title).to.be.equal(title);
 80 |     });
 81 | 
 82 |     it('should test POST_BODY action', () => {
 83 |       const body = 'body';
 84 | 
 85 |       const state = rlReducer(undefined, { type: rlTypes.POST_BODY, payload: { body } });
 86 | 
 87 |       expect(state.body).to.be.equal(body);
 88 |     });
 89 | 
 90 |     it('should test default state with value', () => {
 91 |       const state = rlReducer({ test: true }, { type: 'test' });
 92 | 
 93 |       expect(state.test).to.be.equal(true);
 94 |     });
 95 | 
 96 |     it('should test POST_TITLE action with asParams option', () => {
 97 |       const title = 'title';
 98 | 
 99 |       const newRl = new RL('post');
100 | 
101 |       newRl.addAction('title', { title: '' }, { asParams: 'title' });
102 | 
103 |       const {
104 |         types: newRlTypes,
105 |         reducer: newRlReducer,
106 |       } = newRl.flush();
107 | 
108 |       const state = newRlReducer(undefined, { type: newRlTypes.POST_TITLE, title });
109 | 
110 |       expect(state.title).to.be.equal(title);
111 |     });
112 | 
113 |     it('should test defaultState', () => {
114 |       const prevState = {};
115 | 
116 |       const newRl = new RL('post', prevState);
117 | 
118 |       const { reducer: newRlReducer } = newRl.flush();
119 | 
120 |       const state = newRlReducer(undefined, { type: 'test' });
121 | 
122 |       expect(JSON.stringify(state)).to.be.equal(JSON.stringify(prevState));
123 |     });
124 | 
125 |     it('should test defaultState', () => {
126 |       const prevState = {};
127 | 
128 |       const newRl = new RL('post', prevState);
129 | 
130 |       const { reducer: newRlReducer } = newRl.flush();
131 | 
132 |       const state = newRlReducer(prevState, { type: 'test' });
133 | 
134 |       expect(JSON.stringify(state)).to.be.equal(JSON.stringify(prevState));
135 |     });
136 | 
137 |     it('should test wrong type', () => {
138 |       const prevState = {};
139 | 
140 |       const newRl = new RL('post');
141 | 
142 |       const { reducer: newRlReducer } = newRl.flush();
143 | 
144 |       const state = newRlReducer(prevState, { type: 'test' });
145 | 
146 |       expect(state).to.be.equal(prevState);
147 |     });
148 | 
149 |     it('should test wrong type', () => {
150 |       const prevState = {};
151 | 
152 |       const newRl = new RL('post');
153 | 
154 |       const { reducer: newRlReducer } = newRl.flush();
155 | 
156 |       const state = newRlReducer(undefined, { type: 'test' });
157 | 
158 |       expect(JSON.stringify(state)).to.be.equal(JSON.stringify(prevState));
159 |     });
160 | 
161 |     it('should test empty type', () => {
162 |       const newRl = new RL('post');
163 | 
164 |       newRl.addParamAction('title');
165 |       newRl.addEventAction('event');
166 | 
167 |       const {
168 |         actions: {
169 |           titleAction,
170 |           eventAction,
171 |         },
172 |         reducer: newRlReducer,
173 |       } = newRl.flush();
174 | 
175 |       const state = newRlReducer(
176 |         newRlReducer(undefined, titleAction('test')),
177 |         eventAction(),
178 |       );
179 | 
180 |       expect(state).to.be.eql({ title: 'test' });
181 |     });
182 |   });
183 | });
184 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
  1 | const { connect } = require('react-redux');
  2 | 
  3 | const toUnderscore = text => text.replace(/([A-Z])/g, $1 => `_${$1.toLowerCase()}`);
  4 | 
  5 | const toConst = text => toUnderscore(text).toUpperCase();
  6 | 
  7 | class RL {
  8 |   constructor(ns, defaultState = null) {
  9 |     this.ns = ns.trim();
 10 |     this.defaultState = defaultState;
 11 |     this.actions = [];
 12 |   }
 13 | 
 14 |   addAction(name, payload = {}, options = {}) {
 15 |     if (name === 'type') {
 16 |       throw new Error('Action name should not be "type"! This can create a conflict with redux action creators.');
 17 |     }
 18 | 
 19 |     if (payload.type !== undefined) {
 20 |       throw new Error('You should not make "type" fields! This can create a conflict with redux action creators.');
 21 |     }
 22 | 
 23 |     this.actions.push({ name, payload, options });
 24 |   }
 25 | 
 26 |   addFormAction(name) {
 27 |     this.addAction(name, {}, { isForm: true });
 28 |   }
 29 | 
 30 |   addFormElementAction(name, defaultValue = null) {
 31 |     this.addAction(
 32 |       name,
 33 |       { [name]: defaultValue },
 34 |       { isFormElement: true, asParams: name },
 35 |     );
 36 |   }
 37 | 
 38 |   addEventAction(name) {
 39 |     this.addAction(name, {}, { isEvent: true });
 40 |   }
 41 | 
 42 |   addParamAction(name, defaultValue = null) {
 43 |     this.addAction(
 44 |       name,
 45 |       { [name]: defaultValue },
 46 |       { asParams: name },
 47 |     );
 48 |   }
 49 | 
 50 |   addParamsAction(name, payload = {}) {
 51 |     this.addAction(
 52 |       name,
 53 |       payload,
 54 |       { asParams: Object.keys(payload) },
 55 |     );
 56 |   }
 57 | 
 58 |   addResetAction(name = 'reset', exactly = false) {
 59 |     this.addAction(name, {}, { isReset: true, exactly });
 60 |   }
 61 | 
 62 |   getNSKey() {
 63 |     return `@@${this.ns}`;
 64 |   }
 65 | 
 66 |   flush() {
 67 |     const nameSpace = `${this.getNSKey()}/${toConst(this.ns)}`;
 68 | 
 69 |     const types = {};
 70 |     const actions = {};
 71 |     const defaultState = {};
 72 | 
 73 |     this.actions.forEach((action) => {
 74 |       // types
 75 |       const typeKey = `${toConst(this.ns)}_${toConst(action.name)}`;
 76 |       const type = `${this.getNSKey()}/${toConst(action.name)}`;
 77 |       types[typeKey] = type;
 78 | 
 79 |       // actions
 80 |       const actionKey = `${action.name}Action`;
 81 | 
 82 |       // reset
 83 |       if (action.options.isReset) {
 84 |         const returnState = action.options.exactly ? this.defaultState : defaultState;
 85 |         actions[actionKey] = () => ({ type, ...returnState });
 86 |       }
 87 | 
 88 |       // event
 89 |       if (action.options.isEvent) {
 90 |         actions[actionKey] = () => ({ type });
 91 |       }
 92 | 
 93 |       // submit form
 94 |       if (action.options.isForm) {
 95 |         actions[actionKey] = (event) => {
 96 |           if (event && event.preventDefault) {
 97 |             event.preventDefault();
 98 |           }
 99 | 
100 |           return { type };
101 |         };
102 |       }
103 | 
104 |       // set data from input event (event.target.value)
105 |       if (action.options.isFormElement) {
106 |         actions[actionKey] = (event) => {
107 |           const payload = { ...action.payload };
108 |           if (event && event.target && event.target.value !== undefined) {
109 |             const { target: { value } } = event;
110 |             Object.keys(action.payload).forEach((key) => {
111 |               payload[key] = value;
112 |             });
113 |           }
114 | 
115 |           return { type, payload };
116 |         };
117 |       }
118 | 
119 |       // map action({ data }) to action(data)
120 |       if (action.options.asParams) {
121 |         let params = action.options.asParams;
122 |         if (!Array.isArray(params)) {
123 |           params = [params];
124 |         }
125 | 
126 |         actions[actionKey] = (...args) => {
127 |           const payload = {};
128 |           params.forEach((param, number) => {
129 |             const data = (
130 |               action.options.isFormElement
131 |               && args[number]
132 |               && args[number].target
133 |               && args[number].target.value !== undefined
134 |             )
135 |               ? args[number].target.value
136 |               : args[number];
137 |             payload[param] = data !== undefined ? data : action.payload[param];
138 |           });
139 | 
140 |           return { ...payload, type };
141 |         };
142 |       }
143 | 
144 |       if (!Object.keys(action.options).length) {
145 |         actions[actionKey] = (payload = action.payload) => {
146 |           const response = { type, payload };
147 | 
148 |           if (!Object.keys(payload).length) {
149 |             delete response.payload;
150 |           }
151 | 
152 |           return response;
153 |         };
154 |       }
155 | 
156 |       // default state
157 |       Object.assign(defaultState, action.payload);
158 |     });
159 | 
160 |     // full default state
161 |     Object.assign(defaultState, this.defaultState);
162 | 
163 |     const reducer = (state, action) => {
164 |       const newState = state || defaultState;
165 | 
166 |       if (Object.values(types).includes(action.type)) {
167 |         const returnState = {
168 |           ...newState,
169 |           ...action,
170 |           ...action.payload,
171 |         };
172 | 
173 |         delete returnState.type;
174 | 
175 |         return returnState;
176 |       }
177 | 
178 |       return newState;
179 |     };
180 | 
181 |     const mapStateToProps = state => state[nameSpace];
182 |     const mapDispatchToProps = { ...actions };
183 | 
184 |     const Container = connect(mapStateToProps, mapDispatchToProps);
185 | 
186 |     return {
187 |       nameSpace,
188 |       types,
189 |       actions,
190 |       defaultState,
191 |       reducer,
192 |       mapStateToProps,
193 |       mapDispatchToProps,
194 |       Container,
195 |     };
196 |   }
197 | }
198 | 
199 | module.exports = RL;
200 | 


--------------------------------------------------------------------------------
/docs/options.md:
--------------------------------------------------------------------------------
  1 | # Options
  2 | 
  3 | When you add action you can set the 3rd parameter - options
  4 | 
  5 | ```javascript
  6 | rl.addAction('title', payload, options);
  7 | ```
  8 | ## isEvent
  9 | 
 10 | If you are using **[redux-observable](https://redux-observable.js.org/)** you need to send events to epics.
 11 | Each event action should have only the type without any other fields.
 12 | 
 13 | ```javascript
 14 | rl.addAction('event', {}, { isEvent: true });
 15 | ```
 16 | The same result you can get using addEventAction:
 17 | 
 18 | ```javascript
 19 | rl.addEventAction('event');
 20 | ```
 21 | 
 22 | ## isForm
 23 | 
 24 | When you need action to submit form you need to run event.preventDefault.
 25 | To make this you can wrap function:
 26 | 
 27 | ```javascript
 28 | rl.addAction('submit');
 29 | ```
 30 | 
 31 | And put as props:
 32 | 
 33 | ```html
 34 | <form onSubmit={(event) => {
 35 |     event.preventDefault();
 36 |     props.submitAction();
 37 | }}>
 38 | ```
 39 | 
 40 | Or you can use **isForm** option:
 41 | 
 42 | ```javascript
 43 | rl.addAction('submit', {}, { isForm: true });
 44 | ```
 45 | 
 46 | And put as props:
 47 | 
 48 | ```html
 49 | <form onSubmit={props.submitAction}>
 50 | ```
 51 | 
 52 | The same result you can get using addFormAction:
 53 | 
 54 | ```javascript
 55 | rl.addFormAction('submit');
 56 | ```
 57 | 
 58 | ## isFormElement
 59 | 
 60 | When you need action to get value from form input event (event.target.value):
 61 | 
 62 | ```javascript
 63 | rl.addAction('title', { title: '' });
 64 | ```
 65 | 
 66 | And put as props:
 67 | 
 68 | ```html
 69 | <input
 70 |   type="text"
 71 |   onChange={event => props.titleAction(event.target.value)}
 72 |   value={props.title}
 73 | />
 74 | ```
 75 | Or you can use **isFormElement** option:
 76 | 
 77 | ```javascript
 78 | rl.addAction('title', { title: '' }, { isFormElement: true });
 79 | ```
 80 | And put as props:
 81 | 
 82 | ```html
 83 | <input
 84 |   type="text"
 85 |   onChange={props.titleAction}
 86 |   value={props.title}
 87 | />
 88 | ```
 89 | 
 90 | ## asParams
 91 | 
 92 | Each time to run action you need to put payload as object:
 93 | 
 94 | ```javascript
 95 | rl.addAction('title', { title: '' });
 96 | const { actions } = rl.flush();
 97 | ```
 98 | And you will have action:
 99 | 
100 | ```javascript
101 | const action = actions.titleActions({ title: 'text' });
102 | ```
103 | With payload:
104 | 
105 | ```javascript
106 | {
107 |   type: types.POST_TITLE,
108 |   payload: {
109 |     title: 'text',
110 |   },
111 | }
112 | ```
113 | 
114 | With **asParams** option you can get the same output like with native redux action creator:
115 | 
116 | ```javascript
117 | rl.addAction('title', { title: '' }, { asParams: 'title' });
118 | const { actions } = rl.flush();
119 | ```
120 | And you will have action:
121 | 
122 | ```javascript
123 | const action = actions.titleActions('text');
124 | ```
125 | With payload:
126 | 
127 | ```javascript
128 | {
129 |   type: types.POST_TITLE,
130 |   title: 'text',
131 | }
132 | ```
133 | 
134 | The same result you can get using addFormElementAction:
135 | 
136 | ```javascript
137 | rl.addParamAction('title', '');
138 | ```
139 | 
140 | **You can put many parameters**:
141 | 
142 | ```javascript
143 | rl.addAction('clear', { title: '', body: '' }, { asParams: ['title', 'body'] });
144 | const { actions } = rl.flush();
145 | ```
146 | And you will have action:
147 | 
148 | ```javascript
149 | const action = actions.clearActions('title', 'body');
150 | ```
151 | With payload:
152 | 
153 | ```javascript
154 | {
155 |   type: types.POST_TITLE,
156 |   title: 'title',
157 |   body: 'body',
158 | }
159 | ```
160 | Or with default data:
161 | 
162 | ```javascript
163 | const action = actions.clearActions();
164 | ```
165 | With payload:
166 | 
167 | ```javascript
168 | {
169 |   type: types.POST_TITLE,
170 |   title: '',
171 |   body: '',
172 | }
173 | ```
174 | 
175 | The same result you can get using addFormElementAction:
176 | 
177 | ```javascript
178 | rl.addParamsAction('clear', { title: '', body: '' });
179 | ```
180 | 
181 | ## asParams with isFormElement
182 | 
183 | You can use **asParams** option with **isFormElement**:
184 | 
185 | ```javascript
186 | rl.addAction('title', { title: '' }, { isFormElement: true, asParams: 'title' });
187 | ```
188 | And put as props:
189 | 
190 | ```html
191 | <input
192 |   type="text"
193 |   onChange={props.titleAction}
194 |   value={props.title}
195 | />
196 | ```
197 | It returns:
198 | 
199 | ```javascript
200 | {
201 |   type: types.POST_TITLE,
202 |   title: 'Text input data',
203 | }
204 | ```
205 | 
206 | The same result you can get using addFormElementAction:
207 | 
208 | ```javascript
209 | rl.addFormElementAction('title', '');
210 | ```
211 | 
212 | ## isReset
213 | 
214 | To reset you state to default you need to set isReset option
215 | 
216 | ```javascript
217 | rl.addAction('reset', {}, { isReset: true });
218 | ```
219 | The same result you can get using addResetAction:
220 | 
221 | ```javascript
222 | rl.addResetAction();
223 | ```
224 | 
225 | If you need to rename you action you can set name:
226 | 
227 | ```javascript
228 | rl.addResetAction('clear');
229 | ```
230 | 
231 | And run it in your code as:
232 | 
233 | ```javascript
234 | clearAction();
235 | ```
236 | 
237 | If you set up default state with actions, state will be merged:
238 | 
239 | ```javascript
240 | const rl = new RL('post', { test: true });
241 | 
242 | rl.addParamAction(title, 'title');
243 | ```
244 | 
245 | resetAction will return:
246 | 
247 | ```javascript
248 | { test: true, title: 'title' }
249 | ```
250 | 
251 | To return exactly the same state use exactly option:
252 | 
253 | ```javascript
254 | const rl = new RL('post', { test: true });
255 | 
256 | rl.addParamAction(title, 'title');
257 | rl.addResetAction('clear', true);
258 | ```
259 | 
260 | clearAction will return:
261 | 
262 | ```javascript
263 | { test: true }
264 | ```
265 | 
266 | ## Documentation
267 | 
268 |  * [Install](https://github.com/evheniy/redux-lazy/blob/master/docs/install.md)
269 |  * [How to use](https://github.com/evheniy/redux-lazy/blob/master/docs/use.md)
270 |  * [Types](https://github.com/evheniy/redux-lazy/blob/master/docs/types.md)
271 |  * [Actions](https://github.com/evheniy/redux-lazy/blob/master/docs/actions.md)
272 |  * [Reducer](https://github.com/evheniy/redux-lazy/blob/master/docs/reducer.md)
273 |  * [Container](https://github.com/evheniy/redux-lazy/blob/master/docs/container.md)
274 | 
275 | [More examples](https://github.com/evheniy/redux-lazy/blob/master/tests/actions.js)
276 | 


--------------------------------------------------------------------------------
/tests/actions.js:
--------------------------------------------------------------------------------
  1 | import { expect } from 'chai';
  2 | import { spy } from 'sinon';
  3 | import RL from '../src';
  4 | import * as types from './fixtures/types';
  5 | import * as actions from './fixtures/actions';
  6 | 
  7 | const rl = new RL('post');
  8 | 
  9 | rl.addAction('title', { title: '' });
 10 | rl.addAction('body', { body: '' });
 11 | rl.addAction('submit');
 12 | 
 13 | const { types: rlTypes, actions: rlActions } = rl.flush();
 14 | 
 15 | describe('Testing actions', () => {
 16 |   describe('Redux', () => {
 17 |     it('should test titleAction', () => {
 18 |       const title = 'title';
 19 | 
 20 |       const action = actions.titleAction(title);
 21 | 
 22 |       expect(action).to.be.a('object');
 23 | 
 24 |       expect(action.type).to.be.equal(types.POST_TITLE);
 25 |       expect(action.title).to.be.equal(title);
 26 |     });
 27 | 
 28 |     it('should test bodyAction', () => {
 29 |       const body = 'body';
 30 | 
 31 |       const action = actions.bodyAction(body);
 32 | 
 33 |       expect(action).to.be.a('object');
 34 | 
 35 |       expect(action.type).to.be.equal(types.POST_BODY);
 36 |       expect(action.body).to.be.equal(body);
 37 |     });
 38 | 
 39 |     it('should test submitAction', () => {
 40 |       const action = actions.submitAction();
 41 | 
 42 |       expect(action).to.be.a('object');
 43 | 
 44 |       expect(action.type).to.be.equal(types.POST_SUBMIT);
 45 |     });
 46 |   });
 47 | 
 48 |   describe('Redux Lazy', () => {
 49 |     it('should test titleAction', () => {
 50 |       const title = 'title';
 51 | 
 52 |       const action = rlActions.titleAction({ title });
 53 | 
 54 |       expect(action).to.be.a('object');
 55 | 
 56 |       expect(action.type).to.be.equal(rlTypes.POST_TITLE);
 57 |       expect(action.payload.title).to.be.equal(title);
 58 |     });
 59 | 
 60 |     it('should test titleAction with default params', () => {
 61 |       const action = rlActions.titleAction();
 62 | 
 63 |       expect(action).to.be.a('object');
 64 | 
 65 |       expect(action.type).to.be.equal(rlTypes.POST_TITLE);
 66 |       expect(action.payload.title).to.be.equal('');
 67 |     });
 68 | 
 69 |     it('should test bodyAction', () => {
 70 |       const body = 'body';
 71 | 
 72 |       const action = rlActions.bodyAction({ body });
 73 | 
 74 |       expect(action).to.be.a('object');
 75 | 
 76 |       expect(action.type).to.be.equal(rlTypes.POST_BODY);
 77 |       expect(action.payload.body).to.be.equal(body);
 78 |     });
 79 | 
 80 |     it('should test bodyAction with default params', () => {
 81 |       const action = rlActions.bodyAction();
 82 | 
 83 |       expect(action).to.be.a('object');
 84 | 
 85 |       expect(action.type).to.be.equal(rlTypes.POST_BODY);
 86 |       expect(action.payload.body).to.be.equal('');
 87 |     });
 88 | 
 89 |     it('should test submitAction', () => {
 90 |       const action = rlActions.submitAction();
 91 | 
 92 |       expect(action).to.be.a('object');
 93 | 
 94 |       expect(action.type).to.be.equal(rlTypes.POST_SUBMIT);
 95 |     });
 96 | 
 97 |     it('should test action with camelCase to underscore', () => {
 98 |       const newRl = new RL('newPost');
 99 | 
100 |       newRl.addAction('newTitle', { title: '' });
101 | 
102 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
103 | 
104 |       const title = 'title';
105 | 
106 |       const action = newRlActions.newTitleAction({ title });
107 | 
108 |       expect(action).to.be.a('object');
109 | 
110 |       expect(action.type).to.be.equal(newRlTypes.NEW_POST_NEW_TITLE);
111 |       expect(action.payload.title).to.be.equal(title);
112 |     });
113 | 
114 |     it('should test action with camelCase to underscore and default params', () => {
115 |       const title = 'title';
116 | 
117 |       const newRl = new RL('newPost');
118 | 
119 |       newRl.addAction('newTitle', { title });
120 | 
121 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
122 | 
123 |       const action = newRlActions.newTitleAction();
124 | 
125 |       expect(action).to.be.a('object');
126 | 
127 |       expect(action.type).to.be.equal(newRlTypes.NEW_POST_NEW_TITLE);
128 |       expect(action.payload.title).to.be.equal(title);
129 |     });
130 | 
131 |     it('should test action isForm option', () => {
132 |       const preventDefault = spy();
133 | 
134 |       const event = {
135 |         preventDefault,
136 |       };
137 | 
138 |       const newRl = new RL('post');
139 | 
140 |       newRl.addAction('submit', {}, { isForm: true });
141 | 
142 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
143 | 
144 |       const action = newRlActions.submitAction(event);
145 | 
146 |       expect(action).to.be.a('object');
147 | 
148 |       expect(action.type).to.be.equal(newRlTypes.POST_SUBMIT);
149 |       expect(preventDefault.calledOnce).to.be.equal(true);
150 |     });
151 | 
152 |     it('should test action isForm option without event', () => {
153 |       const newRl = new RL('post');
154 | 
155 |       newRl.addAction('submit', {}, { isForm: true });
156 | 
157 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
158 | 
159 |       const action = newRlActions.submitAction();
160 | 
161 |       expect(action).to.be.a('object');
162 | 
163 |       expect(action.type).to.be.equal(newRlTypes.POST_SUBMIT);
164 |     });
165 | 
166 |     it('should test action isFormElement option', () => {
167 |       const value = 'value';
168 |       const event = {
169 |         target: {
170 |           value,
171 |         },
172 |       };
173 | 
174 |       const newRl = new RL('post');
175 | 
176 |       newRl.addAction('title', { title: '' }, { isFormElement: true });
177 | 
178 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
179 | 
180 |       const action = newRlActions.titleAction(event);
181 | 
182 |       expect(action).to.be.a('object');
183 | 
184 |       expect(action.type).to.be.equal(newRlTypes.POST_TITLE);
185 |       expect(action.payload.title).to.be.equal(value);
186 |     });
187 | 
188 |     it('should test action isFormElement option without event', () => {
189 |       const title = 'title';
190 | 
191 |       const newRl = new RL('post');
192 | 
193 |       newRl.addAction('title', { title }, { isFormElement: true });
194 | 
195 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
196 | 
197 |       const action = newRlActions.titleAction();
198 | 
199 |       expect(action).to.be.a('object');
200 | 
201 |       expect(action.type).to.be.equal(newRlTypes.POST_TITLE);
202 |       expect(action.payload.title).to.be.equal(title);
203 |     });
204 | 
205 |     it('should test action asParams option', () => {
206 |       const title = 'title';
207 | 
208 |       const newRl = new RL('post');
209 | 
210 |       newRl.addAction('title', { title }, { asParams: 'title' });
211 | 
212 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
213 | 
214 |       const action = newRlActions.titleAction(title);
215 | 
216 |       expect(action).to.be.a('object');
217 | 
218 |       expect(action.type).to.be.equal(newRlTypes.POST_TITLE);
219 |       expect(action.title).to.be.equal(title);
220 |     });
221 | 
222 |     it('should test action asParams option with array', () => {
223 |       const title = 'title';
224 |       const body = 'body';
225 | 
226 |       const newRl = new RL('post');
227 | 
228 |       newRl.addAction('clear', { title, body }, { asParams: ['title', 'body'] });
229 | 
230 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
231 | 
232 |       const action = newRlActions.clearAction(title, body);
233 | 
234 |       expect(action).to.be.a('object');
235 | 
236 |       expect(action.type).to.be.equal(newRlTypes.POST_CLEAR);
237 |       expect(action.title).to.be.equal(title);
238 |       expect(action.body).to.be.equal(body);
239 |     });
240 | 
241 |     it('should test action asParams option with default value', () => {
242 |       const title = 'title';
243 | 
244 |       const newRl = new RL('post');
245 | 
246 |       newRl.addAction('title', { title }, { asParams: 'title' });
247 | 
248 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
249 | 
250 |       const action = newRlActions.titleAction();
251 | 
252 |       expect(action).to.be.a('object');
253 | 
254 |       expect(action.type).to.be.equal(newRlTypes.POST_TITLE);
255 |       expect(action.title).to.be.equal(title);
256 |     });
257 | 
258 |     it('should test action asParams option with default value and array', () => {
259 |       const title = 'title';
260 |       const body = 'body';
261 | 
262 |       const newRl = new RL('post');
263 | 
264 |       newRl.addAction('clear', { title, body }, { asParams: ['title', 'body'] });
265 | 
266 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
267 | 
268 |       const action = newRlActions.clearAction();
269 | 
270 |       expect(action).to.be.a('object');
271 | 
272 |       expect(action.type).to.be.equal(newRlTypes.POST_CLEAR);
273 |       expect(action.title).to.be.equal(title);
274 |       expect(action.body).to.be.equal(body);
275 |     });
276 | 
277 |     it('should test action isFormElement option with asParams option', () => {
278 |       const value = 'value';
279 | 
280 |       const event = {
281 |         target: {
282 |           value,
283 |         },
284 |       };
285 | 
286 |       const newRl = new RL('post');
287 | 
288 |       newRl.addAction('title', { title: '' }, { isFormElement: true, asParams: 'title' });
289 | 
290 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
291 | 
292 |       const action = newRlActions.titleAction(event);
293 | 
294 |       expect(action).to.be.a('object');
295 | 
296 |       expect(action.type).to.be.equal(newRlTypes.POST_TITLE);
297 |       expect(action.title).to.be.equal(value);
298 |     });
299 | 
300 |     it('should test action isFormElement option with asParams option and array', () => {
301 |       const value = 'value';
302 | 
303 |       const event = {
304 |         target: {
305 |           value,
306 |         },
307 |       };
308 | 
309 |       const newRl = new RL('post');
310 | 
311 |       newRl.addAction('clear', { title: '', body: '' }, { isFormElement: true, asParams: ['title', 'body'] });
312 | 
313 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
314 | 
315 |       const action = newRlActions.clearAction(event);
316 | 
317 |       expect(action).to.be.a('object');
318 | 
319 |       expect(action.type).to.be.equal(newRlTypes.POST_CLEAR);
320 |       expect(action.title).to.be.equal(value);
321 |       expect(action.body).to.be.equal('');
322 |     });
323 | 
324 |     it('should test action isFormElement option with asParams option and array', () => {
325 |       const value = 'value';
326 | 
327 |       const event = {
328 |         target: {
329 |           value,
330 |         },
331 |       };
332 | 
333 |       const event2 = {
334 |         target: {
335 |           value: 'body',
336 |         },
337 |       };
338 | 
339 |       const newRl = new RL('post');
340 | 
341 |       newRl.addAction('clear', { title: '', body: '' }, { isFormElement: true, asParams: ['title', 'body'] });
342 | 
343 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
344 | 
345 |       const action = newRlActions.clearAction(event, event2);
346 | 
347 |       expect(action).to.be.a('object');
348 | 
349 |       expect(action.type).to.be.equal(newRlTypes.POST_CLEAR);
350 |       expect(action.title).to.be.equal(value);
351 |       expect(action.body).to.be.equal('body');
352 |     });
353 | 
354 |     it('should test action isFormElement option with asParams option and default value', () => {
355 |       const title = 'title';
356 | 
357 |       const newRl = new RL('post');
358 | 
359 |       newRl.addAction('title', { title }, { isFormElement: true, asParams: 'title' });
360 | 
361 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
362 | 
363 |       const action = newRlActions.titleAction();
364 | 
365 |       expect(action).to.be.a('object');
366 | 
367 |       expect(action.type).to.be.equal(newRlTypes.POST_TITLE);
368 |       expect(action.title).to.be.equal(title);
369 |     });
370 | 
371 |     it('should test action isFormElement option with asParams option and default value and array', () => {
372 |       const title = 'title';
373 |       const body = 'body';
374 | 
375 |       const newRl = new RL('post');
376 | 
377 |       newRl.addAction('clear', { title, body }, { isFormElement: true, asParams: ['title', 'body'] });
378 | 
379 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
380 | 
381 |       const action = newRlActions.clearAction();
382 | 
383 |       expect(action).to.be.a('object');
384 | 
385 |       expect(action.type).to.be.equal(newRlTypes.POST_CLEAR);
386 |       expect(action.title).to.be.equal(title);
387 |       expect(action.body).to.be.equal(body);
388 |     });
389 | 
390 |     it('should test action with empty payload', () => {
391 |       const newRl = new RL('post');
392 | 
393 |       newRl.addAction('load');
394 | 
395 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
396 | 
397 |       const action = newRlActions.loadAction();
398 | 
399 |       expect(action).to.be.a('object');
400 | 
401 |       expect(action.type).to.be.equal(newRlTypes.POST_LOAD);
402 |       expect(action.payload).to.be.equal(undefined);
403 |     });
404 | 
405 |     it('should test addFormAction without event', () => {
406 |       const newRl = new RL('post');
407 | 
408 |       newRl.addFormAction('submit');
409 | 
410 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
411 | 
412 |       const action = newRlActions.submitAction();
413 | 
414 |       expect(action).to.be.a('object');
415 | 
416 |       expect(action.type).to.be.equal(newRlTypes.POST_SUBMIT);
417 |       expect(action).to.be.eql({ type: newRlTypes.POST_SUBMIT });
418 |     });
419 | 
420 |     it('should test addFormAction with event', () => {
421 |       const preventDefault = spy();
422 | 
423 |       const event = {
424 |         preventDefault,
425 |       };
426 | 
427 |       const newRl = new RL('post');
428 | 
429 |       newRl.addFormAction('submit');
430 | 
431 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
432 | 
433 |       const action = newRlActions.submitAction(event);
434 | 
435 |       expect(action).to.be.a('object');
436 | 
437 |       expect(action.type).to.be.equal(newRlTypes.POST_SUBMIT);
438 |       expect(action).to.be.eql({ type: newRlTypes.POST_SUBMIT });
439 | 
440 |       expect(preventDefault.calledOnce).to.be.equal(true);
441 |     });
442 | 
443 |     it('should test addFormElementAction without event and defaultState', () => {
444 |       const newRl = new RL('post');
445 | 
446 |       newRl.addFormElementAction('test');
447 | 
448 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
449 | 
450 |       const action = newRlActions.testAction();
451 | 
452 |       expect(action).to.be.a('object');
453 | 
454 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
455 |       expect(action.test).to.be.equal(null);
456 | 
457 |       expect(action).to.be.eql({
458 |         test: null,
459 |         type: newRlTypes.POST_TEST,
460 |       });
461 |     });
462 | 
463 |     it('should test addFormElementAction without event', () => {
464 |       const newRl = new RL('post');
465 | 
466 |       const defaultState = 'defaultState';
467 | 
468 |       newRl.addFormElementAction('test', defaultState);
469 | 
470 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
471 | 
472 |       const action = newRlActions.testAction();
473 | 
474 |       expect(action).to.be.a('object');
475 | 
476 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
477 |       expect(action.test).to.be.equal(defaultState);
478 | 
479 |       expect(action).to.be.eql({
480 |         test: defaultState,
481 |         type: newRlTypes.POST_TEST,
482 |       });
483 |     });
484 | 
485 |     it('should test addFormElementAction with event without defaultState', () => {
486 |       const newRl = new RL('post');
487 | 
488 |       const value = 'value';
489 | 
490 |       const event = {
491 |         target: {
492 |           value,
493 |         },
494 |       };
495 | 
496 |       newRl.addFormElementAction('test');
497 | 
498 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
499 | 
500 |       const action = newRlActions.testAction(event);
501 | 
502 |       expect(action).to.be.a('object');
503 | 
504 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
505 |       expect(action.test).to.be.equal(value);
506 | 
507 |       expect(action).to.be.eql({
508 |         test: value,
509 |         type: newRlTypes.POST_TEST,
510 |       });
511 |     });
512 | 
513 |     it('should test addFormElementAction with event and defaultState', () => {
514 |       const newRl = new RL('post');
515 | 
516 |       const defaultState = 'defaultState';
517 |       const value = 'value';
518 | 
519 |       const event = {
520 |         target: {
521 |           value,
522 |         },
523 |       };
524 | 
525 |       newRl.addFormElementAction('test', defaultState);
526 | 
527 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
528 | 
529 |       const action = newRlActions.testAction(event);
530 | 
531 |       expect(action).to.be.a('object');
532 | 
533 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
534 |       expect(action.test).to.be.equal(value);
535 | 
536 |       expect(action).to.be.eql({
537 |         test: value,
538 |         type: newRlTypes.POST_TEST,
539 |       });
540 |     });
541 | 
542 |     it('should test addAction with isEvent option', () => {
543 |       const newRl = new RL('post');
544 | 
545 |       newRl.addAction('event', {}, { isEvent: true });
546 | 
547 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
548 | 
549 |       const action = newRlActions.eventAction();
550 | 
551 |       expect(action).to.be.a('object');
552 | 
553 |       expect(action.type).to.be.equal(newRlTypes.POST_EVENT);
554 | 
555 |       expect(action).to.be.eql({ type: newRlTypes.POST_EVENT });
556 |     });
557 | 
558 |     it('should test addAction with isEvent option with data', () => {
559 |       const newRl = new RL('post');
560 | 
561 |       newRl.addAction('event', {}, { isEvent: true });
562 | 
563 |       const value = 'value';
564 | 
565 |       const event = {
566 |         target: {
567 |           value,
568 |         },
569 |       };
570 | 
571 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
572 | 
573 |       const action = newRlActions.eventAction(event);
574 | 
575 |       expect(action).to.be.a('object');
576 | 
577 |       expect(action.type).to.be.equal(newRlTypes.POST_EVENT);
578 | 
579 |       expect(action).to.be.eql({ type: newRlTypes.POST_EVENT });
580 |     });
581 | 
582 |     it('should test addEventAction', () => {
583 |       const newRl = new RL('post');
584 | 
585 |       newRl.addEventAction('event');
586 | 
587 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
588 | 
589 |       const action = newRlActions.eventAction();
590 | 
591 |       expect(action).to.be.a('object');
592 | 
593 |       expect(action.type).to.be.equal(newRlTypes.POST_EVENT);
594 | 
595 |       expect(action).to.be.eql({ type: newRlTypes.POST_EVENT });
596 |     });
597 | 
598 |     it('should test addEventAction with data', () => {
599 |       const newRl = new RL('post');
600 | 
601 |       newRl.addEventAction('event');
602 | 
603 |       const value = 'value';
604 | 
605 |       const event = {
606 |         target: {
607 |           value,
608 |         },
609 |       };
610 | 
611 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
612 | 
613 |       const action = newRlActions.eventAction(event);
614 | 
615 |       expect(action).to.be.a('object');
616 | 
617 |       expect(action.type).to.be.equal(newRlTypes.POST_EVENT);
618 | 
619 |       expect(action).to.be.eql({ type: newRlTypes.POST_EVENT });
620 |     });
621 | 
622 |     it('should test addAction with "type" name', () => {
623 |       const newRl = new RL('post');
624 | 
625 |       let isError = false;
626 | 
627 |       try {
628 |         newRl.addAction('type');
629 |       } catch (e) {
630 |         isError = true;
631 |         expect(e.message).to.be.equal('Action name should not be "type"! This can create a conflict with redux action creators.');
632 |       }
633 | 
634 |       expect(isError).to.be.equal(true);
635 |     });
636 | 
637 |     it('should test addAction with "type" payload field', () => {
638 |       const newRl = new RL('post');
639 | 
640 |       let isError = false;
641 | 
642 |       try {
643 |         newRl.addAction('test', { type: 'test' });
644 |       } catch (e) {
645 |         isError = true;
646 |         expect(e.message).to.be.equal('You should not make "type" fields! This can create a conflict with redux action creators.');
647 |       }
648 | 
649 |       expect(isError).to.be.equal(true);
650 |     });
651 | 
652 |     it('should test addEventAction with "type" name', () => {
653 |       const newRl = new RL('post');
654 | 
655 |       let isError = false;
656 | 
657 |       try {
658 |         newRl.addEventAction('type');
659 |       } catch (e) {
660 |         isError = true;
661 |         expect(e.message).to.be.equal('Action name should not be "type"! This can create a conflict with redux action creators.');
662 |       }
663 | 
664 |       expect(isError).to.be.equal(true);
665 |     });
666 | 
667 |     it('should test addFormAction with "type" name', () => {
668 |       const newRl = new RL('post');
669 | 
670 |       let isError = false;
671 | 
672 |       try {
673 |         newRl.addFormAction('type');
674 |       } catch (e) {
675 |         isError = true;
676 |         expect(e.message).to.be.equal('Action name should not be "type"! This can create a conflict with redux action creators.');
677 |       }
678 | 
679 |       expect(isError).to.be.equal(true);
680 |     });
681 | 
682 |     it('should test addFormElementAction with "type" name', () => {
683 |       const newRl = new RL('post');
684 | 
685 |       let isError = false;
686 | 
687 |       try {
688 |         newRl.addFormElementAction('type');
689 |       } catch (e) {
690 |         isError = true;
691 |         expect(e.message).to.be.equal('Action name should not be "type"! This can create a conflict with redux action creators.');
692 |       }
693 | 
694 |       expect(isError).to.be.equal(true);
695 |     });
696 | 
697 |     it('should test addParamAction', () => {
698 |       const newRl = new RL('post');
699 | 
700 |       const defaultValue = 'defaultValue';
701 |       const value = 'value';
702 | 
703 |       newRl.addParamAction('test', defaultValue);
704 | 
705 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
706 | 
707 |       const action = newRlActions.testAction(value);
708 | 
709 |       expect(action).to.be.a('object');
710 | 
711 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
712 |       expect(action.test).to.be.equal(value);
713 | 
714 |       expect(action).to.be.eql({
715 |         test: value,
716 |         type: newRlTypes.POST_TEST,
717 |       });
718 |     });
719 | 
720 |     it('should test addParamAction without value', () => {
721 |       const newRl = new RL('post');
722 | 
723 |       const defaultValue = 'defaultValue';
724 | 
725 |       newRl.addParamAction('test', defaultValue);
726 | 
727 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
728 | 
729 |       const action = newRlActions.testAction();
730 | 
731 |       expect(action).to.be.a('object');
732 | 
733 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
734 |       expect(action.test).to.be.equal(defaultValue);
735 | 
736 |       expect(action).to.be.eql({
737 |         test: defaultValue,
738 |         type: newRlTypes.POST_TEST,
739 |       });
740 |     });
741 | 
742 |     it('should test addParamAction without value and defaultValue', () => {
743 |       const newRl = new RL('post');
744 | 
745 |       newRl.addParamAction('test');
746 | 
747 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
748 | 
749 |       const action = newRlActions.testAction();
750 | 
751 |       expect(action).to.be.a('object');
752 | 
753 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
754 |       expect(action.test).to.be.equal(null);
755 | 
756 |       expect(action).to.be.eql({
757 |         test: null,
758 |         type: newRlTypes.POST_TEST,
759 |       });
760 |     });
761 | 
762 |     it('should test addParamsAction', () => {
763 |       const newRl = new RL('post');
764 | 
765 |       const payload = {
766 |         field1: 'field1',
767 |         field2: 'field2',
768 |       };
769 | 
770 |       newRl.addParamsAction('test', payload);
771 | 
772 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
773 | 
774 |       const action = newRlActions.testAction(1, 2);
775 | 
776 |       expect(action).to.be.a('object');
777 | 
778 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
779 |       expect(action.field1).to.be.equal(1);
780 |       expect(action.field2).to.be.equal(2);
781 | 
782 |       expect(action).to.be.eql({
783 |         field1: 1,
784 |         field2: 2,
785 |         type: newRlTypes.POST_TEST,
786 |       });
787 |     });
788 | 
789 |     it('should test addParamsAction with only first value', () => {
790 |       const newRl = new RL('post');
791 | 
792 |       const payload = {
793 |         field1: 'field1',
794 |         field2: 'field2',
795 |       };
796 | 
797 |       newRl.addParamsAction('test', payload);
798 | 
799 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
800 | 
801 |       const action = newRlActions.testAction(1);
802 | 
803 |       expect(action).to.be.a('object');
804 | 
805 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
806 |       expect(action.field1).to.be.equal(1);
807 |       expect(action.field2).to.be.equal('field2');
808 | 
809 |       expect(action).to.be.eql({
810 |         field1: 1,
811 |         field2: 'field2',
812 |         type: newRlTypes.POST_TEST,
813 |       });
814 |     });
815 | 
816 |     it('should test addParamsAction without values', () => {
817 |       const newRl = new RL('post');
818 | 
819 |       const payload = {
820 |         field1: 'field1',
821 |         field2: 'field2',
822 |       };
823 | 
824 |       newRl.addParamsAction('test', payload);
825 | 
826 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
827 | 
828 |       const action = newRlActions.testAction();
829 | 
830 |       expect(action).to.be.a('object');
831 | 
832 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
833 |       expect(action.field1).to.be.equal('field1');
834 |       expect(action.field2).to.be.equal('field2');
835 | 
836 |       expect(action).to.be.eql({
837 |         field1: 'field1',
838 |         field2: 'field2',
839 |         type: newRlTypes.POST_TEST,
840 |       });
841 |     });
842 | 
843 |     it('should test addParamsAction with empty payload', () => {
844 |       const newRl = new RL('post');
845 | 
846 |       newRl.addParamsAction('test');
847 | 
848 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
849 | 
850 |       const action = newRlActions.testAction();
851 | 
852 |       expect(action).to.be.a('object');
853 | 
854 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
855 | 
856 |       expect(action).to.be.eql({ type: newRlTypes.POST_TEST });
857 |     });
858 | 
859 |     it('should test addParamAction with boolean', () => {
860 |       const newRl = new RL('post');
861 | 
862 |       newRl.addParamAction('test', true);
863 | 
864 |       const { types: newRlTypes, actions: newRlActions } = newRl.flush();
865 | 
866 |       const action = newRlActions.testAction(false);
867 | 
868 |       expect(action).to.be.a('object');
869 | 
870 |       expect(action.type).to.be.equal(newRlTypes.POST_TEST);
871 |       expect(action.test).to.be.equal(false);
872 | 
873 |       expect(action).to.be.eql({
874 |         test: false,
875 |         type: newRlTypes.POST_TEST,
876 |       });
877 |     });
878 |   });
879 | });
880 | 


--------------------------------------------------------------------------------