ucsc-xena-client/dist/controllers/devtools.js

UCSC Xena Client. Functional genomics visualizations.

// Adapted from redux-devtools, so we can use redux state monitors
// with xena state.
//

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

var _ = require('../underscore_ext');
var INIT_ACTION = { type: '@@INIT' };
var identity = function identity(state) {
	return state;
};
var notImplemented = function notImplemented(state, ac) {
	console.log('No support for ' + ac.type);
	return state;
};

var liftState = function liftState(state) {
	return { state: state };
};

function logError(err) {
	if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object' && typeof window.chrome !== 'undefined') {
		// In Chrome, rethrowing provides better source map support
		setTimeout(function () {
			throw err;
		});
	} else {
		console.error(err.stack || err);
	}
}

function liftReducer(reducer) {
	return function (state, action) {
		if (state.error) {
			return _.assoc(state, 'error', 'Interrupted by an error up the chain');
		}
		try {
			return liftState(reducer(state.state, action.action.payload));
		} catch (err) {
			logError(err);
			return _.assoc(state, 'error', err.toString());
		}
	};
}

function recomputeStates(liftedReducer, devState) {
	var committedState = devState.committedState,
	    stagedActionIds = devState.stagedActionIds,
	    skippedActionIds = devState.skippedActionIds,
	    actionsById = devState.actionsById,
	    computedStates = _.reduce(stagedActionIds.slice(1), // skip INIT_ACTION
	function (acc, id) {
		return skippedActionIds.indexOf(id) !== -1 ? _.conj(acc, acc[acc.length - 1]) : _.conj(acc, liftedReducer(acc[acc.length - 1], actionsById[id]));
	}, [liftState(committedState)]);

	return _extends({}, devState, { computedStates: computedStates });
}

var liftAction = function liftAction(action) {
	return { action: { type: action[0], payload: action } };
};

function controls(liftedReducer, initialCommittedState) {
	return {
		'PERFORM_ACTION': function PERFORM_ACTION(devState, _ref) {
			var action = _ref.action;
			var nextActionId = devState.nextActionId,
			    actionsById = devState.actionsById,
			    stagedActionIds = devState.stagedActionIds,
			    computedStates = devState.computedStates,
			    id = nextActionId + 1,
			    curr = computedStates[computedStates.length - 1],
			    liftedAction = liftAction(action),
			    next = liftedReducer(curr, liftedAction);


			return _.assoc(devState, 'stagedActionIds', _.conj(stagedActionIds, id), 'actionsById', _.assoc(actionsById, id, liftedAction), 'computedStates', _.conj(computedStates, next), 'nextActionId', id);
		},
		'RESET': function RESET(devState) {
			return _extends({}, devState, {
				actionsById: { 0: { action: INIT_ACTION } },
				nextActionId: 1,
				stagedActionIds: [0],
				skippedActionIds: [],
				committedState: initialCommittedState,
				computedStates: [liftState(initialCommittedState)]
			});
		},
		'ROLLBACK': function ROLLBACK(devState) {
			return _extends({}, devState, {
				actionsById: { 0: { action: INIT_ACTION } },
				nextActionId: 1,
				stagedActionIds: [0],
				skippedActionIds: [],
				computedStates: [devState.computedStates[0]]
			});
		},
		'COMMIT': function COMMIT(_ref2) {
			var computedStates = _ref2.computedStates,
			    devState = _objectWithoutProperties(_ref2, ['computedStates']);

			return _extends({}, devState, {
				actionsById: { 0: { action: INIT_ACTION } },
				nextActionId: 1,
				stagedActionIds: [0],
				skippedActionIds: [],
				committedState: computedStates[computedStates.length - 1].state,
				computedStates: [_.last(computedStates)]
			});
		},
		'SWEEP': function SWEEP(_ref3) {
			var stagedActionIds = _ref3.stagedActionIds,
			    skippedActionIds = _ref3.skippedActionIds,
			    devState = _objectWithoutProperties(_ref3, ['stagedActionIds', 'skippedActionIds']);

			return recomputeStates(liftedReducer, _extends({}, devState, {
				stagedActionIds: _.difference(stagedActionIds, skippedActionIds),
				skippedActionIds: []
			}));
		},
		'TOGGLE_ACTION': function TOGGLE_ACTION(_ref4, _ref5) {
			var id = _ref5.id;

			var skippedActionIds = _ref4.skippedActionIds,
			    devState = _objectWithoutProperties(_ref4, ['skippedActionIds']);

			return recomputeStates(liftedReducer, skippedActionIds.indexOf(id) === -1 ? _extends({}, devState, {
				skippedActionIds: _.conj(skippedActionIds, id)
			}) : _extends({}, devState, {
				skippedActionIds: _.filter(skippedActionIds, function (i) {
					return i !== id;
				})
			}));
		},
		'JUMP_TO_STATE': notImplemented,
		'IMPORT_STATE': function IMPORT_STATE(devState, _ref6) {
			var nextLiftedState = _ref6.nextLiftedState;
			return recomputeStates(liftedReducer, nextLiftedState);
		}
	};
}

function instrument(controller, monitorReducer, initialState) {
	var initialDevState = {
		nextActionId: 1,
		actionsById: { 0: { action: INIT_ACTION } },
		skippedActionIds: [],
		stagedActionIds: [0],
		computedStates: [{ state: initialState }],
		committedState: initialState,
		select: function select(s) {
			return s;
		},
		monitorState: monitorReducer(undefined, {})
	},
	    liftedReducer = liftReducer(controller.action),
	    ctrls = controls(liftedReducer, initialState);

	return function (state, action) {
		var s = (ctrls[action.type] || identity)(state || initialDevState, action);
		return _extends({}, s, {
			monitorState: monitorReducer(s.monitorState, action)
		});
	};
}

function createDevTools(children) {
	var monitorElement = _react.Children.only(children);
	var monitorProps = monitorElement.props;
	var Monitor = monitorElement.type;
	var enhancer = function enhancer(controller, initialState) {
		return instrument(controller, function (state, action) {
			return Monitor.update(monitorProps, state, action);
		}, initialState);
	};

	var DevTools = function (_React$Component) {
		_inherits(DevTools, _React$Component);

		function DevTools() {
			_classCallCheck(this, DevTools);

			return _possibleConstructorReturn(this, (DevTools.__proto__ || Object.getPrototypeOf(DevTools)).apply(this, arguments));
		}

		_createClass(DevTools, [{
			key: 'render',
			value: function render() {
				return _react2.default.createElement(Monitor, _extends({}, this.props, monitorProps));
			}
		}]);

		return DevTools;
	}(_react2.default.Component);

	DevTools.instrument = enhancer;
	return DevTools;
}

module.exports = {
	instrument: instrument,
	createDevTools: createDevTools
};