reactotron-redux/dist/commonjs/commandHandler.js

A Reactotron plugin for Redux.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = createCommandHandler;
var _reactotronCoreClient = require("reactotron-core-client");
var _stateCleaner = _interopRequireDefault(require("./helpers/stateCleaner"));
var _pathObject = _interopRequireDefault(require("./helpers/pathObject"));
var _subscriptionsHandler = _interopRequireDefault(require("./subscriptionsHandler"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function createCommandHandler(reactotron, pluginConfig, onReduxStoreCreation) {
  // make sure have loaded the StateResponsePlugin
  (0, _reactotronCoreClient.assertHasStateResponsePlugin)(reactotron);
  const client = reactotron;

  // create our subscriptions handler
  const subscriptionsHandler = (0, _subscriptionsHandler.default)(reactotron, onReduxStoreCreation);
  return ({
    type,
    payload
  }) => {
    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
    // @ts-ignore shhhhhh -- this is a private API
    const reduxStore = client.reduxStore;
    switch (type) {
      // client is asking for keys
      case "state.keys.request":
      case "state.values.request":
        {
          const cleanedState = (0, _stateCleaner.default)(reduxStore.getState());
          if (!payload.path) {
            client.stateKeysResponse(null, type === "state.keys.request" ? Object.keys(cleanedState) : cleanedState);
          } else {
            const filteredObj = (0, _pathObject.default)(payload.path, cleanedState);
            const responseMethod = type === "state.keys.request" ? client.stateKeysResponse : client.stateValuesResponse;
            responseMethod(payload.path, type === "state.keys.request" ? typeof filteredObj === "object" ? Object.keys(filteredObj) : undefined : filteredObj);
          }
        }
        break;

      // client is asking to subscribe to some paths
      case "state.values.subscribe":
        subscriptionsHandler.setSubscriptions(payload.paths);
        subscriptionsHandler.sendSubscriptions();
        break;

      // server is asking to dispatch this action
      case "state.action.dispatch":
        reduxStore.dispatch(payload.action);
        break;

      // server is asking to backup state
      case "state.backup.request":
        {
          // run our state through our onBackup
          let backedUpState = reduxStore.getState();
          if (pluginConfig.onBackup) {
            backedUpState = pluginConfig.onBackup(backedUpState);
          }
          client.send("state.backup.response", {
            state: backedUpState
          });
          break;
        }

      // server is asking to clobber state with this
      case "state.restore.request":
        {
          // run our state through our onRestore
          let restoredState = payload.state;
          if (pluginConfig.onRestore) {
            restoredState = pluginConfig.onRestore(payload.state, reduxStore.getState());
          }

          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
          // @ts-ignore shhhhhh -- this is a private API
          client.reduxStore.dispatch({
            type: pluginConfig.restoreActionType,
            state: restoredState
          });
          break;
        }
    }
  };
}
//# sourceMappingURL=commandHandler.js.map