*/
+function getIndexAxis(type, options) {
+ const typeDefaults = defaults[type] || {};
+ const datasetDefaults = typeDefaults.datasets || {};
+ const typeOptions = options[type] || {};
+ const datasetOptions = typeOptions.datasets || {};
+ return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x';
+}
+
+function getAxisFromDefaultScaleID(id, indexAxis) {
+ let axis = id;
+ if (id === '_index_') {
+ axis = indexAxis;
+ } else if (id === '_value_') {
+ axis = indexAxis === 'x' ? 'y' : 'x';
+ }
+ return axis;
+}
+
+function getDefaultScaleIDFromAxis(axis, indexAxis) {
+ return axis === indexAxis ? '_index_' : '_value_';
+}
+
function mergeScaleConfig(config, options) {
options = options || {};
const chartDefaults = defaults[config.type] || {scales: {}};
const configScales = options.scales || {};
+ const chartIndexAxis = getIndexAxis(config.type, options);
const firstIDs = {};
const scales = {};
// First figure out first scale id's per axis.
- // Note: for now, axis is determined from first letter of scale id!
Object.keys(configScales).forEach(id => {
- const axis = id[0];
+ const scaleConf = configScales[id];
+ const axis = determineAxis(id, scaleConf);
+ const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);
firstIDs[axis] = firstIDs[axis] || id;
- scales[id] = mergeIf({}, [configScales[id], chartDefaults.scales[axis]]);
+ scales[id] = mergeIf({axis}, [scaleConf, chartDefaults.scales[axis], chartDefaults.scales[defaultId]]);
});
// Backward compatibility
if (options.scale) {
- scales[options.scale.id || 'r'] = mergeIf({}, [options.scale, chartDefaults.scales.r]);
+ scales[options.scale.id || 'r'] = mergeIf({axis: 'r'}, [options.scale, chartDefaults.scales.r]);
firstIDs.r = firstIDs.r || options.scale.id || 'r';
}
// Then merge dataset defaults to scale configs
config.data.datasets.forEach(dataset => {
- const datasetDefaults = defaults[dataset.type || config.type] || {scales: {}};
+ const type = dataset.type || config.type;
+ const indexAxis = dataset.indexAxis || getIndexAxis(type, options);
+ const datasetDefaults = defaults[type] || {};
const defaultScaleOptions = datasetDefaults.scales || {};
Object.keys(defaultScaleOptions).forEach(defaultID => {
- const id = dataset[defaultID + 'AxisID'] || firstIDs[defaultID] || defaultID;
+ const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);
+ const id = dataset[axis + 'AxisID'] || firstIDs[axis] || axis;
scales[id] = scales[id] || {};
- mergeIf(scales[id], [
- configScales[id],
- defaultScaleOptions[defaultID]
- ]);
+ mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]);
});
});
return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x');
}
+function axisFromPosition(position) {
+ if (position === 'top' || position === 'bottom') {
+ return 'x';
+ }
+ if (position === 'left' || position === 'right') {
+ return 'y';
+ }
+}
+
+function determineAxis(id, scaleOptions) {
+ if (id === 'x' || id === 'y' || id === 'r') {
+ return id;
+ }
+ return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase();
+}
+
function compare2Level(l1, l2) {
return function(a, b) {
return a[l1] === b[l1]
if (scaleOpts) {
items = items.concat(
- Object.keys(scaleOpts).map((axisID) => {
- const axisOptions = scaleOpts[axisID];
- const isRadial = axisID.charAt(0).toLowerCase() === 'r';
- const isHorizontal = axisID.charAt(0).toLowerCase() === 'x';
+ Object.keys(scaleOpts).map((id) => {
+ const scaleOptions = scaleOpts[id];
+ const axis = determineAxis(id, scaleOptions);
+ const isRadial = axis === 'r';
+ const isHorizontal = axis === 'x';
return {
- options: axisOptions,
+ options: scaleOptions,
dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left',
dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear'
};
each(items, (item) => {
const scaleOptions = item.options;
const id = scaleOptions.id;
+ const axis = determineAxis(id, scaleOptions);
const scaleType = valueOrDefault(scaleOptions.type, item.dtype);
- if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, scaleOptions.axis || id[0]) !== positionIsHorizontal(item.dposition)) {
+ if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {
scaleOptions.position = item.dposition;
}
meta = me.getDatasetMeta(i);
}
meta.type = type;
+ meta.indexAxis = dataset.indexAxis || getIndexAxis(type, me.options);
meta.order = dataset.order || 0;
me._updateMetasetIndex(meta, i);
meta.label = '' + dataset.label;
it('should be registered as dataset controller', function() {
expect(typeof Chart.controllers.bar).toBe('function');
- expect(typeof Chart.controllers.horizontalBar).toBe('function');
});
it('should be constructed', function() {
});
it('should correctly count the number of stacks ignoring datasets of other types and hidden datasets', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], type: 'line'},
- {data: [], hidden: true},
- {data: []},
- {data: []}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackCount()).toBe(2);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], type: 'line'},
+ {data: [], hidden: true},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackCount()).toBe(2);
});
it('should correctly count the number of stacks when a group is not specified', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: []},
- {data: []},
- {data: []},
- {data: []}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackCount()).toBe(4);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: []},
+ {data: []},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackCount()).toBe(4);
});
it('should correctly count the number of stacks when a group is not specified and the scale is stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: []},
- {data: []},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: true
- },
- y: {
- stacked: true
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: []},
+ {data: []},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: true
+ },
+ y: {
+ stacked: true
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackCount()).toBe(1);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackCount()).toBe(1);
});
it('should correctly count the number of stacks when a group is not specified and the scale is not stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: []},
- {data: []},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: false
- },
- y: {
- stacked: false
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: []},
+ {data: []},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: false
+ },
+ y: {
+ stacked: false
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackCount()).toBe(4);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackCount()).toBe(4);
});
it('should correctly count the number of stacks when a group is specified for some', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: []},
- {data: []}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(3);
- expect(meta.controller._getStackCount()).toBe(3);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(3);
+ expect(meta.controller._getStackCount()).toBe(3);
});
it('should correctly count the number of stacks when a group is specified for some and the scale is stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: true
- },
- y: {
- stacked: true
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: true
+ },
+ y: {
+ stacked: true
}
}
- });
-
- var meta = chart.getDatasetMeta(3);
- expect(meta.controller._getStackCount()).toBe(2);
+ }
});
+
+ var meta = chart.getDatasetMeta(3);
+ expect(meta.controller._getStackCount()).toBe(2);
});
it('should correctly count the number of stacks when a group is specified for some and the scale is not stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: false
- },
- y: {
- stacked: false
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: false
+ },
+ y: {
+ stacked: false
}
}
- });
-
- var meta = chart.getDatasetMeta(3);
- expect(meta.controller._getStackCount()).toBe(4);
+ }
});
+
+ var meta = chart.getDatasetMeta(3);
+ expect(meta.controller._getStackCount()).toBe(4);
});
it('should correctly count the number of stacks when a group is specified for all', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack2'},
- {data: [], stack: 'stack2'}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(3);
- expect(meta.controller._getStackCount()).toBe(2);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack2'},
+ {data: [], stack: 'stack2'}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(3);
+ expect(meta.controller._getStackCount()).toBe(2);
});
it('should correctly count the number of stacks when a group is specified for all and the scale is stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack2'},
- {data: [], stack: 'stack2'}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: true
- },
- y: {
- stacked: true
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack2'},
+ {data: [], stack: 'stack2'}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: true
+ },
+ y: {
+ stacked: true
}
}
- });
-
- var meta = chart.getDatasetMeta(3);
- expect(meta.controller._getStackCount()).toBe(2);
+ }
});
+
+ var meta = chart.getDatasetMeta(3);
+ expect(meta.controller._getStackCount()).toBe(2);
});
it('should correctly count the number of stacks when a group is specified for all and the scale is not stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack2'},
- {data: [], stack: 'stack2'}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: false
- },
- y: {
- stacked: false
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack2'},
+ {data: [], stack: 'stack2'}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: false
+ },
+ y: {
+ stacked: false
}
}
- });
-
- var meta = chart.getDatasetMeta(3);
- expect(meta.controller._getStackCount()).toBe(4);
+ }
});
+
+ var meta = chart.getDatasetMeta(3);
+ expect(meta.controller._getStackCount()).toBe(4);
});
it('should correctly get the stack index accounting for datasets of other types and hidden datasets', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: []},
- {data: [], hidden: true},
- {data: [], type: 'line'},
- {data: []}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(3)).toBe(1);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: []},
+ {data: [], hidden: true},
+ {data: [], type: 'line'},
+ {data: []}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
it('should correctly get the stack index when a group is not specified', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: []},
- {data: []},
- {data: []},
- {data: []}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(1);
- expect(meta.controller._getStackIndex(2)).toBe(2);
- expect(meta.controller._getStackIndex(3)).toBe(3);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: []},
+ {data: []},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
it('should correctly get the stack index when a group is not specified and the scale is stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: []},
- {data: []},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: true
- },
- y: {
- stacked: true
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: []},
+ {data: []},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: true
+ },
+ y: {
+ stacked: true
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(0);
- expect(meta.controller._getStackIndex(2)).toBe(0);
- expect(meta.controller._getStackIndex(3)).toBe(0);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(0);
+ expect(meta.controller._getStackIndex(3)).toBe(0);
});
it('should correctly get the stack index when a group is not specified and the scale is not stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: []},
- {data: []},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: false
- },
- y: {
- stacked: false
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: []},
+ {data: []},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: false
+ },
+ y: {
+ stacked: false
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(1);
- expect(meta.controller._getStackIndex(2)).toBe(2);
- expect(meta.controller._getStackIndex(3)).toBe(3);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
it('should correctly get the stack index when a group is specified for some', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: []},
- {data: []}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(0);
- expect(meta.controller._getStackIndex(2)).toBe(1);
- expect(meta.controller._getStackIndex(3)).toBe(2);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(2);
});
it('should correctly get the stack index when a group is specified for some and the scale is stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: true
- },
- y: {
- stacked: true
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: true
+ },
+ y: {
+ stacked: true
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(0);
- expect(meta.controller._getStackIndex(2)).toBe(1);
- expect(meta.controller._getStackIndex(3)).toBe(1);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
it('should correctly get the stack index when a group is specified for some and the scale is not stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: []},
- {data: []}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: false
- },
- y: {
- stacked: false
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: []},
+ {data: []}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: false
+ },
+ y: {
+ stacked: false
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(1);
- expect(meta.controller._getStackIndex(2)).toBe(2);
- expect(meta.controller._getStackIndex(3)).toBe(3);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
it('should correctly get the stack index when a group is specified for all', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack2'},
- {data: [], stack: 'stack2'}
- ],
- labels: []
- }
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(0);
- expect(meta.controller._getStackIndex(2)).toBe(1);
- expect(meta.controller._getStackIndex(3)).toBe(1);
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack2'},
+ {data: [], stack: 'stack2'}
+ ],
+ labels: []
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
it('should correctly get the stack index when a group is specified for all and the scale is stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack2'},
- {data: [], stack: 'stack2'}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: true
- },
- y: {
- stacked: true
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack2'},
+ {data: [], stack: 'stack2'}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: true
+ },
+ y: {
+ stacked: true
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(0);
- expect(meta.controller._getStackIndex(2)).toBe(1);
- expect(meta.controller._getStackIndex(3)).toBe(1);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(0);
+ expect(meta.controller._getStackIndex(2)).toBe(1);
+ expect(meta.controller._getStackIndex(3)).toBe(1);
});
it('should correctly get the stack index when a group is specified for all and the scale is not stacked', function() {
- [
- 'bar',
- 'horizontalBar'
- ].forEach(function(barType) {
- var chart = window.acquireChart({
- type: barType,
- data: {
- datasets: [
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack1'},
- {data: [], stack: 'stack2'},
- {data: [], stack: 'stack2'}
- ],
- labels: []
- },
- options: {
- scales: {
- x: {
- stacked: false
- },
- y: {
- stacked: false
- }
+ var chart = window.acquireChart({
+ type: 'bar',
+ data: {
+ datasets: [
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack1'},
+ {data: [], stack: 'stack2'},
+ {data: [], stack: 'stack2'}
+ ],
+ labels: []
+ },
+ options: {
+ scales: {
+ x: {
+ stacked: false
+ },
+ y: {
+ stacked: false
}
}
- });
-
- var meta = chart.getDatasetMeta(1);
- expect(meta.controller._getStackIndex(0)).toBe(0);
- expect(meta.controller._getStackIndex(1)).toBe(1);
- expect(meta.controller._getStackIndex(2)).toBe(2);
- expect(meta.controller._getStackIndex(3)).toBe(3);
+ }
});
+
+ var meta = chart.getDatasetMeta(1);
+ expect(meta.controller._getStackIndex(0)).toBe(0);
+ expect(meta.controller._getStackIndex(1)).toBe(1);
+ expect(meta.controller._getStackIndex(2)).toBe(2);
+ expect(meta.controller._getStackIndex(3)).toBe(3);
});
it('should create rectangle elements for each data item during initialization', function() {
});
});
- describe('Bar height (horizontalBar type)', function() {
+ describe('Bar height (horizontal type)', function() {
beforeEach(function() {
// 2 datasets
this.data = {
it('should correctly set bar height when min and max option is set.', function() {
this.config = {
- type: 'horizontalBar',
+ type: 'bar',
data: this.data,
options: {
+ indexAxis: 'y',
scales: {
y: {
min: 'March',
it('should correctly set bar height when scale are stacked with min and max options.', function() {
this.config = {
- type: 'horizontalBar',
+ type: 'bar',
data: this.data,
options: {
+ indexAxis: 'y',
scales: {
x: {
stacked: true
expect(data[1].base + minBarLength).toEqual(data[1].y);
});
- it('minBarLength settings should be used on X axis on horizontalBar chart', function() {
+ it('minBarLength settings should be used on X axis on horizontal bar chart', function() {
var minBarLength = 4;
var chart = window.acquireChart({
- type: 'horizontalBar',
+ type: 'bar',
data: {
datasets: [{
+ indexAxis: 'y',
minBarLength: minBarLength,
data: [0.05, -0.05, 10, 15, 20, 25, 30, 35]
}]
projects / thirdparty / Chart.js.git / commitdiff
