https://github.com/streammedev/flux-store
A redux like data store for our NERF apps
https://github.com/streammedev/flux-store
Last synced: about 1 year ago
JSON representation
A redux like data store for our NERF apps
- Host: GitHub
- URL: https://github.com/streammedev/flux-store
- Owner: StreamMeDev
- License: isc
- Created: 2016-11-09T07:35:47.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2017-07-31T19:12:07.000Z (almost 9 years ago)
- Last Synced: 2024-04-27T13:24:46.461Z (about 2 years ago)
- Language: JavaScript
- Size: 36.1 KB
- Stars: 2
- Watchers: 2
- Forks: 1
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Flux Store
[](https://npmjs.org/package/@streammedev/flux-store)
[](https://npmjs.org/package/nighthawk)
[](https://standardjs.com)
A Redux-like data store without the enforced opinions. Similar to Redux, this module is based
on Flux principles, the entire state is stored in a single object, and all mutations are
described with action objects and applied with reducers.
The main difference is that this module supports asynchronous actions out of the box, but there are a few
other differences. This flux store allows for multiple reducers, which can be composed based on the action
name, not the data structure. This allows for multiple reducers to access and modify data across the application.
## Install
```
$ npm install --save @streammedev/flux-store
```
## Usage
```javascript
import {createStore} from '@streammedev/flux-store';
// Create our reducers
function incr (state = 0, action) {
return state + (action.value || 1);
}
function decr (state = 0, action) {
return state - (action.value || 1);
}
// Create our store instance with an
// initial state and the reducers
var store = createStore({
incr: incr,
decr: decr
}, 0);
// Subscribe to changes to the store
store.subscribe((state) => {
console.log(state);
});
// dispatch some actions
store.dispatch({
type: 'incr'
}); // 1
store.dispatch({
type: 'incr',
value: 2
}); // 3
store.dispatch({
type: 'decr'
}); // 2
```
## API
### `createStore([reducers[, initialState]])`
Creates a store, with the reducers and state passed in. This is the recommended way to create a store because it ensures
the proper scope for the methods even if you pass them around, like in a React app when you pass `dispatch` as a prop.
---
### `Store([reducers[, initialState]])`
The constructor for a store instance.
#### `.dispatch(action)`
Dispatches an action. Actions in this store can be one of three things:
1. A simple object. For sync actions you can simply do this. The only requirement is that the action
object has a property `type`.
2. A Promise. For actions that do asynchronous things, they should resolve/reject with an action object.
3. A function. For action creators that want to dispatch multiple times. The function will get passed
dispatch as the first and only argument.
#### `.subscribe(func)`
Subscribe to changes in the store. The function passed to subscribe will be called every time
an action is dispatched, even if there were no changes to the store. It is passed the new state,
the old state, and the action dispatched, in that order. Use this method to update the your views.
Subscribe returns the unsubscribe function.
#### `.getState()`
Returns a clone of the current state object.
#### `.replaceState()`
Replaces the current state with a whole new object. This can be called to clear state between route changes
in a single page app, or to initialize the state of a new store. It will result in firing your listener functions.
#### `.replaceReducers()`
Replaces all reducers registered with this store.
#### `.addReducer(type, reducerFunc)`
Adds a reducer for an action type.
---
### `bindActionCreators(actionCreators, dispatch)`
A utility method which takes an object of action creators and returns a new object where
each key's function is not wrapped with a call to `dispatch`. See [Redux's docs for more info](http://redux.js.org/docs/api/bindActionCreators.html).
## Development
This package follows semver, when you wish to publish a version run the proper npm command. For example, if we made a bug fix you can do this:
```
$ npm version patch
$ git push
$ npm publish
```
Here are the other types of version bumps:
- Major (`npm version major`): This is for breaking changes. Anytime a method is changed or the functionality is modified this bump should be made.
- Minor (`npm version minor`): This is for features additions. When a new method is added which doesn't affect the behavior of existing features, this bump should be made.
- Patch (`npm version patch`): This is for bug fixes. Only bump this if it is safe for production code to update wihout being QA'd. (AKA, almost never)
For each of these you can run a 'pre' version by prepending to the command, ex `npm version preminor`.
All feature development should be done on a branch off `master`. When a feature is complete and the pull request approved, publish a 'pre' version of the package for testing across environments. To install that 'pre' version of the package do the following, where the verison number contains the correct 'pre' version:
```
$ npm install --save @streammedev/store@1.0.0-0
```
Running the tests:
```
$ npm install && npm test
```