react-planner-viewer/es/index.js

react-planner-viewer is a React Component for view plans builded with react-planner in 2D mode

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; }; }();

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; }

import React from 'react';
import { Map } from 'immutable';
import { createStore } from 'redux';
import { Provider } from 'react-redux';
import ReactPlanner from './react-planner';
import PropTypes from 'prop-types';

import MyCatalog from './catalog/myCatalog/myCatalog';

import * as PlannerModels from './models';
import PlannerReducer from './reducers/reducer';

var AppState = Map({
  'react-planner': new PlannerModels.State()
});

//define reducer
var reducer = function reducer(state, action) {
  state = state || AppState;
  state = state.update('react-planner', function (plannerState) {
    return PlannerReducer(plannerState, action);
  });
  return state;
};

var store = createStore(reducer, null);

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

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

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

  _createClass(ReactPlannerViewer, [{
    key: 'render',
    value: function render() {
      var _props = this.props,
          width = _props.width,
          height = _props.height,
          project = _props.project,
          scene = _props.scene,
          heatMapValues = _props.heatMapValues,
          heatMapColors = _props.heatMapColors,
          onSelectArea = _props.onSelectArea;

      return React.createElement(
        Provider,
        { store: store },
        React.createElement(ReactPlanner, {
          catalog: MyCatalog,
          width: width,
          height: height,
          newScene: scene,
          heatMapColors: heatMapColors,
          heatMapValues: heatMapValues,
          onSelectArea: onSelectArea,
          stateExtractor: function stateExtractor(state) {
            return state.get('react-planner');
          }
        })
      );
    }
  }]);

  return ReactPlannerViewer;
}(React.Component);

ReactPlannerViewer.propTypes = {
  heatMapColors: PropTypes.array,
  heatmapValues: PropTypes.arrayOf(PropTypes.object),
  width: PropTypes.number,
  height: PropTypes.number,
  onSelectArea: PropTypes.func,
  scene: PropTypes.object
};
ReactPlannerViewer.defaultProps = {
  heatMapValues: [],
  width: 300,
  height: 300,
  onSelectArea: function onSelectArea(areaName) {}
};

export default ReactPlannerViewer;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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