Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@devexpress/dx-react-chart-bootstrap4

Package Overview
Dependencies
Maintainers
13
Versions
74
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@devexpress/dx-react-chart-bootstrap4 - npm Package Compare versions

Comparing version 1.8.0-beta.1 to 1.8.0

97

dist/dx-react-chart-bootstrap4.d.ts
import * as React from 'react';
import {
ScaleObject
} from '@devexpress/dx-react-chart';

@@ -31,2 +31,4 @@

stack?: string;
/** A series color. */
color?: string;
/** A component that renders the series. */

@@ -83,3 +85,3 @@ seriesComponent?: React.ComponentType<AreaSeriesBase.SeriesProps>;

/** A function that returns a tick formatter function. */
tickForamt?: (scale: object) => (tick: string) => string;
tickFormat?: (scale: ScaleObject) => (tick: string) => string;
/** A component that renders the axis's root layout. */

@@ -108,2 +110,29 @@ rootComponent?: React.ComponentType<ArgumentAxisBase.RootProps>;

// -------------------------------------------------------------------------------------------------
// ArgumentGrid
// -------------------------------------------------------------------------------------------------
import {
ArgumentGrid as ArgumentGridBase,
} from '@devexpress/dx-react-chart';
export namespace ArgumentGrid {
/** Describes properties passed to a component that renders a grid line. */
export type LineProps = ArgumentGridBase.LineProps;
}
export interface ArgumentGridProps {
/** An axis name. */
name?: string;
/** A component that renders a grid line. */
lineComponent?: React.ComponentType<ArgumentGridBase.LineProps>;
}
/** The ArgumentGrid plugin visualizes a grid for the argument axis. */
export declare const ArgumentGrid: React.ComponentType<ArgumentGridProps> & {
/** A component that renders a grid line. */
Line: React.ComponentType<ArgumentGridBase.LineProps & { className?: string; style?: React.CSSProperties; [x: string]: any }>;
};
// -------------------------------------------------------------------------------------------------
// BarSeries

@@ -137,2 +166,4 @@ // -------------------------------------------------------------------------------------------------

groupWidth?: number;
/** A series color. */
color?: string;
/** A component that renders a bar. */

@@ -177,29 +208,2 @@ pointComponent?: React.ComponentType<BarSeriesBase.PointProps>;

// -------------------------------------------------------------------------------------------------
// Grid
// -------------------------------------------------------------------------------------------------
import {
Grid as GridBase,
} from '@devexpress/dx-react-chart';
export namespace Grid {
/** Describes properties passed to a component that renders a grid line. */
export type LineProps = GridBase.LineProps;
}
export interface GridProps {
/** An axis name. */
name?: string;
/** A component that renders a grid line. */
lineComponent?: React.ComponentType<GridBase.LineProps>;
}
/** The Grid plugin visualizes a grid for the specified axis. */
export declare const Grid: React.ComponentType<GridProps> & {
/** A component that renders a grid line. */
Line: React.ComponentType<GridBase.LineProps & { className?: string; style?: React.CSSProperties; [x: string]: any }>;
};
// -------------------------------------------------------------------------------------------------
// Legend

@@ -278,2 +282,4 @@ // -------------------------------------------------------------------------------------------------

stack?: string;
/** A series color. */
color?: string;
/** A component that renders the series. */

@@ -354,2 +360,4 @@ seriesComponent?: React.ComponentType<LineSeriesBase.SeriesProps>;

point?: { size : number };
/** A series color. */
color?: string;
/** A component that renders a series point. */

@@ -392,2 +400,4 @@ pointComponent?: React.ComponentType<ScatterSeriesBase.PointProps>;

stack?: string;
/** A series color. */
color?: string;
/** A component that renders the series. */

@@ -473,3 +483,3 @@ seriesComponent?: React.ComponentType<SplineSeriesBase.SeriesProps>;

/** A function that returns a tick formatter function. */
tickForamt?: (scale: object) => (tick: string) => string;
tickFormat?: (scale: ScaleObject) => (tick: string) => string;
/** A component that renders the axis root layout. */

@@ -496,1 +506,28 @@ rootComponent?: React.ComponentType<ValueAxisBase.RootProps>;

};
// -------------------------------------------------------------------------------------------------
// ValueGrid
// -------------------------------------------------------------------------------------------------
import {
ValueGrid as ValueGridBase,
} from '@devexpress/dx-react-chart';
export namespace ValueGrid {
/** Describes properties passed to a component that renders a grid line. */
export type LineProps = ValueGridBase.LineProps;
}
export interface ValueGridProps {
/** An axis name. */
name?: string;
/** A component that renders a grid line. */
lineComponent?: React.ComponentType<ValueGridBase.LineProps>;
}
/** The ValueGrid plugin visualizes a grid for the value axis. */
export declare const ValueGrid: React.ComponentType<ValueGridProps> & {
/** A component that renders a grid line. */
Line: React.ComponentType<ValueGridBase.LineProps & { className?: string; style?: React.CSSProperties; [x: string]: any }>;
};

1040

dist/dx-react-chart-bootstrap4.es.js
/**
* Bundle of @devexpress/dx-react-chart-bootstrap4
* Generated: 2018-09-07
* Version: 1.8.0-beta.1
* Generated: 2018-10-04
* Version: 1.8.0
* License: https://js.devexpress.com/Licensing
*/
import { PureComponent, createElement } from 'react';
import { any, array, func, node, number, object, oneOfType, string } from 'prop-types';
import { AreaSeries, Axis, BarSeries, Chart, Grid, Legend, LineSeries, PieSeries, ScatterSeries, SplineSeries, Title } from '@devexpress/dx-react-chart';
import { withPatchedProps, Chart, withComponents, Palette, Legend, Title, AreaSeries, LineSeries, SplineSeries, Grid, ValueGrid, ArgumentGrid, Axis, ValueAxis, ArgumentAxis } from '@devexpress/dx-react-chart';
export { BarSeries, PieSeries, ScatterSeries } from '@devexpress/dx-react-chart';
import classNames from 'classnames';
import { BOTTOM, LEFT } from '@devexpress/dx-chart-core';
import { createElement, PureComponent } from 'react';
import { node, oneOfType, string, number } from 'prop-types';
var asyncGenerator = function () {
function AwaitValue(value) {
this.value = value;
}
function AsyncGenerator(gen) {
var front, back;
function send(key, arg) {
return new Promise(function (resolve, reject) {
var request = {
key: key,
arg: arg,
resolve: resolve,
reject: reject,
next: null
};
if (back) {
back = back.next = request;
} else {
front = back = request;
resume(key, arg);
}
});
}
function resume(key, arg) {
try {
var result = gen[key](arg);
var value = result.value;
if (value instanceof AwaitValue) {
Promise.resolve(value.value).then(function (arg) {
resume("next", arg);
}, function (arg) {
resume("throw", arg);
});
} else {
settle(result.done ? "return" : "normal", result.value);
}
} catch (err) {
settle("throw", err);
}
}
function settle(type, value) {
switch (type) {
case "return":
front.resolve({
value: value,
done: true
});
break;
case "throw":
front.reject(value);
break;
default:
front.resolve({
value: value,
done: false
});
break;
}
front = front.next;
if (front) {
resume(front.key, front.arg);
} else {
back = null;
}
}
this._invoke = send;
if (typeof gen.return !== "function") {
this.return = undefined;
}
}
if (typeof Symbol === "function" && Symbol.asyncIterator) {
AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
return this;
};
}
AsyncGenerator.prototype.next = function (arg) {
return this._invoke("next", arg);
};
AsyncGenerator.prototype.throw = function (arg) {
return this._invoke("throw", arg);
};
AsyncGenerator.prototype.return = function (arg) {
return this._invoke("return", arg);
};
return {
wrap: function (fn) {
return function () {
return new AsyncGenerator(fn.apply(this, arguments));
};
},
await: function (value) {
return new AwaitValue(value);
}
};
}();
var classCallCheck = function (instance, Constructor) {

@@ -155,8 +38,2 @@ if (!(instance instanceof Constructor)) {

var _extends = Object.assign || function (target) {

@@ -176,4 +53,2 @@ for (var i = 1; i < arguments.length; i++) {

var inherits = function (subClass, superClass) {

@@ -195,10 +70,2 @@ if (typeof superClass !== "function" && superClass !== null) {

var objectWithoutProperties = function (obj, keys) {

@@ -224,59 +91,28 @@ var target = {};

var Root = function (_React$PureComponent) {
inherits(Root, _React$PureComponent);
function Root() {
classCallCheck(this, Root);
return possibleConstructorReturn(this, (Root.__proto__ || Object.getPrototypeOf(Root)).apply(this, arguments));
var withClassName = function withClassName() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
createClass(Root, [{
key: 'render',
value: function render() {
var _props = this.props,
children = _props.children,
width = _props.width,
height = _props.height,
style = _props.style,
className = _props.className,
restProps = objectWithoutProperties(_props, ['children', 'width', 'height', 'style', 'className']);
var setClassName = function setClassName(_ref) {
var className = _ref.className,
restProps = objectWithoutProperties(_ref, ['className']);
return _extends({
className: classNames.apply(undefined, args.concat([className]))
}, restProps);
};
return withPatchedProps(setClassName);
};
var Root = withClassName('dx-c-bs4-container')(Chart.Root);
return createElement(
'div',
_extends({
style: _extends({}, style, {
height: height + 'px'
}, width ? { width: width + 'px' } : null),
className: classNames('dx-c-bs4-container', className)
}, restProps),
children
);
}
}]);
return Root;
}(PureComponent);
var palette = ['#0070ff', '#d72e3d', '#249d3d', '#ffb90c', '#1698af', '#616a72'];
process.env.NODE_ENV !== "production" ? Root.propTypes = {
children: node,
width: number.isRequired,
height: number.isRequired,
style: object,
className: string
} : void 0;
Root.defaultProps = {
children: undefined,
style: undefined,
className: undefined
};
var Chart$1 = function Chart$$1(_ref) {
var ChartWithPalette = function ChartWithPalette(_ref) {
var children = _ref.children,
restProps = objectWithoutProperties(_ref, ['children']);
props = objectWithoutProperties(_ref, ['children']);
return createElement(
Chart,
_extends({
rootComponent: Root
}, restProps),
props,
createElement(Palette, { scheme: palette }),
children

@@ -286,174 +122,32 @@ );

process.env.NODE_ENV !== "production" ? Chart$1.propTypes = {
ChartWithPalette.components = Chart.components;
process.env.NODE_ENV !== "production" ? ChartWithPalette.propTypes = {
children: node.isRequired
} : void 0;
var Root$1 = function (_React$PureComponent) {
inherits(Root, _React$PureComponent);
var Chart$1 = withComponents({ Root: Root })(ChartWithPalette);
function Root() {
classCallCheck(this, Root);
return possibleConstructorReturn(this, (Root.__proto__ || Object.getPrototypeOf(Root)).apply(this, arguments));
}
var Root$1 = withClassName('list-group', 'py-3')(function (props) {
return createElement('ul', props);
});
createClass(Root, [{
key: 'render',
value: function render() {
var _props = this.props,
children = _props.children,
className = _props.className,
restProps = objectWithoutProperties(_props, ['children', 'className']);
var Label = withClassName('text-body', 'pl-2', 'pr-2')(function (_ref) {
var text = _ref.text,
restProps = objectWithoutProperties(_ref, ['text']);
return createElement(
'span',
restProps,
text
);
});
return createElement(
'ul',
_extends({ className: classNames('list-group py-3', className) }, restProps),
children
);
}
}]);
return Root;
}(PureComponent);
var Item = withClassName('d-flex', 'list-group-item', 'border-0', 'py-1', 'px-4', 'align-items-center')(function (props) {
return createElement('li', props);
});
process.env.NODE_ENV !== "production" ? Root$1.propTypes = {
children: node.isRequired,
className: string
} : void 0;
var Legend$1 = withComponents({
Root: Root$1, Item: Item, Label: Label
})(Legend);
Root$1.defaultProps = {
className: undefined
};
var Label = function (_React$PureComponent) {
inherits(Label, _React$PureComponent);
function Label() {
classCallCheck(this, Label);
return possibleConstructorReturn(this, (Label.__proto__ || Object.getPrototypeOf(Label)).apply(this, arguments));
}
createClass(Label, [{
key: 'render',
value: function render() {
var _props = this.props,
text = _props.text,
className = _props.className,
restProps = objectWithoutProperties(_props, ['text', 'className']);
return createElement(
'span',
_extends({ className: classNames('text-body pl-2 pr-2', className) }, restProps),
text
);
}
}]);
return Label;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Label.propTypes = {
text: oneOfType([string, number]).isRequired,
className: string
} : void 0;
Label.defaultProps = {
className: undefined
};
var Marker = function (_React$PureComponent) {
inherits(Marker, _React$PureComponent);
function Marker() {
classCallCheck(this, Marker);
return possibleConstructorReturn(this, (Marker.__proto__ || Object.getPrototypeOf(Marker)).apply(this, arguments));
}
createClass(Marker, [{
key: 'render',
value: function render() {
var _props = this.props,
className = _props.className,
color = _props.color,
restProps = objectWithoutProperties(_props, ['className', 'color']);
return createElement(
'svg',
_extends({ className: className, fill: color, width: '10', height: '10' }, restProps),
createElement('circle', _extends({ r: 5, cx: 5, cy: 5 }, restProps))
);
}
}]);
return Marker;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Marker.propTypes = {
className: string,
color: string
} : void 0;
Marker.defaultProps = {
className: undefined,
color: undefined
};
var Item = function (_React$PureComponent) {
inherits(Item, _React$PureComponent);
function Item() {
classCallCheck(this, Item);
return possibleConstructorReturn(this, (Item.__proto__ || Object.getPrototypeOf(Item)).apply(this, arguments));
}
createClass(Item, [{
key: 'render',
value: function render() {
var _props = this.props,
children = _props.children,
className = _props.className,
restProps = objectWithoutProperties(_props, ['children', 'className']);
return createElement(
'li',
_extends({ className: classNames('d-flex list-group-item border-0 py-1 px-4 align-items-center', className) }, restProps),
children
);
}
}]);
return Item;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Item.propTypes = {
children: node.isRequired,
className: string
} : void 0;
Item.defaultProps = {
className: undefined
};
var Legend$1 = function (_React$PureComponent) {
inherits(Legend$$1, _React$PureComponent);
function Legend$$1() {
classCallCheck(this, Legend$$1);
return possibleConstructorReturn(this, (Legend$$1.__proto__ || Object.getPrototypeOf(Legend$$1)).apply(this, arguments));
}
createClass(Legend$$1, [{
key: 'render',
value: function render() {
return createElement(Legend, _extends({
rootComponent: Root$1,
labelComponent: Label,
markerComponent: Marker,
itemComponent: Item
}, this.props));
}
}]);
return Legend$$1;
}(PureComponent);
Legend$1.Root = Root$1;
Legend$1.Marker = Marker;
Legend$1.Label = Label;
Legend$1.Label = Item;
var Text = function (_React$PureComponent) {

@@ -488,639 +182,37 @@ inherits(Text, _React$PureComponent);

var Title$1 = function (_React$PureComponent) {
inherits(Title$$1, _React$PureComponent);
var Title$1 = withComponents({ Text: Text })(Title);
function Title$$1() {
classCallCheck(this, Title$$1);
return possibleConstructorReturn(this, (Title$$1.__proto__ || Object.getPrototypeOf(Title$$1)).apply(this, arguments));
}
var Area = withClassName('dx-c-bs4-series-opacity')(AreaSeries.Path);
createClass(Title$$1, [{
key: 'render',
value: function render() {
return createElement(Title, _extends({
textComponent: Text
}, this.props));
}
}]);
return Title$$1;
}(PureComponent);
var AreaSeries$1 = withComponents({ Path: Area })(AreaSeries);
Title$1.Text = Text;
var Path = withClassName('dx-c-bs4-fill-none', 'dx-c-bs4-series-path')(LineSeries.Path);
var Bar = function (_React$PureComponent) {
inherits(Bar, _React$PureComponent);
var LineSeries$1 = withComponents({ Path: Path })(LineSeries);
function Bar() {
classCallCheck(this, Bar);
return possibleConstructorReturn(this, (Bar.__proto__ || Object.getPrototypeOf(Bar)).apply(this, arguments));
}
var SplineSeries$1 = withComponents({ Path: Path })(SplineSeries);
createClass(Bar, [{
key: 'render',
value: function render() {
var _props = this.props,
color = _props.color,
value = _props.value,
restProps = objectWithoutProperties(_props, ['color', 'value']);
var Line = withClassName('dx-c-bs4-stroke-current-color', 'dx-c-bs4-crisp-edges', 'dx-c-bs4-axis-opacity')(Grid.Line);
return createElement('rect', _extends({ fill: color }, restProps));
}
}]);
return Bar;
}(PureComponent);
var ValueGrid$1 = withComponents({ Line: Line })(ValueGrid);
process.env.NODE_ENV !== "production" ? Bar.propTypes = {
x: number.isRequired,
y: number.isRequired,
width: number.isRequired,
height: number.isRequired,
color: string,
value: number.isRequired
} : void 0;
var ArgumentGrid$1 = withComponents({ Line: Line })(ArgumentGrid);
Bar.defaultProps = {
color: undefined
};
var Root$2 = withClassName('dx-c-bs4-crisp-edges')(Axis.Root);
var BarSeries$1 = function (_React$PureComponent) {
inherits(BarSeries$$1, _React$PureComponent);
var Tick = withClassName('dx-c-bs4-stroke-current-color', 'dx-c-bs4-crisp-edges', 'dx-c-bs4-axis-opacity')(Axis.Tick);
function BarSeries$$1() {
classCallCheck(this, BarSeries$$1);
return possibleConstructorReturn(this, (BarSeries$$1.__proto__ || Object.getPrototypeOf(BarSeries$$1)).apply(this, arguments));
}
var Label$1 = withClassName('dx-c-bs4-fill-current-color', 'dx-c-bs4-axis-label', 'text-muted')(Axis.Label);
createClass(BarSeries$$1, [{
key: 'render',
value: function render() {
return createElement(BarSeries, _extends({
pointComponent: Bar
}, this.props));
}
}]);
return BarSeries$$1;
}(PureComponent);
var Line$1 = withClassName('dx-c-bs4-stroke-current-color', 'dx-c-bs4-axis-opacity')(Axis.Line);
BarSeries$1.Point = Bar;
var ValueAxis$1 = withComponents({
Root: Root$2, Tick: Tick, Label: Label$1, Line: Line$1
})(ValueAxis);
var Slice = function (_React$PureComponent) {
inherits(Slice, _React$PureComponent);
var ArgumentAxis$1 = withComponents({
Root: Root$2, Tick: Tick, Label: Label$1, Line: Line$1
})(ArgumentAxis);
function Slice() {
classCallCheck(this, Slice);
return possibleConstructorReturn(this, (Slice.__proto__ || Object.getPrototypeOf(Slice)).apply(this, arguments));
}
createClass(Slice, [{
key: 'render',
value: function render() {
var _props = this.props,
x = _props.x,
y = _props.y,
d = _props.d,
value = _props.value,
color = _props.color,
restProps = objectWithoutProperties(_props, ['x', 'y', 'd', 'value', 'color']);
return createElement('path', _extends({
fill: color,
transform: 'translate(' + x + ' ' + y + ')',
d: d
}, restProps));
}
}]);
return Slice;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Slice.propTypes = {
x: number.isRequired,
y: number.isRequired,
d: string.isRequired,
value: number.isRequired,
style: object,
color: string
} : void 0;
Slice.defaultProps = {
style: null,
color: undefined
};
var PieSeries$1 = function (_React$PureComponent) {
inherits(PieSeries$$1, _React$PureComponent);
function PieSeries$$1() {
classCallCheck(this, PieSeries$$1);
return possibleConstructorReturn(this, (PieSeries$$1.__proto__ || Object.getPrototypeOf(PieSeries$$1)).apply(this, arguments));
}
createClass(PieSeries$$1, [{
key: 'render',
value: function render() {
return createElement(PieSeries, _extends({
pointComponent: Slice
}, this.props));
}
}]);
return PieSeries$$1;
}(PureComponent);
PieSeries$1.Point = Slice;
var Path = function (_React$PureComponent) {
inherits(Path, _React$PureComponent);
function Path() {
classCallCheck(this, Path);
return possibleConstructorReturn(this, (Path.__proto__ || Object.getPrototypeOf(Path)).apply(this, arguments));
}
createClass(Path, [{
key: 'render',
value: function render() {
var _props = this.props,
className = _props.className,
coordinates = _props.coordinates,
path = _props.path,
color = _props.color,
restProps = objectWithoutProperties(_props, ['className', 'coordinates', 'path', 'color']);
return createElement('path', _extends({
stroke: color,
className: classNames('dx-c-bs4-fill-none dx-c-bs4-series-path', className),
d: path(coordinates)
}, restProps));
}
}]);
return Path;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Path.propTypes = {
className: string,
coordinates: array.isRequired,
path: func.isRequired,
color: string
} : void 0;
Path.defaultProps = {
className: undefined,
color: undefined
};
var LineSeries$1 = function (_React$PureComponent) {
inherits(LineSeries$$1, _React$PureComponent);
function LineSeries$$1() {
classCallCheck(this, LineSeries$$1);
return possibleConstructorReturn(this, (LineSeries$$1.__proto__ || Object.getPrototypeOf(LineSeries$$1)).apply(this, arguments));
}
createClass(LineSeries$$1, [{
key: 'render',
value: function render() {
return createElement(LineSeries, _extends({
seriesComponent: Path
}, this.props));
}
}]);
return LineSeries$$1;
}(PureComponent);
LineSeries$1.Path = Path;
var Area = function (_React$PureComponent) {
inherits(Area, _React$PureComponent);
function Area() {
classCallCheck(this, Area);
return possibleConstructorReturn(this, (Area.__proto__ || Object.getPrototypeOf(Area)).apply(this, arguments));
}
createClass(Area, [{
key: 'render',
value: function render() {
var _props = this.props,
className = _props.className,
coordinates = _props.coordinates,
path = _props.path,
color = _props.color,
restProps = objectWithoutProperties(_props, ['className', 'coordinates', 'path', 'color']);
return createElement('path', _extends({
fill: color,
className: classNames('dx-c-bs4-series-opacity', className),
d: path(coordinates)
}, restProps));
}
}]);
return Area;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Area.propTypes = {
className: string,
coordinates: array.isRequired,
path: func.isRequired,
color: string
} : void 0;
Area.defaultProps = {
className: undefined,
color: undefined
};
var AreaSeries$1 = function (_React$PureComponent) {
inherits(AreaSeries$$1, _React$PureComponent);
function AreaSeries$$1() {
classCallCheck(this, AreaSeries$$1);
return possibleConstructorReturn(this, (AreaSeries$$1.__proto__ || Object.getPrototypeOf(AreaSeries$$1)).apply(this, arguments));
}
createClass(AreaSeries$$1, [{
key: 'render',
value: function render() {
return createElement(AreaSeries, _extends({
seriesComponent: Area
}, this.props));
}
}]);
return AreaSeries$$1;
}(PureComponent);
AreaSeries$1.Path = Area;
var SplineSeries$1 = function (_React$PureComponent) {
inherits(SplineSeries$$1, _React$PureComponent);
function SplineSeries$$1() {
classCallCheck(this, SplineSeries$$1);
return possibleConstructorReturn(this, (SplineSeries$$1.__proto__ || Object.getPrototypeOf(SplineSeries$$1)).apply(this, arguments));
}
createClass(SplineSeries$$1, [{
key: 'render',
value: function render() {
return createElement(SplineSeries, _extends({
seriesComponent: Path
}, this.props));
}
}]);
return SplineSeries$$1;
}(PureComponent);
SplineSeries$1.Path = Path;
var Point = function (_React$PureComponent) {
inherits(Point, _React$PureComponent);
function Point() {
classCallCheck(this, Point);
return possibleConstructorReturn(this, (Point.__proto__ || Object.getPrototypeOf(Point)).apply(this, arguments));
}
createClass(Point, [{
key: 'render',
value: function render() {
var _props = this.props,
x = _props.x,
y = _props.y,
seriesComponent = _props.seriesComponent,
value = _props.value,
color = _props.color,
restProps = objectWithoutProperties(_props, ['x', 'y', 'seriesComponent', 'value', 'color']);
return createElement('path', _extends({
fill: color,
transform: 'translate(' + x + ' ' + y + ')'
}, restProps));
}
}]);
return Point;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Point.propTypes = {
x: number.isRequired,
y: number.isRequired,
d: string.isRequired,
seriesComponent: any,
value: number.isRequired,
color: string
} : void 0;
Point.defaultProps = {
seriesComponent: null,
color: undefined
};
var ScatterSeries$1 = function (_React$PureComponent) {
inherits(ScatterSeries$$1, _React$PureComponent);
function ScatterSeries$$1() {
classCallCheck(this, ScatterSeries$$1);
return possibleConstructorReturn(this, (ScatterSeries$$1.__proto__ || Object.getPrototypeOf(ScatterSeries$$1)).apply(this, arguments));
}
createClass(ScatterSeries$$1, [{
key: 'render',
value: function render() {
return createElement(ScatterSeries, _extends({
pointComponent: Point
}, this.props));
}
}]);
return ScatterSeries$$1;
}(PureComponent);
ScatterSeries$1.Point = Point;
ScatterSeries$1.Path = ScatterSeries.Path;
var Line = function (_React$PureComponent) {
inherits(Line, _React$PureComponent);
function Line() {
classCallCheck(this, Line);
return possibleConstructorReturn(this, (Line.__proto__ || Object.getPrototypeOf(Line)).apply(this, arguments));
}
createClass(Line, [{
key: 'render',
value: function render() {
var _props = this.props,
x1 = _props.x1,
x2 = _props.x2,
y1 = _props.y1,
y2 = _props.y2,
className = _props.className,
restProps = objectWithoutProperties(_props, ['x1', 'x2', 'y1', 'y2', 'className']);
return createElement('path', _extends({
d: 'M ' + x1 + ' ' + y1 + ' L ' + x2 + ' ' + y2,
className: classNames('dx-c-bs4-stroke-current-color dx-c-bs4-crisp-edges dx-c-bs4-axis-opacity', className)
}, restProps));
}
}]);
return Line;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Line.propTypes = {
x1: number.isRequired,
x2: number.isRequired,
y1: number.isRequired,
y2: number.isRequired,
className: string
} : void 0;
Line.defaultProps = {
className: undefined
};
var Grid$1 = function (_React$PureComponent) {
inherits(Grid$$1, _React$PureComponent);
function Grid$$1() {
classCallCheck(this, Grid$$1);
return possibleConstructorReturn(this, (Grid$$1.__proto__ || Object.getPrototypeOf(Grid$$1)).apply(this, arguments));
}
createClass(Grid$$1, [{
key: 'render',
value: function render() {
return createElement(Grid, _extends({
lineComponent: Line
}, this.props));
}
}]);
return Grid$$1;
}(PureComponent);
Grid$1.Line = Line;
var Root$2 = function (_React$PureComponent) {
inherits(Root, _React$PureComponent);
function Root() {
classCallCheck(this, Root);
return possibleConstructorReturn(this, (Root.__proto__ || Object.getPrototypeOf(Root)).apply(this, arguments));
}
createClass(Root, [{
key: 'render',
value: function render() {
var _props = this.props,
x = _props.x,
y = _props.y,
refsHandler = _props.refsHandler,
children = _props.children,
className = _props.className,
restProps = objectWithoutProperties(_props, ['x', 'y', 'refsHandler', 'children', 'className']);
return createElement(
'g',
_extends({
ref: refsHandler,
transform: 'translate(' + x + ' ' + y + ')',
className: classNames('dx-c-bs4-crisp-edges', className)
}, restProps),
children
);
}
}]);
return Root;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Root$2.propTypes = {
x: number.isRequired,
y: number.isRequired,
refsHandler: func.isRequired,
children: node.isRequired,
className: string
} : void 0;
Root$2.defaultProps = {
className: undefined
};
var Tick = function (_React$PureComponent) {
inherits(Tick, _React$PureComponent);
function Tick() {
classCallCheck(this, Tick);
return possibleConstructorReturn(this, (Tick.__proto__ || Object.getPrototypeOf(Tick)).apply(this, arguments));
}
createClass(Tick, [{
key: 'render',
value: function render() {
var _props = this.props,
x1 = _props.x1,
x2 = _props.x2,
y1 = _props.y1,
y2 = _props.y2,
className = _props.className,
restProps = objectWithoutProperties(_props, ['x1', 'x2', 'y1', 'y2', 'className']);
return createElement('path', _extends({
d: 'M ' + x1 + ' ' + y1 + ' L ' + x2 + ' ' + y2,
className: classNames('dx-c-bs4-stroke-current-color dx-c-bs4-crisp-edges dx-c-bs4-axis-opacity', className)
}, restProps));
}
}]);
return Tick;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Tick.propTypes = {
x1: number.isRequired,
x2: number.isRequired,
y1: number.isRequired,
y2: number.isRequired,
className: string
} : void 0;
Tick.defaultProps = {
className: undefined
};
var Label$1 = function (_React$PureComponent) {
inherits(Label, _React$PureComponent);
function Label() {
classCallCheck(this, Label);
return possibleConstructorReturn(this, (Label.__proto__ || Object.getPrototypeOf(Label)).apply(this, arguments));
}
createClass(Label, [{
key: 'render',
value: function render() {
var _props = this.props,
text = _props.text,
x = _props.x,
y = _props.y,
dominantBaseline = _props.dominantBaseline,
textAnchor = _props.textAnchor,
className = _props.className,
restProps = objectWithoutProperties(_props, ['text', 'x', 'y', 'dominantBaseline', 'textAnchor', 'className']);
return createElement(
'text',
_extends({
dominantBaseline: dominantBaseline,
textAnchor: textAnchor,
x: x,
y: y,
className: classNames('dx-c-bs4-fill-current-color dx-c-bs4-axis-label text-muted', className)
}, restProps),
text
);
}
}]);
return Label;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Label$1.propTypes = {
text: oneOfType([string, number]).isRequired,
x: number.isRequired,
y: number.isRequired,
dominantBaseline: string.isRequired,
textAnchor: string.isRequired,
className: string
} : void 0;
Label$1.defaultProps = {
className: undefined
};
var Line$1 = function (_React$PureComponent) {
inherits(Line, _React$PureComponent);
function Line() {
classCallCheck(this, Line);
return possibleConstructorReturn(this, (Line.__proto__ || Object.getPrototypeOf(Line)).apply(this, arguments));
}
createClass(Line, [{
key: 'render',
value: function render() {
var _props = this.props,
width = _props.width,
height = _props.height,
orientation = _props.orientation,
className = _props.className,
restProps = objectWithoutProperties(_props, ['width', 'height', 'orientation', 'className']);
return createElement('path', _extends({
d: 'M 0 0 L ' + (orientation === 'horizontal' ? width : 0) + ' ' + (orientation === 'horizontal' ? 0 : height),
className: classNames('dx-c-bs4-stroke-current-color dx-c-bs4-axis-opacity', className)
}, restProps));
}
}]);
return Line;
}(PureComponent);
process.env.NODE_ENV !== "production" ? Line$1.propTypes = {
width: number.isRequired,
height: number.isRequired,
orientation: string.isRequired,
className: string
} : void 0;
Line$1.defaultProps = {
className: undefined
};
var ValueAxis = function (_React$PureComponent) {
inherits(ValueAxis, _React$PureComponent);
function ValueAxis() {
classCallCheck(this, ValueAxis);
return possibleConstructorReturn(this, (ValueAxis.__proto__ || Object.getPrototypeOf(ValueAxis)).apply(this, arguments));
}
createClass(ValueAxis, [{
key: 'render',
value: function render() {
return createElement(Axis, _extends({
rootComponent: Root$2,
tickComponent: Tick,
labelComponent: Label$1,
lineComponent: Line$1
}, _extends({ position: LEFT }, this.props)));
}
}]);
return ValueAxis;
}(PureComponent);
ValueAxis.Root = Root$2;
ValueAxis.Tick = Tick;
ValueAxis.Label = Label$1;
ValueAxis.Line = Line$1;
var ArgumentAxis = function (_React$PureComponent) {
inherits(ArgumentAxis, _React$PureComponent);
function ArgumentAxis() {
classCallCheck(this, ArgumentAxis);
return possibleConstructorReturn(this, (ArgumentAxis.__proto__ || Object.getPrototypeOf(ArgumentAxis)).apply(this, arguments));
}
createClass(ArgumentAxis, [{
key: 'render',
value: function render() {
return createElement(Axis, _extends({
rootComponent: Root$2,
tickComponent: Tick,
labelComponent: Label$1,
lineComponent: Line$1
}, _extends({ position: BOTTOM }, this.props, { isArgumentAxis: true })));
}
}]);
return ArgumentAxis;
}(PureComponent);
ArgumentAxis.Root = Root$2;
ArgumentAxis.Tick = Tick;
ArgumentAxis.Label = Label$1;
ArgumentAxis.Line = Line$1;
export { Chart$1 as Chart, Legend$1 as Legend, Title$1 as Title, BarSeries$1 as BarSeries, PieSeries$1 as PieSeries, LineSeries$1 as LineSeries, AreaSeries$1 as AreaSeries, SplineSeries$1 as SplineSeries, ScatterSeries$1 as ScatterSeries, Grid$1 as Grid, ValueAxis, ArgumentAxis };
export { Chart$1 as Chart, Legend$1 as Legend, Title$1 as Title, AreaSeries$1 as AreaSeries, LineSeries$1 as LineSeries, SplineSeries$1 as SplineSeries, ValueGrid$1 as ValueGrid, ArgumentGrid$1 as ArgumentGrid, ValueAxis$1 as ValueAxis, ArgumentAxis$1 as ArgumentAxis };
//# sourceMappingURL=dx-react-chart-bootstrap4.es.js.map

1231

dist/dx-react-chart-bootstrap4.umd.js
/**
* Bundle of @devexpress/dx-react-chart-bootstrap4
* Generated: 2018-09-07
* Version: 1.8.0-beta.1
* Generated: 2018-10-04
* Version: 1.8.0
* License: https://js.devexpress.com/Licensing

@@ -9,1132 +9,225 @@ */

(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('prop-types'), require('@devexpress/dx-react-chart'), require('classnames'), require('@devexpress/dx-chart-core')) :
typeof define === 'function' && define.amd ? define(['exports', 'react', 'prop-types', '@devexpress/dx-react-chart', 'classnames', '@devexpress/dx-chart-core'], factory) :
(factory((global.DevExpress = global.DevExpress || {}, global.DevExpress.DXReactChartBootstrap4 = {}),global.React,global.PropTypes,global.DevExpress.DXReactChart,global.classNames,global.DevExpress.DXChartCore));
}(this, (function (exports,React,PropTypes,dxReactChart,classNames,dxChartCore) { 'use strict';
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@devexpress/dx-react-chart'), require('classnames'), require('react'), require('prop-types')) :
typeof define === 'function' && define.amd ? define(['exports', '@devexpress/dx-react-chart', 'classnames', 'react', 'prop-types'], factory) :
(factory((global.DevExpress = global.DevExpress || {}, global.DevExpress.DXReactChartBootstrap4 = {}),global.DevExpress.DXReactChart,global.classNames,global.React,global.PropTypes));
}(this, (function (exports,dxReactChart,classNames,React,PropTypes) { 'use strict';
if (typeof process === "undefined") { var process = { env: {} }; }
if (typeof process === "undefined") { var process = { env: {} }; }
classNames = classNames && classNames.hasOwnProperty('default') ? classNames['default'] : classNames;
classNames = classNames && classNames.hasOwnProperty('default') ? classNames['default'] : classNames;
var asyncGenerator = function () {
function AwaitValue(value) {
this.value = value;
}
function AsyncGenerator(gen) {
var front, back;
function send(key, arg) {
return new Promise(function (resolve, reject) {
var request = {
key: key,
arg: arg,
resolve: resolve,
reject: reject,
next: null
};
if (back) {
back = back.next = request;
} else {
front = back = request;
resume(key, arg);
}
});
var classCallCheck = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
function resume(key, arg) {
try {
var result = gen[key](arg);
var value = result.value;
if (value instanceof AwaitValue) {
Promise.resolve(value.value).then(function (arg) {
resume("next", arg);
}, function (arg) {
resume("throw", arg);
});
} else {
settle(result.done ? "return" : "normal", result.value);
}
} catch (err) {
settle("throw", err);
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);
}
}
function settle(type, value) {
switch (type) {
case "return":
front.resolve({
value: value,
done: true
});
break;
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
};
}();
case "throw":
front.reject(value);
break;
var _extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
default:
front.resolve({
value: value,
done: false
});
break;
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
front = front.next;
if (front) {
resume(front.key, front.arg);
} else {
back = null;
}
}
this._invoke = send;
return target;
};
if (typeof gen.return !== "function") {
this.return = undefined;
var inherits = function (subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
}
}
if (typeof Symbol === "function" && Symbol.asyncIterator) {
AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
return this;
};
}
AsyncGenerator.prototype.next = function (arg) {
return this._invoke("next", arg);
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;
};
AsyncGenerator.prototype.throw = function (arg) {
return this._invoke("throw", arg);
};
var objectWithoutProperties = function (obj, keys) {
var target = {};
AsyncGenerator.prototype.return = function (arg) {
return this._invoke("return", arg);
for (var i in obj) {
if (keys.indexOf(i) >= 0) continue;
if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
target[i] = obj[i];
}
return target;
};
return {
wrap: function (fn) {
return function () {
return new AsyncGenerator(fn.apply(this, arguments));
};
},
await: function (value) {
return new AwaitValue(value);
var possibleConstructorReturn = function (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;
};
}();
var classCallCheck = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
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);
var withClassName = function withClassName() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
var setClassName = function setClassName(_ref) {
var className = _ref.className,
restProps = objectWithoutProperties(_ref, ['className']);
return _extends({
className: classNames.apply(undefined, args.concat([className]))
}, restProps);
};
return dxReactChart.withPatchedProps(setClassName);
};
}();
var Root = withClassName('dx-c-bs4-container')(dxReactChart.Chart.Root);
var palette = ['#0070ff', '#d72e3d', '#249d3d', '#ffb90c', '#1698af', '#616a72'];
var ChartWithPalette = function ChartWithPalette(_ref) {
var children = _ref.children,
props = objectWithoutProperties(_ref, ['children']);
return React.createElement(
dxReactChart.Chart,
props,
React.createElement(dxReactChart.Palette, { scheme: palette }),
children
);
};
ChartWithPalette.components = dxReactChart.Chart.components;
process.env.NODE_ENV !== "production" ? ChartWithPalette.propTypes = {
children: PropTypes.node.isRequired
} : void 0;
var Chart = dxReactChart.withComponents({ Root: Root })(ChartWithPalette);
var _extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
var Root$1 = withClassName('list-group', 'py-3')(function (props) {
return React.createElement('ul', props);
});
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
var Label = withClassName('text-body', 'pl-2', 'pr-2')(function (_ref) {
var text = _ref.text,
restProps = objectWithoutProperties(_ref, ['text']);
return React.createElement(
'span',
restProps,
text
);
});
return target;
};
var inherits = 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
}
var Item = withClassName('d-flex', 'list-group-item', 'border-0', 'py-1', 'px-4', 'align-items-center')(function (props) {
return React.createElement('li', props);
});
if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};
var Legend = dxReactChart.withComponents({
Root: Root$1, Item: Item, Label: Label
})(dxReactChart.Legend);
var Text = function (_React$PureComponent) {
inherits(Text, _React$PureComponent);
var objectWithoutProperties = function (obj, keys) {
var target = {};
for (var i in obj) {
if (keys.indexOf(i) >= 0) continue;
if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
target[i] = obj[i];
}
return target;
};
var possibleConstructorReturn = function (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;
};
var Root = function (_React$PureComponent) {
inherits(Root, _React$PureComponent);
function Root() {
classCallCheck(this, Root);
return possibleConstructorReturn(this, (Root.__proto__ || Object.getPrototypeOf(Root)).apply(this, arguments));
}
createClass(Root, [{
key: 'render',
value: function render() {
var _props = this.props,
children = _props.children,
width = _props.width,
height = _props.height,
style = _props.style,
className = _props.className,
restProps = objectWithoutProperties(_props, ['children', 'width', 'height', 'style', 'className']);
return React.createElement(
'div',
_extends({
style: _extends({}, style, {
height: height + 'px'
}, width ? { width: width + 'px' } : null),
className: classNames('dx-c-bs4-container', className)
}, restProps),
children
);
function Text() {
classCallCheck(this, Text);
return possibleConstructorReturn(this, (Text.__proto__ || Object.getPrototypeOf(Text)).apply(this, arguments));
}
}]);
return Root;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Root.propTypes = {
children: PropTypes.node,
width: PropTypes.number.isRequired,
height: PropTypes.number.isRequired,
style: PropTypes.object,
className: PropTypes.string
} : void 0;
createClass(Text, [{
key: 'render',
value: function render() {
var _props = this.props,
text = _props.text,
restProps = objectWithoutProperties(_props, ['text']);
Root.defaultProps = {
children: undefined,
style: undefined,
className: undefined
};
return React.createElement(
'h3',
restProps,
text
);
}
}]);
return Text;
}(React.PureComponent);
var Chart$1 = function Chart$$1(_ref) {
var children = _ref.children,
restProps = objectWithoutProperties(_ref, ['children']);
return React.createElement(
dxReactChart.Chart,
_extends({
rootComponent: Root
}, restProps),
children
);
};
process.env.NODE_ENV !== "production" ? Text.propTypes = {
text: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired
} : void 0;
process.env.NODE_ENV !== "production" ? Chart$1.propTypes = {
children: PropTypes.node.isRequired
} : void 0;
var Title = dxReactChart.withComponents({ Text: Text })(dxReactChart.Title);
var Root$1 = function (_React$PureComponent) {
inherits(Root, _React$PureComponent);
var Area = withClassName('dx-c-bs4-series-opacity')(dxReactChart.AreaSeries.Path);
function Root() {
classCallCheck(this, Root);
return possibleConstructorReturn(this, (Root.__proto__ || Object.getPrototypeOf(Root)).apply(this, arguments));
}
var AreaSeries = dxReactChart.withComponents({ Path: Area })(dxReactChart.AreaSeries);
createClass(Root, [{
key: 'render',
value: function render() {
var _props = this.props,
children = _props.children,
className = _props.className,
restProps = objectWithoutProperties(_props, ['children', 'className']);
var Path = withClassName('dx-c-bs4-fill-none', 'dx-c-bs4-series-path')(dxReactChart.LineSeries.Path);
return React.createElement(
'ul',
_extends({ className: classNames('list-group py-3', className) }, restProps),
children
);
}
}]);
return Root;
}(React.PureComponent);
var LineSeries = dxReactChart.withComponents({ Path: Path })(dxReactChart.LineSeries);
process.env.NODE_ENV !== "production" ? Root$1.propTypes = {
children: PropTypes.node.isRequired,
className: PropTypes.string
} : void 0;
var SplineSeries = dxReactChart.withComponents({ Path: Path })(dxReactChart.SplineSeries);
Root$1.defaultProps = {
className: undefined
};
var Line = withClassName('dx-c-bs4-stroke-current-color', 'dx-c-bs4-crisp-edges', 'dx-c-bs4-axis-opacity')(dxReactChart.Grid.Line);
var Label = function (_React$PureComponent) {
inherits(Label, _React$PureComponent);
var ValueGrid = dxReactChart.withComponents({ Line: Line })(dxReactChart.ValueGrid);
function Label() {
classCallCheck(this, Label);
return possibleConstructorReturn(this, (Label.__proto__ || Object.getPrototypeOf(Label)).apply(this, arguments));
}
var ArgumentGrid = dxReactChart.withComponents({ Line: Line })(dxReactChart.ArgumentGrid);
createClass(Label, [{
key: 'render',
value: function render() {
var _props = this.props,
text = _props.text,
className = _props.className,
restProps = objectWithoutProperties(_props, ['text', 'className']);
var Root$2 = withClassName('dx-c-bs4-crisp-edges')(dxReactChart.Axis.Root);
return React.createElement(
'span',
_extends({ className: classNames('text-body pl-2 pr-2', className) }, restProps),
text
);
}
}]);
return Label;
}(React.PureComponent);
var Tick = withClassName('dx-c-bs4-stroke-current-color', 'dx-c-bs4-crisp-edges', 'dx-c-bs4-axis-opacity')(dxReactChart.Axis.Tick);
process.env.NODE_ENV !== "production" ? Label.propTypes = {
text: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
className: PropTypes.string
} : void 0;
var Label$1 = withClassName('dx-c-bs4-fill-current-color', 'dx-c-bs4-axis-label', 'text-muted')(dxReactChart.Axis.Label);
Label.defaultProps = {
className: undefined
};
var Line$1 = withClassName('dx-c-bs4-stroke-current-color', 'dx-c-bs4-axis-opacity')(dxReactChart.Axis.Line);
var Marker = function (_React$PureComponent) {
inherits(Marker, _React$PureComponent);
var ValueAxis = dxReactChart.withComponents({
Root: Root$2, Tick: Tick, Label: Label$1, Line: Line$1
})(dxReactChart.ValueAxis);
function Marker() {
classCallCheck(this, Marker);
return possibleConstructorReturn(this, (Marker.__proto__ || Object.getPrototypeOf(Marker)).apply(this, arguments));
}
var ArgumentAxis = dxReactChart.withComponents({
Root: Root$2, Tick: Tick, Label: Label$1, Line: Line$1
})(dxReactChart.ArgumentAxis);
createClass(Marker, [{
key: 'render',
value: function render() {
var _props = this.props,
className = _props.className,
color = _props.color,
restProps = objectWithoutProperties(_props, ['className', 'color']);
exports.BarSeries = dxReactChart.BarSeries;
exports.PieSeries = dxReactChart.PieSeries;
exports.ScatterSeries = dxReactChart.ScatterSeries;
exports.Chart = Chart;
exports.Legend = Legend;
exports.Title = Title;
exports.AreaSeries = AreaSeries;
exports.LineSeries = LineSeries;
exports.SplineSeries = SplineSeries;
exports.ValueGrid = ValueGrid;
exports.ArgumentGrid = ArgumentGrid;
exports.ValueAxis = ValueAxis;
exports.ArgumentAxis = ArgumentAxis;
return React.createElement(
'svg',
_extends({ className: className, fill: color, width: '10', height: '10' }, restProps),
React.createElement('circle', _extends({ r: 5, cx: 5, cy: 5 }, restProps))
);
}
}]);
return Marker;
}(React.PureComponent);
Object.defineProperty(exports, '__esModule', { value: true });
process.env.NODE_ENV !== "production" ? Marker.propTypes = {
className: PropTypes.string,
color: PropTypes.string
} : void 0;
Marker.defaultProps = {
className: undefined,
color: undefined
};
var Item = function (_React$PureComponent) {
inherits(Item, _React$PureComponent);
function Item() {
classCallCheck(this, Item);
return possibleConstructorReturn(this, (Item.__proto__ || Object.getPrototypeOf(Item)).apply(this, arguments));
}
createClass(Item, [{
key: 'render',
value: function render() {
var _props = this.props,
children = _props.children,
className = _props.className,
restProps = objectWithoutProperties(_props, ['children', 'className']);
return React.createElement(
'li',
_extends({ className: classNames('d-flex list-group-item border-0 py-1 px-4 align-items-center', className) }, restProps),
children
);
}
}]);
return Item;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Item.propTypes = {
children: PropTypes.node.isRequired,
className: PropTypes.string
} : void 0;
Item.defaultProps = {
className: undefined
};
var Legend$1 = function (_React$PureComponent) {
inherits(Legend$$1, _React$PureComponent);
function Legend$$1() {
classCallCheck(this, Legend$$1);
return possibleConstructorReturn(this, (Legend$$1.__proto__ || Object.getPrototypeOf(Legend$$1)).apply(this, arguments));
}
createClass(Legend$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.Legend, _extends({
rootComponent: Root$1,
labelComponent: Label,
markerComponent: Marker,
itemComponent: Item
}, this.props));
}
}]);
return Legend$$1;
}(React.PureComponent);
Legend$1.Root = Root$1;
Legend$1.Marker = Marker;
Legend$1.Label = Label;
Legend$1.Label = Item;
var Text = function (_React$PureComponent) {
inherits(Text, _React$PureComponent);
function Text() {
classCallCheck(this, Text);
return possibleConstructorReturn(this, (Text.__proto__ || Object.getPrototypeOf(Text)).apply(this, arguments));
}
createClass(Text, [{
key: 'render',
value: function render() {
var _props = this.props,
text = _props.text,
restProps = objectWithoutProperties(_props, ['text']);
return React.createElement(
'h3',
restProps,
text
);
}
}]);
return Text;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Text.propTypes = {
text: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired
} : void 0;
var Title$1 = function (_React$PureComponent) {
inherits(Title$$1, _React$PureComponent);
function Title$$1() {
classCallCheck(this, Title$$1);
return possibleConstructorReturn(this, (Title$$1.__proto__ || Object.getPrototypeOf(Title$$1)).apply(this, arguments));
}
createClass(Title$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.Title, _extends({
textComponent: Text
}, this.props));
}
}]);
return Title$$1;
}(React.PureComponent);
Title$1.Text = Text;
var Bar = function (_React$PureComponent) {
inherits(Bar, _React$PureComponent);
function Bar() {
classCallCheck(this, Bar);
return possibleConstructorReturn(this, (Bar.__proto__ || Object.getPrototypeOf(Bar)).apply(this, arguments));
}
createClass(Bar, [{
key: 'render',
value: function render() {
var _props = this.props,
color = _props.color,
value = _props.value,
restProps = objectWithoutProperties(_props, ['color', 'value']);
return React.createElement('rect', _extends({ fill: color }, restProps));
}
}]);
return Bar;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Bar.propTypes = {
x: PropTypes.number.isRequired,
y: PropTypes.number.isRequired,
width: PropTypes.number.isRequired,
height: PropTypes.number.isRequired,
color: PropTypes.string,
value: PropTypes.number.isRequired
} : void 0;
Bar.defaultProps = {
color: undefined
};
var BarSeries$1 = function (_React$PureComponent) {
inherits(BarSeries$$1, _React$PureComponent);
function BarSeries$$1() {
classCallCheck(this, BarSeries$$1);
return possibleConstructorReturn(this, (BarSeries$$1.__proto__ || Object.getPrototypeOf(BarSeries$$1)).apply(this, arguments));
}
createClass(BarSeries$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.BarSeries, _extends({
pointComponent: Bar
}, this.props));
}
}]);
return BarSeries$$1;
}(React.PureComponent);
BarSeries$1.Point = Bar;
var Slice = function (_React$PureComponent) {
inherits(Slice, _React$PureComponent);
function Slice() {
classCallCheck(this, Slice);
return possibleConstructorReturn(this, (Slice.__proto__ || Object.getPrototypeOf(Slice)).apply(this, arguments));
}
createClass(Slice, [{
key: 'render',
value: function render() {
var _props = this.props,
x = _props.x,
y = _props.y,
d = _props.d,
value = _props.value,
color = _props.color,
restProps = objectWithoutProperties(_props, ['x', 'y', 'd', 'value', 'color']);
return React.createElement('path', _extends({
fill: color,
transform: 'translate(' + x + ' ' + y + ')',
d: d
}, restProps));
}
}]);
return Slice;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Slice.propTypes = {
x: PropTypes.number.isRequired,
y: PropTypes.number.isRequired,
d: PropTypes.string.isRequired,
value: PropTypes.number.isRequired,
style: PropTypes.object,
color: PropTypes.string
} : void 0;
Slice.defaultProps = {
style: null,
color: undefined
};
var PieSeries$1 = function (_React$PureComponent) {
inherits(PieSeries$$1, _React$PureComponent);
function PieSeries$$1() {
classCallCheck(this, PieSeries$$1);
return possibleConstructorReturn(this, (PieSeries$$1.__proto__ || Object.getPrototypeOf(PieSeries$$1)).apply(this, arguments));
}
createClass(PieSeries$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.PieSeries, _extends({
pointComponent: Slice
}, this.props));
}
}]);
return PieSeries$$1;
}(React.PureComponent);
PieSeries$1.Point = Slice;
var Path = function (_React$PureComponent) {
inherits(Path, _React$PureComponent);
function Path() {
classCallCheck(this, Path);
return possibleConstructorReturn(this, (Path.__proto__ || Object.getPrototypeOf(Path)).apply(this, arguments));
}
createClass(Path, [{
key: 'render',
value: function render() {
var _props = this.props,
className = _props.className,
coordinates = _props.coordinates,
path = _props.path,
color = _props.color,
restProps = objectWithoutProperties(_props, ['className', 'coordinates', 'path', 'color']);
return React.createElement('path', _extends({
stroke: color,
className: classNames('dx-c-bs4-fill-none dx-c-bs4-series-path', className),
d: path(coordinates)
}, restProps));
}
}]);
return Path;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Path.propTypes = {
className: PropTypes.string,
coordinates: PropTypes.array.isRequired,
path: PropTypes.func.isRequired,
color: PropTypes.string
} : void 0;
Path.defaultProps = {
className: undefined,
color: undefined
};
var LineSeries$1 = function (_React$PureComponent) {
inherits(LineSeries$$1, _React$PureComponent);
function LineSeries$$1() {
classCallCheck(this, LineSeries$$1);
return possibleConstructorReturn(this, (LineSeries$$1.__proto__ || Object.getPrototypeOf(LineSeries$$1)).apply(this, arguments));
}
createClass(LineSeries$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.LineSeries, _extends({
seriesComponent: Path
}, this.props));
}
}]);
return LineSeries$$1;
}(React.PureComponent);
LineSeries$1.Path = Path;
var Area = function (_React$PureComponent) {
inherits(Area, _React$PureComponent);
function Area() {
classCallCheck(this, Area);
return possibleConstructorReturn(this, (Area.__proto__ || Object.getPrototypeOf(Area)).apply(this, arguments));
}
createClass(Area, [{
key: 'render',
value: function render() {
var _props = this.props,
className = _props.className,
coordinates = _props.coordinates,
path = _props.path,
color = _props.color,
restProps = objectWithoutProperties(_props, ['className', 'coordinates', 'path', 'color']);
return React.createElement('path', _extends({
fill: color,
className: classNames('dx-c-bs4-series-opacity', className),
d: path(coordinates)
}, restProps));
}
}]);
return Area;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Area.propTypes = {
className: PropTypes.string,
coordinates: PropTypes.array.isRequired,
path: PropTypes.func.isRequired,
color: PropTypes.string
} : void 0;
Area.defaultProps = {
className: undefined,
color: undefined
};
var AreaSeries$1 = function (_React$PureComponent) {
inherits(AreaSeries$$1, _React$PureComponent);
function AreaSeries$$1() {
classCallCheck(this, AreaSeries$$1);
return possibleConstructorReturn(this, (AreaSeries$$1.__proto__ || Object.getPrototypeOf(AreaSeries$$1)).apply(this, arguments));
}
createClass(AreaSeries$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.AreaSeries, _extends({
seriesComponent: Area
}, this.props));
}
}]);
return AreaSeries$$1;
}(React.PureComponent);
AreaSeries$1.Path = Area;
var SplineSeries$1 = function (_React$PureComponent) {
inherits(SplineSeries$$1, _React$PureComponent);
function SplineSeries$$1() {
classCallCheck(this, SplineSeries$$1);
return possibleConstructorReturn(this, (SplineSeries$$1.__proto__ || Object.getPrototypeOf(SplineSeries$$1)).apply(this, arguments));
}
createClass(SplineSeries$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.SplineSeries, _extends({
seriesComponent: Path
}, this.props));
}
}]);
return SplineSeries$$1;
}(React.PureComponent);
SplineSeries$1.Path = Path;
var Point = function (_React$PureComponent) {
inherits(Point, _React$PureComponent);
function Point() {
classCallCheck(this, Point);
return possibleConstructorReturn(this, (Point.__proto__ || Object.getPrototypeOf(Point)).apply(this, arguments));
}
createClass(Point, [{
key: 'render',
value: function render() {
var _props = this.props,
x = _props.x,
y = _props.y,
seriesComponent = _props.seriesComponent,
value = _props.value,
color = _props.color,
restProps = objectWithoutProperties(_props, ['x', 'y', 'seriesComponent', 'value', 'color']);
return React.createElement('path', _extends({
fill: color,
transform: 'translate(' + x + ' ' + y + ')'
}, restProps));
}
}]);
return Point;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Point.propTypes = {
x: PropTypes.number.isRequired,
y: PropTypes.number.isRequired,
d: PropTypes.string.isRequired,
seriesComponent: PropTypes.any,
value: PropTypes.number.isRequired,
color: PropTypes.string
} : void 0;
Point.defaultProps = {
seriesComponent: null,
color: undefined
};
var ScatterSeries$1 = function (_React$PureComponent) {
inherits(ScatterSeries$$1, _React$PureComponent);
function ScatterSeries$$1() {
classCallCheck(this, ScatterSeries$$1);
return possibleConstructorReturn(this, (ScatterSeries$$1.__proto__ || Object.getPrototypeOf(ScatterSeries$$1)).apply(this, arguments));
}
createClass(ScatterSeries$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.ScatterSeries, _extends({
pointComponent: Point
}, this.props));
}
}]);
return ScatterSeries$$1;
}(React.PureComponent);
ScatterSeries$1.Point = Point;
ScatterSeries$1.Path = dxReactChart.ScatterSeries.Path;
var Line = function (_React$PureComponent) {
inherits(Line, _React$PureComponent);
function Line() {
classCallCheck(this, Line);
return possibleConstructorReturn(this, (Line.__proto__ || Object.getPrototypeOf(Line)).apply(this, arguments));
}
createClass(Line, [{
key: 'render',
value: function render() {
var _props = this.props,
x1 = _props.x1,
x2 = _props.x2,
y1 = _props.y1,
y2 = _props.y2,
className = _props.className,
restProps = objectWithoutProperties(_props, ['x1', 'x2', 'y1', 'y2', 'className']);
return React.createElement('path', _extends({
d: 'M ' + x1 + ' ' + y1 + ' L ' + x2 + ' ' + y2,
className: classNames('dx-c-bs4-stroke-current-color dx-c-bs4-crisp-edges dx-c-bs4-axis-opacity', className)
}, restProps));
}
}]);
return Line;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Line.propTypes = {
x1: PropTypes.number.isRequired,
x2: PropTypes.number.isRequired,
y1: PropTypes.number.isRequired,
y2: PropTypes.number.isRequired,
className: PropTypes.string
} : void 0;
Line.defaultProps = {
className: undefined
};
var Grid$1 = function (_React$PureComponent) {
inherits(Grid$$1, _React$PureComponent);
function Grid$$1() {
classCallCheck(this, Grid$$1);
return possibleConstructorReturn(this, (Grid$$1.__proto__ || Object.getPrototypeOf(Grid$$1)).apply(this, arguments));
}
createClass(Grid$$1, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.Grid, _extends({
lineComponent: Line
}, this.props));
}
}]);
return Grid$$1;
}(React.PureComponent);
Grid$1.Line = Line;
var Root$2 = function (_React$PureComponent) {
inherits(Root, _React$PureComponent);
function Root() {
classCallCheck(this, Root);
return possibleConstructorReturn(this, (Root.__proto__ || Object.getPrototypeOf(Root)).apply(this, arguments));
}
createClass(Root, [{
key: 'render',
value: function render() {
var _props = this.props,
x = _props.x,
y = _props.y,
refsHandler = _props.refsHandler,
children = _props.children,
className = _props.className,
restProps = objectWithoutProperties(_props, ['x', 'y', 'refsHandler', 'children', 'className']);
return React.createElement(
'g',
_extends({
ref: refsHandler,
transform: 'translate(' + x + ' ' + y + ')',
className: classNames('dx-c-bs4-crisp-edges', className)
}, restProps),
children
);
}
}]);
return Root;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Root$2.propTypes = {
x: PropTypes.number.isRequired,
y: PropTypes.number.isRequired,
refsHandler: PropTypes.func.isRequired,
children: PropTypes.node.isRequired,
className: PropTypes.string
} : void 0;
Root$2.defaultProps = {
className: undefined
};
var Tick = function (_React$PureComponent) {
inherits(Tick, _React$PureComponent);
function Tick() {
classCallCheck(this, Tick);
return possibleConstructorReturn(this, (Tick.__proto__ || Object.getPrototypeOf(Tick)).apply(this, arguments));
}
createClass(Tick, [{
key: 'render',
value: function render() {
var _props = this.props,
x1 = _props.x1,
x2 = _props.x2,
y1 = _props.y1,
y2 = _props.y2,
className = _props.className,
restProps = objectWithoutProperties(_props, ['x1', 'x2', 'y1', 'y2', 'className']);
return React.createElement('path', _extends({
d: 'M ' + x1 + ' ' + y1 + ' L ' + x2 + ' ' + y2,
className: classNames('dx-c-bs4-stroke-current-color dx-c-bs4-crisp-edges dx-c-bs4-axis-opacity', className)
}, restProps));
}
}]);
return Tick;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Tick.propTypes = {
x1: PropTypes.number.isRequired,
x2: PropTypes.number.isRequired,
y1: PropTypes.number.isRequired,
y2: PropTypes.number.isRequired,
className: PropTypes.string
} : void 0;
Tick.defaultProps = {
className: undefined
};
var Label$1 = function (_React$PureComponent) {
inherits(Label, _React$PureComponent);
function Label() {
classCallCheck(this, Label);
return possibleConstructorReturn(this, (Label.__proto__ || Object.getPrototypeOf(Label)).apply(this, arguments));
}
createClass(Label, [{
key: 'render',
value: function render() {
var _props = this.props,
text = _props.text,
x = _props.x,
y = _props.y,
dominantBaseline = _props.dominantBaseline,
textAnchor = _props.textAnchor,
className = _props.className,
restProps = objectWithoutProperties(_props, ['text', 'x', 'y', 'dominantBaseline', 'textAnchor', 'className']);
return React.createElement(
'text',
_extends({
dominantBaseline: dominantBaseline,
textAnchor: textAnchor,
x: x,
y: y,
className: classNames('dx-c-bs4-fill-current-color dx-c-bs4-axis-label text-muted', className)
}, restProps),
text
);
}
}]);
return Label;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Label$1.propTypes = {
text: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
x: PropTypes.number.isRequired,
y: PropTypes.number.isRequired,
dominantBaseline: PropTypes.string.isRequired,
textAnchor: PropTypes.string.isRequired,
className: PropTypes.string
} : void 0;
Label$1.defaultProps = {
className: undefined
};
var Line$1 = function (_React$PureComponent) {
inherits(Line, _React$PureComponent);
function Line() {
classCallCheck(this, Line);
return possibleConstructorReturn(this, (Line.__proto__ || Object.getPrototypeOf(Line)).apply(this, arguments));
}
createClass(Line, [{
key: 'render',
value: function render() {
var _props = this.props,
width = _props.width,
height = _props.height,
orientation = _props.orientation,
className = _props.className,
restProps = objectWithoutProperties(_props, ['width', 'height', 'orientation', 'className']);
return React.createElement('path', _extends({
d: 'M 0 0 L ' + (orientation === 'horizontal' ? width : 0) + ' ' + (orientation === 'horizontal' ? 0 : height),
className: classNames('dx-c-bs4-stroke-current-color dx-c-bs4-axis-opacity', className)
}, restProps));
}
}]);
return Line;
}(React.PureComponent);
process.env.NODE_ENV !== "production" ? Line$1.propTypes = {
width: PropTypes.number.isRequired,
height: PropTypes.number.isRequired,
orientation: PropTypes.string.isRequired,
className: PropTypes.string
} : void 0;
Line$1.defaultProps = {
className: undefined
};
var ValueAxis = function (_React$PureComponent) {
inherits(ValueAxis, _React$PureComponent);
function ValueAxis() {
classCallCheck(this, ValueAxis);
return possibleConstructorReturn(this, (ValueAxis.__proto__ || Object.getPrototypeOf(ValueAxis)).apply(this, arguments));
}
createClass(ValueAxis, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.Axis, _extends({
rootComponent: Root$2,
tickComponent: Tick,
labelComponent: Label$1,
lineComponent: Line$1
}, _extends({ position: dxChartCore.LEFT }, this.props)));
}
}]);
return ValueAxis;
}(React.PureComponent);
ValueAxis.Root = Root$2;
ValueAxis.Tick = Tick;
ValueAxis.Label = Label$1;
ValueAxis.Line = Line$1;
var ArgumentAxis = function (_React$PureComponent) {
inherits(ArgumentAxis, _React$PureComponent);
function ArgumentAxis() {
classCallCheck(this, ArgumentAxis);
return possibleConstructorReturn(this, (ArgumentAxis.__proto__ || Object.getPrototypeOf(ArgumentAxis)).apply(this, arguments));
}
createClass(ArgumentAxis, [{
key: 'render',
value: function render() {
return React.createElement(dxReactChart.Axis, _extends({
rootComponent: Root$2,
tickComponent: Tick,
labelComponent: Label$1,
lineComponent: Line$1
}, _extends({ position: dxChartCore.BOTTOM }, this.props, { isArgumentAxis: true })));
}
}]);
return ArgumentAxis;
}(React.PureComponent);
ArgumentAxis.Root = Root$2;
ArgumentAxis.Tick = Tick;
ArgumentAxis.Label = Label$1;
ArgumentAxis.Line = Line$1;
exports.Chart = Chart$1;
exports.Legend = Legend$1;
exports.Title = Title$1;
exports.BarSeries = BarSeries$1;
exports.PieSeries = PieSeries$1;
exports.LineSeries = LineSeries$1;
exports.AreaSeries = AreaSeries$1;
exports.SplineSeries = SplineSeries$1;
exports.ScatterSeries = ScatterSeries$1;
exports.Grid = Grid$1;
exports.ValueAxis = ValueAxis;
exports.ArgumentAxis = ArgumentAxis;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=dx-react-chart-bootstrap4.umd.js.map

30

package.json
{
"name": "@devexpress/dx-react-chart-bootstrap4",
"version": "1.8.0-beta.1",
"version": "1.8.0",
"description": "Bootstrap 4 templates for DevExtreme React Chart component",

@@ -48,6 +48,6 @@ "author": {

"devDependencies": {
"@devexpress/dx-chart-core": "^1.8.0-beta.1",
"@devexpress/dx-react-chart": "^1.8.0-beta.1",
"@devexpress/dx-react-core": "^1.8.0-beta.1",
"@devexpress/dx-testing": "^1.8.0-beta.1",
"@devexpress/dx-chart-core": "^1.8.0",
"@devexpress/dx-react-chart": "^1.8.0",
"@devexpress/dx-react-core": "^1.8.0",
"@devexpress/dx-testing": "^1.8.0",
"babel-core": "^6.26.3",

@@ -64,3 +64,3 @@ "babel-jest": "^23.4.2",

"enzyme-adapter-react-16": "^1.2.0",
"eslint": "^5.4.0",
"eslint": "^5.6.1",
"eslint-config-airbnb": "^17.1.0",

@@ -70,15 +70,15 @@ "eslint-config-airbnb-base": "^13.1.0",

"eslint-plugin-import": "^2.14.0",
"eslint-plugin-jest": "^21.22.0",
"eslint-plugin-jest": "^21.24.0",
"eslint-plugin-jsx-a11y": "^6.1.1",
"eslint-plugin-react": "^7.11.1",
"jest": "^23.5.0",
"react": "^16.4.2",
"react-dom": "^16.4.2",
"react-test-renderer": "^16.4.2",
"jest": "^23.6.0",
"react": "^16.5.2",
"react-dom": "^16.5.2",
"react-test-renderer": "^16.5.2",
"reactstrap": "^6.4.0",
"rollup": "0.50.0",
"rollup": "^0.66.2",
"rollup-plugin-babel": "^3.0.4",
"rollup-plugin-css-only": "^0.4.0",
"rollup-plugin-license": "^0.6.0",
"rollup-plugin-node-resolve": "^3.3.0"
"rollup-plugin-license": "^0.7.0",
"rollup-plugin-node-resolve": "^3.4.0"
},

@@ -96,3 +96,3 @@ "dependencies": {

},
"gitHead": "8fb5dc5f32b4a02a8922917f07398b48902ecc5c"
"gitHead": "30dd98f003c170e60ce6eb79d48fe4e3ac99338d"
}
dist/dx-react-chart-bootstrap4.es.js.map

Sorry, the diff of this file is not supported yet

dist/dx-react-chart-bootstrap4.umd.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc