immutable-data | Easily update nested objects and arrays | Functional Programming library

duration property would help you to restrict view to a specific time limit. It accepts time in millisecods and for 20 minutes view you can configure it like below.

For more details, check plugin Configuration

This all looks non-mutating to me. Are you mutating any of the variables, e.g. gameHistory elsewhere? Your reducer should be the only function that does that.

You are giving the redux state a reference to the history, so if you append anything to that object elsewhere in code it could cause issues.

One solution, as you say, is to use gameHistory: Object.assign({}, action.gameSetup.gameHistory) to make a copy, but this will just be a "shallow" copy (if your object contains other objects, they will be copied by reference). The (disgusting hack, but as far as I know only way for general objects) of making a deep copy is to use deep_copy_obj = JSON.parse(JSON.stringify(my_obj)).

The immutable way of doing things is to have your reducer managing things like appending to history, and if you want to edit the history when a button is clicked, make the button dispatch an action.

The example in case of trie is not a general solution for immutability, it's just a way of representing an array in a tree then applying general solutions for persistent trees.

Following are general solutions for persistent graphs

1. Fat node.
   Each node stores history of it's changes and timestamp of those changes. When looking for a graph at specific point in time, we provide the timestamp to get version at that time. It's space efficient (only new value is stored) however access time suffers in this case due to an additional search (Mulplicative slowdown) on the modification array (of arbitrary length) for each node.

2. Path copying
   In this case we create a new node keeping all the children, we create a new node for each node in it's path to root. In this case we have to store an array of roots. It's access time is same as original graph, only extra time that it takes is due to search on the root array (Additive slowdown). This is what's being used in the trie example. It's space inefficient as every change creates a set of new nodes with new root, representing path to new node from new root.

3. Modification Box(Sleator, Tarjan et al)
   This one combines both Fat node and Path copying. Every node can store only one modification. If we try to update an already modified node then we use path copying and try to create a duplicate node with duplicate path to it. Interestingly while creating new path we'll have to take care of modification boxes. In the new path only those nodes are duplicated which have been already modified, else only there modification boxes are updated.

Note: Path copy and Modification box are application to trees (or may be DAGs) and not not generic graphs. As both of these involve cascading creation of new nodes from mdoified node to root. A generic graph doesn't have a root. So only method available to us is Fat Node for generic graphs.

Ref:
1. https://en.wikipedia.org/wiki/Persistent_data_structure
2. https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-854j-advanced-algorithms-fall-2005/lecture-notes/persistent.pdf

Fat Node

Following structure of Node and Graph should suffice

You could do something like this: