@rfprodz/client-d3-charts 1.0.0

package/esm2020/lib/util/line-chart.util.mjs

@@ -0,0 +1,266 @@
+import * as d3 from 'd3';
+import { generateConfiguration } from './configuration.util';
+/**
+ * The line chart default configuration.
+ */
+export const defaultLineChartConfig = Object.freeze({
+    chartTitle: '',
+    width: 350,
+    height: 350,
+    margin: {
+        top: 70,
+        right: 50,
+        bottom: 50,
+        left: 50,
+    },
+    transitionDuration: 400,
+    dotRadius: 3.5,
+    xAxisTitle: '',
+    yAxisTitle: '',
+    ticks: {
+        x: 5,
+        y: 10,
+    },
+    displayAxisLabels: true,
+    labelTextWrapWidth: 20,
+    color: d3.scaleOrdinal(d3.schemeCategory10),
+});
+/**
+ * Creates a container for the line chart.
+ * @param container the chart container
+ * @param config the chart configuration
+ * @returns the object with the svg element and the g element
+ */
+const createContainer = (container, config) => {
+    const id = container.nativeElement.id ?? 'line-0';
+    d3.select(`#${id}`).select('svg').remove();
+    const svg = d3
+        .select(`#${id}`)
+        .append('svg')
+        .attr('width', config.width + config.margin.left + config.margin.right)
+        .attr('height', config.height + config.margin.top + config.margin.bottom)
+        .attr('class', id);
+    const g = svg.append('g').attr('transform', `translate(${config.margin.left},${config.margin.top / 2})`);
+    return { svg, g };
+};
+/**
+ * Wraps the line chart axis labels text.
+ * @param svgText the svg text elements
+ * @param width the chart axis label width
+ */
+const wrapSvgText = (svgText, width) => {
+    svgText.each(function () {
+        const text = d3.select(this);
+        const words = text.text().split(/\s+/).reverse();
+        let line = [];
+        let lineNumber = 0;
+        const lineHeight = 1.4;
+        const y = text.attr('y');
+        const x = text.attr('x');
+        const dy = parseFloat(text.attr('dy') ?? 0);
+        let tspan = text.text(null).append('tspan').attr('x', x).attr('y', y).attr('dy', `${dy}em`); // axis label
+        let word = words.pop();
+        while (typeof word !== 'undefined') {
+            line.push(word ?? '');
+            tspan.text(line.join(' '));
+            if ((tspan.node()?.getComputedTextLength() ?? 0) > width) {
+                line.pop();
+                tspan.text(line.join(' '));
+                line = [word ?? ''];
+                lineNumber += 1;
+                tspan = text
+                    .append('tspan')
+                    .attr('x', 0)
+                    .attr('y', y)
+                    .attr('dy', `${lineNumber * lineHeight + dy}em`)
+                    .text(word ?? '');
+            }
+            word = words.pop();
+        }
+    });
+};
+/**
+ * Creates the legend.
+ * @param g the svg g element
+ * @param config the chart configuration
+ */
+const createLegend = (g, config) => {
+    if (config.displayAxisLabels && config.xAxisTitle !== '') {
+        g.append('g')
+            .attr('transform', `translate(0, ${config.height + config.margin.bottom})`)
+            .append('text')
+            .style('font-size', '12px')
+            .attr('class', 'legend')
+            .attr('dx', '1.5em')
+            .attr('dy', '1em')
+            .text(`x - ${config.xAxisTitle}`);
+    }
+    if (config.displayAxisLabels && config.yAxisTitle !== '') {
+        g.append('g')
+            .attr('transform', `translate(0, ${config.height + config.margin.bottom})`)
+            .append('text')
+            .style('font-size', '12px')
+            .attr('class', 'legend')
+            .attr('dx', '1.5em')
+            .attr('dy', '2.5em')
+            .text(`y - ${config.yAxisTitle}`);
+    }
+    if (config.chartTitle !== '') {
+        g.append('g')
+            .attr('transform', `translate(0, 0)`)
+            .append('text')
+            .style('font-size', '12px')
+            .attr('class', 'legend')
+            .attr('dx', '1.5em')
+            .attr('dy', '-2em')
+            .text(config.chartTitle);
+    }
+};
+/**
+ * Creates the x axis.
+ * @param g the svg g element
+ * @param x the x axis scale
+ * @param config the chart configuration
+ */
+const createAxisX = (g, x, config) => {
+    const xLabels = g
+        .append('g')
+        .attr('transform', `translate(0, ${config.height})`)
+        .call(d3
+        .axisBottom(x)
+        .ticks(config.ticks.x)
+        .tickFormat(d => {
+        const date = new Date(d.valueOf());
+        const formattingOffset = 10;
+        const day = date.getDate();
+        const dd = day < formattingOffset ? `0${day}` : day;
+        const month = date.getMonth() + 1;
+        const mm = month < formattingOffset ? `0${month}` : month;
+        const year = date.getFullYear().toString();
+        const yy = year.slice(2);
+        const hours = date.getHours();
+        const hour = hours < formattingOffset ? `0${hours}` : hours;
+        const minutes = date.getMinutes();
+        const minute = minutes < formattingOffset ? `0${minutes}` : minutes;
+        return `${dd}/${mm}/${yy} ${hour}:${minute}`;
+    }))
+        .append('text');
+    g.selectAll('text').call(wrapSvgText, config.labelTextWrapWidth);
+    if (config.displayAxisLabels) {
+        xLabels.attr('transform', `translate(${config.width}, 0)`).attr('class', 'legend').attr('dx', '1.5em').attr('dy', '0.7em').text('x');
+    }
+};
+/**
+ * Creates the y axis.
+ * @param g the svg g element
+ * @param y the y axis scale
+ * @param config the chart configuration
+ */
+const createAxisY = (g, y, config) => {
+    const yLabels = g
+        .append('g')
+        .call(d3
+        .axisLeft(y)
+        .ticks(config.ticks.y)
+        .tickFormat(d => `${d}`))
+        .append('text');
+    if (config.displayAxisLabels) {
+        yLabels.attr('class', 'legend').attr('dy', '-1.5em').attr('class', 'legend').text('y');
+    }
+};
+/**
+ * The mouse over event handler.
+ * @param self an svg circle element
+ * @param d the chart data node
+ * @param g the svg g element
+ * @param config the chart configuration
+ */
+const onMouseOver = (self, d, g, config) => {
+    const duration = 400;
+    d3.select(self)
+        .transition()
+        .duration(duration)
+        .attr('r', config.dotRadius * 2);
+    const tooltipShift = 4;
+    const tooltipDy = -10;
+    g.append('text')
+        .attr('class', 'val')
+        .style('font-size', '11px')
+        .attr('dx', () => (config.width - config.margin.left - config.margin.right) / tooltipShift)
+        .attr('dy', () => tooltipDy)
+        .text(() => `${d.value} (${new Date(d.timestamp).toUTCString()})`);
+};
+/**
+ * The mouse out event handler.
+ * @param self an svg circle element
+ * @param config the chart configuration
+ */
+const onMouseOut = (self, config) => {
+    const duration = 400;
+    d3.select(self).attr('class', 'dot');
+    d3.select(self).transition().duration(duration).attr('r', config.dotRadius);
+    d3.selectAll('.val').remove();
+};
+/**
+ * Draws the chart lines, dots, and sets the mouse pointer events.
+ * @param g the svg g element
+ * @param x the x axis scale
+ * @param y the y axis scale
+ * @param config the chart configuration
+ * @param data the chart data
+ */
+const drawLinesDotsAndSetPointerEvents = (g, x, y, config, data) => {
+    const line = d3
+        .line()
+        .x(d => x(d.timestamp))
+        .y(d => y(d.value))
+        .curve(d3.curveMonotoneX);
+    g.append('path').attr('id', 'line').style('fill', 'none').style('stroke', 'red').style('stroke-width', '2px').attr('d', line(data));
+    g.selectAll('.dot')
+        .data(data)
+        .enter()
+        .append('circle')
+        .attr('class', 'dot')
+        .style('pointer-events', 'all')
+        .style('fill', (d, i) => config.color(i.toString()))
+        .on('mouseover', function (event, d) {
+        return onMouseOver(this, d, g, config);
+    })
+        .on('mouseout', function () {
+        return onMouseOut(this, config);
+    })
+        .attr('cx', function (d) {
+        return x(d.timestamp);
+    })
+        .attr('cy', function (d) {
+        return y(d.value);
+    })
+        .attr('r', 0)
+        .transition()
+        .ease(d3.easeLinear)
+        .duration(config.transitionDuration)
+        .delay((d, i) => {
+        const multiplier = 50;
+        return i * multiplier;
+    })
+        .attr('r', config.dotRadius);
+};
+/**
+ * Draws the line chart.
+ * @param container the chart container
+ * @param data the chart data
+ * @param options the chart options
+ * @returns the chart configuration
+ */
+export const drawLineChart = (container, data, options) => {
+    const config = generateConfiguration(defaultLineChartConfig, options, {});
+    const { g } = createContainer(container, config);
+    const x = d3.scaleTime([0, config.width]).domain([Math.min(...data.map(d => d.timestamp)), Math.max(...data.map(d => d.timestamp))]);
+    const y = d3.scaleLinear([config.height, 0]).domain([0, d3.max(data, d => d.value) ?? 1]);
+    createAxisX(g, x, config);
+    createAxisY(g, y, config);
+    createLegend(g, config);
+    drawLinesDotsAndSetPointerEvents(g, x, y, config, data);
+    return config;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line-chart.util.js","sourceRoot":"","sources":["../../../../../../libs/client-d3-charts/src/lib/util/line-chart.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef } from '@angular/core';\nimport * as d3 from 'd3';\n\nimport { ILineChartDataNode, ILineChartOptions, TLineChartData } from '../interfaces/line-chart.interface';\nimport { generateConfiguration } from './configuration.util';\n\n/**\n * The line chart default configuration.\n */\nexport const defaultLineChartConfig: ILineChartOptions = Object.freeze(<ILineChartOptions>{\n  chartTitle: '',\n  width: 350,\n  height: 350,\n  margin: {\n    top: 70,\n    right: 50,\n    bottom: 50,\n    left: 50,\n  },\n  transitionDuration: 400,\n  dotRadius: 3.5,\n  xAxisTitle: '',\n  yAxisTitle: '',\n  ticks: {\n    x: 5,\n    y: 10,\n  },\n  displayAxisLabels: true,\n  labelTextWrapWidth: 20, // the number of pixels after which a label needs to be given a new line\n  color: d3.scaleOrdinal(d3.schemeCategory10),\n});\n\n/**\n * Creates a container for the line chart.\n * @param container the chart container\n * @param config the chart configuration\n * @returns the object with the svg element and the g element\n */\nconst createContainer = (container: ElementRef<HTMLDivElement>, config: ILineChartOptions) => {\n  const id = container.nativeElement.id ?? 'line-0';\n\n  d3.select(`#${id}`).select('svg').remove();\n  const svg = d3\n    .select(`#${id}`)\n    .append('svg')\n    .attr('width', config.width + config.margin.left + config.margin.right)\n    .attr('height', config.height + config.margin.top + config.margin.bottom)\n    .attr('class', id);\n  const g = svg.append('g').attr('transform', `translate(${config.margin.left},${config.margin.top / 2})`);\n\n  return { svg, g };\n};\n\n/**\n * Wraps the line chart axis labels text.\n * @param svgText the svg text elements\n * @param width the chart axis label width\n */\nconst wrapSvgText = (svgText: d3.Selection<d3.BaseType, unknown, SVGGElement, unknown>, width: number) => {\n  svgText.each(function (this: d3.BaseType) {\n    const text = d3.select<d3.BaseType, string>(this);\n    const words = text.text().split(/\\s+/).reverse();\n    let line: string[] = [];\n    let lineNumber = 0;\n    const lineHeight = 1.4;\n    const y = text.attr('y');\n    const x = text.attr('x');\n    const dy = parseFloat(text.attr('dy') ?? 0);\n    let tspan = text.text(null).append('tspan').attr('x', x).attr('y', y).attr('dy', `${dy}em`); // axis label\n\n    let word = words.pop();\n\n    while (typeof word !== 'undefined') {\n      line.push(word ?? '');\n      tspan.text(line.join(' '));\n      if ((tspan.node()?.getComputedTextLength() ?? 0) > width) {\n        line.pop();\n        tspan.text(line.join(' '));\n        line = [word ?? ''];\n        lineNumber += 1;\n        tspan = text\n          .append('tspan')\n          .attr('x', 0)\n          .attr('y', y)\n          .attr('dy', `${lineNumber * lineHeight + dy}em`)\n          .text(word ?? '');\n      }\n      word = words.pop();\n    }\n  });\n};\n\n/**\n * Creates the legend.\n * @param g the svg g element\n * @param config the chart configuration\n */\nconst createLegend = (g: d3.Selection<SVGGElement, unknown, HTMLElement, unknown>, config: ILineChartOptions) => {\n  if (config.displayAxisLabels && config.xAxisTitle !== '') {\n    g.append('g')\n      .attr('transform', `translate(0, ${config.height + config.margin.bottom})`)\n      .append('text')\n      .style('font-size', '12px')\n      .attr('class', 'legend')\n      .attr('dx', '1.5em')\n      .attr('dy', '1em')\n      .text(`x - ${config.xAxisTitle}`);\n  }\n\n  if (config.displayAxisLabels && config.yAxisTitle !== '') {\n    g.append('g')\n      .attr('transform', `translate(0, ${config.height + config.margin.bottom})`)\n      .append('text')\n      .style('font-size', '12px')\n      .attr('class', 'legend')\n      .attr('dx', '1.5em')\n      .attr('dy', '2.5em')\n      .text(`y - ${config.yAxisTitle}`);\n  }\n\n  if (config.chartTitle !== '') {\n    g.append('g')\n      .attr('transform', `translate(0, 0)`)\n      .append('text')\n      .style('font-size', '12px')\n      .attr('class', 'legend')\n      .attr('dx', '1.5em')\n      .attr('dy', '-2em')\n      .text(config.chartTitle);\n  }\n};\n\n/**\n * Creates the x axis.\n * @param g the svg g element\n * @param x the x axis scale\n * @param config the chart configuration\n */\nconst createAxisX = (\n  g: d3.Selection<SVGGElement, unknown, HTMLElement, unknown>,\n  x: d3.ScaleTime<number, number>,\n  config: ILineChartOptions,\n) => {\n  const xLabels = g\n    .append('g')\n    .attr('transform', `translate(0, ${config.height})`)\n    .call(\n      d3\n        .axisBottom(x)\n        .ticks(config.ticks.x)\n        .tickFormat(d => {\n          const date = new Date(d.valueOf());\n          const formattingOffset = 10;\n          const day = date.getDate();\n          const dd = day < formattingOffset ? `0${day}` : day;\n          const month = date.getMonth() + 1;\n          const mm = month < formattingOffset ? `0${month}` : month;\n          const year = date.getFullYear().toString();\n          const yy = year.slice(2);\n          const hours = date.getHours();\n          const hour = hours < formattingOffset ? `0${hours}` : hours;\n          const minutes = date.getMinutes();\n          const minute = minutes < formattingOffset ? `0${minutes}` : minutes;\n          return `${dd}/${mm}/${yy} ${hour}:${minute}`;\n        }),\n    )\n    .append('text');\n\n  g.selectAll('text').call(wrapSvgText, config.labelTextWrapWidth);\n\n  if (config.displayAxisLabels) {\n    xLabels.attr('transform', `translate(${config.width}, 0)`).attr('class', 'legend').attr('dx', '1.5em').attr('dy', '0.7em').text('x');\n  }\n};\n\n/**\n * Creates the y axis.\n * @param g the svg g element\n * @param y the y axis scale\n * @param config the chart configuration\n */\nconst createAxisY = (\n  g: d3.Selection<SVGGElement, unknown, HTMLElement, unknown>,\n  y: d3.ScaleLinear<number, number>,\n  config: ILineChartOptions,\n) => {\n  const yLabels = g\n    .append('g')\n    .call(\n      d3\n        .axisLeft(y)\n        .ticks(config.ticks.y)\n        .tickFormat(d => `${d}`),\n    )\n    .append('text');\n\n  if (config.displayAxisLabels) {\n    yLabels.attr('class', 'legend').attr('dy', '-1.5em').attr('class', 'legend').text('y');\n  }\n};\n\n/**\n * The mouse over event handler.\n * @param self an svg circle element\n * @param d the chart data node\n * @param g the svg g element\n * @param config the chart configuration\n */\nconst onMouseOver = (\n  self: SVGCircleElement,\n  d: ILineChartDataNode,\n  g: d3.Selection<SVGGElement, unknown, HTMLElement, unknown>,\n  config: ILineChartOptions,\n) => {\n  const duration = 400;\n  d3.select(self)\n    .transition()\n    .duration(duration)\n    .attr('r', config.dotRadius * 2);\n\n  const tooltipShift = 4;\n  const tooltipDy = -10;\n  g.append('text')\n    .attr('class', 'val')\n    .style('font-size', '11px')\n    .attr('dx', () => (config.width - config.margin.left - config.margin.right) / tooltipShift)\n    .attr('dy', () => tooltipDy)\n    .text(() => `${d.value} (${new Date(d.timestamp).toUTCString()})`);\n};\n\n/**\n * The mouse out event handler.\n * @param self an svg circle element\n * @param config the chart configuration\n */\nconst onMouseOut = (self: SVGCircleElement, config: ILineChartOptions) => {\n  const duration = 400;\n  d3.select(self).attr('class', 'dot');\n  d3.select(self).transition().duration(duration).attr('r', config.dotRadius);\n\n  d3.selectAll('.val').remove();\n};\n\n/**\n * Draws the chart lines, dots, and sets the mouse pointer events.\n * @param g the svg g element\n * @param x the x axis scale\n * @param y the y axis scale\n * @param config the chart configuration\n * @param data the chart data\n */\nconst drawLinesDotsAndSetPointerEvents = (\n  g: d3.Selection<SVGGElement, unknown, HTMLElement, unknown>,\n  x: d3.ScaleTime<number, number>,\n  y: d3.ScaleLinear<number, number>,\n  config: ILineChartOptions,\n  data: TLineChartData,\n) => {\n  const line = d3\n    .line<ILineChartDataNode>()\n    .x(d => x(d.timestamp))\n    .y(d => y(d.value))\n    .curve(d3.curveMonotoneX);\n\n  g.append('path').attr('id', 'line').style('fill', 'none').style('stroke', 'red').style('stroke-width', '2px').attr('d', line(data));\n\n  g.selectAll('.dot')\n    .data(data)\n    .enter()\n    .append('circle')\n    .attr('class', 'dot')\n    .style('pointer-events', 'all')\n    .style('fill', (d, i) => config.color(i.toString()))\n    .on('mouseover', function (this, event, d) {\n      return onMouseOver(this, d, g, config);\n    })\n    .on('mouseout', function (this) {\n      return onMouseOut(this, config);\n    })\n    .attr('cx', function (this, d) {\n      return x(d.timestamp);\n    })\n    .attr('cy', function (this, d) {\n      return y(d.value);\n    })\n    .attr('r', 0)\n    .transition()\n    .ease(d3.easeLinear)\n    .duration(config.transitionDuration)\n    .delay((d, i) => {\n      const multiplier = 50;\n      return i * multiplier;\n    })\n    .attr('r', config.dotRadius);\n};\n\n/**\n * Draws the line chart.\n * @param container the chart container\n * @param data the chart data\n * @param options the chart options\n * @returns the chart configuration\n */\nexport const drawLineChart = (container: ElementRef<HTMLDivElement>, data: TLineChartData, options?: Partial<ILineChartOptions>) => {\n  const config: ILineChartOptions = generateConfiguration<ILineChartOptions>(defaultLineChartConfig, options, {});\n\n  const { g } = createContainer(container, config);\n\n  const x = d3.scaleTime([0, config.width]).domain([Math.min(...data.map(d => d.timestamp)), Math.max(...data.map(d => d.timestamp))]);\n  const y = d3.scaleLinear([config.height, 0]).domain([0, d3.max(data, d => d.value) ?? 1]);\n\n  createAxisX(g, x, config);\n\n  createAxisY(g, y, config);\n\n  createLegend(g, config);\n\n  drawLinesDotsAndSetPointerEvents(g, x, y, config, data);\n\n  return config;\n};\n"]}

package/esm2020/lib/util/pie-chart.util.mjs

@@ -0,0 +1,89 @@
+import * as d3 from 'd3';
+import { generateConfiguration } from './configuration.util';
+/**
+ * The pie chart default configuration.
+ */
+export const defaultPieChartConfig = Object.freeze({
+    chartTitle: '',
+    width: 600,
+    height: 600,
+    margin: {
+        top: 20,
+        right: 20,
+        bottom: 20,
+        left: 20,
+    },
+    innerRadius: 0,
+    labelRadiusModifier: 50,
+    labelTextWrapWidth: 60,
+    color: d3.scaleOrdinal(d3.schemeCategory10),
+});
+/**
+ * Creates a container for the pie chart.
+ * @param container the chart container
+ * @param config the chart configuration
+ * @returns the object with the svg element and the g element
+ */
+const createContainer = (container, config) => {
+    const id = container.nativeElement.id ?? 'pie-0';
+    d3.select(`#${id}`).select('svg').remove();
+    const svg = d3
+        .select(`#${id}`)
+        .append('svg')
+        .attr('width', config.width + config.margin.left + config.margin.right)
+        .attr('height', config.height + config.margin.top + config.margin.bottom)
+        .attr('class', id);
+    const g = svg
+        .append('g')
+        .attr('transform', `translate(${config.width / 2 + config.margin.left},${config.height / 2 + config.margin.top})`);
+    return { svg, g };
+};
+/**
+ * Draws the pie chart.
+ * @param container the chart container
+ * @param data the chart data
+ * @param options the chart options
+ * @returns the chart configuration
+ */
+export const drawPieChart = (container, data, options) => {
+    const config = generateConfiguration(defaultPieChartConfig, options, {});
+    const { g } = createContainer(container, config);
+    const pie = d3.pie().value(datum => datum.y);
+    const radius = Math.min(config.width, config.height) / 2;
+    const arc = d3.arc().innerRadius(config.innerRadius).outerRadius(radius);
+    const arcs = g
+        .selectAll('arc')
+        .data(pie(data))
+        .enter()
+        .append('g')
+        .attr('class', 'arc')
+        .on('mouseover', function (event, d) {
+        d3.select('#tooltip')
+            .style('left', `${event.pageX}px`)
+            .style('top', `${event.pageY}px`)
+            .style('opacity', 1)
+            .select('#value')
+            .text(d.value);
+    })
+        .on('mouseout', function (event, d) {
+        d3.select('#tooltip').style('opacity', 0);
+    });
+    const label = d3
+        .arc()
+        .innerRadius(radius)
+        .outerRadius(radius + config.labelRadiusModifier);
+    arcs
+        .append('path')
+        .attr('fill', (d, i) => config.color(i.toString()))
+        .attr('d', arc);
+    const textDy = 5;
+    arcs
+        .append('text')
+        .attr('class', 'legend')
+        .attr('text-anchor', 'middle')
+        .attr('dy', textDy)
+        .attr('transform', d => `translate(${label.centroid(d)})`)
+        .text(d => d.data.y);
+    return config;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pie-chart.util.js","sourceRoot":"","sources":["../../../../../../libs/client-d3-charts/src/lib/util/pie-chart.util.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef } from '@angular/core';\nimport * as d3 from 'd3';\n\nimport { IPieChartDataNode, IPieChartOptions } from '../interfaces/pie-chart.interface';\nimport { generateConfiguration } from './configuration.util';\n\n/**\n * The pie chart default configuration.\n */\nexport const defaultPieChartConfig: IPieChartOptions = Object.freeze({\n  chartTitle: '',\n  width: 600,\n  height: 600,\n  margin: {\n    top: 20,\n    right: 20,\n    bottom: 20,\n    left: 20,\n  },\n  innerRadius: 0, // increase inner radius to render a donut chart\n  labelRadiusModifier: 50,\n  labelTextWrapWidth: 60,\n  color: d3.scaleOrdinal(d3.schemeCategory10),\n});\n\n/**\n * Creates a container for the pie chart.\n * @param container the chart container\n * @param config the chart configuration\n * @returns the object with the svg element and the g element\n */\nconst createContainer = (container: ElementRef<HTMLDivElement>, config: IPieChartOptions) => {\n  const id = container.nativeElement.id ?? 'pie-0';\n\n  d3.select(`#${id}`).select('svg').remove();\n  const svg = d3\n    .select(`#${id}`)\n    .append('svg')\n    .attr('width', config.width + config.margin.left + config.margin.right)\n    .attr('height', config.height + config.margin.top + config.margin.bottom)\n    .attr('class', id);\n  const g = svg\n    .append('g')\n    .attr('transform', `translate(${config.width / 2 + config.margin.left},${config.height / 2 + config.margin.top})`);\n\n  return { svg, g };\n};\n\n/**\n * Draws the pie chart.\n * @param container the chart container\n * @param data the chart data\n * @param options the chart options\n * @returns the chart configuration\n */\nexport const drawPieChart = (container: ElementRef<HTMLDivElement>, data: IPieChartDataNode[], options?: Partial<IPieChartOptions>) => {\n  const config: IPieChartOptions = generateConfiguration<IPieChartOptions>(defaultPieChartConfig, options, {});\n\n  const { g } = createContainer(container, config);\n\n  const pie = d3.pie<IPieChartDataNode>().value(datum => datum.y);\n\n  const radius = Math.min(config.width, config.height) / 2;\n\n  const arc = d3.arc<d3.PieArcDatum<IPieChartDataNode>>().innerRadius(config.innerRadius).outerRadius(radius);\n\n  const arcs = g\n    .selectAll('arc')\n    .data(pie(data))\n    .enter()\n    .append('g')\n    .attr('class', 'arc')\n    .on('mouseover', function (this, event: MouseEvent, d) {\n      d3.select('#tooltip')\n        .style('left', `${event.pageX}px`)\n        .style('top', `${event.pageY}px`)\n        .style('opacity', 1)\n        .select('#value')\n        .text(d.value);\n    })\n    .on('mouseout', function (this, event, d) {\n      d3.select('#tooltip').style('opacity', 0);\n    });\n\n  const label = d3\n    .arc<d3.PieArcDatum<IPieChartDataNode>>()\n    .innerRadius(radius)\n    .outerRadius(radius + config.labelRadiusModifier);\n\n  arcs\n    .append('path')\n    .attr('fill', (d, i) => config.color(i.toString()))\n    .attr('d', arc);\n\n  const textDy = 5;\n  arcs\n    .append('text')\n    .attr('class', 'legend')\n    .attr('text-anchor', 'middle')\n    .attr('dy', textDy)\n    .attr('transform', d => `translate(${label.centroid(d)})`)\n    .text(d => d.data.y);\n\n  return config;\n};\n"]}