react-nvd3-roadcert-edition
Version:
React nvd3 reusable graph components.
1,453 lines (1,184 loc) • 41.8 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("react"), require("d3"), require("nvd3"));
else if(typeof define === 'function' && define.amd)
define(["react", "d3", "nvd3"], factory);
else if(typeof exports === 'object')
exports["NVD3Chart"] = factory(require("react"), require("d3"), require("nvd3"));
else
root["NVD3Chart"] = factory(root["React"], root["d3"], root["nv"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_55__, __WEBPACK_EXTERNAL_MODULE_56__, __WEBPACK_EXTERNAL_MODULE_57__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _extends2 = __webpack_require__(1);
var _extends3 = _interopRequireDefault(_extends2);
var _assign = __webpack_require__(2);
var _assign2 = _interopRequireDefault(_assign);
var _getPrototypeOf = __webpack_require__(17);
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = __webpack_require__(21);
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = __webpack_require__(22);
var _createClass3 = _interopRequireDefault(_createClass2);
var _possibleConstructorReturn2 = __webpack_require__(25);
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = __webpack_require__(48);
var _inherits3 = _interopRequireDefault(_inherits2);
var _react = __webpack_require__(55);
var _react2 = _interopRequireDefault(_react);
var _d = __webpack_require__(56);
var _d2 = _interopRequireDefault(_d);
var _nvd = __webpack_require__(57);
var _nvd2 = _interopRequireDefault(_nvd);
var _utils = __webpack_require__(58);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var SETTINGS = ['x', 'y', 'type', 'datum', 'configure'];
var SIZE = ['width', 'height'];
var MARGIN = 'margin';
var LEGEND = 'legend';
var TOOLTIP = 'tooltip';
var CONTAINER_STYLE = 'containerStyle';
var RENDER_START = 'renderStart';
var RENDER_END = 'renderEnd';
var READY = 'ready';
var NVD3Chart = function (_React$Component) {
(0, _inherits3.default)(NVD3Chart, _React$Component);
function NVD3Chart() {
(0, _classCallCheck3.default)(this, NVD3Chart);
return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(NVD3Chart).apply(this, arguments));
}
(0, _createClass3.default)(NVD3Chart, [{
key: 'componentDidMount',
/**
* Instantiate a new chart setting
* a callback if exists
*/
value: function componentDidMount() {
var _this2 = this;
_nvd2.default.addGraph(this.renderChart.bind(this), function (chart) {
if ((0, _utils.isCallable)(_this2.props.ready)) _this2.props.ready(chart, READY);
});
}
/**
* Update the chart after state is changed.
*/
}, {
key: 'componentDidUpdate',
value: function componentDidUpdate() {
//this.renderChart();
console.log("DO NOT RE-RENDER TEST. FIGURE OUT TO RENDER JUST THIS ONE IN CONTEXT");
}
/**
* Remove listeners
*/
}, {
key: 'componentWillUnmount',
value: function componentWillUnmount() {
if (this.resizeHandler) this.resizeHandler.clear();
}
/**
* Creates a chart model and render it
*/
}, {
key: 'renderChart',
value: function renderChart() {
console.log("rendering chart... ", this.rendering);
var dispatcher = void 0;
// We try to reuse the current chart instance. If not possible then lets instantiate again
this.chart = this.chart && !this.rendering ? this.chart : _nvd2.default.models[this.props.type]();
if ((0, _utils.isCallable)(this.props.renderStart)) this.props.renderStart(this.chart, RENDER_START);
this.parsedProps = (0, _utils.bindFunctions)(this.props, this.props.context);
this.chart.x && this.chart.x((0, _utils.getValueFunction)(this.parsedProps.x, 'x'));
this.chart.y && this.chart.y((0, _utils.getValueFunction)(this.parsedProps.y, 'y'));
this.props.margin && this.chart.margin(this.options(MARGIN, _utils.pick).margin || (0, _utils.propsByPrefix)('margin', this.props) || {});
// Configure componentes recursively
this.configureComponents(this.chart, this.options(SETTINGS.concat(CONTAINER_STYLE), _utils.without));
// hook for configuring the chart
!this.props.configure || this.props.configure(this.chart);
// Render chart using d3
this.selection = _d2.default.select(this.refs.svg).datum(this.props.datum).call(this.chart);
// Update the chart if the window size change.
// Save resizeHandle to remove the resize listener later.
if (!this.resizeHandler) this.resizeHandler = _nvd2.default.utils.windowResize(this.chart.update);
// PieCharts and lineCharts are an special case. Their dispacher is the pie component inside the chart.
// There are some charts do not feature the renderEnd event
switch (this.props.type) {
case 'pieChart':
dispatcher = this.chart.pie.dispatch;
break;
case 'lineChart':
dispatcher = this.chart.lines.dispatch;
break;
default:
dispatcher = this.chart.dispatch;
}
dispatcher.renderEnd && dispatcher.on('renderEnd', this.renderEnd.bind(this));
this.rendering = true;
return this.chart;
}
/**
* Render end callback function
* @param {Event} e
*/
}, {
key: 'renderEnd',
value: function renderEnd(e) {
if ((0, _utils.isCallable)(this.props.renderEnd)) this.props.renderEnd(this.chart, RENDER_END);
// Once renders end then we set rendering to false to allow to reuse the chart instance.
this.rendering = false;
}
/**
* Configure components recursively
* @param {nvd3 chart} chart A nvd3 chart instance
* @param {object} options A key value object
*/
}, {
key: 'configureComponents',
value: function configureComponents(chart, options) {
for (var optionName in options) {
var optionValue = options[optionName];
if (chart) {
if ((0, _utils.isPlainObject)(optionValue)) {
this.configureComponents(chart[optionName], optionValue);
} else if (typeof chart[optionName] === 'function') {
chart[optionName](optionValue);
}
}
}
}
/**
* Filter options base on predicates
* @param {Array} keys An array of keys to preserve or remove
* @param {Function} predicate The function used to filter keys
*/
}, {
key: 'options',
value: function options(keys, predicate) {
// DEPRECATED: this.props.chartOptions
var opt = this.parsedProps.options || this.parsedProps || this.props.chartOptions;
predicate = predicate || _utils.pick;
return predicate(opt, keys);
}
/**
* Render function
* svg element needs to have height and width.
*/
}, {
key: 'render',
value: function render() {
var size = (0, _utils.pick)(this.props, SIZE);
var style = (0, _assign2.default)({}, size, this.props.containerStyle);
return _react2.default.createElement(
'div',
{ ref: 'root', className: 'nv-chart', style: style },
_react2.default.createElement('svg', (0, _extends3.default)({ ref: 'svg' }, size))
);
}
}]);
return NVD3Chart;
}(_react2.default.Component);
// Babel 6 issue: http://stackoverflow.com/questions/33505992/babel-6-changes-how-it-exports-default
exports.default = NVD3Chart;
module.exports = NVD3Chart;
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _Object$assign = __webpack_require__(2)["default"];
exports["default"] = _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;
};
exports.__esModule = true;
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(3), __esModule: true };
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(4);
module.exports = __webpack_require__(7).Object.assign;
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.3.1 Object.assign(target, source)
var $export = __webpack_require__(5);
$export($export.S + $export.F, 'Object', {assign: __webpack_require__(10)});
/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(6)
, core = __webpack_require__(7)
, ctx = __webpack_require__(8)
, PROTOTYPE = 'prototype';
var $export = function(type, name, source){
var IS_FORCED = type & $export.F
, IS_GLOBAL = type & $export.G
, IS_STATIC = type & $export.S
, IS_PROTO = type & $export.P
, IS_BIND = type & $export.B
, IS_WRAP = type & $export.W
, exports = IS_GLOBAL ? core : core[name] || (core[name] = {})
, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
, key, own, out;
if(IS_GLOBAL)source = name;
for(key in source){
// contains in native
own = !IS_FORCED && target && key in target;
if(own && key in exports)continue;
// export native or passed
out = own ? target[key] : source[key];
// prevent global pollution for namespaces
exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
// bind timers to global for call from export context
: IS_BIND && own ? ctx(out, global)
// wrap global constructors for prevent change them in library
: IS_WRAP && target[key] == out ? (function(C){
var F = function(param){
return this instanceof C ? new C(param) : C(param);
};
F[PROTOTYPE] = C[PROTOTYPE];
return F;
// make static versions for prototype methods
})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;
}
};
// type bitmap
$export.F = 1; // forced
$export.G = 2; // global
$export.S = 4; // static
$export.P = 8; // proto
$export.B = 16; // bind
$export.W = 32; // wrap
module.exports = $export;
/***/ },
/* 6 */
/***/ function(module, exports) {
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
/***/ },
/* 7 */
/***/ function(module, exports) {
var core = module.exports = {version: '1.2.6'};
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
// optional / simple context binding
var aFunction = __webpack_require__(9);
module.exports = function(fn, that, length){
aFunction(fn);
if(that === undefined)return fn;
switch(length){
case 1: return function(a){
return fn.call(that, a);
};
case 2: return function(a, b){
return fn.call(that, a, b);
};
case 3: return function(a, b, c){
return fn.call(that, a, b, c);
};
}
return function(/* ...args */){
return fn.apply(that, arguments);
};
};
/***/ },
/* 9 */
/***/ function(module, exports) {
module.exports = function(it){
if(typeof it != 'function')throw TypeError(it + ' is not a function!');
return it;
};
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.1 Object.assign(target, source, ...)
var $ = __webpack_require__(11)
, toObject = __webpack_require__(12)
, IObject = __webpack_require__(14);
// should work with symbols and should have deterministic property order (V8 bug)
module.exports = __webpack_require__(16)(function(){
var a = Object.assign
, A = {}
, B = {}
, S = Symbol()
, K = 'abcdefghijklmnopqrst';
A[S] = 7;
K.split('').forEach(function(k){ B[k] = k; });
return a({}, A)[S] != 7 || Object.keys(a({}, B)).join('') != K;
}) ? function assign(target, source){ // eslint-disable-line no-unused-vars
var T = toObject(target)
, $$ = arguments
, $$len = $$.length
, index = 1
, getKeys = $.getKeys
, getSymbols = $.getSymbols
, isEnum = $.isEnum;
while($$len > index){
var S = IObject($$[index++])
, keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
, length = keys.length
, j = 0
, key;
while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
}
return T;
} : Object.assign;
/***/ },
/* 11 */
/***/ function(module, exports) {
var $Object = Object;
module.exports = {
create: $Object.create,
getProto: $Object.getPrototypeOf,
isEnum: {}.propertyIsEnumerable,
getDesc: $Object.getOwnPropertyDescriptor,
setDesc: $Object.defineProperty,
setDescs: $Object.defineProperties,
getKeys: $Object.keys,
getNames: $Object.getOwnPropertyNames,
getSymbols: $Object.getOwnPropertySymbols,
each: [].forEach
};
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.13 ToObject(argument)
var defined = __webpack_require__(13);
module.exports = function(it){
return Object(defined(it));
};
/***/ },
/* 13 */
/***/ function(module, exports) {
// 7.2.1 RequireObjectCoercible(argument)
module.exports = function(it){
if(it == undefined)throw TypeError("Can't call method on " + it);
return it;
};
/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {
// fallback for non-array-like ES3 and non-enumerable old V8 strings
var cof = __webpack_require__(15);
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
return cof(it) == 'String' ? it.split('') : Object(it);
};
/***/ },
/* 15 */
/***/ function(module, exports) {
var toString = {}.toString;
module.exports = function(it){
return toString.call(it).slice(8, -1);
};
/***/ },
/* 16 */
/***/ function(module, exports) {
module.exports = function(exec){
try {
return !!exec();
} catch(e){
return true;
}
};
/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(18), __esModule: true };
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(19);
module.exports = __webpack_require__(7).Object.getPrototypeOf;
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.9 Object.getPrototypeOf(O)
var toObject = __webpack_require__(12);
__webpack_require__(20)('getPrototypeOf', function($getPrototypeOf){
return function getPrototypeOf(it){
return $getPrototypeOf(toObject(it));
};
});
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
// most Object methods by ES6 should accept primitives
var $export = __webpack_require__(5)
, core = __webpack_require__(7)
, fails = __webpack_require__(16);
module.exports = function(KEY, exec){
var fn = (core.Object || {})[KEY] || Object[KEY]
, exp = {};
exp[KEY] = exec(fn);
$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
};
/***/ },
/* 21 */
/***/ function(module, exports) {
"use strict";
exports.__esModule = true;
exports.default = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
var _defineProperty = __webpack_require__(23);
var _defineProperty2 = _interopRequireDefault(_defineProperty);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = 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;
(0, _defineProperty2.default)(target, descriptor.key, descriptor);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
};
}();
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(24), __esModule: true };
/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(11);
module.exports = function defineProperty(it, key, desc){
return $.setDesc(it, key, desc);
};
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
var _typeof2 = __webpack_require__(26);
var _typeof3 = _interopRequireDefault(_typeof2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = function (self, call) {
if (!self) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return call && ((typeof call === "undefined" ? "undefined" : (0, _typeof3.default)(call)) === "object" || typeof call === "function") ? call : self;
};
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _Symbol = __webpack_require__(27)["default"];
exports["default"] = function (obj) {
return obj && obj.constructor === _Symbol ? "symbol" : typeof obj;
};
exports.__esModule = true;
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(28), __esModule: true };
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(29);
__webpack_require__(47);
module.exports = __webpack_require__(7).Symbol;
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
// ECMAScript 6 symbols shim
var $ = __webpack_require__(11)
, global = __webpack_require__(6)
, has = __webpack_require__(30)
, DESCRIPTORS = __webpack_require__(31)
, $export = __webpack_require__(5)
, redefine = __webpack_require__(32)
, $fails = __webpack_require__(16)
, shared = __webpack_require__(35)
, setToStringTag = __webpack_require__(36)
, uid = __webpack_require__(38)
, wks = __webpack_require__(37)
, keyOf = __webpack_require__(39)
, $names = __webpack_require__(41)
, enumKeys = __webpack_require__(42)
, isArray = __webpack_require__(43)
, anObject = __webpack_require__(44)
, toIObject = __webpack_require__(40)
, createDesc = __webpack_require__(34)
, getDesc = $.getDesc
, setDesc = $.setDesc
, _create = $.create
, getNames = $names.get
, $Symbol = global.Symbol
, $JSON = global.JSON
, _stringify = $JSON && $JSON.stringify
, setter = false
, HIDDEN = wks('_hidden')
, isEnum = $.isEnum
, SymbolRegistry = shared('symbol-registry')
, AllSymbols = shared('symbols')
, useNative = typeof $Symbol == 'function'
, ObjectProto = Object.prototype;
// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
var setSymbolDesc = DESCRIPTORS && $fails(function(){
return _create(setDesc({}, 'a', {
get: function(){ return setDesc(this, 'a', {value: 7}).a; }
})).a != 7;
}) ? function(it, key, D){
var protoDesc = getDesc(ObjectProto, key);
if(protoDesc)delete ObjectProto[key];
setDesc(it, key, D);
if(protoDesc && it !== ObjectProto)setDesc(ObjectProto, key, protoDesc);
} : setDesc;
var wrap = function(tag){
var sym = AllSymbols[tag] = _create($Symbol.prototype);
sym._k = tag;
DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, {
configurable: true,
set: function(value){
if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
setSymbolDesc(this, tag, createDesc(1, value));
}
});
return sym;
};
var isSymbol = function(it){
return typeof it == 'symbol';
};
var $defineProperty = function defineProperty(it, key, D){
if(D && has(AllSymbols, key)){
if(!D.enumerable){
if(!has(it, HIDDEN))setDesc(it, HIDDEN, createDesc(1, {}));
it[HIDDEN][key] = true;
} else {
if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
D = _create(D, {enumerable: createDesc(0, false)});
} return setSymbolDesc(it, key, D);
} return setDesc(it, key, D);
};
var $defineProperties = function defineProperties(it, P){
anObject(it);
var keys = enumKeys(P = toIObject(P))
, i = 0
, l = keys.length
, key;
while(l > i)$defineProperty(it, key = keys[i++], P[key]);
return it;
};
var $create = function create(it, P){
return P === undefined ? _create(it) : $defineProperties(_create(it), P);
};
var $propertyIsEnumerable = function propertyIsEnumerable(key){
var E = isEnum.call(this, key);
return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key]
? E : true;
};
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
var D = getDesc(it = toIObject(it), key);
if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
return D;
};
var $getOwnPropertyNames = function getOwnPropertyNames(it){
var names = getNames(toIObject(it))
, result = []
, i = 0
, key;
while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);
return result;
};
var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
var names = getNames(toIObject(it))
, result = []
, i = 0
, key;
while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);
return result;
};
var $stringify = function stringify(it){
if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
var args = [it]
, i = 1
, $$ = arguments
, replacer, $replacer;
while($$.length > i)args.push($$[i++]);
replacer = args[1];
if(typeof replacer == 'function')$replacer = replacer;
if($replacer || !isArray(replacer))replacer = function(key, value){
if($replacer)value = $replacer.call(this, key, value);
if(!isSymbol(value))return value;
};
args[1] = replacer;
return _stringify.apply($JSON, args);
};
var buggyJSON = $fails(function(){
var S = $Symbol();
// MS Edge converts symbol values to JSON as {}
// WebKit converts symbol values to JSON as null
// V8 throws on boxed symbols
return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
});
// 19.4.1.1 Symbol([description])
if(!useNative){
$Symbol = function Symbol(){
if(isSymbol(this))throw TypeError('Symbol is not a constructor');
return wrap(uid(arguments.length > 0 ? arguments[0] : undefined));
};
redefine($Symbol.prototype, 'toString', function toString(){
return this._k;
});
isSymbol = function(it){
return it instanceof $Symbol;
};
$.create = $create;
$.isEnum = $propertyIsEnumerable;
$.getDesc = $getOwnPropertyDescriptor;
$.setDesc = $defineProperty;
$.setDescs = $defineProperties;
$.getNames = $names.get = $getOwnPropertyNames;
$.getSymbols = $getOwnPropertySymbols;
if(DESCRIPTORS && !__webpack_require__(46)){
redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
}
}
var symbolStatics = {
// 19.4.2.1 Symbol.for(key)
'for': function(key){
return has(SymbolRegistry, key += '')
? SymbolRegistry[key]
: SymbolRegistry[key] = $Symbol(key);
},
// 19.4.2.5 Symbol.keyFor(sym)
keyFor: function keyFor(key){
return keyOf(SymbolRegistry, key);
},
useSetter: function(){ setter = true; },
useSimple: function(){ setter = false; }
};
// 19.4.2.2 Symbol.hasInstance
// 19.4.2.3 Symbol.isConcatSpreadable
// 19.4.2.4 Symbol.iterator
// 19.4.2.6 Symbol.match
// 19.4.2.8 Symbol.replace
// 19.4.2.9 Symbol.search
// 19.4.2.10 Symbol.species
// 19.4.2.11 Symbol.split
// 19.4.2.12 Symbol.toPrimitive
// 19.4.2.13 Symbol.toStringTag
// 19.4.2.14 Symbol.unscopables
$.each.call((
'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +
'species,split,toPrimitive,toStringTag,unscopables'
).split(','), function(it){
var sym = wks(it);
symbolStatics[it] = useNative ? sym : wrap(sym);
});
setter = true;
$export($export.G + $export.W, {Symbol: $Symbol});
$export($export.S, 'Symbol', symbolStatics);
$export($export.S + $export.F * !useNative, 'Object', {
// 19.1.2.2 Object.create(O [, Properties])
create: $create,
// 19.1.2.4 Object.defineProperty(O, P, Attributes)
defineProperty: $defineProperty,
// 19.1.2.3 Object.defineProperties(O, Properties)
defineProperties: $defineProperties,
// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
// 19.1.2.7 Object.getOwnPropertyNames(O)
getOwnPropertyNames: $getOwnPropertyNames,
// 19.1.2.8 Object.getOwnPropertySymbols(O)
getOwnPropertySymbols: $getOwnPropertySymbols
});
// 24.3.2 JSON.stringify(value [, replacer [, space]])
$JSON && $export($export.S + $export.F * (!useNative || buggyJSON), 'JSON', {stringify: $stringify});
// 19.4.3.5 Symbol.prototype[@@toStringTag]
setToStringTag($Symbol, 'Symbol');
// 20.2.1.9 Math[@@toStringTag]
setToStringTag(Math, 'Math', true);
// 24.3.3 JSON[@@toStringTag]
setToStringTag(global.JSON, 'JSON', true);
/***/ },
/* 30 */
/***/ function(module, exports) {
var hasOwnProperty = {}.hasOwnProperty;
module.exports = function(it, key){
return hasOwnProperty.call(it, key);
};
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(16)(function(){
return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
});
/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(33);
/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(11)
, createDesc = __webpack_require__(34);
module.exports = __webpack_require__(31) ? function(object, key, value){
return $.setDesc(object, key, createDesc(1, value));
} : function(object, key, value){
object[key] = value;
return object;
};
/***/ },
/* 34 */
/***/ function(module, exports) {
module.exports = function(bitmap, value){
return {
enumerable : !(bitmap & 1),
configurable: !(bitmap & 2),
writable : !(bitmap & 4),
value : value
};
};
/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(6)
, SHARED = '__core-js_shared__'
, store = global[SHARED] || (global[SHARED] = {});
module.exports = function(key){
return store[key] || (store[key] = {});
};
/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {
var def = __webpack_require__(11).setDesc
, has = __webpack_require__(30)
, TAG = __webpack_require__(37)('toStringTag');
module.exports = function(it, tag, stat){
if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
};
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
var store = __webpack_require__(35)('wks')
, uid = __webpack_require__(38)
, Symbol = __webpack_require__(6).Symbol;
module.exports = function(name){
return store[name] || (store[name] =
Symbol && Symbol[name] || (Symbol || uid)('Symbol.' + name));
};
/***/ },
/* 38 */
/***/ function(module, exports) {
var id = 0
, px = Math.random();
module.exports = function(key){
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
};
/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(11)
, toIObject = __webpack_require__(40);
module.exports = function(object, el){
var O = toIObject(object)
, keys = $.getKeys(O)
, length = keys.length
, index = 0
, key;
while(length > index)if(O[key = keys[index++]] === el)return key;
};
/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {
// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(14)
, defined = __webpack_require__(13);
module.exports = function(it){
return IObject(defined(it));
};
/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
var toIObject = __webpack_require__(40)
, getNames = __webpack_require__(11).getNames
, toString = {}.toString;
var windowNames = typeof window == 'object' && Object.getOwnPropertyNames
? Object.getOwnPropertyNames(window) : [];
var getWindowNames = function(it){
try {
return getNames(it);
} catch(e){
return windowNames.slice();
}
};
module.exports.get = function getOwnPropertyNames(it){
if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);
return getNames(toIObject(it));
};
/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {
// all enumerable object keys, includes symbols
var $ = __webpack_require__(11);
module.exports = function(it){
var keys = $.getKeys(it)
, getSymbols = $.getSymbols;
if(getSymbols){
var symbols = getSymbols(it)
, isEnum = $.isEnum
, i = 0
, key;
while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);
}
return keys;
};
/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {
// 7.2.2 IsArray(argument)
var cof = __webpack_require__(15);
module.exports = Array.isArray || function(arg){
return cof(arg) == 'Array';
};
/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(45);
module.exports = function(it){
if(!isObject(it))throw TypeError(it + ' is not an object!');
return it;
};
/***/ },
/* 45 */
/***/ function(module, exports) {
module.exports = function(it){
return typeof it === 'object' ? it !== null : typeof it === 'function';
};
/***/ },
/* 46 */
/***/ function(module, exports) {
module.exports = true;
/***/ },
/* 47 */
/***/ function(module, exports) {
/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _Object$create = __webpack_require__(49)["default"];
var _Object$setPrototypeOf = __webpack_require__(51)["default"];
exports["default"] = function (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;
};
exports.__esModule = true;
/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(50), __esModule: true };
/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {
var $ = __webpack_require__(11);
module.exports = function create(P, D){
return $.create(P, D);
};
/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(52), __esModule: true };
/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(53);
module.exports = __webpack_require__(7).Object.setPrototypeOf;
/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.3.19 Object.setPrototypeOf(O, proto)
var $export = __webpack_require__(5);
$export($export.S, 'Object', {setPrototypeOf: __webpack_require__(54).set});
/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {
// Works with __proto__ only. Old v8 can't work with null proto objects.
/* eslint-disable no-proto */
var getDesc = __webpack_require__(11).getDesc
, isObject = __webpack_require__(45)
, anObject = __webpack_require__(44);
var check = function(O, proto){
anObject(O);
if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
};
module.exports = {
set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
function(test, buggy, set){
try {
set = __webpack_require__(8)(Function.call, getDesc(Object.prototype, '__proto__').set, 2);
set(test, []);
buggy = !(test instanceof Array);
} catch(e){ buggy = true; }
return function setPrototypeOf(O, proto){
check(O, proto);
if(buggy)O.__proto__ = proto;
else set(O, proto);
return O;
};
}({}, false) : undefined),
check: check
};
/***/ },
/* 55 */
/***/ function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_55__;
/***/ },
/* 56 */
/***/ function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_56__;
/***/ },
/* 57 */
/***/ function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_57__;
/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _getPrototypeOf = __webpack_require__(17);
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _typeof2 = __webpack_require__(26);
var _typeof3 = _interopRequireDefault(_typeof2);
var _keys = __webpack_require__(59);
var _keys2 = _interopRequireDefault(_keys);
exports.includes = includes;
exports.negate = negate;
exports.filterObject = filterObject;
exports.pick = pick;
exports.without = without;
exports.isPlainObject = isPlainObject;
exports.bindFunctions = bindFunctions;
exports.getValueFunction = getValueFunction;
exports.propsByPrefix = propsByPrefix;
exports.isCallable = isCallable;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* Checks if an item is present in the given array
* @param {Array} array
* @param {Object} item
* @return {Boolean}
*/
function includes(array, item) {
return array.indexOf(item) >= 0;
}
/**
* Returns a negated version of a function
* @param {Function} f Function to be negated
* @return {Function} Negated function
*/
function negate(f) {
return function () {
return !f.apply(this, arguments);
};
}
/**
* Filter an object entries using the predicate
* {predicate} and the keys {keys} as arguments
* @param {Object} obj
* @param {Array} keys
* @param {Function} predicate
* @return {Object}
*/
function filterObject(obj, keys, predicate) {
var result = {};
var ks = (0, _keys2.default)(obj);
for (var i = 0, l = ks.length; i < l; i++) {
var key = ks[i];
var value = obj[key];
if (predicate(keys, key)) result[key] = value;
};
return result;
}
/**
* Returns the object {obj} only with the
* keys {keys}
* @param {Object} obj Original object
* @param {Array} keys An array of keys to be picked
* @return {Object} Result object
*/
function pick(obj, keys) {
return filterObject(obj, keys, includes);
}
/**
* Returns the object {obj} without the
* keys {keys}
* @param {Object} obj Original object
* @param {Array} keys An array of keys to be removed
* @return {Object} Result object
*/
function without(obj, keys) {
return filterObject(obj, keys, negate(includes));
}
/**
* Check if an object is a plain object. In other words
* if it's an instance of Object.
* @param {Any} obj Any object to be checked
* @return {Boolean}
*/
function isPlainObject(obj) {
if ((typeof obj === 'undefined' ? 'undefined' : (0, _typeof3.default)(obj)) == 'object' && obj !== null) {
if (typeof _getPrototypeOf2.default == 'function') {
var proto = (0, _getPrototypeOf2.default)(obj);
return proto === Object.prototype || proto === null;
}
return Object.prototype.toString.call(obj) == '[object Object]';
}
return false;
}
/**
* It replace all the {type:'function', name: 'nameOffunction'}
* ocurrences in a give object by the functions stored
* in the {context} with the name {name}
* @param {Object} o The original object to be patched
* @param {Object} context A dictionary with name:function
* @return {Object} A patched version of the object
*/
function bindFunctions(o, context) {
var out, v, key;
out = Array.isArray(o) ? [] : {};
for (key in o) {
v = o[key];
if (v == null) {
continue;
} else if ((typeof v === 'undefined' ? 'undefined' : (0, _typeof3.default)(v)) === 'object' && v !== null && v.type !== 'function') {
out[key] = bindFunctions(v, context);
} else if (v.type === 'function') {
out[key] = context[v.name];
} else {
out[key] = v;
}
}
return out;
}
/**
* Allow to use either a value or a function to
* @param {[type]} v Either a getter or a function name
* @param {String} _default A default string used as getter
* @return {Function} Returns a function to use as getter
*/
function getValueFunction(v, _default) {
if (typeof v === 'function') return v;
return function (d) {
return typeof d[v] !== 'undefined' ? d[v] : d[_default];
};
}
/**
* Get properties using a prefix
* @param {String} prefix
* @return {[type]} Return an object with wanted keys
* DEPRECATED: This was created only for margins and
* since we changed the api we don't need this anymore.
*/
function propsByPrefix(prefix, props) {
console.warn('Set margin with prefixes is deprecated use an object instead');
prefix = prefix + '-';
return (0, _keys2.default)(props).reduce(function (memo, prop) {
if (prop.substr(0, prefix.length) === prefix) memo[prop.replace(prefix, '')] = props[prop];
return memo;
}, {});
}
function isCallable(value) {
return value && typeof value === 'function';
}
/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(60), __esModule: true };
/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(61);
module.exports = __webpack_require__(7).Object.keys;
/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.14 Object.keys(O)
var toObject = __webpack_require__(12);
__webpack_require__(20)('keys', function($keys){
return function keys(it){
return $keys(toObject(it));
};
});
/***/ }
/******/ ])
});
;