rxact-debugger/es/debugger.js

Debugger for rxact

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 _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

import { StateStream } from 'rxact';
import { operatorLogger, emitterLogger } from './logger';
import { isOperator, isEmitter, isDispose, isDebugger, isPresent } from './helpers';

export var clean = function clean() {
  window.rxactDebugger = undefined;
};

function createDebuggerProxy(instance) {
  var _this = this;

  var streamName = instance.streamName;
  var handler = {
    get: function get(target, prop) {
      if (isDebugger(prop)) {
        return {
          start: function start() {
            _this.isStarted = true;
          },
          stop: function stop() {
            _this.isStarted = false;
          }
        };
      }

      var type = 'operator';

      if (!isPresent(target, prop)) {
        console.warn('Operator does not exist: ' + streamName + '.' + prop);
      }
      if (!isOperator(target, prop) || isEmitter(target.emitters, prop)) {
        return target[prop];
      }

      if (isDispose(prop)) {
        type = 'dispose';
      }

      return function () {
        if (_this.isStarted) {
          operatorLogger(type, 'log', streamName, prop);
        }

        return target[prop].apply(target, arguments);
      };
    },
    set: function set(target, prop, value) {
      if (target[prop]) {
        console.warn('Operator redefined: ' + streamName + '.' + prop);
      }
      target[prop] = value;

      return true;
    }
  };

  return new Proxy(instance, handler);
}

function createEmitterProxy(instance) {
  var _this2 = this;

  var handler = {
    apply: function apply(target, thisArg, argumentsList) {
      var _argumentsList = _slicedToArray(argumentsList, 2),
          name = _argumentsList[0],
          emitter = _argumentsList[1];

      var loggableEmitter = function loggableEmitter() {
        for (var _len = arguments.length, params = Array(_len), _key = 0; _key < _len; _key++) {
          params[_key] = arguments[_key];
        }

        return function (prevState) {
          var nextState = emitter.apply(undefined, params)(prevState);

          if (_this2.isStarted) {
            emitterLogger(instance.streamName, name, prevState, nextState);
          }

          return nextState;
        };
      };

      return target.call(thisArg, name, loggableEmitter);
    }
  };

  return new Proxy(instance.emitter, handler);
}

var isStartDefault = function isStartDefault(start, stream) {
  return start === true || Array.isArray(start) && start.find(function (item) {
    return item === stream;
  });
};

var defaultOptions = {
  start: false
};

var rxactDebugger = function rxactDebugger() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) !== 'object' || Array.isArray(options)) {
    throw new Error('rxact-debugger: Expect options to be an object.');
  }

  return function (instance) {
    var finalOptions = _extends({}, defaultOptions, options);
    var start = finalOptions.start;

    var startDefault = isStartDefault(start, instance.streamName);
    var context = {
      isStarted: false
    };

    var debuggableProxy = createDebuggerProxy.call(context, instance);
    var emitterProxy = createEmitterProxy.call(context, instance);

    instance.emitter = emitterProxy;

    if (!window.rxactDebugger) {
      window.rxactDebugger = {};
    }
    window.rxactDebugger[instance.streamName] = debuggableProxy;

    if (startDefault) {
      debuggableProxy.debugger.start();
    }

    return debuggableProxy;
  };
};

export default rxactDebugger;