a-chart/dist/index.1.js

A-Chart is a ReactJS Library/Package to address all posibilities of Reporting Functionality

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.Chart = undefined;

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 _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _redux = require('redux');

var _reactRedux = require('react-redux');

var _grid = require('./components/dataGrid/grid');

var _grid2 = _interopRequireDefault(_grid);

var _indexR = require('./reducer/indexR');

var _indexR2 = _interopRequireDefault(_indexR);

var _userMethods = require('./util/userMethods');

var _userMethods2 = _interopRequireDefault(_userMethods);

var _utilFns = require('./util/utilFns');

var Util = _interopRequireWildcard(_utilFns);

var _reduxThunk = require('redux-thunk');

var _reduxThunk2 = _interopRequireDefault(_reduxThunk);

require('font-awesome/css/font-awesome.min.css');

require('./styles.css');

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

var HOCFN = function HOCFN(WrappedComponent) {
    var HOC = function (_React$Component) {
        _inherits(HOC, _React$Component);

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

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

        _createClass(HOC, [{
            key: 'render',
            value: function render() {
                return _react2.default.createElement(WrappedComponent, this.props);
            }
        }]);

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

    return HOC;
};

var Achart = function (_UserClass) {
    _inherits(Achart, _UserClass);

    function Achart(props) {
        _classCallCheck(this, Achart);

        var _this2 = _possibleConstructorReturn(this, (Achart.__proto__ || Object.getPrototypeOf(Achart)).call(this, props));

        var defConfig = {
            "width": "666",
            "header": true, // Default  true
            "headerConfig": {},
            "headers": [], //  **optional
            "formatters": {}, //**optional
            //Type:collection of ojects// property of dsiplay array
            //formatters are giving a option to apply your formatting logic(display format like amount and currency format) while rendering cells.
            //Also inside the function you will get hte complete scope of the cuurent row in "this" Object
            //Example:   name is column property
            // formatters: {
            //     name: function(val){
            //       return  this.col2+"---"+val
            //     }
            //   }

            "columnsToHide": "", //Comma seprated string, to hide specific columns from grid   **optional
            "columnsForSort": "", //Comma seprated string, to enable sorting for columns  **optional
            "analyticalColumns": "", //Comma seprated string, to show sum of numerical columns  **optional
            "rowFocus": false, // Default  false   **optional
            "export": "", // export data to xls or csv (now will support only one type in single config)  Default  false   **optional
            "mode": "None", //Multi,Single,None   Default  none   **optional
            "fieldsToEdit": "", //Comma seprated string, these fields can edit from grid  **optional
            "search": false, // Search functionality **optional // Default  false
            "searchFields": "" // Comma seprated string, Search will happen only against these columns  **optional
        };

        defConfig._tableId = "achart-d-grid_" + Math.floor(Math.random() * 11111);
        _this2.state = { key: Math.random() };

        _this2.config = Object.assign({}, defConfig, _this2.props.config);
        if (typeof _this2.props.items === "string") {
            _this2.items = _this2.props.items;
        } else {
            _this2.items = Object.assign([], _this2.props.items);
        }

        var that = _this2;

        _this2.Util = Util;
        _this2.Util._prepHeader = _this2.Util._prepHeader.bind(that);
        var headePrep = _this2.Util._prepHeader;

        var customMiddleWare = function customMiddleWare(store) {
            return function (next) {
                return function (action) {

                    headePrep(action.items, action.config);
                    next(action);
                };
            };
        };
        customMiddleWare.bind(that);
        var m = [_reduxThunk2.default, customMiddleWare];

        _this2.store = (0, _redux.createStore)(_indexR2.default, _redux.applyMiddleware.apply(undefined, m));
        return _this2;
    }

    _createClass(Achart, [{
        key: 'componentDidMount',
        value: function componentDidMount() {}
    }, {
        key: 'render',
        value: function render() {

            if (this.config && this.config.headers && this.items) {

                // this.Util._prepHeader();
            }

            return _react2.default.createElement(
                _reactRedux.Provider,
                { store: this.store },
                _react2.default.createElement(
                    'div',
                    { className: 'aChart' },
                    this.items ? _react2.default.createElement(_grid2.default, { key: this.state.key, itemSource: this.items, config: this.config }) : _react2.default.createElement(
                        'h3',
                        null,
                        ' Please provide data source to plot, \'items\'  as Arrays  '
                    )
                )
            );
        }
    }]);

    return Achart;
}(_userMethods2.default);

var Chart = exports.Chart = function (_Component) {
    _inherits(Chart, _Component);

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

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

    _createClass(Chart, [{
        key: 'render',
        value: function render() {

            return _react2.default.createElement(
                'div',
                null,
                _react2.default.createElement(
                    'h3',
                    null,
                    'Charting '
                ),
                this.items.map(function (d, i) {
                    return _react2.default.createElement(
                        'div',
                        null,
                        d.make
                    );
                })
            );
        }
    }]);

    return Chart;
}(_react.Component);

module.exports = Achart;
//export default Achart;