dash-renderer/lib/reducers/reducer.js

render dash components in react

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.apiRequests = void 0;
exports.createReducer = createReducer;
var _ramda = require("ramda");
var _redux = require("redux");
var _dependencies_ts = require("../actions/dependencies_ts");
var _api = _interopRequireDefault(require("./api"));
var _appLifecycle = _interopRequireDefault(require("./appLifecycle"));
var _callbacks = _interopRequireDefault(require("./callbacks"));
var _config = _interopRequireDefault(require("./config"));
var _dependencyGraph = _interopRequireDefault(require("./dependencyGraph"));
var _error = _interopRequireDefault(require("./error"));
var _history = _interopRequireDefault(require("./history"));
var _hooks = _interopRequireDefault(require("./hooks"));
var _profile = _interopRequireDefault(require("./profile"));
var _changed = _interopRequireDefault(require("./changed"));
var _isLoading = _interopRequireDefault(require("./isLoading"));
var _layout = _interopRequireDefault(require("./layout"));
var _paths = _interopRequireDefault(require("./paths"));
var _callbackJobs = _interopRequireDefault(require("./callbackJobs"));
var _loading = _interopRequireDefault(require("./loading"));
var _wrapping = require("../wrapper/wrapping");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
var apiRequests = exports.apiRequests = ['dependenciesRequest', 'layoutRequest', 'reloadRequest', 'loginRequest'];
var layoutHashes = function layoutHashes() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var action = arguments.length > 1 ? arguments[1] : undefined;
  if ((0, _ramda.includes)(action.type, ['UNDO_PROP_CHANGE', 'REDO_PROP_CHANGE', 'ON_PROP_CHANGE'])) {
    // Let us compare the paths sums to get updates without triggering
    // render on the parent containers.
    var actionPath = action.payload.itempath;
    var strPath = (0, _wrapping.stringifyPath)(actionPath);
    var prev = (0, _ramda.pathOr)(0, [strPath, 'hash'], state);
    state = (0, _ramda.assoc)(strPath, {
      hash: prev + 1,
      changedProps: action.payload.props,
      renderType: action.payload.renderType
    }, state);
  }
  return state;
};
function mainReducer() {
  var parts = {
    appLifecycle: _appLifecycle.default,
    callbacks: _callbacks.default,
    config: _config.default,
    error: _error.default,
    graphs: _dependencyGraph.default,
    history: _history.default,
    hooks: _hooks.default,
    profile: _profile.default,
    changed: _changed.default,
    isLoading: _isLoading.default,
    layout: _layout.default,
    paths: _paths.default,
    layoutHashes,
    loading: _loading.default
  };
  (0, _ramda.forEach)(r => {
    parts[r] = (0, _api.default)(r);
  }, apiRequests);
  parts.callbackJobs = _callbackJobs.default;
  return (0, _redux.combineReducers)(parts);
}
function getInputHistoryState(payload, state, recordChanges) {
  var graphs = state.graphs,
    paths = state.paths,
    layout = state.layout;
  var itempath = payload.itempath,
    props = payload.props;
  var refProps = (0, _ramda.path)(itempath.concat(['props']), layout) || {};
  var id = refProps.id;
  var historyEntry;
  if (id) {
    if (recordChanges) {
      state.changed = {
        id,
        props
      };
    }
    historyEntry = {
      id,
      props: {}
    };
    (0, _ramda.keys)(props).forEach(propKey => {
      if ((0, _dependencies_ts.getCallbacksByInput)(graphs, paths, id, propKey).length) {
        historyEntry.props[propKey] = refProps[propKey];
      }
    });
  }
  return historyEntry;
}
function recordHistory(reducer) {
  return function (state, action) {
    // Record initial state
    var type = action.type,
      payload = action.payload;
    if (type === 'ON_PROP_CHANGE') {
      // history records all prop changes that are inputs.
      var historyEntry = getInputHistoryState(payload, state, true);
      if (historyEntry && !(0, _ramda.isEmpty)(historyEntry.props)) {
        state.history.present = historyEntry;
      }
    }
    var nextState = reducer(state, action);
    if (type === 'ON_PROP_CHANGE' && payload.source !== 'response') {
      /*
       * if the prop change is an input, then
       * record it so that it can be played back
       */
      var _historyEntry = getInputHistoryState(payload, nextState);
      if (_historyEntry && !(0, _ramda.isEmpty)(_historyEntry.props)) {
        nextState.history = {
          past: [...nextState.history.past, state.history.present],
          present: _historyEntry,
          future: []
        };
      }
    }
    return nextState;
  };
}
function reloaderReducer(reducer) {
  return function (state, action) {
    var _ref = state || {},
      history = _ref.history,
      config = _ref.config,
      hooks = _ref.hooks;
    var newState = state;
    if (action.type === 'RELOAD') {
      newState = {
        history,
        config,
        hooks
      };
    } else if (action.type === 'SET_CONFIG') {
      // new config also reloads, and even clears history,
      // in case there's a new user or even a totally different app!
      // hooks are set at an even higher level than config though.
      newState = {
        hooks
      };
    }
    return reducer(newState, action);
  };
}
function createReducer() {
  return reloaderReducer(recordHistory(mainReducer()));
}