How to use the seamless-immutable.from function in seamless-immutable

this.x = x;
    this.y = y;
    this.width = width;
    this.height = height;
    this.selection = selection;
  }

  // some additional methods
  getRatio(): number {
    return this.width / this.height;
  }
}

export type GNode = ImmutableObject;
let gnodeMutable = new GNodeMutable("title",1,0,0,10,10);
const immutableNode:GNode = SeamlessImmutable.from(gnodeMutable);
const mutated:GNode = immutableNode.set("title","NewTitle");

export class Graph {
  nodes: Map;

  constructor(nodes: GNodeMutable[]) {
    this.nodes = Graph.createNodeMap(nodes);
  }

  static createNodeMap(nodes: GNodeMutable[]) {
    return Map(nodes.map(node => [node.id, SeamlessImmutable.from(node)]))
  }

  moveNodes(nodeIds: number[], dx: number, dy: number) {
    for (let nodeId of nodeIds) {
      var node: GNode = this.getNode(nodeId);

({ theme, scene, scenes, index }) => {
		// console.log('>>>>', scene, scenes)
		const headerTitleStylePath = ['descriptor', 'options', 'headerTitleStyle']
		const headerStylePath = ['descriptor', 'options', 'headerStyle']
		const headerTintColorPath = ['descriptor', 'options', 'headerTintColor']
		// const headerTintColorPath = ['descriptor', 'options', 'headerTintColor']
		const headerTitleStyle = path(headerTitleStylePath)(scene) || theme.appStyle.toolbar.text
		const headerTintColor = path(headerTintColorPath)(scene) || theme.palette.toolbar.contrastText
		// const headerTintColor = path(headerTintColorPath)(scene) || theme.palette.toolbar.contrastText
		const headerStyle = path(headerStylePath)(scene) || theme.appStyle.toolbar.main
		// const headerTintColor = path(headerTitleStylePath)(scene) || theme.palette.appStyle.text
		const newScene = from(scene).setIn(headerTitleStylePath, headerTitleStyle)
									.setIn(headerStylePath, headerStyle)
									// .setIn(headerTintColorPath, headerTintColor)
									.setIn(headerTintColorPath, headerTintColor)
		// >>>>>>>>>>>>>>>>>>>>
		// For android
		// I don't know why error come from
		// I wonder why react-navigation also have 2: scene, scenes
		// So I will override both
		const sceneInScenes = path([index])(scenes)
		const newsceneInScenes = from(sceneInScenes).setIn(headerTitleStylePath, headerTitleStyle)
		.setIn(headerStylePath, headerStyle)
		.setIn(headerTintColorPath, headerTintColor)
		// <<<<<<<<<<<<
		const newScenes = from(scenes).set(index, newsceneInScenes)
		return {
			scene: newScene,

// const headerTintColor = path(headerTitleStylePath)(scene) || theme.palette.appStyle.text
		const newScene = from(scene).setIn(headerTitleStylePath, headerTitleStyle)
									.setIn(headerStylePath, headerStyle)
									// .setIn(headerTintColorPath, headerTintColor)
									.setIn(headerTintColorPath, headerTintColor)
		// >>>>>>>>>>>>>>>>>>>>
		// For android
		// I don't know why error come from
		// I wonder why react-navigation also have 2: scene, scenes
		// So I will override both
		const sceneInScenes = path([index])(scenes)
		const newsceneInScenes = from(sceneInScenes).setIn(headerTitleStylePath, headerTitleStyle)
		.setIn(headerStylePath, headerStyle)
		.setIn(headerTintColorPath, headerTintColor)
		// <<<<<<<<<<<<
		const newScenes = from(scenes).set(index, newsceneInScenes)
		return {
			scene: newScene,
			scenes: newScenes,
		}
	},
)

import * as SI from "seamless-immutable";
import { createStore, applyMiddleware, combineReducers, compose } from "redux";
import { composeWithDevTools } from "redux-devtools-extension";
import thunk from "redux-thunk";
import reducers from "../reducers";

// Set up store
const initialState: any = SI.from({});
const store: any = createStore(reducers, initialState, composeWithDevTools(
  applyMiddleware(thunk)
));

export default store;

module.exports = function hotLoad(appName) {
  const STATE_KEY = `${appName}-hmr-application-state-cache`;

  // load state when reloaded
  try {
    const cachedState = JSON.parse(window.localStorage.getItem(STATE_KEY) || '{}');
    Reflux.state = Immutable.from(cachedState);
    Reflux.stateStream.next(Reflux.state);
  } catch (e) {
    window.localStorage.setItem(STATE_KEY, undefined);
  }

  // save state on each change
  Reflux.stateStream.subscribe(state => window.localStorage
    .setItem(STATE_KEY, JSON.stringify(state)), undefined, undefined);
};

exports.objectSetSeamlessImmutableJs = (cycles) => {
  const obj = seamlessImmutableJs.from({value});

  let newValue;

  for (let i = 0; i < cycles; i++) {
    newValue = Math.random();

    obj.set('value', newValue);
  }
};

exports.arraySetSeamlessImmutableJs = (cycles) => {
  const arr = seamlessImmutableJs.from(array);
  const maxIndex = arr.length - 1;

  let index, newVal;

  for (let i = 0; i < cycles; i++) {
    index = ~~(Math.random() * maxIndex);
    newVal = Math.random();

    arr.set(index, newVal);
  }
};

import { from, ImmutableObject } from 'seamless-immutable'

export const initialState = from({
	isAuthenticated: false,
})


export interface TAuthenticationState {
	isAuthenticated: boolean
}

import { from } from 'seamless-immutable';
import { createReducer, createAsyncAction } from '../../../utils/actions';

export const FETCH_DASHBOARD = 'dashboard/dashboard/FETCH_DASHBOARD';

export const fetchDashboard = createAsyncAction(FETCH_DASHBOARD);

const initialState = from({
  daysLeft: 0,
  ethBalance: '',
  raised: {
    BTC: '',
    ETH: '',
    USD: ''
  },
  tokenBalance: '',
  tokenPrice: {
    ETH: '',
    USD: ''
  },
  tokensSold: ''
});

export default createReducer({

import { from } from 'seamless-immutable';
import { createReducer, createAsyncAction } from '../../../utils/actions';

export const FETCH_FEE = 'dashboard/txFee/FETCH_FEE';

export const fetchFee = createAsyncAction(FETCH_FEE);

const initialState = from({
  fetching: false,
  gasPrice: '',
  gas: '',
  expectedTxFee: '',
  minInvest: ''
});

export default createReducer({
  [fetchFee.REQUEST]: (state) => (
    state.merge({
      fetching: true
    })
  ),

  [fetchFee.SUCCESS]: (state, { payload }) => (
    state.merge({