1.4.0

1.4.0 (September 21, 2016)

• [NEW] Added ability to switch out the default caching strategy for caching getter values. Also expose an LRU cache that can be swapped in for the basic cache
• [NEW] Add ability to supply your own logger and override the default console group logger in NuclearJS
• [UPGRADE] Upgrade immutable to 3.8.1

Cache Configuration

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),
});

Using your own Logger

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)
    },
  },
});

Big thanks to

@loganlinn @niftymonkey @gerges @andrei-cacio @raulmatei @lchski

1.3.0

1.3.0 (December 31, 2015)

• [NEW] Store hot-reloading via reactor.replaceStores(stores) which replaces the implementation of a store without resetting its underlying state value. See hot reloading example.
• [NEW] Support for more granular options for logging and triggering invariants in the NuclearJS runtime. See API Docs for details.

1.2.1

Changes

• [FIXED] Observers of the entire app state not triggering on actions from a late registered store

1.2.0

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.

Changes

• [NEW] Exposed new API methods: batchStart and batchStop.
• [NEW] Changed the transpiler to Babel.
• [FIXED] Completely refactored Reactor, Evaluator and ChangeObserver.
• [FIXED] Fixed all issues related to hash code collisions.
• [FIXED] Refactored how change observation works to be much more efficient.

Shoutouts

Bigs thanks to @lyonlai and @bhamodi for helping with this release!

1.1.2

• [FIXED] Fix for observer iteration when removed during notify. Issue #151

1.1.1

• [ADDED] Bowser support via bower.json

1.1.0

• [NEW] added Reactor#serialize, Reactor#loadState, Store#serialize and Store#deserialize methods
• [NEW] added Reactor#batch to allow batch dispatches before notify observers
• [NEW] throw error when trying to dispatch within a dispatch
• [FIXED] fix Evaluator locking if getter evaluation errors

Isomorphic Story

NuclearJS now supports server side rendering better than ever with NuclearJS React Addons.

To see this in action, check out the Isomorphic Flux Chat Example.

API Additions

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#serialize

Serialization 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#deserialize

Serialization 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)
  },
  // ...
})

Shoutouts

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.

1.1.0 (proposed)

• [NEW] added Reactor#serialize, Reactor#loadState, Store#serialize and Store#deserialize methods
• [NEW] added Reactor#batch to allow batch dispatches before notify observers
• [FIXED] fix Evaluator locking if getter evaluation errors

API Additions

Reactor#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#serialize

Serialization 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#deserialize

Serialization 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)
  },
  // ...
})

1.0.5

Changes:

• [fixed] removed accidentally checked in node_modules directory fixes #73
• [added] added linting, run via grunt eslint

Bigs thanks to @bhamodi for all of the lint work!

1.0.2

Changes:

• [critical] [fixed] support Utils.isFunction in all browsers (#57)
• [deprecated] reactor.registerStore will be deprecated in 1.1.x - use reactor.registerStores instead. Add deprecation warning.
• [fixed] properly observe getters when passing silent=true for registerStores - this option no longer makes sense as it makes future observations unreliable.
• [improvement] Evaluator doesn't evaluate getter args twice when checking if there is stale value

Bigs thanks to @bhamodi @loganlinn @yolk @goatslacker @appsforartists for your contributions, prs and issues. Everything helps!