@devexpress/dx-chart-core
Advanced tools
@devexpress/dx-chart-core - npm Package Compare versions
Comparing version 1.8.0-beta.1 to 1.8.0
| /** | ||
| * Bundle of @devexpress/dx-chart-core | ||
| * 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,4 +9,4 @@ */ | ||
| import { extent } from 'd3-array'; | ||
| import { scaleBand, scaleLinear, scaleOrdinal } from 'd3-scale'; | ||
| import { arc, area, curveMonotoneX, line, pie, stack, symbol, symbolCircle } from 'd3-shape'; | ||
| import { scaleLinear, scaleBand, scaleOrdinal } from 'd3-scale'; | ||
| import { symbol, symbolCircle, line, curveMonotoneX, area, arc, pie, stack } from 'd3-shape'; | ||
@@ -23,129 +23,8 @@ var HORIZONTAL = 'horizontal'; | ||
| var LINEAR = 'linear'; | ||
| var BAND = 'band'; | ||
| var asyncGenerator = function () { | ||
| function AwaitValue(value) { | ||
| this.value = value; | ||
| } | ||
| var ARGUMENT_DOMAIN = 'argument-domain'; | ||
| var VALUE_DOMAIN = 'value-domain'; | ||
| 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 defineProperty = function (obj, key, value) { | ||
@@ -180,36 +59,2 @@ if (key in obj) { | ||
| var toConsumableArray = function (arr) { | ||
@@ -229,18 +74,12 @@ if (Array.isArray(arr)) { | ||
| var collectAxesOptions = function collectAxesOptions(axes) { | ||
| return axes.reduce(function (domains, _ref) { | ||
| var name = _ref.name, | ||
| type = _ref.type, | ||
| tickFormat = _ref.tickFormat; | ||
| return _extends({}, domains, defineProperty({}, name, { | ||
| type: type, | ||
| tickFormat: tickFormat | ||
| })); | ||
| }, {}); | ||
| var getValueDomainName = function getValueDomainName(name) { | ||
| return name || VALUE_DOMAIN; | ||
| }; | ||
| var calculateDomainField = function calculateDomainField(getFieldItemFirst, getFieldItemSecond, data) { | ||
| var domain = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : []; | ||
| var type = arguments[4]; | ||
| // TODO: Property name should not contain "axis" part as it actually means domain. | ||
| var getSeriesValueDomainName = function getSeriesValueDomainName(series) { | ||
| return getValueDomainName(series.axisName); | ||
| }; | ||
| var calculateDomainField = function calculateDomainField(getFieldItemFirst, getFieldItemSecond, data, domain, type) { | ||
| var getCategories = function getCategories(prev, cur) { | ||
@@ -263,5 +102,5 @@ var categories = getFieldItemFirst(cur); | ||
| })[field] === 'string') { | ||
| return 'band'; | ||
| return BAND; | ||
| } | ||
| return type || 'linear'; | ||
| return type || LINEAR; | ||
| }; | ||
@@ -273,70 +112,85 @@ | ||
| var calculateDomain = function calculateDomain(series, data, axesOptions, argumentAxisName, startFromZero) { | ||
| return series.reduce(function (domains, _ref2) { | ||
| var _babelHelpers$extends2; | ||
| var calculateDomains = function calculateDomains(domains, seriesList, data) { | ||
| seriesList.forEach(function (seriesItem) { | ||
| var valueDomainName = getSeriesValueDomainName(seriesItem); | ||
| var argumentField = seriesItem.argumentField, | ||
| valueField = seriesItem.valueField, | ||
| name = seriesItem.name; | ||
| var valueField = _ref2.valueField, | ||
| argumentField = _ref2.argumentField, | ||
| axisName = _ref2.axisName, | ||
| name = _ref2.name; | ||
| var argumentDomain = domains[ARGUMENT_DOMAIN]; | ||
| var valueDomain = domains[valueDomainName]; | ||
| var valueType = getCorrectAxisType(domains[axisName] && domains[axisName].type, data, valueField); | ||
| var argumentType = getCorrectAxisType(domains[argumentAxisName] && domains[argumentAxisName].type, data, argumentField); | ||
| return _extends({}, domains, (_babelHelpers$extends2 = {}, defineProperty(_babelHelpers$extends2, axisName, { | ||
| domain: calculateDomainField(function (object) { | ||
| return getFieldStack(1, object[valueField + '-' + name + '-stack']); | ||
| }, startFromZero[axisName] ? function (object) { | ||
| return getFieldStack(0, object[valueField + '-' + name + '-stack']); | ||
| } : undefined, data, domains[axisName] && domains[axisName].domain, valueType), | ||
| orientation: VERTICAL, | ||
| type: valueType, | ||
| tickFormat: domains[axisName] && domains[axisName].tickFormat | ||
| }), defineProperty(_babelHelpers$extends2, argumentAxisName, { | ||
| domain: calculateDomainField(function (object) { | ||
| return object[argumentField]; | ||
| }, null, data, domains[argumentAxisName] && domains[argumentAxisName].domain, argumentType), | ||
| orientation: HORIZONTAL, | ||
| type: argumentType, | ||
| tickFormat: domains[argumentAxisName] && domains[argumentAxisName].tickFormat | ||
| }), _babelHelpers$extends2)); | ||
| }, axesOptions); | ||
| var valueType = getCorrectAxisType(valueDomain.type, data, valueField); | ||
| var argumentType = getCorrectAxisType(argumentDomain.type, data, argumentField); | ||
| valueDomain.domain = calculateDomainField(function (object) { | ||
| return getFieldStack(1, object[valueField + '-' + name + '-stack']); | ||
| }, valueDomain.isStartedFromZero ? function (object) { | ||
| return getFieldStack(0, object[valueField + '-' + name + '-stack']); | ||
| } : undefined, data, valueDomain.domain, valueType); | ||
| valueDomain.type = valueType; | ||
| argumentDomain.domain = calculateDomainField(function (object) { | ||
| return object[argumentField]; | ||
| }, null, data, argumentDomain.domain, argumentType); | ||
| argumentDomain.type = argumentType; | ||
| }); | ||
| }; | ||
| var recalculateDomain = function recalculateDomain(range, currentDomain) { | ||
| return { | ||
| domain: currentDomain.type !== BAND ? range : currentDomain.domain, | ||
| type: currentDomain.type, | ||
| orientation: currentDomain.orientation, | ||
| tickFormat: currentDomain.tickFormat | ||
| }; | ||
| var computeExtension = function computeExtension(extension) { | ||
| var defaultExtension = [{ type: LINEAR, constructor: scaleLinear }, { type: BAND, constructor: scaleBand }]; | ||
| return extension.concat(defaultExtension); | ||
| }; | ||
| var adjustDomains = function adjustDomains(axes, calculatedDomains) { | ||
| return axes.reduce(function (domains, _ref3) { | ||
| var name = _ref3.name, | ||
| min = _ref3.min, | ||
| max = _ref3.max; | ||
| var currentDomain = domains[name]; | ||
| return _extends({}, domains, defineProperty({}, name, recalculateDomain([isDefined(min) ? min : currentDomain.domain[0], isDefined(max) ? max : currentDomain.domain[1]], currentDomain))); | ||
| }, calculatedDomains); | ||
| var collectDomains = function collectDomains(seriesList) { | ||
| var domains = defineProperty({}, ARGUMENT_DOMAIN, { domain: [], orientation: HORIZONTAL }); | ||
| seriesList.forEach(function (seriesItem) { | ||
| var name = getSeriesValueDomainName(seriesItem); | ||
| var domain = domains[name] || { domain: [], orientation: VERTICAL }; | ||
| domains[name] = domain; | ||
| domain.isStartedFromZero = domain.isStartedFromZero || seriesItem.isStartedFromZero; | ||
| }); | ||
| return domains; | ||
| }; | ||
| var computedExtension = function computedExtension(extension) { | ||
| var defaultExtension = [{ type: 'linear', constructor: scaleLinear }, { type: 'band', constructor: scaleBand }]; | ||
| return extension.concat(defaultExtension); | ||
| var takeTypeFromAxesOptions = function takeTypeFromAxesOptions(domains, axes) { | ||
| axes.forEach(function (_ref) { | ||
| var name = _ref.name, | ||
| type = _ref.type; | ||
| var domain = domains[name]; | ||
| if (domain) { | ||
| domain.type = type; | ||
| } | ||
| }); | ||
| }; | ||
| var domains = function domains() { | ||
| var axes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; | ||
| var series = arguments[1]; | ||
| var data = arguments[2]; | ||
| var argumentAxisName = arguments[3]; | ||
| var startFromZero = arguments[4]; | ||
| var takeRestAxesOptions = function takeRestAxesOptions(domains, axes) { | ||
| axes.forEach(function (_ref2) { | ||
| var name = _ref2.name, | ||
| tickFormat = _ref2.tickFormat, | ||
| min = _ref2.min, | ||
| max = _ref2.max; | ||
| var axesOptions = collectAxesOptions(axes); | ||
| var calculatedDomains = calculateDomain(series, data, axesOptions, argumentAxisName, startFromZero); | ||
| return adjustDomains(axes, calculatedDomains); | ||
| var domain = domains[name]; | ||
| if (!domain) { | ||
| return; | ||
| } | ||
| domain.tickFormat = tickFormat; | ||
| if (domain.type !== BAND) { | ||
| domain.domain = [isDefined(min) ? min : domain.domain[0], isDefined(max) ? max : domain.domain[1]]; | ||
| } | ||
| }); | ||
| }; | ||
| var computeDomains = function computeDomains(axes, series, data) { | ||
| var result = collectDomains(series); | ||
| // Axes options are taken in two steps because *type* is required for domains calculation | ||
| // and other options must be applied after domains are calculated. | ||
| takeTypeFromAxesOptions(result, axes); | ||
| calculateDomains(result, series, data); | ||
| takeRestAxesOptions(result, axes); | ||
| return result; | ||
| }; | ||
| var isEqual = function isEqual(_ref, _ref2) { | ||
@@ -444,5 +298,3 @@ var firstWidth = _ref.width, | ||
| var axesData = function axesData() { | ||
| var axes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; | ||
| var axisProps = arguments[1]; | ||
| var axesData = function axesData(axes, axisProps) { | ||
| return [].concat(toConsumableArray(axes), [axisProps]); | ||
@@ -501,3 +353,3 @@ }; | ||
| var radius = Math.min(width, height) / 2; | ||
| var pieData = pie().value(function (d) { | ||
| var pieData = pie().sort(null).value(function (d) { | ||
| return d[valueField]; | ||
@@ -610,4 +462,6 @@ })(data); | ||
| var checkZeroStart = function checkZeroStart(fromZero, axisName, pathType) { | ||
| return _extends({}, fromZero, defineProperty({}, axisName, fromZero[axisName] || pathType === 'area' || pathType === 'bar')); | ||
| var getPieItems = function getPieItems(series, domain) { | ||
| return domain.map(function (uniqueName) { | ||
| return { uniqueName: uniqueName }; | ||
| }); | ||
| }; | ||
@@ -680,15 +534,9 @@ | ||
| var PALETTE = ['#2196F3', '#F44336', '#4CAF50', '#FFEB3B', '#E91E63', '#9C27B0']; | ||
| var palette = function palette(series) { | ||
| var palette = function palette(series, scheme) { | ||
| return scaleOrdinal().domain(series.map(function (_ref) { | ||
| var uniqueName = _ref.uniqueName; | ||
| return uniqueName; | ||
| })).range(PALETTE); | ||
| })).range(scheme); | ||
| }; | ||
| var axisName = function axisName(argumentAxisName) { | ||
| return argumentAxisName || 'argumentAxis'; | ||
| }; | ||
| var prepareData = function prepareData(data, series, processingData) { | ||
@@ -704,3 +552,3 @@ return processingData ? processingData(series, data) : data.map(function (singleData) { | ||
| return _extends({}, prevValue, defineProperty({}, valueField + '-' + name + '-stack', [0, singleData[valueField]])); | ||
| return _extends({}, prevValue, defineProperty({}, valueField + "-" + name + "-stack", [0, singleData[valueField]])); | ||
| }, singleData); | ||
@@ -710,3 +558,3 @@ }); | ||
| export { computedExtension, domains, bBoxes, axisCoordinates, axesData, dArea, dLine, dSpline, xyScales, pieAttributes, coordinates, barCoordinates, findSeriesByName, dBar, pointAttributes, seriesData, checkZeroStart, createScale, getWidth, HORIZONTAL, VERTICAL, TOP, BOTTOM, LEFT, RIGHT, MIDDLE, END, START, BAND, processData, seriesWithStacks, stacks, palette, axisName, prepareData }; | ||
| export { getValueDomainName, computeExtension, computeDomains, bBoxes, axisCoordinates, axesData, dArea, dLine, dSpline, xyScales, pieAttributes, coordinates, barCoordinates, findSeriesByName, dBar, pointAttributes, seriesData, getPieItems, createScale, getWidth, HORIZONTAL, VERTICAL, TOP, BOTTOM, LEFT, RIGHT, MIDDLE, END, START, LINEAR, BAND, ARGUMENT_DOMAIN, VALUE_DOMAIN, processData, seriesWithStacks, stacks, palette, prepareData }; | ||
| //# sourceMappingURL=dx-chart-core.es.js.map |
| /** | ||
| * Bundle of @devexpress/dx-chart-core | ||
| * 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,733 +9,584 @@ */ | ||
| (function (global, factory) { | ||
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-array'), require('d3-scale'), require('d3-shape')) : | ||
| typeof define === 'function' && define.amd ? define(['exports', 'd3-array', 'd3-scale', 'd3-shape'], factory) : | ||
| (factory((global.DevExpress = global.DevExpress || {}, global.DevExpress.DXChartCore = {}),global.d3Array,global.d3Scale,global.d3Shape)); | ||
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-array'), require('d3-scale'), require('d3-shape')) : | ||
| typeof define === 'function' && define.amd ? define(['exports', 'd3-array', 'd3-scale', 'd3-shape'], factory) : | ||
| (factory((global.DevExpress = global.DevExpress || {}, global.DevExpress.DXChartCore = {}),global.d3Array,global.d3Scale,global.d3Shape)); | ||
| }(this, (function (exports,d3Array,d3Scale,d3Shape) { 'use strict'; | ||
| var HORIZONTAL = 'horizontal'; | ||
| var VERTICAL = 'vertical'; | ||
| var TOP = 'top'; | ||
| var BOTTOM = 'bottom'; | ||
| var LEFT = 'left'; | ||
| var RIGHT = 'right'; | ||
| var MIDDLE = 'middle'; | ||
| var END = 'end'; | ||
| var START = 'start'; | ||
| var HORIZONTAL = 'horizontal'; | ||
| var VERTICAL = 'vertical'; | ||
| var TOP = 'top'; | ||
| var BOTTOM = 'bottom'; | ||
| var LEFT = 'left'; | ||
| var RIGHT = 'right'; | ||
| var MIDDLE = 'middle'; | ||
| var END = 'end'; | ||
| var START = 'start'; | ||
| var BAND = 'band'; | ||
| var LINEAR = 'linear'; | ||
| var BAND = 'band'; | ||
| var asyncGenerator = function () { | ||
| function AwaitValue(value) { | ||
| this.value = value; | ||
| } | ||
| var ARGUMENT_DOMAIN = 'argument-domain'; | ||
| var VALUE_DOMAIN = 'value-domain'; | ||
| 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 defineProperty = function (obj, key, value) { | ||
| if (key in obj) { | ||
| Object.defineProperty(obj, key, { | ||
| value: value, | ||
| enumerable: true, | ||
| configurable: true, | ||
| writable: true | ||
| }); | ||
| } else { | ||
| obj[key] = value; | ||
| } | ||
| function resume(key, arg) { | ||
| try { | ||
| var result = gen[key](arg); | ||
| var value = result.value; | ||
| return obj; | ||
| }; | ||
| 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); | ||
| var _extends = Object.assign || function (target) { | ||
| for (var i = 1; i < arguments.length; i++) { | ||
| var source = arguments[i]; | ||
| for (var key in source) { | ||
| if (Object.prototype.hasOwnProperty.call(source, key)) { | ||
| target[key] = source[key]; | ||
| } | ||
| } catch (err) { | ||
| settle("throw", err); | ||
| } | ||
| } | ||
| function settle(type, value) { | ||
| switch (type) { | ||
| case "return": | ||
| front.resolve({ | ||
| value: value, | ||
| done: true | ||
| }); | ||
| break; | ||
| return target; | ||
| }; | ||
| case "throw": | ||
| front.reject(value); | ||
| break; | ||
| var toConsumableArray = function (arr) { | ||
| if (Array.isArray(arr)) { | ||
| for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; | ||
| default: | ||
| front.resolve({ | ||
| value: value, | ||
| done: false | ||
| }); | ||
| break; | ||
| } | ||
| front = front.next; | ||
| if (front) { | ||
| resume(front.key, front.arg); | ||
| } else { | ||
| back = null; | ||
| } | ||
| return arr2; | ||
| } else { | ||
| return Array.from(arr); | ||
| } | ||
| }; | ||
| this._invoke = send; | ||
| var isDefined = function isDefined(item) { | ||
| return item !== undefined; | ||
| }; | ||
| 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); | ||
| var getValueDomainName = function getValueDomainName(name) { | ||
| return name || VALUE_DOMAIN; | ||
| }; | ||
| AsyncGenerator.prototype.throw = function (arg) { | ||
| return this._invoke("throw", arg); | ||
| // TODO: Property name should not contain "axis" part as it actually means domain. | ||
| var getSeriesValueDomainName = function getSeriesValueDomainName(series) { | ||
| return getValueDomainName(series.axisName); | ||
| }; | ||
| AsyncGenerator.prototype.return = function (arg) { | ||
| return this._invoke("return", arg); | ||
| var calculateDomainField = function calculateDomainField(getFieldItemFirst, getFieldItemSecond, data, domain, type) { | ||
| var getCategories = function getCategories(prev, cur) { | ||
| var categories = getFieldItemFirst(cur); | ||
| if (isDefined(categories)) { | ||
| return [].concat(toConsumableArray(prev), [categories]); | ||
| } | ||
| return prev; | ||
| }; | ||
| if (type === BAND) { | ||
| return [].concat(toConsumableArray(domain), toConsumableArray(data.reduce(getCategories, []))); | ||
| } | ||
| return d3Array.extent([].concat(toConsumableArray(domain), toConsumableArray(d3Array.extent(data, getFieldItemFirst)), toConsumableArray(d3Array.extent(data, getFieldItemSecond)))); | ||
| }; | ||
| return { | ||
| wrap: function (fn) { | ||
| return function () { | ||
| return new AsyncGenerator(fn.apply(this, arguments)); | ||
| }; | ||
| }, | ||
| await: function (value) { | ||
| return new AwaitValue(value); | ||
| var getCorrectAxisType = function getCorrectAxisType(type, data, field) { | ||
| if (!type && typeof data.find(function (item) { | ||
| return isDefined(item[field]); | ||
| })[field] === 'string') { | ||
| return BAND; | ||
| } | ||
| return type || LINEAR; | ||
| }; | ||
| }(); | ||
| var getFieldStack = function getFieldStack(index, object) { | ||
| return object && isDefined(object[index]) ? object[index] : undefined; | ||
| }; | ||
| var calculateDomains = function calculateDomains(domains, seriesList, data) { | ||
| seriesList.forEach(function (seriesItem) { | ||
| var valueDomainName = getSeriesValueDomainName(seriesItem); | ||
| var argumentField = seriesItem.argumentField, | ||
| valueField = seriesItem.valueField, | ||
| name = seriesItem.name; | ||
| var argumentDomain = domains[ARGUMENT_DOMAIN]; | ||
| var valueDomain = domains[valueDomainName]; | ||
| var valueType = getCorrectAxisType(valueDomain.type, data, valueField); | ||
| var argumentType = getCorrectAxisType(argumentDomain.type, data, argumentField); | ||
| valueDomain.domain = calculateDomainField(function (object) { | ||
| return getFieldStack(1, object[valueField + '-' + name + '-stack']); | ||
| }, valueDomain.isStartedFromZero ? function (object) { | ||
| return getFieldStack(0, object[valueField + '-' + name + '-stack']); | ||
| } : undefined, data, valueDomain.domain, valueType); | ||
| valueDomain.type = valueType; | ||
| argumentDomain.domain = calculateDomainField(function (object) { | ||
| return object[argumentField]; | ||
| }, null, data, argumentDomain.domain, argumentType); | ||
| argumentDomain.type = argumentType; | ||
| }); | ||
| }; | ||
| var computeExtension = function computeExtension(extension) { | ||
| var defaultExtension = [{ type: LINEAR, constructor: d3Scale.scaleLinear }, { type: BAND, constructor: d3Scale.scaleBand }]; | ||
| return extension.concat(defaultExtension); | ||
| }; | ||
| var collectDomains = function collectDomains(seriesList) { | ||
| var domains = defineProperty({}, ARGUMENT_DOMAIN, { domain: [], orientation: HORIZONTAL }); | ||
| seriesList.forEach(function (seriesItem) { | ||
| var name = getSeriesValueDomainName(seriesItem); | ||
| var domain = domains[name] || { domain: [], orientation: VERTICAL }; | ||
| domains[name] = domain; | ||
| domain.isStartedFromZero = domain.isStartedFromZero || seriesItem.isStartedFromZero; | ||
| }); | ||
| return domains; | ||
| }; | ||
| var takeTypeFromAxesOptions = function takeTypeFromAxesOptions(domains, axes) { | ||
| axes.forEach(function (_ref) { | ||
| var name = _ref.name, | ||
| type = _ref.type; | ||
| var defineProperty = function (obj, key, value) { | ||
| if (key in obj) { | ||
| Object.defineProperty(obj, key, { | ||
| value: value, | ||
| enumerable: true, | ||
| configurable: true, | ||
| writable: true | ||
| var domain = domains[name]; | ||
| if (domain) { | ||
| domain.type = type; | ||
| } | ||
| }); | ||
| } else { | ||
| obj[key] = value; | ||
| } | ||
| }; | ||
| return obj; | ||
| }; | ||
| var takeRestAxesOptions = function takeRestAxesOptions(domains, axes) { | ||
| axes.forEach(function (_ref2) { | ||
| var name = _ref2.name, | ||
| tickFormat = _ref2.tickFormat, | ||
| min = _ref2.min, | ||
| max = _ref2.max; | ||
| var _extends = Object.assign || function (target) { | ||
| for (var i = 1; i < arguments.length; i++) { | ||
| var source = arguments[i]; | ||
| for (var key in source) { | ||
| if (Object.prototype.hasOwnProperty.call(source, key)) { | ||
| target[key] = source[key]; | ||
| var domain = domains[name]; | ||
| if (!domain) { | ||
| return; | ||
| } | ||
| } | ||
| } | ||
| domain.tickFormat = tickFormat; | ||
| if (domain.type !== BAND) { | ||
| domain.domain = [isDefined(min) ? min : domain.domain[0], isDefined(max) ? max : domain.domain[1]]; | ||
| } | ||
| }); | ||
| }; | ||
| return target; | ||
| }; | ||
| var computeDomains = function computeDomains(axes, series, data) { | ||
| var result = collectDomains(series); | ||
| // Axes options are taken in two steps because *type* is required for domains calculation | ||
| // and other options must be applied after domains are calculated. | ||
| takeTypeFromAxesOptions(result, axes); | ||
| calculateDomains(result, series, data); | ||
| takeRestAxesOptions(result, axes); | ||
| return result; | ||
| }; | ||
| var isEqual = function isEqual(_ref, _ref2) { | ||
| var firstWidth = _ref.width, | ||
| firstHeight = _ref.height; | ||
| var secondWidth = _ref2.width, | ||
| secondHeight = _ref2.height; | ||
| return firstWidth === secondWidth && firstHeight === secondHeight; | ||
| }; | ||
| var bBoxes = function bBoxes(prevBBoxes, _ref3) { | ||
| var bBox = _ref3.bBox, | ||
| placeholder = _ref3.placeholder; | ||
| if (isEqual(prevBBoxes[placeholder] || {}, bBox)) return prevBBoxes; | ||
| return _extends({}, prevBBoxes, defineProperty({}, placeholder, bBox)); | ||
| }; | ||
| var createScale = function createScale(_ref, width, height, constructor) { | ||
| var domain = _ref.domain, | ||
| orientation = _ref.orientation; | ||
| var padding = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0; | ||
| var toConsumableArray = function (arr) { | ||
| if (Array.isArray(arr)) { | ||
| for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; | ||
| return arr2; | ||
| } else { | ||
| return Array.from(arr); | ||
| } | ||
| }; | ||
| var isDefined = function isDefined(item) { | ||
| return item !== undefined; | ||
| }; | ||
| var collectAxesOptions = function collectAxesOptions(axes) { | ||
| return axes.reduce(function (domains, _ref) { | ||
| var name = _ref.name, | ||
| type = _ref.type, | ||
| tickFormat = _ref.tickFormat; | ||
| return _extends({}, domains, defineProperty({}, name, { | ||
| type: type, | ||
| tickFormat: tickFormat | ||
| })); | ||
| }, {}); | ||
| }; | ||
| var calculateDomainField = function calculateDomainField(getFieldItemFirst, getFieldItemSecond, data) { | ||
| var domain = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : []; | ||
| var type = arguments[4]; | ||
| var getCategories = function getCategories(prev, cur) { | ||
| var categories = getFieldItemFirst(cur); | ||
| if (isDefined(categories)) { | ||
| return [].concat(toConsumableArray(prev), [categories]); | ||
| var scale = constructor(); | ||
| if (scale.paddingInner) { | ||
| scale.paddingInner(padding).paddingOuter(padding / 2); | ||
| } | ||
| return prev; | ||
| return scale.domain(domain).range(orientation === HORIZONTAL ? [0, width] : [height, 0]); | ||
| }; | ||
| if (type === BAND) { | ||
| return [].concat(toConsumableArray(domain), toConsumableArray(data.reduce(getCategories, []))); | ||
| } | ||
| return d3Array.extent([].concat(toConsumableArray(domain), toConsumableArray(d3Array.extent(data, getFieldItemFirst)), toConsumableArray(d3Array.extent(data, getFieldItemSecond)))); | ||
| }; | ||
| var getCorrectAxisType = function getCorrectAxisType(type, data, field) { | ||
| if (!type && typeof data.find(function (item) { | ||
| return isDefined(item[field]); | ||
| })[field] === 'string') { | ||
| return 'band'; | ||
| } | ||
| return type || 'linear'; | ||
| }; | ||
| var getWidth = function getWidth(scale) { | ||
| return scale.bandwidth ? scale.bandwidth() : 0; | ||
| }; | ||
| var getFieldStack = function getFieldStack(index, object) { | ||
| return object && isDefined(object[index]) ? object[index] : undefined; | ||
| }; | ||
| var calculateDomain = function calculateDomain(series, data, axesOptions, argumentAxisName, startFromZero) { | ||
| return series.reduce(function (domains, _ref2) { | ||
| var _babelHelpers$extends2; | ||
| var valueField = _ref2.valueField, | ||
| argumentField = _ref2.argumentField, | ||
| axisName = _ref2.axisName, | ||
| name = _ref2.name; | ||
| var valueType = getCorrectAxisType(domains[axisName] && domains[axisName].type, data, valueField); | ||
| var argumentType = getCorrectAxisType(domains[argumentAxisName] && domains[argumentAxisName].type, data, argumentField); | ||
| return _extends({}, domains, (_babelHelpers$extends2 = {}, defineProperty(_babelHelpers$extends2, axisName, { | ||
| domain: calculateDomainField(function (object) { | ||
| return getFieldStack(1, object[valueField + '-' + name + '-stack']); | ||
| }, startFromZero[axisName] ? function (object) { | ||
| return getFieldStack(0, object[valueField + '-' + name + '-stack']); | ||
| } : undefined, data, domains[axisName] && domains[axisName].domain, valueType), | ||
| orientation: VERTICAL, | ||
| type: valueType, | ||
| tickFormat: domains[axisName] && domains[axisName].tickFormat | ||
| }), defineProperty(_babelHelpers$extends2, argumentAxisName, { | ||
| domain: calculateDomainField(function (object) { | ||
| return object[argumentField]; | ||
| }, null, data, domains[argumentAxisName] && domains[argumentAxisName].domain, argumentType), | ||
| orientation: HORIZONTAL, | ||
| type: argumentType, | ||
| tickFormat: domains[argumentAxisName] && domains[argumentAxisName].tickFormat | ||
| }), _babelHelpers$extends2)); | ||
| }, axesOptions); | ||
| }; | ||
| var recalculateDomain = function recalculateDomain(range, currentDomain) { | ||
| return { | ||
| domain: currentDomain.type !== BAND ? range : currentDomain.domain, | ||
| type: currentDomain.type, | ||
| orientation: currentDomain.orientation, | ||
| tickFormat: currentDomain.tickFormat | ||
| var getTicks = function getTicks(scale) { | ||
| return scale.ticks ? scale.ticks() : scale.domain(); | ||
| }; | ||
| }; | ||
| var adjustDomains = function adjustDomains(axes, calculatedDomains) { | ||
| return axes.reduce(function (domains, _ref3) { | ||
| var name = _ref3.name, | ||
| min = _ref3.min, | ||
| max = _ref3.max; | ||
| var currentDomain = domains[name]; | ||
| return _extends({}, domains, defineProperty({}, name, recalculateDomain([isDefined(min) ? min : currentDomain.domain[0], isDefined(max) ? max : currentDomain.domain[1]], currentDomain))); | ||
| }, calculatedDomains); | ||
| }; | ||
| var computedExtension = function computedExtension(extension) { | ||
| var defaultExtension = [{ type: 'linear', constructor: d3Scale.scaleLinear }, { type: 'band', constructor: d3Scale.scaleBand }]; | ||
| return extension.concat(defaultExtension); | ||
| }; | ||
| var domains = function domains() { | ||
| var axes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; | ||
| var series = arguments[1]; | ||
| var data = arguments[2]; | ||
| var argumentAxisName = arguments[3]; | ||
| var startFromZero = arguments[4]; | ||
| var axesOptions = collectAxesOptions(axes); | ||
| var calculatedDomains = calculateDomain(series, data, axesOptions, argumentAxisName, startFromZero); | ||
| return adjustDomains(axes, calculatedDomains); | ||
| }; | ||
| var isEqual = function isEqual(_ref, _ref2) { | ||
| var firstWidth = _ref.width, | ||
| firstHeight = _ref.height; | ||
| var secondWidth = _ref2.width, | ||
| secondHeight = _ref2.height; | ||
| return firstWidth === secondWidth && firstHeight === secondHeight; | ||
| }; | ||
| var bBoxes = function bBoxes(prevBBoxes, _ref3) { | ||
| var bBox = _ref3.bBox, | ||
| placeholder = _ref3.placeholder; | ||
| if (isEqual(prevBBoxes[placeholder] || {}, bBox)) return prevBBoxes; | ||
| return _extends({}, prevBBoxes, defineProperty({}, placeholder, bBox)); | ||
| }; | ||
| var createScale = function createScale(_ref, width, height, constructor) { | ||
| var domain = _ref.domain, | ||
| orientation = _ref.orientation; | ||
| var padding = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0; | ||
| var scale = constructor(); | ||
| if (scale.paddingInner) { | ||
| scale.paddingInner(padding).paddingOuter(padding / 2); | ||
| } | ||
| return scale.domain(domain).range(orientation === HORIZONTAL ? [0, width] : [height, 0]); | ||
| }; | ||
| var getWidth = function getWidth(scale) { | ||
| return scale.bandwidth ? scale.bandwidth() : 0; | ||
| }; | ||
| var getTicks = function getTicks(scale) { | ||
| return scale.ticks ? scale.ticks() : scale.domain(); | ||
| }; | ||
| var getDominantBaseline = function getDominantBaseline(orientation, position) { | ||
| if (orientation === HORIZONTAL) { | ||
| return position === TOP ? 'baseline' : 'hanging'; | ||
| } | ||
| return MIDDLE; | ||
| }; | ||
| var getTextAnchor = function getTextAnchor(orientation, position) { | ||
| if (orientation === HORIZONTAL) { | ||
| var getDominantBaseline = function getDominantBaseline(orientation, position) { | ||
| if (orientation === HORIZONTAL) { | ||
| return position === TOP ? 'baseline' : 'hanging'; | ||
| } | ||
| return MIDDLE; | ||
| } | ||
| return position === LEFT ? END : START; | ||
| }; | ||
| }; | ||
| var getTextAnchor = function getTextAnchor(orientation, position) { | ||
| if (orientation === HORIZONTAL) { | ||
| return MIDDLE; | ||
| } | ||
| return position === LEFT ? END : START; | ||
| }; | ||
| var getFormat = function getFormat(scale, tickFormat) { | ||
| if (scale.tickFormat) { | ||
| return tickFormat ? tickFormat(scale) : scale.tickFormat(); | ||
| } | ||
| return function (tick) { | ||
| return tick; | ||
| var getFormat = function getFormat(scale, tickFormat) { | ||
| if (scale.tickFormat) { | ||
| return tickFormat ? tickFormat(scale) : scale.tickFormat(); | ||
| } | ||
| return function (tick) { | ||
| return tick; | ||
| }; | ||
| }; | ||
| }; | ||
| var calculateAxisCoordinates = function calculateAxisCoordinates(scale, orientation, position, tickSize, indentFromAxis, tickFormat) { | ||
| var ticks = getTicks(scale); | ||
| var offset = getWidth(scale) / 2; | ||
| var dominantBaseline = getDominantBaseline(orientation, position); | ||
| var textAnchor = getTextAnchor(orientation, position); | ||
| var getTickCoordinates = function getTickCoordinates(tick, index) { | ||
| var coordinates = scale(tick) + offset; | ||
| if (orientation === HORIZONTAL) { | ||
| var calculateAxisCoordinates = function calculateAxisCoordinates(scale, orientation, position, tickSize, indentFromAxis, tickFormat) { | ||
| var ticks = getTicks(scale); | ||
| var offset = getWidth(scale) / 2; | ||
| var dominantBaseline = getDominantBaseline(orientation, position); | ||
| var textAnchor = getTextAnchor(orientation, position); | ||
| var getTickCoordinates = function getTickCoordinates(tick, index) { | ||
| var coordinates = scale(tick) + offset; | ||
| if (orientation === HORIZONTAL) { | ||
| return { | ||
| dominantBaseline: dominantBaseline, | ||
| textAnchor: textAnchor, | ||
| x1: coordinates, | ||
| x2: coordinates, | ||
| y1: position === TOP ? -tickSize : 0, | ||
| y2: position === TOP ? 0 : tickSize, | ||
| text: getFormat(scale, tickFormat)(tick), | ||
| xText: coordinates, | ||
| yText: position === TOP ? -tickSize - indentFromAxis : tickSize + indentFromAxis, | ||
| key: index | ||
| }; | ||
| } | ||
| return { | ||
| dominantBaseline: dominantBaseline, | ||
| textAnchor: textAnchor, | ||
| x1: coordinates, | ||
| x2: coordinates, | ||
| y1: position === TOP ? -tickSize : 0, | ||
| y2: position === TOP ? 0 : tickSize, | ||
| y1: coordinates, | ||
| y2: coordinates, | ||
| x1: position === LEFT ? -tickSize : 0, | ||
| x2: position === LEFT ? 0 : tickSize, | ||
| text: getFormat(scale, tickFormat)(tick), | ||
| xText: coordinates, | ||
| yText: position === TOP ? -tickSize - indentFromAxis : tickSize + indentFromAxis, | ||
| xText: position === LEFT ? -tickSize - indentFromAxis : tickSize + indentFromAxis, | ||
| yText: coordinates, | ||
| key: index | ||
| }; | ||
| } | ||
| }; | ||
| return { | ||
| dominantBaseline: dominantBaseline, | ||
| textAnchor: textAnchor, | ||
| y1: coordinates, | ||
| y2: coordinates, | ||
| x1: position === LEFT ? -tickSize : 0, | ||
| x2: position === LEFT ? 0 : tickSize, | ||
| text: getFormat(scale, tickFormat)(tick), | ||
| xText: position === LEFT ? -tickSize - indentFromAxis : tickSize + indentFromAxis, | ||
| yText: coordinates, | ||
| key: index | ||
| ticks: ticks.map(getTickCoordinates) | ||
| }; | ||
| }; | ||
| return { | ||
| ticks: ticks.map(getTickCoordinates) | ||
| }; | ||
| }; | ||
| var axisCoordinates = function axisCoordinates(domainOptions, position, width, height, tickSize, indentFromAxis, constructor) { | ||
| var scale = createScale(domainOptions, width, height, constructor); | ||
| var axisCoordinates = function axisCoordinates(domainOptions, position, width, height, tickSize, indentFromAxis, constructor) { | ||
| var scale = createScale(domainOptions, width, height, constructor); | ||
| return calculateAxisCoordinates(scale, domainOptions.orientation, position, tickSize, indentFromAxis, domainOptions.tickFormat); | ||
| }; | ||
| return calculateAxisCoordinates(scale, domainOptions.orientation, position, tickSize, indentFromAxis, domainOptions.tickFormat); | ||
| }; | ||
| var axesData = function axesData() { | ||
| var axes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; | ||
| var axisProps = arguments[1]; | ||
| return [].concat(toConsumableArray(axes), [axisProps]); | ||
| }; | ||
| var axesData = function axesData(axes, axisProps) { | ||
| return [].concat(toConsumableArray(axes), [axisProps]); | ||
| }; | ||
| var getX = function getX(_ref) { | ||
| var x = _ref.x; | ||
| return x; | ||
| }; | ||
| var getY = function getY(_ref2) { | ||
| var y = _ref2.y; | ||
| return y; | ||
| }; | ||
| var getY1 = function getY1(_ref3) { | ||
| var y1 = _ref3.y1; | ||
| return y1; | ||
| }; | ||
| var getX = function getX(_ref) { | ||
| var x = _ref.x; | ||
| return x; | ||
| }; | ||
| var getY = function getY(_ref2) { | ||
| var y = _ref2.y; | ||
| return y; | ||
| }; | ||
| var getY1 = function getY1(_ref3) { | ||
| var y1 = _ref3.y1; | ||
| return y1; | ||
| }; | ||
| var DEFAULT_POINT_SIZE = 7; | ||
| var DEFAULT_POINT_SIZE = 7; | ||
| var dArea = d3Shape.area().x(getX).y1(getY).y0(getY1); | ||
| var dArea = d3Shape.area().x(getX).y1(getY).y0(getY1); | ||
| var dLine = d3Shape.line().x(getX).y(getY); | ||
| var dLine = d3Shape.line().x(getX).y(getY); | ||
| var dSpline = d3Shape.line().x(getX).y(getY).curve(d3Shape.curveMonotoneX); | ||
| var dSpline = d3Shape.line().x(getX).y(getY).curve(d3Shape.curveMonotoneX); | ||
| var getConstructor = function getConstructor(scaleExtension, type) { | ||
| return scaleExtension.find(function (item) { | ||
| return item.type === type; | ||
| }).constructor; | ||
| }; | ||
| var xyScales = function xyScales(argumentDomainOptions, valueDomainOptions, _ref4, groupWidth, scaleExtension) { | ||
| var width = _ref4.width, | ||
| height = _ref4.height; | ||
| var xConstructor = getConstructor(scaleExtension, argumentDomainOptions.type); | ||
| var yConstructor = getConstructor(scaleExtension, valueDomainOptions.type); | ||
| return { | ||
| xScale: createScale(argumentDomainOptions, width, height, xConstructor, 1 - groupWidth), | ||
| yScale: createScale(valueDomainOptions, width, height, yConstructor) | ||
| var getConstructor = function getConstructor(scaleExtension, type) { | ||
| return scaleExtension.find(function (item) { | ||
| return item.type === type; | ||
| }).constructor; | ||
| }; | ||
| }; | ||
| var pieAttributes = function pieAttributes(data, _ref5, argumentField, valueField, name, stack$$1, stacks, _ref6) { | ||
| var xScale = _ref5.xScale, | ||
| yScale = _ref5.yScale; | ||
| var _ref6$innerRadius = _ref6.innerRadius, | ||
| innerRadius = _ref6$innerRadius === undefined ? 0 : _ref6$innerRadius, | ||
| _ref6$outerRadius = _ref6.outerRadius, | ||
| outerRadius = _ref6$outerRadius === undefined ? 1 : _ref6$outerRadius; | ||
| var xyScales = function xyScales(argumentDomainOptions, valueDomainOptions, _ref4, groupWidth, scaleExtension) { | ||
| var width = _ref4.width, | ||
| height = _ref4.height; | ||
| var width = Math.max.apply(null, xScale.range()); | ||
| var height = Math.max.apply(null, yScale.range()); | ||
| var radius = Math.min(width, height) / 2; | ||
| var pieData = d3Shape.pie().value(function (d) { | ||
| return d[valueField]; | ||
| })(data); | ||
| return pieData.map(function (_ref7) { | ||
| var startAngle = _ref7.startAngle, | ||
| endAngle = _ref7.endAngle, | ||
| value = _ref7.value, | ||
| itemData = _ref7.data; | ||
| var xConstructor = getConstructor(scaleExtension, argumentDomainOptions.type); | ||
| var yConstructor = getConstructor(scaleExtension, valueDomainOptions.type); | ||
| return { | ||
| d: d3Shape.arc().innerRadius(innerRadius * radius).outerRadius(outerRadius * radius).startAngle(startAngle).endAngle(endAngle)(), | ||
| value: value, | ||
| data: itemData, | ||
| id: itemData[argumentField], | ||
| x: width / 2, | ||
| y: height / 2 | ||
| xScale: createScale(argumentDomainOptions, width, height, xConstructor, 1 - groupWidth), | ||
| yScale: createScale(valueDomainOptions, width, height, yConstructor) | ||
| }; | ||
| }); | ||
| }; | ||
| }; | ||
| var coordinates = function coordinates(data, _ref8, argumentField, valueField, name) { | ||
| var xScale = _ref8.xScale, | ||
| yScale = _ref8.yScale; | ||
| return data.reduce(function (result, dataItem, index) { | ||
| if (dataItem[argumentField] !== undefined && dataItem[valueField] !== undefined) { | ||
| return [].concat(toConsumableArray(result), [{ | ||
| x: xScale(dataItem[argumentField]) + getWidth(xScale) / 2, | ||
| y: yScale(dataItem[valueField + '-' + name + '-stack'][1]), | ||
| y1: yScale(dataItem[valueField + '-' + name + '-stack'][0]), | ||
| id: index, | ||
| value: dataItem[valueField] | ||
| }]); | ||
| } | ||
| return result; | ||
| }, []); | ||
| }; | ||
| var pieAttributes = function pieAttributes(data, _ref5, argumentField, valueField, name, stack, stacks, _ref6) { | ||
| var xScale = _ref5.xScale, | ||
| yScale = _ref5.yScale; | ||
| var _ref6$innerRadius = _ref6.innerRadius, | ||
| innerRadius = _ref6$innerRadius === undefined ? 0 : _ref6$innerRadius, | ||
| _ref6$outerRadius = _ref6.outerRadius, | ||
| outerRadius = _ref6$outerRadius === undefined ? 1 : _ref6$outerRadius; | ||
| var barCoordinates = function barCoordinates(data, _ref9, argumentField, valueField, name, stack$$1) { | ||
| var xScale = _ref9.xScale, | ||
| yScale = _ref9.yScale; | ||
| var stacks = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [undefined]; | ||
| var _ref10 = arguments[7]; | ||
| var _ref10$barWidth = _ref10.barWidth, | ||
| barWidth = _ref10$barWidth === undefined ? 0.9 : _ref10$barWidth; | ||
| var scaleExtension = arguments[8]; | ||
| var width = Math.max.apply(null, xScale.range()); | ||
| var height = Math.max.apply(null, yScale.range()); | ||
| var radius = Math.min(width, height) / 2; | ||
| var pieData = d3Shape.pie().sort(null).value(function (d) { | ||
| return d[valueField]; | ||
| })(data); | ||
| var rawCoordinates = coordinates(data, { xScale: xScale, yScale: yScale }, argumentField, valueField, name); | ||
| var width = getWidth(xScale); | ||
| var x0Scale = createScale({ | ||
| domain: stacks | ||
| }, width, width, getConstructor(scaleExtension, 'band'), 1 - barWidth); | ||
| return rawCoordinates.map(function (item) { | ||
| return _extends({}, item, { | ||
| width: getWidth(x0Scale), | ||
| x: item.x - width / 2 + x0Scale(stack$$1) | ||
| return pieData.map(function (_ref7) { | ||
| var startAngle = _ref7.startAngle, | ||
| endAngle = _ref7.endAngle, | ||
| value = _ref7.value, | ||
| itemData = _ref7.data; | ||
| return { | ||
| d: d3Shape.arc().innerRadius(innerRadius * radius).outerRadius(outerRadius * radius).startAngle(startAngle).endAngle(endAngle)(), | ||
| value: value, | ||
| data: itemData, | ||
| id: itemData[argumentField], | ||
| x: width / 2, | ||
| y: height / 2 | ||
| }; | ||
| }); | ||
| }); | ||
| }; | ||
| }; | ||
| var findSeriesByName = function findSeriesByName(name, series) { | ||
| return series.find(function (seriesItem) { | ||
| return seriesItem.symbolName === name; | ||
| }); | ||
| }; | ||
| var coordinates = function coordinates(data, _ref8, argumentField, valueField, name) { | ||
| var xScale = _ref8.xScale, | ||
| yScale = _ref8.yScale; | ||
| return data.reduce(function (result, dataItem, index) { | ||
| if (dataItem[argumentField] !== undefined && dataItem[valueField] !== undefined) { | ||
| return [].concat(toConsumableArray(result), [{ | ||
| x: xScale(dataItem[argumentField]) + getWidth(xScale) / 2, | ||
| y: yScale(dataItem[valueField + '-' + name + '-stack'][1]), | ||
| y1: yScale(dataItem[valueField + '-' + name + '-stack'][0]), | ||
| id: index, | ||
| value: dataItem[valueField] | ||
| }]); | ||
| } | ||
| return result; | ||
| }, []); | ||
| }; | ||
| var dBar = function dBar(_ref11) { | ||
| var x = _ref11.x, | ||
| y = _ref11.y, | ||
| y1 = _ref11.y1, | ||
| width = _ref11.width; | ||
| return { | ||
| x: x, y: Math.min(y, y1), width: width || 2, height: Math.abs(y1 - y) | ||
| var barCoordinates = function barCoordinates(data, _ref9, argumentField, valueField, name, stack) { | ||
| var xScale = _ref9.xScale, | ||
| yScale = _ref9.yScale; | ||
| var stacks = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [undefined]; | ||
| var _ref10 = arguments[7]; | ||
| var _ref10$barWidth = _ref10.barWidth, | ||
| barWidth = _ref10$barWidth === undefined ? 0.9 : _ref10$barWidth; | ||
| var scaleExtension = arguments[8]; | ||
| var rawCoordinates = coordinates(data, { xScale: xScale, yScale: yScale }, argumentField, valueField, name); | ||
| var width = getWidth(xScale); | ||
| var x0Scale = createScale({ | ||
| domain: stacks | ||
| }, width, width, getConstructor(scaleExtension, 'band'), 1 - barWidth); | ||
| return rawCoordinates.map(function (item) { | ||
| return _extends({}, item, { | ||
| width: getWidth(x0Scale), | ||
| x: item.x - width / 2 + x0Scale(stack) | ||
| }); | ||
| }); | ||
| }; | ||
| }; | ||
| var pointAttributes = function pointAttributes(_ref12) { | ||
| var _ref12$size = _ref12.size, | ||
| size = _ref12$size === undefined ? DEFAULT_POINT_SIZE : _ref12$size; | ||
| var findSeriesByName = function findSeriesByName(name, series) { | ||
| return series.find(function (seriesItem) { | ||
| return seriesItem.symbolName === name; | ||
| }); | ||
| }; | ||
| var dPoint = d3Shape.symbol().size([Math.pow(size, 2)]).type(d3Shape.symbolCircle)(); | ||
| return function (item) { | ||
| var dBar = function dBar(_ref11) { | ||
| var x = _ref11.x, | ||
| y = _ref11.y, | ||
| y1 = _ref11.y1, | ||
| width = _ref11.width; | ||
| return { | ||
| d: dPoint, | ||
| x: item.x, | ||
| y: item.y | ||
| x: x, y: Math.min(y, y1), width: width || 2, height: Math.abs(y1 - y) | ||
| }; | ||
| }; | ||
| }; | ||
| var createNewUniqueName = function createNewUniqueName(name) { | ||
| return name.replace(/\d*$/, function (str) { | ||
| return str ? +str + 1 : 0; | ||
| }); | ||
| }; | ||
| var pointAttributes = function pointAttributes(_ref12) { | ||
| var _ref12$size = _ref12.size, | ||
| size = _ref12$size === undefined ? DEFAULT_POINT_SIZE : _ref12$size; | ||
| var seriesData = function seriesData() { | ||
| var series = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; | ||
| var seriesProps = arguments[1]; | ||
| var dPoint = d3Shape.symbol().size([Math.pow(size, 2)]).type(d3Shape.symbolCircle)(); | ||
| return function (item) { | ||
| return { | ||
| d: dPoint, | ||
| x: item.x, | ||
| y: item.y | ||
| }; | ||
| }; | ||
| }; | ||
| if (series.find(function (_ref13) { | ||
| var uniqueName = _ref13.uniqueName; | ||
| return uniqueName === seriesProps.uniqueName; | ||
| })) { | ||
| return seriesData(series, _extends({}, seriesProps, { uniqueName: createNewUniqueName(seriesProps.uniqueName) })); | ||
| } | ||
| return [].concat(toConsumableArray(series), [seriesProps]); | ||
| }; | ||
| var createNewUniqueName = function createNewUniqueName(name) { | ||
| return name.replace(/\d*$/, function (str) { | ||
| return str ? +str + 1 : 0; | ||
| }); | ||
| }; | ||
| var checkZeroStart = function checkZeroStart(fromZero, axisName, pathType) { | ||
| return _extends({}, fromZero, defineProperty({}, axisName, fromZero[axisName] || pathType === 'area' || pathType === 'bar')); | ||
| }; | ||
| var seriesData = function seriesData() { | ||
| var series = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; | ||
| var seriesProps = arguments[1]; | ||
| var getStacks = function getStacks(series) { | ||
| return series.reduce(function (prevValue, _ref, index) { | ||
| var valueField = _ref.valueField, | ||
| seriesStack = _ref.stack; | ||
| if (series.find(function (_ref13) { | ||
| var uniqueName = _ref13.uniqueName; | ||
| return uniqueName === seriesProps.uniqueName; | ||
| })) { | ||
| return seriesData(series, _extends({}, seriesProps, { uniqueName: createNewUniqueName(seriesProps.uniqueName) })); | ||
| } | ||
| return [].concat(toConsumableArray(series), [seriesProps]); | ||
| }; | ||
| if (!prevValue[seriesStack]) { | ||
| var getPieItems = function getPieItems(series, domain) { | ||
| return domain.map(function (uniqueName) { | ||
| return { uniqueName: uniqueName }; | ||
| }); | ||
| }; | ||
| var getStacks = function getStacks(series) { | ||
| return series.reduce(function (prevValue, _ref, index) { | ||
| var valueField = _ref.valueField, | ||
| seriesStack = _ref.stack; | ||
| if (!prevValue[seriesStack]) { | ||
| return _extends({}, prevValue, defineProperty({}, seriesStack, { | ||
| keys: [valueField], | ||
| series: [index] | ||
| })); | ||
| } | ||
| return _extends({}, prevValue, defineProperty({}, seriesStack, { | ||
| keys: [valueField], | ||
| series: [index] | ||
| keys: [].concat(toConsumableArray(prevValue[seriesStack].keys), [valueField]), | ||
| series: [].concat(toConsumableArray(prevValue[seriesStack].series), [index]) | ||
| })); | ||
| } | ||
| return _extends({}, prevValue, defineProperty({}, seriesStack, { | ||
| keys: [].concat(toConsumableArray(prevValue[seriesStack].keys), [valueField]), | ||
| series: [].concat(toConsumableArray(prevValue[seriesStack].series), [index]) | ||
| })); | ||
| }, {}); | ||
| }; | ||
| }, {}); | ||
| }; | ||
| var filtering = function filtering(_ref2) { | ||
| var seriesStack = _ref2.stack; | ||
| return seriesStack; | ||
| }; | ||
| var filtering = function filtering(_ref2) { | ||
| var seriesStack = _ref2.stack; | ||
| return seriesStack; | ||
| }; | ||
| var processData = function processData(offset, order) { | ||
| return function (series, data) { | ||
| var stacks = getStacks(series); | ||
| var processData = function processData(offset, order) { | ||
| return function (series, data) { | ||
| var stacks = getStacks(series); | ||
| var arrayOfStacks = Object.entries(stacks).reduce(function (prevValue, item) { | ||
| return _extends({}, prevValue, defineProperty({}, item[0], d3Shape.stack().keys(item[1].keys).order(order).offset(offset)(data))); | ||
| }, {}); | ||
| var arrayOfStacks = Object.entries(stacks).reduce(function (prevValue, item) { | ||
| return _extends({}, prevValue, defineProperty({}, item[0], d3Shape.stack().keys(item[1].keys).order(order).offset(offset)(data))); | ||
| }, {}); | ||
| return data.map(function (singleData, dataIndex) { | ||
| return series.reduce(function (prevValue, _ref3, index) { | ||
| var valueField = _ref3.valueField, | ||
| name = _ref3.name, | ||
| seriesStack = _ref3.stack; | ||
| return data.map(function (singleData, dataIndex) { | ||
| return series.reduce(function (prevValue, _ref3, index) { | ||
| var valueField = _ref3.valueField, | ||
| name = _ref3.name, | ||
| seriesStack = _ref3.stack; | ||
| var seriesIndex = stacks[seriesStack].series.findIndex(function (item) { | ||
| return item === index; | ||
| }); | ||
| return _extends({}, prevValue, defineProperty({}, valueField + '-' + name + '-stack', arrayOfStacks[seriesStack][seriesIndex][dataIndex])); | ||
| }, singleData); | ||
| }); | ||
| var seriesIndex = stacks[seriesStack].series.findIndex(function (item) { | ||
| return item === index; | ||
| }); | ||
| return _extends({}, prevValue, defineProperty({}, valueField + '-' + name + '-stack', arrayOfStacks[seriesStack][seriesIndex][dataIndex])); | ||
| }, singleData); | ||
| }); | ||
| }; | ||
| }; | ||
| }; | ||
| var seriesWithStacks = function seriesWithStacks(series) { | ||
| return series.reduce(function (prevResult, singleSeries, index) { | ||
| var _singleSeries$stack = singleSeries.stack, | ||
| seriesStack = _singleSeries$stack === undefined ? 'stack' + index : _singleSeries$stack; | ||
| var seriesWithStacks = function seriesWithStacks(series) { | ||
| return series.reduce(function (prevResult, singleSeries, index) { | ||
| var _singleSeries$stack = singleSeries.stack, | ||
| seriesStack = _singleSeries$stack === undefined ? 'stack' + index : _singleSeries$stack; | ||
| return [].concat(toConsumableArray(prevResult), [_extends({}, singleSeries, { stack: seriesStack })]); | ||
| }, []); | ||
| }; | ||
| return [].concat(toConsumableArray(prevResult), [_extends({}, singleSeries, { stack: seriesStack })]); | ||
| }, []); | ||
| }; | ||
| var stacks = function stacks(series) { | ||
| return [].concat(toConsumableArray(new Set(series.filter(function (singleSeries) { | ||
| return filtering(singleSeries); | ||
| }).map(function (_ref4) { | ||
| var seriesStack = _ref4.stack; | ||
| return seriesStack; | ||
| })))); | ||
| }; | ||
| var stacks = function stacks(series) { | ||
| return [].concat(toConsumableArray(new Set(series.filter(function (singleSeries) { | ||
| return filtering(singleSeries); | ||
| }).map(function (_ref4) { | ||
| var seriesStack = _ref4.stack; | ||
| return seriesStack; | ||
| })))); | ||
| }; | ||
| var PALETTE = ['#2196F3', '#F44336', '#4CAF50', '#FFEB3B', '#E91E63', '#9C27B0']; | ||
| var palette = function palette(series, scheme) { | ||
| return d3Scale.scaleOrdinal().domain(series.map(function (_ref) { | ||
| var uniqueName = _ref.uniqueName; | ||
| return uniqueName; | ||
| })).range(scheme); | ||
| }; | ||
| var palette = function palette(series) { | ||
| return d3Scale.scaleOrdinal().domain(series.map(function (_ref) { | ||
| var uniqueName = _ref.uniqueName; | ||
| return uniqueName; | ||
| })).range(PALETTE); | ||
| }; | ||
| var prepareData = function prepareData(data, series, processingData) { | ||
| return processingData ? processingData(series, data) : data.map(function (singleData) { | ||
| return series.reduce(function (prevValue, _ref) { | ||
| var valueField = _ref.valueField, | ||
| name = _ref.name; | ||
| var axisName = function axisName(argumentAxisName) { | ||
| return argumentAxisName || 'argumentAxis'; | ||
| }; | ||
| if (singleData[valueField] === undefined) { | ||
| return prevValue; | ||
| } | ||
| var prepareData = function prepareData(data, series, processingData) { | ||
| return processingData ? processingData(series, data) : data.map(function (singleData) { | ||
| return series.reduce(function (prevValue, _ref) { | ||
| var valueField = _ref.valueField, | ||
| name = _ref.name; | ||
| return _extends({}, prevValue, defineProperty({}, valueField + "-" + name + "-stack", [0, singleData[valueField]])); | ||
| }, singleData); | ||
| }); | ||
| }; | ||
| if (singleData[valueField] === undefined) { | ||
| return prevValue; | ||
| } | ||
| exports.getValueDomainName = getValueDomainName; | ||
| exports.computeExtension = computeExtension; | ||
| exports.computeDomains = computeDomains; | ||
| exports.bBoxes = bBoxes; | ||
| exports.axisCoordinates = axisCoordinates; | ||
| exports.axesData = axesData; | ||
| exports.dArea = dArea; | ||
| exports.dLine = dLine; | ||
| exports.dSpline = dSpline; | ||
| exports.xyScales = xyScales; | ||
| exports.pieAttributes = pieAttributes; | ||
| exports.coordinates = coordinates; | ||
| exports.barCoordinates = barCoordinates; | ||
| exports.findSeriesByName = findSeriesByName; | ||
| exports.dBar = dBar; | ||
| exports.pointAttributes = pointAttributes; | ||
| exports.seriesData = seriesData; | ||
| exports.getPieItems = getPieItems; | ||
| exports.createScale = createScale; | ||
| exports.getWidth = getWidth; | ||
| exports.HORIZONTAL = HORIZONTAL; | ||
| exports.VERTICAL = VERTICAL; | ||
| exports.TOP = TOP; | ||
| exports.BOTTOM = BOTTOM; | ||
| exports.LEFT = LEFT; | ||
| exports.RIGHT = RIGHT; | ||
| exports.MIDDLE = MIDDLE; | ||
| exports.END = END; | ||
| exports.START = START; | ||
| exports.LINEAR = LINEAR; | ||
| exports.BAND = BAND; | ||
| exports.ARGUMENT_DOMAIN = ARGUMENT_DOMAIN; | ||
| exports.VALUE_DOMAIN = VALUE_DOMAIN; | ||
| exports.processData = processData; | ||
| exports.seriesWithStacks = seriesWithStacks; | ||
| exports.stacks = stacks; | ||
| exports.palette = palette; | ||
| exports.prepareData = prepareData; | ||
| return _extends({}, prevValue, defineProperty({}, valueField + '-' + name + '-stack', [0, singleData[valueField]])); | ||
| }, singleData); | ||
| }); | ||
| }; | ||
| Object.defineProperty(exports, '__esModule', { value: true }); | ||
| exports.computedExtension = computedExtension; | ||
| exports.domains = domains; | ||
| exports.bBoxes = bBoxes; | ||
| exports.axisCoordinates = axisCoordinates; | ||
| exports.axesData = axesData; | ||
| exports.dArea = dArea; | ||
| exports.dLine = dLine; | ||
| exports.dSpline = dSpline; | ||
| exports.xyScales = xyScales; | ||
| exports.pieAttributes = pieAttributes; | ||
| exports.coordinates = coordinates; | ||
| exports.barCoordinates = barCoordinates; | ||
| exports.findSeriesByName = findSeriesByName; | ||
| exports.dBar = dBar; | ||
| exports.pointAttributes = pointAttributes; | ||
| exports.seriesData = seriesData; | ||
| exports.checkZeroStart = checkZeroStart; | ||
| exports.createScale = createScale; | ||
| exports.getWidth = getWidth; | ||
| exports.HORIZONTAL = HORIZONTAL; | ||
| exports.VERTICAL = VERTICAL; | ||
| exports.TOP = TOP; | ||
| exports.BOTTOM = BOTTOM; | ||
| exports.LEFT = LEFT; | ||
| exports.RIGHT = RIGHT; | ||
| exports.MIDDLE = MIDDLE; | ||
| exports.END = END; | ||
| exports.START = START; | ||
| exports.BAND = BAND; | ||
| exports.processData = processData; | ||
| exports.seriesWithStacks = seriesWithStacks; | ||
| exports.stacks = stacks; | ||
| exports.palette = palette; | ||
| exports.axisName = axisName; | ||
| exports.prepareData = prepareData; | ||
| Object.defineProperty(exports, '__esModule', { value: true }); | ||
| }))); | ||
| //# sourceMappingURL=dx-chart-core.umd.js.map |
| { | ||
| "name": "@devexpress/dx-chart-core", | ||
| "version": "1.8.0-beta.1", | ||
| "version": "1.8.0", | ||
| "description": "Core library for the DevExtreme Reactive Chart component", | ||
@@ -49,11 +49,11 @@ "author": { | ||
| "core-js": "^2.5.7", | ||
| "eslint": "^5.4.0", | ||
| "eslint": "^5.6.1", | ||
| "eslint-config-airbnb-base": "^13.1.0", | ||
| "eslint-plugin-filenames": "^1.3.2", | ||
| "eslint-plugin-import": "^2.14.0", | ||
| "eslint-plugin-jest": "^21.22.0", | ||
| "jest": "^23.5.0", | ||
| "rollup": "0.50.0", | ||
| "eslint-plugin-jest": "^21.24.0", | ||
| "jest": "^23.6.0", | ||
| "rollup": "^0.66.2", | ||
| "rollup-plugin-babel": "^3.0.4", | ||
| "rollup-plugin-license": "^0.6.0" | ||
| "rollup-plugin-license": "^0.7.0" | ||
| }, | ||
@@ -65,3 +65,3 @@ "dependencies": { | ||
| }, | ||
| "gitHead": "8fb5dc5f32b4a02a8922917f07398b48902ecc5c" | ||
| "gitHead": "30dd98f003c170e60ce6eb79d48fe4e3ac99338d" | ||
| } |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
No v1
QualityPackage is not semver >=1. This means it is not stable and does not support ^ ranges.
Found 1 instance in 1 package
Improved metrics
- Number of low quality alerts
- decreased by-100%
0
Worsened metrics
- Total package byte prevSize
- decreased by-2.41%
112296
- Lines of code
- decreased by-15.3%
980
No dependency changes