@net7/components 3.0.2-rc.2

package/esm2020/lib/components/histogram-range/histogram-range.mjs

@@ -0,0 +1,376 @@
+/* eslint-disable no-use-before-define */
+//---------------------------
+// HISTOGRAM-RANGE.ts
+//---------------------------
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class HistogramRangeComponent {
+    constructor() {
+        this.sliders = [];
+        this._loaded = false;
+        this.draw = () => {
+            const { d3 } = this;
+            const { width, margin, height, items, colours, containerId, axis, setSliders } = this.data;
+            // data validation
+            const rangeMode = items.every((d) => d.range);
+            if (!rangeMode && items.some((d) => !d.range)) {
+                throw Error('All items must have the "range" property');
+            }
+            // Helpers - Start:
+            const LABELtoX = d3
+                .scaleBand()
+                .domain(items.map((d) => d.label))
+                .range([0, width])
+                .paddingInner(0.17)
+                .paddingOuter(1);
+            const XtoLABEL = (value) => {
+                const domain = LABELtoX.domain();
+                const paddingOuter = LABELtoX(domain[0]);
+                const eachBand = LABELtoX.step();
+                const index = Math.floor(((value - paddingOuter) / eachBand));
+                return domain[Math.max(0, Math.min(index, domain.length - 1))];
+            };
+            // YEAR SELECTION CIRCLES
+            // let sliders;
+            if (setSliders && this.sliders) {
+                this.sliders = setSliders
+                    .map((d) => ({ x: LABELtoX(d) + LABELtoX.bandwidth() / 2, y: height }));
+            }
+            else {
+                this.sliders = d3
+                    .extent(items, (d) => d.label)
+                    .map((d) => ({ x: LABELtoX(d) + LABELtoX.bandwidth() / 2, y: height }));
+            }
+            const isInRange = (y) => {
+                const allItems = this.sliders.map((d) => XtoLABEL(d.x));
+                if (y >= d3.min(allItems) && y <= d3.max(allItems))
+                    return true;
+                return false;
+            };
+            function colourBars(d) {
+                if (isInRange(d.label))
+                    return 'url(#gradient)';
+                return '#e3e3e3';
+            }
+            this.colourBars = colourBars;
+            this.getSelectedRange = () => {
+                const rangeStart = items.find((it) => it.label === XtoLABEL(this.sliders[0].x));
+                const rangeEnd = items.find((it) => it.label === XtoLABEL(this.sliders[1].x));
+                return [
+                    rangeStart.payload,
+                    rangeMode
+                        ? rangeEnd.range.payload
+                        : rangeEnd.payload
+                ];
+            };
+            // Helpers - End.
+            // clear HTML contents
+            document.getElementById(containerId).innerHTML = '';
+            const svg = d3
+                .select(`#${containerId}`)
+                .attr('viewBox', `0 0 ${width + margin.left + margin.right} ${height + margin.top + margin.bottom}`);
+            const scaleHeight = d3
+                .scaleSymlog() // most similar scale to the original
+                .domain([0, d3.max(items, (d) => d.value)])
+                .range([height, 0]);
+            // GRADIENT
+            const defs = svg.append('defs'); // definitions
+            const gradient = defs
+                .append('linearGradient')
+                .attr('id', 'gradient')
+                .attr('gradientUnits', 'userSpaceOnUse')
+                .attr('x1', 0)
+                .attr('y1', height)
+                .attr('x2', 0)
+                .attr('y2', margin.top);
+            gradient
+                .append('stop')
+                .attr('class', 'start')
+                .attr('offset', '0%')
+                .attr('stop-color', colours.bottom) // bottom gradient
+                .attr('stop-opacity', 1);
+            gradient
+                .append('stop')
+                .attr('class', 'end')
+                .attr('offset', '100%')
+                .attr('stop-color', colours.top) // top gradient
+                .attr('stop-opacity', 1);
+            // DRAW INSIDE MARGINS
+            const g = svg
+                .append('g')
+                .attr('class', 'chart')
+                .attr('transform', `translate(${margin.left},${margin.top})`);
+            const barsLayer = g.append('g').attr('class', 'bars');
+            const controlsLayer = g.append('g').attr('class', 'controls');
+            // BAR CHART
+            barsLayer // bars
+                .selectAll('rect.bars')
+                .data(items)
+                .join('rect')
+                .attr('class', 'bars')
+                .attr('width', LABELtoX.bandwidth)
+                .attr('height', (d) => height - scaleHeight(d.value))
+                .attr('y', (d) => scaleHeight(d.value))
+                .attr('x', (d) => LABELtoX(d.label))
+                .attr('data-start', (d) => d.payload) // make the data easily accessible
+                .attr('data-end', (d) => (d.range ? d.range.payload : d.payload))
+                .attr('fill', 'url(#gradient)');
+            barsLayer // catch bar events
+                .on('mousemove', (event) => {
+                const year = XtoLABEL(event.offsetX - margin.left);
+                d3.selectAll('rect.bars').attr('fill', (d) => {
+                    if (year === d.label)
+                        return '#B0CCF8';
+                    return colourBars(d);
+                });
+            })
+                .on('mouseout', () => {
+                d3.selectAll('rect.bars').attr('fill', (d) => colourBars(d));
+            })
+                .on('click', (event) => {
+                const label = XtoLABEL(event.offsetX - margin.left);
+                const xAxisValue = LABELtoX(label) + LABELtoX.bandwidth() / 2;
+                const newValue = {
+                    x: xAxisValue,
+                    y: height
+                };
+                this.sliders = [
+                    // avoid joining the two objects!
+                    { ...newValue },
+                    { ...newValue }
+                ];
+                rangePicker
+                    .data(this.sliders)
+                    .select('circle')
+                    .transition()
+                    .ease(d3.easeQuadOut)
+                    .duration(550)
+                    .attr('cx', (d) => d.x);
+                controlsLayer
+                    .select('path.blueline')
+                    .transition()
+                    .ease(d3.easeQuadOut)
+                    .duration(550)
+                    .attr('d', d3.line()(this.sliders.map((d) => [d.x, d.y])));
+                controlsLayer
+                    .selectAll('text')
+                    .transition()
+                    .ease(d3.easeQuadOut)
+                    .duration(550)
+                    .attr('x', () => xAxisValue)
+                    .text((d, i) => {
+                    if (!rangeMode)
+                        return label;
+                    const item = items.find((it) => it.label === label);
+                    if (i > 0)
+                        return item.range.label;
+                    return item.label;
+                });
+                g.selectAll('rect.bars').attr('fill', (d) => colourBars(d));
+                this.textCollision(this.sliders);
+                this.emit('rangeselected', this.getSelectedRange());
+            });
+            controlsLayer // gray line
+                .append('path')
+                .attr('class', 'grayline')
+                .attr('d', d3.line()([
+                [0, height],
+                [width, height]
+            ]))
+                .attr('stroke-width', 2)
+                .attr('opacity', 1)
+                .attr('stroke', '#C1C5C7');
+            controlsLayer // blue line
+                .append('path')
+                .attr('class', 'blueline')
+                .attr('d', d3.line()(this.sliders.map((d) => [d.x, d.y])))
+                .attr('stroke-width', 2)
+                .attr('stroke', colours.accent);
+            const rangePicker = controlsLayer
+                .selectAll('g.rangepicker')
+                .data(this.sliders.sort((a, b) => d3.ascending(a.x, b.x)))
+                .join('g')
+                .attr('class', 'rangepicker');
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this; // FIXME: Allow use of class "this" inside dragging update;
+            /**
+             * Animate the elements while the user is dragging one of the range selectors
+             */
+            function draggingUpdate(event, data) {
+                const label = XtoLABEL(event.x);
+                const xAxisValue = LABELtoX(label) + LABELtoX.bandwidth() / 2;
+                const yb = [];
+                g.selectAll('circle').each(function setBallPosition() {
+                    yb.push({ x: +d3.select(this).attr('cx'), y: height });
+                });
+                self.sliders = yb.sort((a, b) => d3.ascending(a.x, b.x));
+                // move the circle
+                d3.select(this)
+                    .select('circle')
+                    .attr('cx', data.x = xAxisValue);
+                // move the blue line
+                controlsLayer
+                    .select('path.blueline')
+                    .attr('d', d3.line()(self.sliders.map((d) => [d.x, d.y])));
+                // change the text position
+                d3.select(this)
+                    .select('text')
+                    .attr('x', () => xAxisValue);
+                // change the text values
+                controlsLayer
+                    .selectAll('text')
+                    .text((d) => {
+                    const l = XtoLABEL(d.x);
+                    if (!rangeMode)
+                        return l;
+                    const position = self.sliders.findIndex((slider) => slider.x === d.x);
+                    const range = self.getSelectedRange();
+                    if (position === 1)
+                        return range[1];
+                    return range[0];
+                });
+                self.textCollision(self.sliders);
+                // colour the bars
+                g.selectAll('rect.bars').attr('fill', (d) => colourBars(d));
+            }
+            rangePicker // drag handler
+                .call(d3.drag()
+                .on('drag', draggingUpdate)
+                .on('end', (event, data) => {
+                // update one last time to prevent desyncing
+                draggingUpdate(event, data);
+                // emit the selected range
+                this.emit('rangeselected', this.getSelectedRange());
+            }));
+            rangePicker
+                .append('circle')
+                .attr('cx', (d) => d.x)
+                .attr('cy', (d) => d.y)
+                .attr('r', 9)
+                .attr('fill', 'white')
+                .attr('stroke-width', 2)
+                .attr('stroke', colours.accent)
+                .attr('style', 'cursor: pointer');
+            rangePicker
+                .attr('text-anchor', 'middle')
+                .attr('font-family', 'Roboto, Arial, sans-serif')
+                .attr('font-size', '12px')
+                .append('text')
+                .attr('y', (d) => d.y + margin.bottom / 2)
+                .attr('x', (d) => d.x)
+                .attr('fill', colours.accent)
+                .text((d, i) => {
+                const l = XtoLABEL(d.x);
+                if (rangeMode && i === 1) {
+                    return items.find((item) => item.label === l).range.label;
+                }
+                return l;
+            });
+            if (axis?.yAxis?.show) {
+                const yAxis = d3.axisLeft(scaleHeight)
+                    .ticks(axis.yAxis.tickAmount ?? 2)
+                    .tickValues(axis.yAxis.values ? axis.yAxis.values : null);
+                const yAxisGroup = svg.append('g')
+                    .attr('transform', `translate(${margin.left}, ${margin.top})`)
+                    .call(yAxis);
+                yAxisGroup.selectAll('path, line').style('stroke', colours.accent);
+                yAxisGroup.selectAll('text').style('fill', colours.accent);
+            }
+        };
+        /** Avoid collision of the slider labels */
+        this.textCollision = (sliders) => {
+            // pre-requisites
+            const controlsLayer = this.d3.select('g.chart').select('g.controls');
+            const { items, margin } = this.data;
+            const rangeMode = items.every((d) => d.range);
+            // run collision detection
+            const isColliding = sliders[0].x === sliders[1].x;
+            if (rangeMode && isColliding) {
+                controlsLayer
+                    .selectAll('text')
+                    .attr('y', (d, i) => (i > 0 ? d.y + margin.bottom / 2 + 12 : d.y + margin.bottom / 2))
+                    .text((d, i) => {
+                    const range = this.getSelectedRange();
+                    return range[i];
+                });
+            }
+            else {
+                controlsLayer
+                    .selectAll('text')
+                    .attr('y', (d) => d.y + margin.bottom / 2);
+            }
+        };
+        /** Public api that allows to dinamically change the bars */
+        this.setBars = (newBars) => {
+            this.data.items = newBars;
+            this.draw();
+            this.d3.selectAll('rect.bars').attr('fill', (d) => this.colourBars(d));
+        };
+        /** Public api that allows to dinamically change the slider position */
+        this.setSliders = ([startLabel, endLabel]) => {
+            this.data.setSliders = [`${startLabel}`, `${endLabel}`];
+            this.draw();
+            this.d3.selectAll('rect.bars').attr('fill', (d) => this.colourBars(d));
+            const range = this.getSelectedRange();
+            this.emit('rangeselected', range);
+            this.textCollision(this.sliders);
+            return range;
+        };
+    }
+    ngAfterContentChecked() {
+        /*
+         Waits for the dom to be loaded, then fires the draw function
+         that renders the chart.
+        */
+        if (this.data) {
+            if (this._loaded)
+                return;
+            this._loaded = true;
+            setTimeout(() => {
+                import('d3').then((module) => {
+                    this.d3 = module;
+                    this.draw();
+                    this.emitLoaded(true);
+                    if (this.data && this.data.setDraw) {
+                        this.data.setDraw(this.draw);
+                    }
+                    if (this.data.setApi) { // expose the component api
+                        this.data.setApi({
+                            setSliders: this.setSliders,
+                            setBars: this.setBars,
+                        });
+                    }
+                    // eslint-disable-next-line dot-notation
+                    window['setSliders'] = this.setSliders;
+                });
+            });
+        }
+    }
+    /** Get x-axis position from label */
+    labelToX() {
+        return this.d3
+            .scaleBand()
+            .domain(this.data.items.map((d) => d.label))
+            .range([0, this.data.width])
+            .paddingInner(0.17)
+            .paddingOuter(1);
+    }
+    /** Emits an event when the component has loaded */
+    emitLoaded(payload) {
+        if (!this.emit)
+            return;
+        this.emit('loaded', payload);
+    }
+}
+HistogramRangeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: HistogramRangeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+HistogramRangeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: HistogramRangeComponent, selector: "n7-histogram-range", inputs: { data: "data", emit: "emit" }, ngImport: i0, template: "<div *ngIf=\"data\" class=\"n7-histogram-range\">\n    <svg #histogramRange [id]=\"data.containerId\"></svg>\n</div>\n", directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: HistogramRangeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'n7-histogram-range', template: "<div *ngIf=\"data\" class=\"n7-histogram-range\">\n    <svg #histogramRange [id]=\"data.containerId\"></svg>\n</div>\n" }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], emit: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"histogram-range.js","sourceRoot":"","sources":["../../../../../../projects/dv-components-lib/src/lib/components/histogram-range/histogram-range.ts","../../../../../../projects/dv-components-lib/src/lib/components/histogram-range/histogram-range.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-use-before-define */\n//---------------------------\n// HISTOGRAM-RANGE.ts\n//---------------------------\n\nimport { AfterContentChecked, Component, Input } from '@angular/core';\n/**\n * Interface for HistogramRangeComponent's \"data\"\n */\nexport interface HistogramRangeData {\n    /**\n     * unique identifier for the histogram-range svg\n     */\n    containerId: string;\n    /**\n     * total width for the svg element\n     */\n    width: number;\n    /**\n     * total height for the svg element\n     */\n    height: number;\n    /**\n     * Internal margins of the svg\n     */\n    margin: {\n        left: number;\n        right: number;\n        top: number;\n        bottom: number;\n    };\n    /**\n     * Theme of the histogram\n     */\n    colours: {\n        top: string;\n        bottom: string;\n        accent: string;\n    };\n    /**\n     * Data for the histogram bars\n     */\n    items: {\n        /** default label of the item */\n        label: string;\n        /** y-axis value of the bar (height) */\n        value: number;\n        /** payload that the item should emit when selected */\n        payload: any;\n        /**\n         * 'upper' values of the range.\n         * only used when each bar represents a range.\n         */\n        range?: {\n            /** label loaded when selected by the right-most pointer */\n            label: string;\n            /** payload emitted when selected by the right-most pointer */\n            payload: any;\n        };\n    }[];\n    /**\n     * Axis settings\n     */\n    axis?: {\n        /** Y Axis settings */\n        yAxis?: {\n            /** Turn on and off the axis */\n            show?: boolean;\n            /** Manually set the axis values to show */\n            values?: number[];\n            /** How many ticks do you want to see */\n            tickAmount?: number;\n        };\n    };\n    /**\n     * expose the draw function outside of n7-frontend/components library\n     * this is needed to redraw bubble-chart-component on command\n     */\n    setDraw?: any;\n    /**\n     * setSliders\n     */\n    setSliders?: LabelCouple;\n    /**\n     * Public api\n     */\n    setApi?: any;\n}\n\ntype Sliders = { x: number; y: number }[];\ntype LabelCouple = [string, string];\n\n@Component({\n    selector: 'n7-histogram-range',\n    templateUrl: './histogram-range.html'\n})\nexport class HistogramRangeComponent implements AfterContentChecked {\n    @Input() data: HistogramRangeData;\n\n    @Input() emit: any;\n\n    private d3;\n\n    private sliders: Sliders = [];\n\n    private _loaded = false;\n\n    private colourBars;\n\n    private getSelectedRange;\n\n    ngAfterContentChecked() {\n        /*\n         Waits for the dom to be loaded, then fires the draw function\n         that renders the chart.\n        */\n        if (this.data) {\n            if (this._loaded) return;\n            this._loaded = true;\n            setTimeout(() => {\n                import('d3').then((module) => {\n                    this.d3 = module;\n                    this.draw();\n                    this.emitLoaded(true);\n                    if (this.data && this.data.setDraw) {\n                        this.data.setDraw(this.draw);\n                    }\n                    if (this.data.setApi) { // expose the component api\n                        this.data.setApi({\n                            setSliders: this.setSliders,\n                            setBars: this.setBars,\n                        });\n                    }\n                    // eslint-disable-next-line dot-notation\n                    window['setSliders'] = this.setSliders;\n                });\n            });\n        }\n    }\n\n    draw = () => {\n        const { d3 } = this;\n        const {\n            width, margin, height,\n            items, colours, containerId,\n            axis, setSliders\n        } = this.data;\n\n        // data validation\n        const rangeMode = items.every((d) => d.range);\n        if (!rangeMode && items.some((d) => !d.range)) {\n            throw Error('All items must have the \"range\" property');\n        }\n\n        // Helpers - Start:\n        const LABELtoX = d3\n            .scaleBand()\n            .domain(items.map((d) => d.label))\n            .range([0, width])\n            .paddingInner(0.17)\n            .paddingOuter(1);\n\n        const XtoLABEL = (value) => {\n            const domain = LABELtoX.domain();\n            const paddingOuter = LABELtoX(domain[0]);\n            const eachBand = LABELtoX.step();\n            const index = Math.floor(((value - paddingOuter) / eachBand));\n            return domain[Math.max(0, Math.min(index, domain.length - 1))];\n        };\n\n        // YEAR SELECTION CIRCLES\n        // let sliders;\n        if (setSliders && this.sliders) {\n            this.sliders = setSliders\n                .map((d) => ({ x: LABELtoX(d) + LABELtoX.bandwidth() / 2, y: height }));\n        } else {\n            this.sliders = d3\n                .extent(items, (d) => d.label)\n                .map((d) => ({ x: LABELtoX(d) + LABELtoX.bandwidth() / 2, y: height }));\n        }\n\n        const isInRange = (y) => {\n            const allItems = this.sliders.map((d) => XtoLABEL(d.x));\n            if (y >= d3.min(allItems) && y <= d3.max(allItems)) return true;\n            return false;\n        };\n\n        function colourBars(d) {\n            if (isInRange(d.label)) return 'url(#gradient)';\n            return '#e3e3e3';\n        }\n        this.colourBars = colourBars;\n\n        this.getSelectedRange = () => {\n            const rangeStart = items.find((it) => it.label === XtoLABEL(this.sliders[0].x));\n            const rangeEnd = items.find((it) => it.label === XtoLABEL(this.sliders[1].x));\n            return [\n                rangeStart.payload,\n                rangeMode\n                    ? rangeEnd.range.payload\n                    : rangeEnd.payload\n            ];\n        };\n        // Helpers - End.\n\n        // clear HTML contents\n        document.getElementById(containerId).innerHTML = '';\n        const svg = d3\n            .select(`#${containerId}`)\n            .attr('viewBox', `0 0 ${width + margin.left + margin.right} ${height + margin.top + margin.bottom}`);\n\n        const scaleHeight = d3\n            .scaleSymlog() // most similar scale to the original\n            .domain([0, d3.max(items, (d) => d.value)])\n            .range([height, 0]);\n\n        // GRADIENT\n        const defs = svg.append('defs'); // definitions\n        const gradient = defs\n            .append('linearGradient')\n            .attr('id', 'gradient')\n            .attr('gradientUnits', 'userSpaceOnUse')\n            .attr('x1', 0)\n            .attr('y1', height)\n            .attr('x2', 0)\n            .attr('y2', margin.top);\n        gradient\n            .append('stop')\n            .attr('class', 'start')\n            .attr('offset', '0%')\n            .attr('stop-color', colours.bottom) // bottom gradient\n            .attr('stop-opacity', 1);\n        gradient\n            .append('stop')\n            .attr('class', 'end')\n            .attr('offset', '100%')\n            .attr('stop-color', colours.top) // top gradient\n            .attr('stop-opacity', 1);\n\n        // DRAW INSIDE MARGINS\n        const g = svg\n            .append('g')\n            .attr('class', 'chart')\n            .attr('transform', `translate(${margin.left},${margin.top})`);\n\n        const barsLayer = g.append('g').attr('class', 'bars');\n        const controlsLayer = g.append('g').attr('class', 'controls');\n\n        // BAR CHART\n        barsLayer // bars\n            .selectAll('rect.bars')\n            .data(items)\n            .join('rect')\n            .attr('class', 'bars')\n            .attr('width', LABELtoX.bandwidth)\n            .attr('height', (d) => height - scaleHeight(d.value))\n            .attr('y', (d) => scaleHeight(d.value))\n            .attr('x', (d) => LABELtoX(d.label))\n            .attr('data-start', (d) => d.payload) // make the data easily accessible\n            .attr('data-end', (d) => (d.range ? d.range.payload : d.payload))\n            .attr('fill', 'url(#gradient)');\n\n        barsLayer // catch bar events\n            .on('mousemove', (event) => {\n                const year = XtoLABEL(event.offsetX - margin.left);\n                d3.selectAll('rect.bars').attr('fill', (d) => {\n                    if (year === d.label) return '#B0CCF8';\n                    return colourBars(d);\n                });\n            })\n            .on('mouseout', () => {\n                d3.selectAll('rect.bars').attr('fill', (d) => colourBars(d));\n            })\n            .on('click', (event) => {\n                const label = XtoLABEL(event.offsetX - margin.left);\n                const xAxisValue = LABELtoX(label) + LABELtoX.bandwidth() / 2;\n                const newValue = {\n                    x: xAxisValue,\n                    y: height\n                };\n                this.sliders = [\n                    // avoid joining the two objects!\n                    { ...newValue },\n                    { ...newValue }\n                ];\n                rangePicker\n                    .data(this.sliders)\n                    .select('circle')\n                    .transition()\n                    .ease(d3.easeQuadOut)\n                    .duration(550)\n                    .attr('cx', (d) => d.x);\n                controlsLayer\n                    .select('path.blueline')\n                    .transition()\n                    .ease(d3.easeQuadOut)\n                    .duration(550)\n                    .attr('d', d3.line()(this.sliders.map((d) => [d.x, d.y])));\n                controlsLayer\n                    .selectAll('text')\n                    .transition()\n                    .ease(d3.easeQuadOut)\n                    .duration(550)\n                    .attr('x', () => xAxisValue)\n                    .text((d, i) => {\n                        if (!rangeMode) return label;\n                        const item = items.find((it) => it.label === label);\n                        if (i > 0) return item.range.label;\n                        return item.label;\n                    });\n                g.selectAll('rect.bars').attr('fill', (d) => colourBars(d));\n                this.textCollision(this.sliders);\n                this.emit('rangeselected', this.getSelectedRange());\n            });\n\n        controlsLayer // gray line\n            .append('path')\n            .attr('class', 'grayline')\n            .attr(\n                'd',\n                d3.line()([\n                    [0, height],\n                    [width, height]\n                ])\n            )\n            .attr('stroke-width', 2)\n            .attr('opacity', 1)\n            .attr('stroke', '#C1C5C7');\n\n        controlsLayer // blue line\n            .append('path')\n            .attr('class', 'blueline')\n            .attr('d', d3.line()(this.sliders.map((d) => [d.x, d.y])))\n            .attr('stroke-width', 2)\n            .attr('stroke', colours.accent);\n\n        const rangePicker = controlsLayer\n            .selectAll('g.rangepicker')\n            .data(this.sliders.sort((a, b) => d3.ascending(a.x, b.x)))\n            .join('g')\n            .attr('class', 'rangepicker');\n\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        const self = this; // FIXME: Allow use of class \"this\" inside dragging update;\n        /**\n         * Animate the elements while the user is dragging one of the range selectors\n         */\n        function draggingUpdate(event, data) {\n            const label = XtoLABEL(event.x);\n            const xAxisValue = LABELtoX(label) + LABELtoX.bandwidth() / 2;\n            const yb = [];\n            g.selectAll('circle').each(function setBallPosition() {\n                yb.push({ x: +d3.select(this).attr('cx'), y: height });\n            });\n            self.sliders = yb.sort((a, b) => d3.ascending(a.x, b.x));\n            // move the circle\n            d3.select(this)\n                .select('circle')\n                .attr('cx', data.x = xAxisValue);\n            // move the blue line\n            controlsLayer\n                .select('path.blueline')\n                .attr('d', d3.line()(self.sliders.map((d) => [d.x, d.y])));\n            // change the text position\n            d3.select(this)\n                .select('text')\n                .attr('x', () => xAxisValue);\n            // change the text values\n            controlsLayer\n                .selectAll('text')\n                .text((d) => {\n                    const l = XtoLABEL(d.x);\n                    if (!rangeMode) return l;\n                    const position = self.sliders.findIndex((slider) => slider.x === d.x);\n                    const range = self.getSelectedRange();\n                    if (position === 1) return range[1];\n                    return range[0];\n                });\n            self.textCollision(self.sliders);\n            // colour the bars\n            g.selectAll('rect.bars').attr('fill', (d) => colourBars(d));\n        }\n\n        rangePicker // drag handler\n            .call(d3.drag()\n                .on('drag', draggingUpdate)\n                .on('end', (event, data) => {\n                    // update one last time to prevent desyncing\n                    draggingUpdate(event, data);\n                    // emit the selected range\n                    this.emit('rangeselected', this.getSelectedRange());\n                }));\n\n        rangePicker\n            .append('circle')\n            .attr('cx', (d) => d.x)\n            .attr('cy', (d) => d.y)\n            .attr('r', 9)\n            .attr('fill', 'white')\n            .attr('stroke-width', 2)\n            .attr('stroke', colours.accent)\n            .attr('style', 'cursor: pointer');\n\n        rangePicker\n            .attr('text-anchor', 'middle')\n            .attr('font-family', 'Roboto, Arial, sans-serif')\n            .attr('font-size', '12px')\n            .append('text')\n            .attr('y', (d) => d.y + margin.bottom / 2)\n            .attr('x', (d) => d.x)\n            .attr('fill', colours.accent)\n            .text((d, i) => {\n                const l = XtoLABEL(d.x);\n                if (rangeMode && i === 1) {\n                    return items.find((item) => item.label === l).range.label;\n                } return l;\n            });\n\n        if (axis?.yAxis?.show) {\n            const yAxis = d3.axisLeft(scaleHeight)\n                .ticks(axis.yAxis.tickAmount ?? 2)\n                .tickValues(axis.yAxis.values ? axis.yAxis.values : null);\n            const yAxisGroup = svg.append('g')\n                .attr('transform', `translate(${margin.left}, ${margin.top})`)\n                .call(yAxis);\n\n            yAxisGroup.selectAll('path, line').style('stroke', colours.accent);\n            yAxisGroup.selectAll('text').style('fill', colours.accent);\n        }\n    };\n\n    /** Avoid collision of the slider labels */\n    textCollision = (sliders: Sliders) => {\n        // pre-requisites\n        const controlsLayer = this.d3.select('g.chart').select('g.controls');\n        const { items, margin } = this.data;\n        const rangeMode = items.every((d) => d.range);\n        // run collision detection\n        const isColliding = sliders[0].x === sliders[1].x;\n        if (rangeMode && isColliding) {\n            controlsLayer\n                .selectAll('text')\n                .attr('y', (d, i) => (i > 0 ? d.y + margin.bottom / 2 + 12 : d.y + margin.bottom / 2))\n                .text((d, i) => {\n                    const range = this.getSelectedRange();\n                    return range[i];\n                });\n        } else {\n            controlsLayer\n                .selectAll('text')\n                .attr('y', (d) => d.y + margin.bottom / 2);\n        }\n    };\n\n    /** Get x-axis position from label */\n    labelToX() {\n        return this.d3\n            .scaleBand()\n            .domain(this.data.items.map((d) => d.label))\n            .range([0, this.data.width])\n            .paddingInner(0.17)\n            .paddingOuter(1);\n    }\n\n    /** Public api that allows to dinamically change the bars */\n    setBars = (newBars) => {\n        this.data.items = newBars;\n        this.draw();\n        this.d3.selectAll('rect.bars').attr('fill', (d) => this.colourBars(d));\n    };\n\n    /** Public api that allows to dinamically change the slider position */\n    setSliders = ([startLabel, endLabel]) => {\n        this.data.setSliders = [`${startLabel}`, `${endLabel}`];\n        this.draw();\n        this.d3.selectAll('rect.bars').attr('fill', (d) => this.colourBars(d));\n        const range = this.getSelectedRange();\n        this.emit('rangeselected', range);\n        this.textCollision(this.sliders);\n        return range;\n    };\n\n    /** Emits an event when the component has loaded */\n    emitLoaded(payload) {\n        if (!this.emit) return;\n        this.emit('loaded', payload);\n    }\n}\n","<div *ngIf=\"data\" class=\"n7-histogram-range\">\n    <svg #histogramRange [id]=\"data.containerId\"></svg>\n</div>\n"]}