391 lines
11 KiB
Vue
391 lines
11 KiB
Vue
<script>
|
|
import * as d3 from 'd3';
|
|
import tooltip from '../directives/tooltip';
|
|
import Icon from './icon.vue';
|
|
import SvgGradient from './svg_gradient.vue';
|
|
import {
|
|
GRADIENT_COLORS,
|
|
GRADIENT_OPACITY,
|
|
INVERSE_GRADIENT_COLORS,
|
|
INVERSE_GRADIENT_OPACITY,
|
|
} from './bar_chart_constants';
|
|
|
|
/**
|
|
* Renders a bar chart that can be dragged(scrolled) when the number
|
|
* of elements to renders surpasses that of the available viewport space
|
|
* while keeping even padding and a width of 24px (customizable)
|
|
*
|
|
* It can render data with the following format:
|
|
* graphData: [{
|
|
* name: 'element' // x domain data
|
|
* value: 1 // y domain data
|
|
* }]
|
|
*
|
|
* Used in:
|
|
* - Contribution analytics - all of the rows describing pushes, merge requests and issues
|
|
*/
|
|
|
|
export default {
|
|
directives: {
|
|
tooltip,
|
|
},
|
|
components: {
|
|
Icon,
|
|
SvgGradient,
|
|
},
|
|
props: {
|
|
graphData: {
|
|
type: Array,
|
|
required: true,
|
|
},
|
|
barWidth: {
|
|
type: Number,
|
|
required: false,
|
|
default: 24,
|
|
},
|
|
yAxisLabel: {
|
|
type: String,
|
|
required: true,
|
|
},
|
|
},
|
|
data() {
|
|
return {
|
|
minX: -40,
|
|
minY: 0,
|
|
vbWidth: 0,
|
|
vbHeight: 0,
|
|
vpWidth: 0,
|
|
vpHeight: 350,
|
|
preserveAspectRatioType: 'xMidYMid meet',
|
|
containerMargin: {
|
|
leftRight: 30,
|
|
},
|
|
viewBoxMargin: {
|
|
topBottom: 150,
|
|
},
|
|
panX: 0,
|
|
xScale: {},
|
|
yScale: {},
|
|
zoom: {},
|
|
bars: {},
|
|
xGraphRange: 0,
|
|
isLoading: true,
|
|
paddingThreshold: 50,
|
|
showScrollIndicator: false,
|
|
showLeftScrollIndicator: false,
|
|
isGrabbed: false,
|
|
isPanAvailable: false,
|
|
gradientColors: GRADIENT_COLORS,
|
|
gradientOpacity: GRADIENT_OPACITY,
|
|
inverseGradientColors: INVERSE_GRADIENT_COLORS,
|
|
inverseGradientOpacity: INVERSE_GRADIENT_OPACITY,
|
|
maxTextWidth: 72,
|
|
rectYAxisLabelDims: {},
|
|
xAxisTextElements: {},
|
|
yAxisRectTransformPadding: 20,
|
|
yAxisTextTransformPadding: 10,
|
|
yAxisTextRotation: 90,
|
|
};
|
|
},
|
|
computed: {
|
|
svgViewBox() {
|
|
return `${this.minX} ${this.minY} ${this.vbWidth} ${this.vbHeight}`;
|
|
},
|
|
xAxisLocation() {
|
|
return `translate(${this.panX}, ${this.vbHeight})`;
|
|
},
|
|
barTranslationTransform() {
|
|
return `translate(${this.panX}, 0)`;
|
|
},
|
|
scrollIndicatorTransform() {
|
|
return `translate(${this.vbWidth - 80}, 0)`;
|
|
},
|
|
activateGrabCursor() {
|
|
return {
|
|
'svg-graph-container-with-grab': this.isPanAvailable,
|
|
'svg-graph-container-grabbed': this.isPanAvailable && this.isGrabbed,
|
|
};
|
|
},
|
|
yAxisLabelRectTransform() {
|
|
const rectWidth =
|
|
this.rectYAxisLabelDims.height != null ? this.rectYAxisLabelDims.height / 2 : 0;
|
|
const yCoord = this.vbHeight / 2 - rectWidth;
|
|
|
|
return `translate(${this.minX - this.yAxisRectTransformPadding}, ${yCoord})`;
|
|
},
|
|
yAxisLabelTextTransform() {
|
|
const rectWidth =
|
|
this.rectYAxisLabelDims.height != null ? this.rectYAxisLabelDims.height / 2 : 0;
|
|
const yCoord = this.vbHeight / 2 + rectWidth - 5;
|
|
|
|
return `translate(${this.minX + this.yAxisTextTransformPadding}, ${yCoord}) rotate(-${this.yAxisTextRotation})`;
|
|
},
|
|
},
|
|
mounted() {
|
|
if (!this.allValuesEmpty) {
|
|
this.draw();
|
|
}
|
|
},
|
|
methods: {
|
|
draw() {
|
|
// update viewport
|
|
this.vpWidth = this.$refs.svgContainer.clientWidth - this.containerMargin.leftRight;
|
|
// update viewbox
|
|
this.vbWidth = this.vpWidth;
|
|
this.vbHeight = this.vpHeight - this.viewBoxMargin.topBottom;
|
|
let padding = 0;
|
|
if (this.graphData.length * this.barWidth > this.vbWidth) {
|
|
this.xGraphRange = this.graphData.length * this.barWidth;
|
|
padding = this.calculatePadding(this.barWidth);
|
|
this.showScrollIndicator = true;
|
|
this.isPanAvailable = true;
|
|
} else {
|
|
this.xGraphRange = this.vbWidth - Math.abs(this.minX);
|
|
}
|
|
|
|
this.xScale = d3
|
|
.scaleBand()
|
|
.range([0, this.xGraphRange])
|
|
.round(true)
|
|
.paddingInner(padding);
|
|
this.yScale = d3.scaleLinear().rangeRound([this.vbHeight, 0]);
|
|
|
|
this.xScale.domain(this.graphData.map(d => d.name));
|
|
this.yScale.domain([0, d3.max(this.graphData.map(d => d.value))]);
|
|
|
|
// Zoom/Panning Function
|
|
this.zoom = d3
|
|
.zoom()
|
|
.translateExtent([[0, 0], [this.xGraphRange, this.vbHeight]])
|
|
.on('zoom', this.panGraph)
|
|
.on('end', this.removeGrabStyling);
|
|
|
|
const xAxis = d3.axisBottom().scale(this.xScale);
|
|
|
|
const yAxis = d3
|
|
.axisLeft()
|
|
.scale(this.yScale)
|
|
.ticks(4);
|
|
|
|
const renderedXAxis = d3
|
|
.select(this.$refs.baseSvg)
|
|
.select('.x-axis')
|
|
.call(xAxis);
|
|
|
|
this.xAxisTextElements = this.$refs.xAxis.querySelectorAll('text');
|
|
|
|
renderedXAxis.select('.domain').remove();
|
|
|
|
renderedXAxis
|
|
.selectAll('text')
|
|
.style('text-anchor', 'end')
|
|
.attr('dx', '-.3em')
|
|
.attr('dy', '-.95em')
|
|
.attr('class', 'tick-text')
|
|
.attr('transform', 'rotate(-90)');
|
|
|
|
renderedXAxis.selectAll('line').remove();
|
|
|
|
const { maxTextWidth } = this;
|
|
renderedXAxis.selectAll('text').each(function formatText() {
|
|
const axisText = d3.select(this);
|
|
let textLength = axisText.node().getComputedTextLength();
|
|
let textContent = axisText.text();
|
|
while (textLength > maxTextWidth && textContent.length > 0) {
|
|
textContent = textContent.slice(0, -1);
|
|
axisText.text(`${textContent}...`);
|
|
textLength = axisText.node().getComputedTextLength();
|
|
}
|
|
});
|
|
|
|
const width = this.vbWidth;
|
|
|
|
const renderedYAxis = d3
|
|
.select(this.$refs.baseSvg)
|
|
.select('.y-axis')
|
|
.call(yAxis);
|
|
|
|
renderedYAxis.selectAll('.tick').each(function createTickLines(d, i) {
|
|
if (i > 0) {
|
|
d3
|
|
.select(this)
|
|
.select('line')
|
|
.attr('x2', width)
|
|
.attr('class', 'axis-tick');
|
|
}
|
|
});
|
|
|
|
// Add the panning capabilities
|
|
if (this.isPanAvailable) {
|
|
d3
|
|
.select(this.$refs.baseSvg)
|
|
.call(this.zoom)
|
|
.on('wheel.zoom', null); // This disables the pan of the graph with the scroll of the mouse wheel
|
|
}
|
|
|
|
this.isLoading = false;
|
|
// Update the yAxisLabel coordinates
|
|
const labelDims = this.$refs.yAxisLabel.getBBox();
|
|
this.rectYAxisLabelDims = {
|
|
height: labelDims.width + 10,
|
|
};
|
|
},
|
|
panGraph() {
|
|
const allowedRightScroll = this.xGraphRange - this.vbWidth - this.paddingThreshold;
|
|
const graphMaxPan = Math.abs(d3.event.transform.x) < allowedRightScroll;
|
|
this.isGrabbed = true;
|
|
this.panX = d3.event.transform.x;
|
|
|
|
if (d3.event.transform.x === 0) {
|
|
this.showLeftScrollIndicator = false;
|
|
} else {
|
|
this.showLeftScrollIndicator = true;
|
|
this.showScrollIndicator = true;
|
|
}
|
|
|
|
if (!graphMaxPan) {
|
|
this.panX = -1 * (this.xGraphRange - this.vbWidth + this.paddingThreshold);
|
|
this.showScrollIndicator = false;
|
|
}
|
|
},
|
|
setTooltipTitle(data) {
|
|
return data !== null ? `${data.name}: ${data.value}` : '';
|
|
},
|
|
calculatePadding(desiredBarWidth) {
|
|
const widthWithMargin = this.vbWidth - Math.abs(this.minX);
|
|
const dividend = widthWithMargin - this.graphData.length * desiredBarWidth;
|
|
const divisor = widthWithMargin - desiredBarWidth;
|
|
|
|
return dividend / divisor;
|
|
},
|
|
removeGrabStyling() {
|
|
this.isGrabbed = false;
|
|
},
|
|
barHoveredIn(index) {
|
|
this.xAxisTextElements[index].classList.add('x-axis-text');
|
|
},
|
|
barHoveredOut(index) {
|
|
this.xAxisTextElements[index].classList.remove('x-axis-text');
|
|
},
|
|
},
|
|
};
|
|
</script>
|
|
<template>
|
|
<div
|
|
ref="svgContainer"
|
|
:class="activateGrabCursor"
|
|
class="svg-graph-container"
|
|
>
|
|
<svg
|
|
ref="baseSvg"
|
|
:width="vpWidth"
|
|
:height="vpHeight"
|
|
:viewBox="svgViewBox"
|
|
:preserveAspectRatio="preserveAspectRatioType">
|
|
<g
|
|
ref="xAxis"
|
|
:transform="xAxisLocation"
|
|
class="x-axis"
|
|
/>
|
|
<g v-if="!isLoading">
|
|
<template
|
|
v-for="(data, index) in graphData">
|
|
<rect
|
|
v-tooltip
|
|
:key="index"
|
|
:width="xScale.bandwidth()"
|
|
:x="xScale(data.name)"
|
|
:y="yScale(data.value)"
|
|
:height="vbHeight - yScale(data.value)"
|
|
:transform="barTranslationTransform"
|
|
:title="setTooltipTitle(data)"
|
|
class="bar-rect"
|
|
data-placement="top"
|
|
@mouseover="barHoveredIn(index)"
|
|
@mouseout="barHoveredOut(index)"
|
|
/>
|
|
</template>
|
|
</g>
|
|
<rect
|
|
:height="vbHeight + 100"
|
|
transform="translate(-100, -5)"
|
|
width="100"
|
|
fill="#fff"
|
|
/>
|
|
<g class="y-axis-label">
|
|
<line
|
|
:x1="0"
|
|
:x2="0"
|
|
:y1="0"
|
|
:y2="vbHeight"
|
|
transform="translate(-35, 0)"
|
|
stroke="black"
|
|
/>
|
|
<!--Get text length and change the height of this rect accordingly-->
|
|
<rect
|
|
:height="rectYAxisLabelDims.height"
|
|
:transform="yAxisLabelRectTransform"
|
|
:width="30"
|
|
fill="#fff"
|
|
/>
|
|
<text
|
|
ref="yAxisLabel"
|
|
:transform="yAxisLabelTextTransform"
|
|
>
|
|
{{ yAxisLabel }}
|
|
</text>
|
|
</g>
|
|
<g
|
|
class="y-axis"
|
|
/>
|
|
<g v-if="showScrollIndicator">
|
|
<rect
|
|
:height="vbHeight + 100"
|
|
:transform="`translate(${vpWidth - 60}, -5)`"
|
|
width="40"
|
|
fill="#fff"
|
|
/>
|
|
<icon
|
|
:x="vpWidth - 50"
|
|
:y="vbHeight / 2"
|
|
:width="14"
|
|
:height="14"
|
|
name="chevron-right"
|
|
class="animate-flicker"
|
|
/>
|
|
</g>
|
|
<!--The line that shows up when the data elements surpass the available width -->
|
|
<g
|
|
v-if="showScrollIndicator"
|
|
:transform="scrollIndicatorTransform">
|
|
<rect
|
|
:height="vbHeight"
|
|
x="0"
|
|
y="0"
|
|
width="20"
|
|
fill="url(#shadow-gradient)"
|
|
/>
|
|
</g>
|
|
<!--Left scroll indicator-->
|
|
<g
|
|
v-if="showLeftScrollIndicator"
|
|
transform="translate(0, 0)">
|
|
<rect
|
|
:height="vbHeight"
|
|
x="0"
|
|
y="0"
|
|
width="20"
|
|
fill="url(#left-shadow-gradient)"
|
|
/>
|
|
</g>
|
|
<svg-gradient
|
|
:colors="gradientColors"
|
|
:opacity="gradientOpacity"
|
|
identifier-name="shadow-gradient"/>
|
|
<svg-gradient
|
|
:colors="inverseGradientColors"
|
|
:opacity="inverseGradientOpacity"
|
|
identifier-name="left-shadow-gradient"/>
|
|
</svg>
|
|
</div>
|
|
</template>
|