@net7/components 3.0.2-rc.2

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

@@ -0,0 +1,315 @@
+//---------------------------
+// BUBBLECHART.ts
+//---------------------------
+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;
+        this.draw = () => {
+            const { d3 } = this;
+            const { containerId, data, height, width, selected, transition, colorMatch, shuffle, fontRendering } = this.data;
+            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';
+            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;
+            }
+            let t = d3
+                .transition()
+                .duration(0);
+            if (typeof transition === 'number') {
+                t = d3
+                    .transition()
+                    .duration(transition)
+                    .ease(d3.easeCubicInOut);
+            }
+            const colorMap = d3.scaleOrdinal()
+                .domain(colorMatch ? colorMatch.domain : ['persona', 'luogo', 'organizzazione', 'cosa notevole'])
+                .range(colorMatch ? colorMatch.range : d3.schemeTableau10);
+            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)]);
+            const pack = (children) => d3
+                .pack()
+                .size([width - 2, height - 2])
+                .padding(1.5)(d3.hierarchy({ children }).sum((d) => sizeScale(d.count)));
+            const root = () => {
+                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);
+            };
+            const svg = d3
+                .select(`#${containerId}`)
+                .attr('viewBox', [0, 0, width, height])
+                .attr('font-family', 'Verdana, Geneva, sans-serif')
+                .attr('text-anchor', 'middle');
+            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})`)
+                .attr('font-size', (d) => {
+                let size = d.r / 5.5;
+                size *= 1;
+                size += 1;
+                return `${Math.round(size)}px`;
+            });
+            leaf.selectAll('.close-icon').remove(); // clear all existing close icons
+            if (selected) {
+                leaf // render 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);
+            leaf
+                .select('text')
+                .attr('font-family', () => {
+                if (fontRendering && fontRendering.label && fontRendering.label.family) {
+                    return fontRendering.label.family;
+                }
+                return 'inherit';
+            })
+                .attr('font-weight', () => {
+                if (fontRendering && fontRendering.label && fontRendering.label.weight) {
+                    return fontRendering.label.weight;
+                }
+                return 'inherit';
+            })
+                .selectAll('tspan')
+                .data((d) => {
+                if (d.r / 4 > 4.5) {
+                    // show text and number threshhold
+                    let label = (d.data.entity.label.charAt(0).toUpperCase()
+                        + d.data.entity.label.slice(1)).split(/ +/g);
+                    if (label.length > 3) {
+                        label = label.slice(0, 3);
+                        label[2] += '…';
+                    }
+                    return label;
+                }
+                if (d.r / 4 > 2.5) {
+                    // show text threshhold
+                    let label = (d.data.entity.label.charAt(0).toUpperCase()
+                        + d.data.entity.label.slice(1)).split(/ +/g);
+                    if (label.length > 3) {
+                        label = label.slice(0, 3);
+                        label[2] += '…';
+                    }
+                    return label;
+                }
+                return '';
+            })
+                .join('tspan')
+                .attr('x', 0)
+                .attr('y', (d, i, nodes) => `${i - (nodes.length + 1) / 2 + 0.97}em`)
+                .attr('fill', 'white')
+                .text((d) => d);
+            leaf
+                .select('.label-count')
+                .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';
+            })
+                .attr('fill', 'white')
+                .text((d) => {
+                if (d.r / 4 > 2.5) {
+                    // show text and number threshhold
+                    return d.data.count;
+                }
+                return '';
+            })
+                .attr('y', (d) => {
+                let labelLength = d.data.entity.label.split(/ +/g);
+                if (labelLength.length > 3) {
+                    labelLength = labelLength.slice(0, 3);
+                }
+                return `${labelLength.length - (labelLength.length + 1) / 2 + 0.97}em`;
+            });
+            const g = leaf.enter().append('g');
+            g.attr('transform', (d) => `translate(${d.x + 1},${d.y + 1})`)
+                .attr('font-size', (d) => {
+                let size = d.r / 5.5;
+                size *= 1;
+                size += 1;
+                return `${Math.round(size)}px`;
+            })
+                .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);
+            g.append('clipPath')
+                .attr('id', (d) => { d.clipUid = `Clip-${d.data.entity.id}`; })
+                .append('use')
+                .attr('xlink:href', (d) => d.leafUid.href);
+            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';
+            })
+                .selectAll('tspan')
+                .data((d) => {
+                if (d.r / 4 > 4.5) {
+                    // show text and number threshhold
+                    let label = (d.data.entity.label.charAt(0).toUpperCase()
+                        + d.data.entity.label.slice(1)).split(/ +/g);
+                    if (label.length > 3) {
+                        label = label.slice(0, 3);
+                        label[2] += '…';
+                    }
+                    return label;
+                }
+                if (d.r / 4 > 2.5) {
+                    // show text threshhold
+                    let label = (d.data.entity.label.charAt(0).toUpperCase()
+                        + d.data.entity.label.slice(1)).split(/ +/g);
+                    if (label.length > 3) {
+                        label = label.slice(0, 3);
+                        label[2] += '…';
+                    }
+                    return label;
+                }
+                return '';
+            })
+                .join('tspan')
+                .attr('x', 0)
+                .attr('y', (d, i, nodes) => `${i - (nodes.length + 1) / 2 + 0.97}em`)
+                .attr('fill', 'white')
+                .text((d) => d)
+                .attr('fill-opacity', 0)
+                .transition(t) // enter() transition on <tspan>
+                .attr('fill-opacity', 1);
+            g.append('text') // Count label
+                .attr('class', 'label-count')
+                .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';
+            })
+                .attr('fill', 'white')
+                .text((d) => {
+                if (d.r / 4 > 2.5) {
+                    // show text and number threshhold
+                    return d.data.count;
+                }
+                return '';
+            })
+                .attr('y', (d) => {
+                let labelLength = d.data.entity.label.split(/ +/g);
+                if (labelLength.length > 3) {
+                    labelLength = labelLength.slice(0, 3);
+                }
+                return `${labelLength.length - (labelLength.length + 1) / 2 + 0.97}em`;
+            })
+                .attr('fill-opacity', 0)
+                .transition(t) // enter() transition on <text>
+                .attr('fill-opacity', 1);
+            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)';
+                });
+            }
+            this.emit('d3end', data); // communicate end of draw
+        };
+    }
+    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);
+    }
+}
+BubbleChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: BubbleChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BubbleChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", 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>", directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", 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>" }]
+        }], 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":"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","sourcesContent":["//---------------------------\n// BUBBLECHART.ts\n//---------------------------\nimport { Component, Input, AfterContentChecked } from '@angular/core';\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/**\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@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  draw = () => {\n    const { d3 } = this;\n    const {\n      containerId, data, height,\n      width, selected, transition,\n      colorMatch, shuffle,\n      fontRendering\n    } = this.data;\n    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';\n\n    if (!Array.isArray(data)) {\n      // Check if it is possible to draw with the current dataset\n      console.warn('(n7-bubble-chart) The data object is not in the expected format!');\n      return;\n    }\n\n    let t = d3\n      .transition()\n      .duration(0);\n    if (typeof transition === 'number') {\n      t = d3\n        .transition()\n        .duration(transition)\n        .ease(d3.easeCubicInOut);\n    }\n\n    const colorMap = d3.scaleOrdinal()\n      .domain(colorMatch ? colorMatch.domain : ['persona', 'luogo', 'organizzazione', 'cosa notevole'])\n      .range(colorMatch ? colorMatch.range : d3.schemeTableau10);\n\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    const pack = (children) => 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    const root = () => { // 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    const svg = d3\n      .select(`#${containerId}`)\n      .attr('viewBox', [0, 0, width, height])\n      .attr('font-family', 'Verdana, Geneva, sans-serif')\n      .attr('text-anchor', 'middle');\n\n    const leaf = svg.selectAll('g').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      .attr('font-size', (d) => {\n        let size = d.r / 5.5;\n        size *= 1;\n        size += 1;\n        return `${Math.round(size)}px`;\n      });\n\n    leaf.selectAll('.close-icon').remove(); // clear all existing close icons\n    if (selected) {\n      leaf // render 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    leaf\n      .select('text')\n      .attr('font-family', () => {\n        if (fontRendering && fontRendering.label && fontRendering.label.family) {\n          return fontRendering.label.family;\n        }\n        return 'inherit';\n      })\n      .attr('font-weight', () => {\n        if (fontRendering && fontRendering.label && fontRendering.label.weight) {\n          return fontRendering.label.weight;\n        }\n        return 'inherit';\n      })\n      .selectAll('tspan')\n      .data((d) => {\n        if (d.r / 4 > 4.5) {\n          // show text and number threshhold\n          let label = (\n            d.data.entity.label.charAt(0).toUpperCase()\n            + d.data.entity.label.slice(1)\n          ).split(/ +/g);\n          if (label.length > 3) {\n            label = label.slice(0, 3);\n            label[2] += '…';\n          }\n          return label;\n        } if (d.r / 4 > 2.5) {\n          // show text threshhold\n          let label = (\n            d.data.entity.label.charAt(0).toUpperCase()\n            + d.data.entity.label.slice(1)\n          ).split(/ +/g);\n          if (label.length > 3) {\n            label = label.slice(0, 3);\n            label[2] += '…';\n          }\n          return label;\n        }\n        return '';\n      })\n      .join('tspan')\n      .attr('x', 0)\n      .attr('y', (d, i, nodes) => `${i - (nodes.length + 1) / 2 + 0.97}em`)\n      .attr('fill', 'white')\n      .text((d) => d);\n\n    leaf\n      .select('.label-count')\n      .attr('font-family', () => {\n        if (fontRendering && fontRendering.counter && fontRendering.counter.family) {\n          return fontRendering.counter.family;\n        }\n        return 'inherit';\n      })\n      .attr('font-weight', () => {\n        if (fontRendering && fontRendering.counter && fontRendering.counter.weight) {\n          return fontRendering.counter.weight;\n        }\n        return 'inherit';\n      })\n      .attr('fill', 'white')\n      .text((d) => {\n        if (d.r / 4 > 2.5) {\n          // show text and number threshhold\n          return d.data.count;\n        }\n        return '';\n      })\n      .attr('y', (d) => {\n        let labelLength = d.data.entity.label.split(/ +/g);\n        if (labelLength.length > 3) {\n          labelLength = labelLength.slice(0, 3);\n        }\n        return `${labelLength.length - (labelLength.length + 1) / 2 + 0.97}em`;\n      });\n\n\n    const g = leaf.enter().append('g');\n\n    g.attr('transform', (d) => `translate(${d.x + 1},${d.y + 1})`)\n      .attr('font-size', (d) => {\n        let size = d.r / 5.5;\n        size *= 1;\n        size += 1;\n        return `${Math.round(size)}px`;\n      })\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) => { d.leafUid = d.data.entity.id; })\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    g.append('clipPath')\n      .attr('id', (d) => { d.clipUid = `Clip-${d.data.entity.id}`; })\n      .append('use')\n      .attr('xlink:href', (d) => d.leafUid.href);\n\n    g.append('text')\n      .attr('font-family', () => {\n        if (fontRendering && fontRendering.label && fontRendering.label.family) {\n          return fontRendering.label.family;\n        }\n        return 'inherit';\n      })\n      .attr('font-weight', () => {\n        if (fontRendering && fontRendering && fontRendering.label && fontRendering.label.weight) {\n          return fontRendering.label.weight;\n        }\n        return 'inherit';\n      })\n      .selectAll('tspan')\n      .data((d) => {\n        if (d.r / 4 > 4.5) {\n          // show text and number threshhold\n          let label = (\n            d.data.entity.label.charAt(0).toUpperCase()\n            + d.data.entity.label.slice(1)\n          ).split(/ +/g);\n          if (label.length > 3) {\n            label = label.slice(0, 3);\n            label[2] += '…';\n          }\n          return label;\n        } if (d.r / 4 > 2.5) {\n          // show text threshhold\n          let label = (\n            d.data.entity.label.charAt(0).toUpperCase()\n            + d.data.entity.label.slice(1)\n          ).split(/ +/g);\n          if (label.length > 3) {\n            label = label.slice(0, 3);\n            label[2] += '…';\n          }\n          return label;\n        }\n        return '';\n      })\n      .join('tspan')\n      .attr('x', 0)\n      .attr('y', (d, i, nodes) => `${i - (nodes.length + 1) / 2 + 0.97}em`)\n      .attr('fill', 'white')\n      .text((d) => d)\n      .attr('fill-opacity', 0)\n      .transition(t) // enter() transition on <tspan>\n      .attr('fill-opacity', 1);\n\n    g.append('text') // Count label\n      .attr('class', 'label-count')\n      .attr('font-family', () => {\n        if (fontRendering && fontRendering.counter && fontRendering.counter.family) {\n          return fontRendering.counter.family;\n        }\n        return 'inherit';\n      })\n      .attr('font-weight', () => {\n        if (fontRendering && fontRendering.counter && fontRendering.counter.weight) {\n          return fontRendering.counter.weight;\n        }\n        return 'inherit';\n      })\n      .attr('fill', 'white')\n      .text((d) => {\n        if (d.r / 4 > 2.5) {\n          // show text and number threshhold\n          return d.data.count;\n        }\n        return '';\n      })\n      .attr('y', (d) => {\n        let labelLength = d.data.entity.label.split(/ +/g);\n        if (labelLength.length > 3) {\n          labelLength = labelLength.slice(0, 3);\n        }\n        return `${labelLength.length - (labelLength.length + 1) / 2 + 0.97}em`;\n      })\n      .attr('fill-opacity', 0)\n      .transition(t) // enter() transition on <text>\n      .attr('fill-opacity', 1);\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    this.emit('d3end', data); // communicate end of draw\n  }\n}\n","<div *ngIf=\"data\" class=\"n7-bubble-chart {{ data.classes || '' }}\">\n    <svg #bubbleChart id=\"{{data.containerId}}\"></svg>\n</div>"]}