Reactive Flux built with ImmutableJS data structures. Framework agnostic.
immutable to 3.8.1
import * as Nuclear from 'nuclear-js';
const MAX_ITEMS = 1000 // (optional, default = 1000) how many items to keep in the LRU cache before evicting
const EVICT_COUNT = 10 // (optional, default = 1) how many items to throw out when the cache fills up
new Nuclear.Reactor({
debug: false,
cache: new Nuclear.LRUCache(MAX_ITEMS, EVICT_COUNT),
});
import * as Nuclear from 'nuclear-js';
new Nuclear.Reactor({
logger: {
dispatchStart(reactorState, actionType, payload) {
console.log(`dispatch: actionType=${actionTypes}`, payload)
},
dispatchError(reactorState, error) {
// useful if you need to close a console.group if an error is thrown during dispatch
},
dispatchEnd(reactorState, state, dirtyStores, previousState) {
const prevStateChanges = previousState.filter((val, key) => dirtyStores.contains(key)).toJS()
const stateChanges = state.filter((val, key) => dirtyStores.contains(key)).toJS()
console.log('prev state: ', prevStateChanges)
console.log('new state: ', stateChanges)
},
},
});
@loganlinn @niftymonkey @gerges @andrei-cacio @raulmatei @lchski
reactor.replaceStores(stores) which replaces the implementation of a store without resetting its underlying state value. See hot reloading example.A complete functional refactor of NuclearJS's evaluation and observation mechanisms, solving all of the frustrating cache collision issues while also making observation much more efficient in cases where the number of stores changing is low.
batchStart and batchStop.Reactor, Evaluator and ChangeObserver.Bigs thanks to @lyonlai and @bhamodi for helping with this release!
Reactor#serialize, Reactor#loadState, Store#serialize and Store#deserialize methodsReactor#batch to allow batch dispatches before notify observersNuclearJS now supports server side rendering better than ever with NuclearJS React Addons.
To see this in action, check out the Isomorphic Flux Chat Example.
Reactor#serialize()Returns a plain JavaScript object representing the application state. By default this maps over all stores and returns toJS(storeState).
reactor.loadState(reactor.serialize())
Reactor#loadState( state )Takes a plain JavaScript object and merges into the reactor state, using store.deserialize
This can be useful if you need to load data already on the page.
reactor.loadState({
stringStore: 'bar',
listStore: [4,5,6],
})
Store#serializeSerialization method for the store's data, by default its implemented as `Nuclear.toJS' which converts ImmutableJS objects to plain JavaScript. This is overridable for your specific data needs.
// serializing an Immutable map while preserving numerical keys
Nuclear.Store({
// ...
serialize(state) {
if (!state) {
return state;
}
return state.entrySeq().toJS()
},
// ...
})
Store#deserializeSerialization method for the store's data, by default its implemented as `Nuclear.toImmutable' which converts plain JavaScript objects to ImmutableJS data structures. This is overridable for your specific data needs.
// deserializing an array of arrays [[1, 'one'], [2, 'two']] to an Immutable.Map
Nuclear.Store({
// ...
deserialize(state) {
return Immutable.Map(state)
},
// ...
})
Huge thanks to @Sinewyk for spearheading all of the isomorphic work and updating the examples.
Also big things to @bhamodi @balloob @mark-rushakoff @kurumpa for their contributions this release.
Reactor#serialize, Reactor#loadState, Store#serialize and Store#deserialize methodsReactor#batch to allow batch dispatches before notify observersReactor#serialize()Returns a plain javascript object representing the application state. By defualt this maps over all stores and returns toJS(storeState).
reactor.loadState(reactor.serialize())
Reactor#loadState( state )Takes a plain javascript object and merges into the reactor state, using store.deserialize
This can be useful if you need to load data already on the page.
reactor.loadState({
stringStore: 'bar',
listStore: [4,5,6],
})
Store#serializeSerialization method for the store's data, by default its implemented as `Nuclear.toJS' which converts ImmutableJS objects to plain javascript. This is overridable for your specific data needs.
// serializing an Immutable map while preserving numerical keys
Nuclear.Store({
// ...
serialize(state) {
if (!state) {
return state;
}
return state.entrySeq().toJS()
},
// ...
})
Store#deserializeSerialization method for the store's data, by default its implemented as `Nuclear.toImmutable' which converts plain javascript objects to ImmutableJS data structures. This is overridable for your specific data needs.
// deserializing an array of arrays [[1, 'one'], [2, 'two']] to an Immutable.Map
Nuclear.Store({
// ...
deserialize(state) {
return Immutable.Map(state)
},
// ...
})
Changes:
node_modules directory fixes #73grunt eslint
Bigs thanks to @bhamodi for all of the lint work!
Bigs thanks to @bhamodi @loganlinn @yolk @goatslacker @appsforartists for your contributions, prs and issues. Everything helps!