@net7/components 4.2.1 → 4.2.3

package/esm2022/lib/components/bubble-chart/bubble-chart.mjs

@@ -0,0 +1,336 @@
+//---------------------------
+// BUBBLECHART.ts
+//---------------------------
+/**
+ * The bubble chart is drawn using d3js, a library to create and update anything in svg.
+ *
+ * LEGEND:
+ * - svg -> the canvas/<svg> element where everything will be drawn on (appended).
+ * - g -> <g> is a group of svg elements.
+ * - leaf -> this is the svg circle, the bubble.
+ * - text -> this is all the text inside the circle.
+ * - tspan -> this is just one line of text.
+ *
+ * What are "join, enter, update, exit?"
+ * https://observablehq.com/@d3/learn-d3-joins?collection=@d3/learn-d3
+ * https://observablehq.com/@thetylerwolf/day-18-join-enter-update-exit
+ *
+ * Each line can have a different width, but all of the text inside a circle
+ * needs to be scaled by a constant factor.
+ * https://observablehq.com/@mbostock/fit-text-to-circle
+ */
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class BubbleChartComponent {
+    constructor() {
+        this._loaded = false;
+        /**
+         * Reference for much of the new text scaling code comes from:
+         * https://observablehq.com/@mbostock/fit-text-to-circle
+         */
+        this.measureWidth = (text) => {
+            const context = document.createElement('canvas').getContext('2d');
+            // measure text with the correct font family and weight
+            if (this.data?.fontRendering?.label?.family &&
+                this.data?.fontRendering?.label?.weight) {
+                context.font = `${this.data.fontRendering.label.weight} ${this.data.fontRendering.label.family}`;
+            }
+            // calculated width + padding
+            return context.measureText(text).width * 1.15;
+        };
+        this.isValidNumber = (value) => !Number.isNaN(Number.parseFloat(value));
+        this.draw = () => {
+            const { d3 } = this;
+            const { containerId, data, height, width, selected, transition, colorMatch, shuffle, fontRendering, } = this.data;
+            // SVG shape path for the close icon
+            const closeIconPath = 'M -50,40 L-40,50 0,10 40,50 50,40 10,0 50,-40 40,-50 0,-10 -40,-50 -50,-40 -10,0 -50,40';
+            const defaultLineHeight = 13;
+            // word count before truncating with ellipsis
+            const ellipsisThreshold = 4;
+            const textScalingFactor = 1;
+            if (!Array.isArray(data)) {
+                // Check if it is possible to draw with the current dataset
+                console.warn('(n7-bubble-chart) The data object is not in the expected format!');
+                return;
+            }
+            // animation settings used to render changes in the chart
+            let t = d3.transition().duration(0);
+            if (typeof transition === 'number') {
+                t = d3.transition().duration(transition).ease(d3.easeCubicInOut);
+            }
+            // calculate the bubble background color from it's type (domain)
+            const colorMap = d3
+                .scaleOrdinal()
+                .domain(colorMatch
+                ? colorMatch.domain
+                : ['persona', 'luogo', 'organizzazione', 'cosa notevole'])
+                .range(colorMatch ? colorMatch.range : d3.schemeTableau10);
+            // calculate how big the radius of the bubble should be
+            const sizeScale = d3 // map entity count to bubble size
+                .scaleLinear()
+                .domain([0, d3.max(data, (d) => +d.count)])
+                .range([3, d3.max(data, (d) => +d.count)]);
+            // pack is a d3js method which calculates the bubble's x & y position in the chart
+            // circle packing reference: https://observablehq.com/@d3/pack
+            const pack = (children) => d3
+                .pack()
+                .size([width - 2, height - 2])
+                .padding(1.5)(d3.hierarchy({ children }).sum((d) => sizeScale(d.count)));
+            // the bubbles are packed in a single level tree, this is the root
+            // see circle packing reference: https://observablehq.com/@d3/pack
+            const root = () => {
+                // if shuffle is undefined or true, shuffle the data
+                if (typeof shuffle === 'undefined' || shuffle) {
+                    const shuffData = data.slice(); // do not modify the source data!
+                    return pack(d3.shuffle(shuffData));
+                } // if shuffle is set to false, skip the data shuffle
+                return pack(data);
+            };
+            // svg canvas where all the bubbles are drawn
+            const svg = d3
+                .select(`#${containerId}`)
+                .attr('viewBox', [0, 0, width, height])
+                .style('font', '10px Verdana, Geneva, sans-serif')
+                .style('max-width', '100%')
+                .attr('text-anchor', 'middle');
+            this.removeUnneededNodes(svg);
+            // a leaf of the "pack tree" corresponds to a bubble
+            const leaf = svg
+                .selectAll('g')
+                .data(root().leaves(), (d) => d.data.entity.id);
+            leaf
+                .transition(t) // update transition on <g>
+                .attr('fill-opacity', 1)
+                .attr('transform', (d) => `translate(${d.x + 1},${d.y + 1})`);
+            // clear all existing close icons from the bubbles
+            leaf.selectAll('.close-icon').remove();
+            if (selected) {
+                leaf // render only the necessary close icons
+                    .filter((d) => selected.includes(d.data.entity.id))
+                    .append('path')
+                    .attr('class', 'close-icon')
+                    .attr('d', closeIconPath)
+                    .attr('fill', '#fff')
+                    .attr('transform', (d) => {
+                    if (d.r / 4 > 3) {
+                        return `scale(.08) translate(0, ${d.r * 10 - 80})`;
+                    }
+                    return 'scale(.08)';
+                });
+            }
+            leaf
+                .select('circle')
+                .transition(t) // update transition on <circle>
+                .attr('fill-opacity', 1)
+                .attr('r', (d) => d.r);
+            // g represents a "group of svg items"
+            // items grouped together can be added / removed / scaled together
+            const g = leaf.enter().append('g');
+            g.attr('transform', (d) => `translate(${d.x + 1},${d.y + 1})`)
+                .attr('cursor', 'pointer')
+                .on('click', (event, d) => {
+                this.onClick(d.data.entity.id);
+            })
+                .attr('id', (d) => `g_${d.data.entity.id}`)
+                .append('circle')
+                .attr('id', (d) => {
+                d.leafUid = d.data.entity.id;
+            })
+                .attr('r', 0)
+                .transition(t) // enter() transition on <circle>
+                .attr('fill-opacity', 1)
+                .attr('fill', (d) => colorMap(d.data.entity.typeOfEntity))
+                .attr('r', (d) => d.r);
+            // prevents the text from overflowing the bubble
+            g.append('clipPath')
+                .attr('id', (d) => {
+                d.clipUid = `Clip-${d.data.entity.id}`;
+            })
+                .append('use')
+                .attr('xlink:href', (d) => d.leafUid.href);
+            /** NEW TEXT LOGIC */
+            g.append('text')
+                .attr('font-family', () => {
+                if (fontRendering &&
+                    fontRendering.label &&
+                    fontRendering.label.family) {
+                    return fontRendering.label.family;
+                }
+                return 'inherit';
+            })
+                .attr('font-weight', () => {
+                if (fontRendering &&
+                    fontRendering &&
+                    fontRendering.label &&
+                    fontRendering.label.weight) {
+                    return fontRendering.label.weight;
+                }
+                return 'inherit';
+            })
+                .attr('fill', 'white')
+                .each((d) => {
+                // Capitalize the first letter of the label
+                d.data.entity.label =
+                    d.data.entity.label.charAt(0).toUpperCase() +
+                        d.data.entity.label.slice(1);
+                // 1. initialize meta object
+                if (!d._meta || typeof d._meta !== 'object')
+                    d._meta = {};
+                // 2. tokenize label & count into words
+                const words = d.data.entity.label.split(/[\s]+/g); // To hyphenate: /\s+|(?<=-)/
+                // Truncate with ellipsis if the label is longer than the threshold
+                if (words.length > ellipsisThreshold) {
+                    words.splice(ellipsisThreshold, words.length - ellipsisThreshold);
+                    words[ellipsisThreshold - 1] += '…';
+                }
+                // add counter
+                if (d.r / 4 > 2.5) {
+                    // show text threshold
+                    if (!words[words.length - 1])
+                        words.pop();
+                    if (!words[0])
+                        words.shift();
+                }
+                if (d.r / 4 > 4.5) {
+                    // show number threshold
+                    words.push(`${d.data.count}`);
+                }
+                d._meta.words = words;
+                d._meta.lineHeight = defaultLineHeight;
+                const targetWidth = Math.sqrt(this.measureWidth(d._meta.words.join(' ').trim()) * defaultLineHeight);
+                // 3. build lines of text
+                d._meta.lines = [];
+                let line;
+                let lineWidth0 = Infinity;
+                for (let i = 0, n = d._meta.words.length; i < n; i += 1) {
+                    const lineText1 = (line ? `${line.text} ` : '') + words[i];
+                    const lineWidth1 = this.measureWidth(lineText1);
+                    if ((lineWidth0 + lineWidth1) / 2 < targetWidth && i !== n - 1) {
+                        line.width = lineWidth0;
+                        lineWidth0 = lineWidth1;
+                        line.text = lineText1;
+                    }
+                    else {
+                        // if line is too long or this is the last line (counter), push to next line
+                        lineWidth0 = this.measureWidth(words[i]);
+                        line = { width: lineWidth0, text: words[i] };
+                        d._meta.lines.push(line);
+                    }
+                }
+                // 4. compute the bounding radius
+                let radius = 0;
+                for (let i = 0, n = d._meta.lines.length; i < n; i += 1) {
+                    const dy = (Math.abs(i - n / 2) + 0.8) * d._meta.lineHeight;
+                    const dx = d._meta.lines[i].width / 2;
+                    radius = Math.max(radius, Math.sqrt(dx * dx + dy * dy));
+                }
+                d._meta.textRadius = radius;
+                return d;
+            })
+                .attr('transform', (d) => {
+                const scale = ((d.r * 0.8) / d._meta.textRadius) * textScalingFactor;
+                return `scale(${scale})`;
+            })
+                .filter((d) => d.r / 4 > 2.5)
+                .selectAll('tspan')
+                .data((d) => d._meta.lines)
+                .enter()
+                .append('tspan')
+                .attr('x', 0)
+                .attr('y', (d, i, n) => (i - n.length / 2 + 0.8) * defaultLineHeight)
+                .attr('class', (d, i, n) => 
+            // if it's the last label and a valid number, mark as counter
+            i === n.length - 1 && this.isValidNumber(d.text)
+                ? 'label-counter'
+                : 'label-text')
+                .text((d) => d.text)
+                .attr('fill-opacity', 0)
+                .transition(t) // enter() transition on <tspan>
+                .attr('fill-opacity', 1);
+            // custom style for the counter
+            g.selectAll('tspan.label-counter')
+                .attr('font-family', () => {
+                if (fontRendering &&
+                    fontRendering.counter &&
+                    fontRendering.counter.family) {
+                    return fontRendering.counter.family;
+                }
+                return 'inherit';
+            })
+                .attr('font-weight', () => {
+                if (fontRendering &&
+                    fontRendering.counter &&
+                    fontRendering.counter.weight) {
+                    return fontRendering.counter.weight;
+                }
+                return 'inherit';
+            });
+            leaf
+                .exit() // EXIT CYCLE
+                .remove();
+            if (selected) {
+                g.filter((d) => selected.includes(d.leafUid)) // append 'X' icon // only for selected bubbles
+                    .append('path')
+                    .attr('d', closeIconPath)
+                    .attr('class', 'close-icon')
+                    .attr('fill', (d) => {
+                    if (d.r / 4 > 2.5) {
+                        return '#fff';
+                    }
+                    return 'transparent';
+                })
+                    .attr('transform', (d) => {
+                    if (d.r / 4 > 3) {
+                        return `scale(.08) translate(0, ${d.r * 10 - 80})`;
+                    }
+                    return 'scale(.08)';
+                });
+            }
+            // communicate end of draw
+            this.emit('d3end', data);
+        };
+    }
+    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();
+                    if (this.data && this.data.setDraw) {
+                        this.data.setDraw(this.draw);
+                    }
+                });
+            });
+        }
+    }
+    onClick(payload) {
+        if (!this.emit)
+            return;
+        this.emit('click', payload);
+    }
+    removeUnneededNodes(svg) {
+        // select all nodes and rejoin data
+        const nodes = svg.selectAll('g').data(this.data);
+        // remove excess nodes
+        nodes.exit().remove();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BubbleChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BubbleChartComponent, selector: "n7-bubble-chart", inputs: { data: "data", emit: "emit" }, ngImport: i0, template: "<div *ngIf=\"data\" class=\"n7-bubble-chart {{ data.classes || '' }}\">\n  <svg #bubbleChart id=\"{{data.containerId}}\"></svg>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BubbleChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'n7-bubble-chart', template: "<div *ngIf=\"data\" class=\"n7-bubble-chart {{ data.classes || '' }}\">\n  <svg #bubbleChart id=\"{{data.containerId}}\"></svg>\n</div>\n" }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], emit: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bubble-chart.js","sourceRoot":"","sources":["../../../../../../projects/dv-components-lib/src/lib/components/bubble-chart/bubble-chart.ts","../../../../../../projects/dv-components-lib/src/lib/components/bubble-chart/bubble-chart.html"],"names":[],"mappings":"AAAA,6BAA6B;AAC7B,iBAAiB;AACjB,6BAA6B;AAE7B;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAuB,MAAM,eAAe,CAAC;;;AA0HtE,MAAM,OAAO,oBAAoB;IAJjC;QAWU,YAAO,GAAG,KAAK,CAAC;QA2BxB;;;WAGG;QACH,iBAAY,GAAG,CAAC,IAAI,EAAE,EAAE;YACtB,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAClE,uDAAuD;YACvD,IACE,IAAI,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM;gBACvC,IAAI,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EACvC,CAAC;gBACD,OAAO,CAAC,IAAI,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YACnG,CAAC;YACD,6BAA6B;YAC7B,OAAO,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC;QAChD,CAAC,CAAC;QAEF,kBAAa,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;QASnE,SAAI,GAAG,GAAG,EAAE;YACV,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;YACpB,MAAM,EACJ,WAAW,EACX,IAAI,EACJ,MAAM,EACN,KAAK,EACL,QAAQ,EACR,UAAU,EACV,UAAU,EACV,OAAO,EACP,aAAa,GACd,GAAG,IAAI,CAAC,IAAI,CAAC;YACd,oCAAoC;YACpC,MAAM,aAAa,GACjB,yFAAyF,CAAC;YAC5F,MAAM,iBAAiB,GAAG,EAAE,CAAC;YAC7B,6CAA6C;YAC7C,MAAM,iBAAiB,GAAG,CAAC,CAAC;YAC5B,MAAM,iBAAiB,GAAG,CAAC,CAAC;YAE5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBACzB,2DAA2D;gBAC3D,OAAO,CAAC,IAAI,CACV,kEAAkE,CACnE,CAAC;gBACF,OAAO;YACT,CAAC;YAED,yDAAyD;YACzD,IAAI,CAAC,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACpC,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;gBACnC,CAAC,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC;YACnE,CAAC;YAED,gEAAgE;YAChE,MAAM,QAAQ,GAAG,EAAE;iBAChB,YAAY,EAAE;iBACd,MAAM,CACL,UAAU;gBACR,CAAC,CAAC,UAAU,CAAC,MAAM;gBACnB,CAAC,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,eAAe,CAAC,CAC5D;iBACA,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC;YAE7D,uDAAuD;YACvD,MAAM,SAAS,GAAG,EAAE,CAAC,kCAAkC;iBACpD,WAAW,EAAE;iBACb,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;iBAC1C,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAE7C,kFAAkF;YAClF,8DAA8D;YAC9D,MAAM,IAAI,GAAG,CAAC,QAAQ,EAAE,EAAE,CACxB,EAAE;iBACC,IAAI,EAAE;iBACN,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;iBAC7B,OAAO,CAAC,GAAG,CAAC,CACb,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAC1D,CAAC;YAEJ,kEAAkE;YAClE,kEAAkE;YAClE,MAAM,IAAI,GAAG,GAAG,EAAE;gBAChB,oDAAoD;gBACpD,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,EAAE,CAAC;oBAC9C,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,iCAAiC;oBACjE,OAAO,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;gBACrC,CAAC,CAAC,oDAAoD;gBACtD,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC,CAAC;YAEF,6CAA6C;YAC7C,MAAM,GAAG,GAAG,EAAE;iBACX,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;iBACzB,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;iBACtC,KAAK,CAAC,MAAM,EAAE,kCAAkC,CAAC;iBACjD,KAAK,CAAC,WAAW,EAAE,MAAM,CAAC;iBAC1B,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;YAEjC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;YAE9B,oDAAoD;YACpD,MAAM,IAAI,GAAG,GAAG;iBACb,SAAS,CAAC,GAAG,CAAC;iBACd,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAClD,IAAI;iBACD,UAAU,CAAC,CAAC,CAAC,CAAC,2BAA2B;iBACzC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;iBACvB,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAEhE,kDAAkD;YAClD,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,CAAC;YACvC,IAAI,QAAQ,EAAE,CAAC;gBACb,IAAI,CAAC,wCAAwC;qBAC1C,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;qBAClD,MAAM,CAAC,MAAM,CAAC;qBACd,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC;qBAC3B,IAAI,CAAC,GAAG,EAAE,aAAa,CAAC;qBACxB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;qBACpB,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE;oBACvB,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;wBAChB,OAAO,2BAA2B,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;oBACrD,CAAC;oBACD,OAAO,YAAY,CAAC;gBACtB,CAAC,CAAC,CAAC;YACP,CAAC;YAED,IAAI;iBACD,MAAM,CAAC,QAAQ,CAAC;iBAChB,UAAU,CAAC,CAAC,CAAC,CAAC,gCAAgC;iBAC9C,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;iBACvB,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAEzB,sCAAsC;YACtC,kEAAkE;YAClE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAEnC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;iBAC3D,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;iBACzB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;gBACxB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACjC,CAAC,CAAC;iBACD,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;iBAC1C,MAAM,CAAC,QAAQ,CAAC;iBAChB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE;gBAChB,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/B,CAAC,CAAC;iBACD,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;iBACZ,UAAU,CAAC,CAAC,CAAC,CAAC,iCAAiC;iBAC/C,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;iBACvB,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;iBACzD,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAEzB,gDAAgD;YAChD,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;iBACjB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE;gBAChB,CAAC,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YACzC,CAAC,CAAC;iBACD,MAAM,CAAC,KAAK,CAAC;iBACb,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAE7C,qBAAqB;YACrB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;iBACb,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE;gBACxB,IACE,aAAa;oBACb,aAAa,CAAC,KAAK;oBACnB,aAAa,CAAC,KAAK,CAAC,MAAM,EAC1B,CAAC;oBACD,OAAO,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC;gBACpC,CAAC;gBACD,OAAO,SAAS,CAAC;YACnB,CAAC,CAAC;iBACD,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE;gBACxB,IACE,aAAa;oBACb,aAAa;oBACb,aAAa,CAAC,KAAK;oBACnB,aAAa,CAAC,KAAK,CAAC,MAAM,EAC1B,CAAC;oBACD,OAAO,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC;gBACpC,CAAC;gBACD,OAAO,SAAS,CAAC;YACnB,CAAC,CAAC;iBACD,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC;iBACrB,IAAI,CAAC,CAAC,CAAa,EAAE,EAAE;gBACtB,2CAA2C;gBAC3C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK;oBACjB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;wBAC3C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC/B,4BAA4B;gBAC5B,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ;oBAAE,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;gBAC1D,uCAAuC;gBACvC,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,6BAA6B;gBAChF,mEAAmE;gBACnE,IAAI,KAAK,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;oBACrC,KAAK,CAAC,MAAM,CAAC,iBAAiB,EAAE,KAAK,CAAC,MAAM,GAAG,iBAAiB,CAAC,CAAC;oBAClE,KAAK,CAAC,iBAAiB,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC;gBACtC,CAAC;gBACD,cAAc;gBACd,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC;oBAClB,sBAAsB;oBACtB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;wBAAE,KAAK,CAAC,GAAG,EAAE,CAAC;oBAC1C,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;wBAAE,KAAK,CAAC,KAAK,EAAE,CAAC;gBAC/B,CAAC;gBACD,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC;oBAClB,wBAAwB;oBACxB,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;gBAChC,CAAC;gBACD,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;gBACtB,CAAC,CAAC,KAAK,CAAC,UAAU,GAAG,iBAAiB,CAAC;gBACvC,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAC3B,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,iBAAiB,CACtE,CAAC;gBACF,yBAAyB;gBACzB,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;gBACnB,IAAI,IAAI,CAAC;gBACT,IAAI,UAAU,GAAG,QAAQ,CAAC;gBAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;oBACxD,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC3D,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;oBAChD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,WAAW,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;wBAC/D,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC;wBACxB,UAAU,GAAG,UAAU,CAAC;wBACxB,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;oBACxB,CAAC;yBAAM,CAAC;wBACN,4EAA4E;wBAC5E,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;wBACzC,IAAI,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;wBAC7C,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC3B,CAAC;gBACH,CAAC;gBACD,iCAAiC;gBACjC,IAAI,MAAM,GAAG,CAAC,CAAC;gBACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;oBACxD,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC;oBAC5D,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;oBACtC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;gBAC1D,CAAC;gBACD,CAAC,CAAC,KAAK,CAAC,UAAU,GAAG,MAAM,CAAC;gBAC5B,OAAO,CAAC,CAAC;YACX,CAAC,CAAC;iBACD,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE;gBACvB,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,iBAAiB,CAAC;gBACrE,OAAO,SAAS,KAAK,GAAG,CAAC;YAC3B,CAAC,CAAC;iBACD,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;iBAC5B,SAAS,CAAC,OAAO,CAAC;iBAClB,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;iBAC1B,KAAK,EAAE;iBACP,MAAM,CAAC,OAAO,CAAC;iBACf,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;iBACZ,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,iBAAiB,CAAC;iBACpE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;YACzB,6DAA6D;YAC7D,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC9C,CAAC,CAAC,eAAe;gBACjB,CAAC,CAAC,YAAY,CACjB;iBACA,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;iBACnB,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;iBACvB,UAAU,CAAC,CAAC,CAAC,CAAC,gCAAgC;iBAC9C,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;YAE3B,+BAA+B;YAC/B,CAAC,CAAC,SAAS,CAAC,qBAAqB,CAAC;iBAC/B,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE;gBACxB,IACE,aAAa;oBACb,aAAa,CAAC,OAAO;oBACrB,aAAa,CAAC,OAAO,CAAC,MAAM,EAC5B,CAAC;oBACD,OAAO,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC;gBACtC,CAAC;gBACD,OAAO,SAAS,CAAC;YACnB,CAAC,CAAC;iBACD,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE;gBACxB,IACE,aAAa;oBACb,aAAa,CAAC,OAAO;oBACrB,aAAa,CAAC,OAAO,CAAC,MAAM,EAC5B,CAAC;oBACD,OAAO,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC;gBACtC,CAAC;gBACD,OAAO,SAAS,CAAC;YACnB,CAAC,CAAC,CAAC;YAEL,IAAI;iBACD,IAAI,EAAE,CAAC,aAAa;iBACpB,MAAM,EAAE,CAAC;YAEZ,IAAI,QAAQ,EAAE,CAAC;gBACb,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,+CAA+C;qBAC1F,MAAM,CAAC,MAAM,CAAC;qBACd,IAAI,CAAC,GAAG,EAAE,aAAa,CAAC;qBACxB,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC;qBAC3B,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE;oBAClB,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC;wBAClB,OAAO,MAAM,CAAC;oBAChB,CAAC;oBACD,OAAO,aAAa,CAAC;gBACvB,CAAC,CAAC;qBACD,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE;oBACvB,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;wBAChB,OAAO,2BAA2B,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;oBACrD,CAAC;oBACD,OAAO,YAAY,CAAC;gBACtB,CAAC,CAAC,CAAC;YACP,CAAC;YAED,0BAA0B;YAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC3B,CAAC,CAAC;KACH;IAzVC,qBAAqB;QACnB;;;UAGE;QACF,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACd,IAAI,IAAI,CAAC,OAAO;gBAAE,OAAO;YACzB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,UAAU,CAAC,GAAG,EAAE;gBACd,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;oBAC3B,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC;oBACjB,IAAI,CAAC,IAAI,EAAE,CAAC;oBACZ,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;wBACnC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC/B,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,OAAO,CAAC,OAAO;QACb,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QACvB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC9B,CAAC;IAqBD,mBAAmB,CAAC,GAAG;QACrB,mCAAmC;QACnC,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjD,sBAAsB;QACtB,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;IACxB,CAAC;8GA1DU,oBAAoB;kGAApB,oBAAoB,+FCjJjC,2IAGA;;2FD8Ia,oBAAoB;kBAJhC,SAAS;+BACE,iBAAiB;8BAIlB,IAAI;sBAAZ,KAAK;gBAEG,IAAI;sBAAZ,KAAK","sourcesContent":["//---------------------------\n// BUBBLECHART.ts\n//---------------------------\n\n/**\n * The bubble chart is drawn using d3js, a library to create and update anything in svg.\n *\n * LEGEND:\n * - svg -> the canvas/<svg> element where everything will be drawn on (appended).\n * - g -> <g> is a group of svg elements.\n * - leaf -> this is the svg circle, the bubble.\n * - text -> this is all the text inside the circle.\n * - tspan -> this is just one line of text.\n *\n * What are \"join, enter, update, exit?\"\n * https://observablehq.com/@d3/learn-d3-joins?collection=@d3/learn-d3\n * https://observablehq.com/@thetylerwolf/day-18-join-enter-update-exit\n *\n * Each line can have a different width, but all of the text inside a circle\n * needs to be scaled by a constant factor.\n * https://observablehq.com/@mbostock/fit-text-to-circle\n */\n\nimport { Component, Input, AfterContentChecked } from '@angular/core';\n\n/**\n * Interface for D3Chart's \"data\"\n *\n * @property entity (required)\n * - id (required)\n * - label (optional)\n * - typeOfEntity (optional)\n * @property count (required)\n */\nexport interface BubbleChartDataItem {\n  entity: {\n    id: string;\n    label?: string;\n    typeOfEntity?: string;\n  };\n  count: number;\n}\n\n/**\n * Interface for a Circle's node data\n */\nexport interface CircleNode {\n  clipUid: string;\n  data: BubbleChartDataItem;\n  depth: number;\n  height: number;\n  leafUid: string;\n  parent: Node;\n  x: number;\n  y: number;\n  r: number;\n  value: number;\n  /** Dynamic data for internal logic */\n  _meta?: any;\n}\n\n/**\n * Interface for BubbleChartComponent's \"data\"\n *\n * @property containerId (required)\n * @property containerWidth (required)\n * @property containerHeight (required)\n * @property bubblesData (required)\n * @property isForceSimulationEnabled (required)\n * @property classes (optional)\n * @property reset (optional)\n */\nexport interface BubbleChartData {\n  /**\n   * unique identifier for the bubble-chart\n   */\n  containerId: string;\n  /**\n   * total width for the bubble-chart\n   */\n  width: number;\n  /**\n   * total height for the bubble-chart\n   */\n  height: number;\n  /**\n   * data about the bubbles\n   */\n  data: BubbleChartDataItem[];\n  /**\n   * additional css classes\n   */\n  classes?: string;\n  /**\n   * list of ID's of selected items\n   * (selected items will render with a 'X' icon)\n   */\n  selected?: string[];\n  /**\n   * Specify a list of typeOfEntity types (domain),\n   * and a list of colors (range), which will be mapped together.\n   */\n  colorMatch?: {\n    domain: string[];\n    range: string[];\n  };\n  /**\n   * Define a max and min size for the bubbles\n   */\n  sizeRange: [number, number];\n  /**\n   * If defined, transition will be activated\n   * and the value will be used as duration\n   */\n  transition?: number;\n  /**\n   * If set to false, stops the shuffling of the data\n   * before rendering.\n   */\n  shuffle?: boolean;\n  /**\n   * Defines the font-family and the font-weight for each text group\n   */\n  fontRendering?: {\n    label?: {\n      family?: string;\n      weight?: string;\n    };\n    counter?: {\n      family?: string;\n      weight?: string;\n    };\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\n@Component({\n  selector: 'n7-bubble-chart',\n  templateUrl: './bubble-chart.html',\n})\nexport class BubbleChartComponent implements AfterContentChecked {\n  @Input() data: BubbleChartData;\n\n  @Input() emit: any;\n\n  private d3;\n\n  private _loaded = false;\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          if (this.data && this.data.setDraw) {\n            this.data.setDraw(this.draw);\n          }\n        });\n      });\n    }\n  }\n\n  onClick(payload) {\n    if (!this.emit) return;\n    this.emit('click', payload);\n  }\n\n  /**\n   * Reference for much of the new text scaling code comes from:\n   * https://observablehq.com/@mbostock/fit-text-to-circle\n   */\n  measureWidth = (text) => {\n    const context = document.createElement('canvas').getContext('2d');\n    // measure text with the correct font family and weight\n    if (\n      this.data?.fontRendering?.label?.family &&\n      this.data?.fontRendering?.label?.weight\n    ) {\n      context.font = `${this.data.fontRendering.label.weight} ${this.data.fontRendering.label.family}`;\n    }\n    // calculated width + padding\n    return context.measureText(text).width * 1.15;\n  };\n\n  isValidNumber = (value) => !Number.isNaN(Number.parseFloat(value));\n\n  removeUnneededNodes(svg) {\n    // select all nodes and rejoin data\n    const nodes = svg.selectAll('g').data(this.data);\n    // remove excess nodes\n    nodes.exit().remove();\n  }\n\n  draw = () => {\n    const { d3 } = this;\n    const {\n      containerId,\n      data,\n      height,\n      width,\n      selected,\n      transition,\n      colorMatch,\n      shuffle,\n      fontRendering,\n    } = this.data;\n    // SVG shape path for the close icon\n    const closeIconPath =\n      'M -50,40 L-40,50 0,10 40,50 50,40 10,0 50,-40 40,-50 0,-10 -40,-50 -50,-40 -10,0 -50,40';\n    const defaultLineHeight = 13;\n    // word count before truncating with ellipsis\n    const ellipsisThreshold = 4;\n    const textScalingFactor = 1;\n\n    if (!Array.isArray(data)) {\n      // Check if it is possible to draw with the current dataset\n      console.warn(\n        '(n7-bubble-chart) The data object is not in the expected format!'\n      );\n      return;\n    }\n\n    // animation settings used to render changes in the chart\n    let t = d3.transition().duration(0);\n    if (typeof transition === 'number') {\n      t = d3.transition().duration(transition).ease(d3.easeCubicInOut);\n    }\n\n    // calculate the bubble background color from it's type (domain)\n    const colorMap = d3\n      .scaleOrdinal()\n      .domain(\n        colorMatch\n          ? colorMatch.domain\n          : ['persona', 'luogo', 'organizzazione', 'cosa notevole']\n      )\n      .range(colorMatch ? colorMatch.range : d3.schemeTableau10);\n\n    // calculate how big the radius of the bubble should be\n    const sizeScale = d3 // map entity count to bubble size\n      .scaleLinear()\n      .domain([0, d3.max(data, (d) => +d.count)])\n      .range([3, d3.max(data, (d) => +d.count)]);\n\n    // pack is a d3js method which calculates the bubble's x & y position in the chart\n    // circle packing reference: https://observablehq.com/@d3/pack\n    const pack = (children) =>\n      d3\n        .pack()\n        .size([width - 2, height - 2])\n        .padding(1.5)(\n        d3.hierarchy({ children }).sum((d) => sizeScale(d.count))\n      );\n\n    // the bubbles are packed in a single level tree, this is the root\n    // see circle packing reference: https://observablehq.com/@d3/pack\n    const root = () => {\n      // if shuffle is undefined or true, shuffle the data\n      if (typeof shuffle === 'undefined' || shuffle) {\n        const shuffData = data.slice(); // do not modify the source data!\n        return pack(d3.shuffle(shuffData));\n      } // if shuffle is set to false, skip the data shuffle\n      return pack(data);\n    };\n\n    // svg canvas where all the bubbles are drawn\n    const svg = d3\n      .select(`#${containerId}`)\n      .attr('viewBox', [0, 0, width, height])\n      .style('font', '10px Verdana, Geneva, sans-serif')\n      .style('max-width', '100%')\n      .attr('text-anchor', 'middle');\n\n    this.removeUnneededNodes(svg);\n\n    // a leaf of the \"pack tree\" corresponds to a bubble\n    const leaf = svg\n      .selectAll('g')\n      .data(root().leaves(), (d) => d.data.entity.id);\n    leaf\n      .transition(t) // update transition on <g>\n      .attr('fill-opacity', 1)\n      .attr('transform', (d) => `translate(${d.x + 1},${d.y + 1})`);\n\n    // clear all existing close icons from the bubbles\n    leaf.selectAll('.close-icon').remove();\n    if (selected) {\n      leaf // render only the necessary close icons\n        .filter((d) => selected.includes(d.data.entity.id))\n        .append('path')\n        .attr('class', 'close-icon')\n        .attr('d', closeIconPath)\n        .attr('fill', '#fff')\n        .attr('transform', (d) => {\n          if (d.r / 4 > 3) {\n            return `scale(.08) translate(0, ${d.r * 10 - 80})`;\n          }\n          return 'scale(.08)';\n        });\n    }\n\n    leaf\n      .select('circle')\n      .transition(t) // update transition on <circle>\n      .attr('fill-opacity', 1)\n      .attr('r', (d) => d.r);\n\n    // g represents a \"group of svg items\"\n    // items grouped together can be added / removed / scaled together\n    const g = leaf.enter().append('g');\n\n    g.attr('transform', (d) => `translate(${d.x + 1},${d.y + 1})`)\n      .attr('cursor', 'pointer')\n      .on('click', (event, d) => {\n        this.onClick(d.data.entity.id);\n      })\n      .attr('id', (d) => `g_${d.data.entity.id}`)\n      .append('circle')\n      .attr('id', (d) => {\n        d.leafUid = d.data.entity.id;\n      })\n      .attr('r', 0)\n      .transition(t) // enter() transition on <circle>\n      .attr('fill-opacity', 1)\n      .attr('fill', (d) => colorMap(d.data.entity.typeOfEntity))\n      .attr('r', (d) => d.r);\n\n    // prevents the text from overflowing the bubble\n    g.append('clipPath')\n      .attr('id', (d) => {\n        d.clipUid = `Clip-${d.data.entity.id}`;\n      })\n      .append('use')\n      .attr('xlink:href', (d) => d.leafUid.href);\n\n    /** NEW TEXT LOGIC */\n    g.append('text')\n      .attr('font-family', () => {\n        if (\n          fontRendering &&\n          fontRendering.label &&\n          fontRendering.label.family\n        ) {\n          return fontRendering.label.family;\n        }\n        return 'inherit';\n      })\n      .attr('font-weight', () => {\n        if (\n          fontRendering &&\n          fontRendering &&\n          fontRendering.label &&\n          fontRendering.label.weight\n        ) {\n          return fontRendering.label.weight;\n        }\n        return 'inherit';\n      })\n      .attr('fill', 'white')\n      .each((d: CircleNode) => {\n        // Capitalize the first letter of the label\n        d.data.entity.label =\n          d.data.entity.label.charAt(0).toUpperCase() +\n          d.data.entity.label.slice(1);\n        // 1. initialize meta object\n        if (!d._meta || typeof d._meta !== 'object') d._meta = {};\n        // 2. tokenize label & count into words\n        const words = d.data.entity.label.split(/[\\s]+/g); // To hyphenate: /\\s+|(?<=-)/\n        // Truncate with ellipsis if the label is longer than the threshold\n        if (words.length > ellipsisThreshold) {\n          words.splice(ellipsisThreshold, words.length - ellipsisThreshold);\n          words[ellipsisThreshold - 1] += '…';\n        }\n        // add counter\n        if (d.r / 4 > 2.5) {\n          // show text threshold\n          if (!words[words.length - 1]) words.pop();\n          if (!words[0]) words.shift();\n        }\n        if (d.r / 4 > 4.5) {\n          // show number threshold\n          words.push(`${d.data.count}`);\n        }\n        d._meta.words = words;\n        d._meta.lineHeight = defaultLineHeight;\n        const targetWidth = Math.sqrt(\n          this.measureWidth(d._meta.words.join(' ').trim()) * defaultLineHeight\n        );\n        // 3. build lines of text\n        d._meta.lines = [];\n        let line;\n        let lineWidth0 = Infinity;\n        for (let i = 0, n = d._meta.words.length; i < n; i += 1) {\n          const lineText1 = (line ? `${line.text} ` : '') + words[i];\n          const lineWidth1 = this.measureWidth(lineText1);\n          if ((lineWidth0 + lineWidth1) / 2 < targetWidth && i !== n - 1) {\n            line.width = lineWidth0;\n            lineWidth0 = lineWidth1;\n            line.text = lineText1;\n          } else {\n            // if line is too long or this is the last line (counter), push to next line\n            lineWidth0 = this.measureWidth(words[i]);\n            line = { width: lineWidth0, text: words[i] };\n            d._meta.lines.push(line);\n          }\n        }\n        // 4. compute the bounding radius\n        let radius = 0;\n        for (let i = 0, n = d._meta.lines.length; i < n; i += 1) {\n          const dy = (Math.abs(i - n / 2) + 0.8) * d._meta.lineHeight;\n          const dx = d._meta.lines[i].width / 2;\n          radius = Math.max(radius, Math.sqrt(dx * dx + dy * dy));\n        }\n        d._meta.textRadius = radius;\n        return d;\n      })\n      .attr('transform', (d) => {\n        const scale = ((d.r * 0.8) / d._meta.textRadius) * textScalingFactor;\n        return `scale(${scale})`;\n      })\n      .filter((d) => d.r / 4 > 2.5)\n      .selectAll('tspan')\n      .data((d) => d._meta.lines)\n      .enter()\n      .append('tspan')\n      .attr('x', 0)\n      .attr('y', (d, i, n) => (i - n.length / 2 + 0.8) * defaultLineHeight)\n      .attr('class', (d, i, n) =>\n        // if it's the last label and a valid number, mark as counter\n        i === n.length - 1 && this.isValidNumber(d.text)\n          ? 'label-counter'\n          : 'label-text'\n      )\n      .text((d) => d.text)\n      .attr('fill-opacity', 0)\n      .transition(t) // enter() transition on <tspan>\n      .attr('fill-opacity', 1);\n\n    // custom style for the counter\n    g.selectAll('tspan.label-counter')\n      .attr('font-family', () => {\n        if (\n          fontRendering &&\n          fontRendering.counter &&\n          fontRendering.counter.family\n        ) {\n          return fontRendering.counter.family;\n        }\n        return 'inherit';\n      })\n      .attr('font-weight', () => {\n        if (\n          fontRendering &&\n          fontRendering.counter &&\n          fontRendering.counter.weight\n        ) {\n          return fontRendering.counter.weight;\n        }\n        return 'inherit';\n      });\n\n    leaf\n      .exit() // EXIT CYCLE\n      .remove();\n\n    if (selected) {\n      g.filter((d) => selected.includes(d.leafUid)) // append 'X' icon // only for selected bubbles\n        .append('path')\n        .attr('d', closeIconPath)\n        .attr('class', 'close-icon')\n        .attr('fill', (d) => {\n          if (d.r / 4 > 2.5) {\n            return '#fff';\n          }\n          return 'transparent';\n        })\n        .attr('transform', (d) => {\n          if (d.r / 4 > 3) {\n            return `scale(.08) translate(0, ${d.r * 10 - 80})`;\n          }\n          return 'scale(.08)';\n        });\n    }\n\n    // communicate end of draw\n    this.emit('d3end', data);\n  };\n}\n","<div *ngIf=\"data\" class=\"n7-bubble-chart {{ data.classes || '' }}\">\n  <svg #bubbleChart id=\"{{data.containerId}}\"></svg>\n</div>\n"]}