@tolle_/tolle-ui 18.2.29 → 18.2.30

package/esm2022/lib/chart-pie.component.mjs

@@ -0,0 +1,386 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { cva } from 'class-variance-authority';
+import { cn } from './utils/cn';
+import { ChartService, ChartColorScale } from './chart.service';
+import { ChartTableComponent } from './chart.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+let chartPieId = 0;
+/** Converts an angle measured clockwise from 12 o'clock into svg coordinates. */
+export function polarPoint(cx, cy, r, angle) {
+    return [cx + r * Math.sin(angle), cy - r * Math.cos(angle)];
+}
+/**
+ * Builds one slice. `innerRadius` above zero produces a donut segment; a span
+ * covering the full circle is drawn as two half arcs, because an SVG arc whose
+ * start and end points coincide renders nothing at all.
+ */
+export function arcPath(cx, cy, outer, inner, start, end) {
+    const span = end - start;
+    if (span <= 0)
+        return '';
+    if (span >= Math.PI * 2 - 1e-6) {
+        const mid = start + Math.PI;
+        return arcPath(cx, cy, outer, inner, start, mid) + ' ' + arcPath(cx, cy, outer, inner, mid, end);
+    }
+    const large = span > Math.PI ? 1 : 0;
+    const [ox0, oy0] = polarPoint(cx, cy, outer, start);
+    const [ox1, oy1] = polarPoint(cx, cy, outer, end);
+    if (inner > 0) {
+        const [ix1, iy1] = polarPoint(cx, cy, inner, end);
+        const [ix0, iy0] = polarPoint(cx, cy, inner, start);
+        return ('M ' + ox0 + ' ' + oy0 +
+            ' A ' + outer + ' ' + outer + ' 0 ' + large + ' 1 ' + ox1 + ' ' + oy1 +
+            ' L ' + ix1 + ' ' + iy1 +
+            ' A ' + inner + ' ' + inner + ' 0 ' + large + ' 0 ' + ix0 + ' ' + iy0 +
+            ' Z');
+    }
+    return ('M ' + cx + ' ' + cy +
+        ' L ' + ox0 + ' ' + oy0 +
+        ' A ' + outer + ' ' + outer + ' 0 ' + large + ' 1 ' + ox1 + ' ' + oy1 +
+        ' Z');
+}
+const chartPieVariants = cva('relative w-full', {
+    variants: {
+        variant: {
+            default: '',
+            card: 'rounded-lg border border-border bg-background p-4',
+        },
+    },
+    defaultVariants: { variant: 'default' },
+});
+/**
+ * A pie or donut drawn from hand-written SVG arcs.
+ *
+ * Slices are separated by a real 2px angular gap rather than a stroke, so what
+ * divides them is surface rather than added ink. Colour is assigned by slice
+ * label, so re-sorting or filtering the data never repaints a slice, and a
+ * sixth slice falls back to a neutral rather than reusing `--chart-1`.
+ *
+ * Renders its own legend at two or more slices, a per-slice hover tooltip, and
+ * the same accessible `tolle-chart-table` fallback as `tolle-chart`.
+ * @new
+ */
+export class ChartPieComponent {
+    /** Rows to plot, one slice each. @default [] */
+    data = [];
+    /** Row key holding each slice's numeric value. @default 'value' */
+    valueKey = 'value';
+    /** Row key holding each slice's label. @default 'label' */
+    labelKey = 'label';
+    /** Cuts a hole in the middle, making it a donut. @default false */
+    donut = false;
+    /** Hole size as a fraction of the outer radius, used when `donut` is set. @default 0.6 */
+    innerRadius = 0.6;
+    /** Width and height of the square plot in px. @default 240 */
+    size = 240;
+    /** Angular gap between slices, expressed in px of arc at the outer edge. @default 2 */
+    gap = 2;
+    /** Accessible name for the chart, used as the svg `<title>`. @default '' */
+    ariaLabel = '';
+    /** Longer summary used as the svg `<desc>`. Falls back to `ariaLabel`. @default '' */
+    description = '';
+    /** Shows the data table instead of leaving it visually hidden. @default false */
+    showTable = false;
+    /** Column header the table fallback gives the label column. @default 'Category' */
+    labelHeader = 'Category';
+    /** Column header the table fallback gives the value column. @default 'Value' */
+    valueHeader = 'Value';
+    /** Visual treatment of the chart frame. @default 'default' */
+    variant = 'default';
+    /** Extra Tailwind classes merged onto the chart via `cn()` (last-wins). */
+    class = '';
+    /** Emitted with the hovered slice index, or null when the pointer leaves. */
+    activeIndexChange = new EventEmitter();
+    cdr = inject(ChangeDetectorRef);
+    /** Only used to feed the shared table fallback; the pie owns its own colours. */
+    tableSource = inject(ChartService);
+    colors = new ChartColorScale();
+    /** Id of the table fallback, referenced by the svg's `aria-describedby`. */
+    tableId = 'chart-pie-table-' + chartPieId++;
+    /** Index of the hovered slice, or null. */
+    activeIndex = null;
+    ngOnChanges() {
+        // Reserve palette slots in data order, so a slice keeps its colour when the
+        // data is later re-sorted or filtered.
+        this.colors.register(this.labels);
+        this.tableSource.configure({
+            data: this.data ?? [],
+            xKey: this.labelKey,
+            series: [{ key: this.valueKey, label: this.valueHeader }],
+        });
+        this._slices = this.computeSlices();
+        // A bound `class` input is written through Angular's styling path,
+        // which does not mark an OnPush view dirty on its own.
+        this.cdr.markForCheck();
+    }
+    get labels() {
+        return (this.data ?? []).map((row) => {
+            const raw = row?.[this.labelKey];
+            return raw == null ? '' : String(raw);
+        });
+    }
+    get viewBox() {
+        return '0 0 ' + this.size + ' ' + this.size;
+    }
+    get outerRadius() {
+        return this.size / 2;
+    }
+    /**
+     * Resolved slices in data order, each already padded for the surface gap.
+     *
+     * Computed once per input change, NOT per read. Three template bindings read
+     * this each pass; when it rebuilt the array every time, `*ngFor` saw fresh
+     * identities and tore down every `<path>` on every change-detection run.
+     * Destroying the node under the pointer re-fires `pointerenter`, which calls
+     * `markForCheck`, which schedules another pass — the chart locked the page up.
+     */
+    get slices() {
+        return this._slices;
+    }
+    _slices = [];
+    /** Identity for `*ngFor`, so a redraw patches attributes instead of replacing nodes. */
+    trackSlice = (_, slice) => slice.label;
+    computeSlices() {
+        const rows = this.data ?? [];
+        const values = rows.map((row) => {
+            const num = Number(row?.[this.valueKey]);
+            // A pie divides a whole; a negative share has no meaning in one.
+            return Number.isFinite(num) && num > 0 ? num : 0;
+        });
+        const total = values.reduce((sum, v) => sum + v, 0);
+        if (total <= 0)
+            return [];
+        const cx = this.size / 2;
+        const cy = this.size / 2;
+        const outer = this.outerRadius;
+        const inner = this.donut ? outer * Math.min(0.95, Math.max(0, this.innerRadius)) : 0;
+        // Turn a px gap at the rim into the angle that subtends it.
+        const pad = outer > 0 ? this.gap / outer : 0;
+        const out = [];
+        let cursor = 0;
+        for (let i = 0; i < rows.length; i++) {
+            const value = values[i];
+            if (value <= 0)
+                continue;
+            const span = (value / total) * Math.PI * 2;
+            const start = cursor;
+            const end = cursor + span;
+            cursor = end;
+            // Never let the gap eat a slice: a sliver keeps a hairline of itself.
+            const usable = Math.max(span * 0.2, span - pad);
+            const inset = (span - usable) / 2;
+            const label = this.labels[i];
+            const mid = start + span / 2;
+            const [anchorX, anchorY] = polarPoint(cx, cy, (outer + inner) / 2, mid);
+            out.push({
+                label,
+                value,
+                percent: value / total,
+                color: this.colors.colorFor(label),
+                d: arcPath(cx, cy, outer, inner, start + inset, end - inset),
+                anchorX,
+                anchorY,
+            });
+        }
+        return out;
+    }
+    get activeSlice() {
+        if (this.activeIndex === null)
+            return null;
+        return this.slices[this.activeIndex] ?? null;
+    }
+    get tooltipLeft() {
+        const slice = this.activeSlice;
+        if (!slice)
+            return 0;
+        // Flip toward the centre rather than let the readout leave the frame.
+        return slice.anchorX > this.size / 2
+            ? Math.max(0, slice.anchorX - 140)
+            : Math.min(this.size, slice.anchorX + 8);
+    }
+    get tooltipTop() {
+        return this.activeSlice ? this.activeSlice.anchorY : 0;
+    }
+    formatValue(value) {
+        return value.toLocaleString('en-US');
+    }
+    formatPercent(percent) {
+        return (percent * 100).toFixed(1) + '%';
+    }
+    onEnter(index) {
+        if (this.activeIndex === index)
+            return;
+        this.activeIndex = index;
+        this.activeIndexChange.emit(index);
+        this.cdr.markForCheck();
+    }
+    onLeave() {
+        if (this.activeIndex === null)
+            return;
+        this.activeIndex = null;
+        this.activeIndexChange.emit(null);
+        this.cdr.markForCheck();
+    }
+    get computedClass() {
+        return cn(chartPieVariants({ variant: this.variant }), this.class);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartPieComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ChartPieComponent, isStandalone: true, selector: "tolle-chart-pie", inputs: { data: "data", valueKey: "valueKey", labelKey: "labelKey", donut: "donut", innerRadius: "innerRadius", size: "size", gap: "gap", ariaLabel: "ariaLabel", description: "description", showTable: "showTable", labelHeader: "labelHeader", valueHeader: "valueHeader", variant: "variant", class: "class" }, outputs: { activeIndexChange: "activeIndexChange" }, providers: [ChartService], usesOnChanges: true, ngImport: i0, template: `
+    <div [class]="computedClass">
+      <div class="relative w-full">
+        <svg
+          role="img"
+          width="100%"
+          [attr.height]="size"
+          [attr.viewBox]="viewBox"
+          [attr.aria-label]="ariaLabel || null"
+          [attr.aria-describedby]="tableId"
+          class="block w-full"
+          (pointerleave)="onLeave()"
+        >
+          <title>{{ ariaLabel }}</title>
+          <desc>{{ description || ariaLabel }}</desc>
+
+          <svg:path
+            *ngFor="let slice of slices; let i = index; trackBy: trackSlice"
+            [attr.d]="slice.d"
+            [attr.fill]="slice.color"
+            [attr.fill-opacity]="activeIndex === i ? 1 : 0.85"
+            (pointerenter)="onEnter(i)"
+          ></svg:path>
+        </svg>
+
+        <div
+          *ngIf="activeSlice"
+          role="status"
+          aria-live="polite"
+          class="pointer-events-none absolute z-10 min-w-[8rem] rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md"
+          [style.left.px]="tooltipLeft"
+          [style.top.px]="tooltipTop"
+        >
+          <div class="flex items-center gap-2 text-xs">
+            <span class="h-2 w-2 shrink-0 rounded-[2px]" [style.background]="activeSlice.color"></span>
+            <span class="text-muted-foreground">{{ activeSlice.label }}</span>
+            <span class="ml-auto font-medium tabular-nums text-foreground">
+              {{ formatValue(activeSlice.value) }}
+            </span>
+          </div>
+          <p class="mt-0.5 text-right text-xs text-muted-foreground tabular-nums">
+            {{ formatPercent(activeSlice.percent) }}
+          </p>
+        </div>
+      </div>
+
+      <ul *ngIf="slices.length > 1" class="flex flex-wrap items-center justify-center gap-x-4 gap-y-1 pt-2 text-xs">
+        <li *ngFor="let slice of slices; trackBy: trackSlice" class="flex items-center gap-1.5">
+          <span class="h-2 w-2 shrink-0 rounded-[2px]" [style.background]="slice.color"></span>
+          <span class="text-muted-foreground">{{ slice.label }}</span>
+        </li>
+      </ul>
+
+      <tolle-chart-table
+        [tableId]="tableId"
+        [visible]="showTable"
+        [xHeader]="labelHeader"
+        [caption]="ariaLabel || 'Chart data'"
+      ></tolle-chart-table>
+    </div>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: ChartTableComponent, selector: "tolle-chart-table", inputs: ["visible", "tableId", "xHeader", "caption", "class"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChartPieComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tolle-chart-pie', standalone: true, imports: [CommonModule, ChartTableComponent], providers: [ChartService], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div [class]="computedClass">
+      <div class="relative w-full">
+        <svg
+          role="img"
+          width="100%"
+          [attr.height]="size"
+          [attr.viewBox]="viewBox"
+          [attr.aria-label]="ariaLabel || null"
+          [attr.aria-describedby]="tableId"
+          class="block w-full"
+          (pointerleave)="onLeave()"
+        >
+          <title>{{ ariaLabel }}</title>
+          <desc>{{ description || ariaLabel }}</desc>
+
+          <svg:path
+            *ngFor="let slice of slices; let i = index; trackBy: trackSlice"
+            [attr.d]="slice.d"
+            [attr.fill]="slice.color"
+            [attr.fill-opacity]="activeIndex === i ? 1 : 0.85"
+            (pointerenter)="onEnter(i)"
+          ></svg:path>
+        </svg>
+
+        <div
+          *ngIf="activeSlice"
+          role="status"
+          aria-live="polite"
+          class="pointer-events-none absolute z-10 min-w-[8rem] rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md"
+          [style.left.px]="tooltipLeft"
+          [style.top.px]="tooltipTop"
+        >
+          <div class="flex items-center gap-2 text-xs">
+            <span class="h-2 w-2 shrink-0 rounded-[2px]" [style.background]="activeSlice.color"></span>
+            <span class="text-muted-foreground">{{ activeSlice.label }}</span>
+            <span class="ml-auto font-medium tabular-nums text-foreground">
+              {{ formatValue(activeSlice.value) }}
+            </span>
+          </div>
+          <p class="mt-0.5 text-right text-xs text-muted-foreground tabular-nums">
+            {{ formatPercent(activeSlice.percent) }}
+          </p>
+        </div>
+      </div>
+
+      <ul *ngIf="slices.length > 1" class="flex flex-wrap items-center justify-center gap-x-4 gap-y-1 pt-2 text-xs">
+        <li *ngFor="let slice of slices; trackBy: trackSlice" class="flex items-center gap-1.5">
+          <span class="h-2 w-2 shrink-0 rounded-[2px]" [style.background]="slice.color"></span>
+          <span class="text-muted-foreground">{{ slice.label }}</span>
+        </li>
+      </ul>
+
+      <tolle-chart-table
+        [tableId]="tableId"
+        [visible]="showTable"
+        [xHeader]="labelHeader"
+        [caption]="ariaLabel || 'Chart data'"
+      ></tolle-chart-table>
+    </div>
+  `, styles: [":host{display:block}\n"] }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], valueKey: [{
+                type: Input
+            }], labelKey: [{
+                type: Input
+            }], donut: [{
+                type: Input
+            }], innerRadius: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], gap: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], showTable: [{
+                type: Input
+            }], labelHeader: [{
+                type: Input
+            }], valueHeader: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], activeIndexChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-pie.component.js","sourceRoot":"","sources":["../../../../projects/tolle/src/lib/chart-pie.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ChangeDetectorRef, OnChanges, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { cva, type VariantProps } from 'class-variance-authority';\nimport { cn } from './utils/cn';\nimport { ChartService, ChartColorScale } from './chart.service';\nimport { ChartTableComponent } from './chart.component';\n\nlet chartPieId = 0;\n\n/** One resolved slice: its geometry, its paint, and the numbers behind it. */\nexport interface ChartPieSlice {\n  label: string;\n  value: number;\n  percent: number;\n  color: string;\n  /** The arc path, already padded for the surface gap. */\n  d: string;\n  /** Mid-angle point on the outer edge, used to place the tooltip. */\n  anchorX: number;\n  anchorY: number;\n}\n\n/** Converts an angle measured clockwise from 12 o'clock into svg coordinates. */\nexport function polarPoint(cx: number, cy: number, r: number, angle: number): [number, number] {\n  return [cx + r * Math.sin(angle), cy - r * Math.cos(angle)];\n}\n\n/**\n * Builds one slice. `innerRadius` above zero produces a donut segment; a span\n * covering the full circle is drawn as two half arcs, because an SVG arc whose\n * start and end points coincide renders nothing at all.\n */\nexport function arcPath(\n  cx: number,\n  cy: number,\n  outer: number,\n  inner: number,\n  start: number,\n  end: number\n): string {\n  const span = end - start;\n  if (span <= 0) return '';\n\n  if (span >= Math.PI * 2 - 1e-6) {\n    const mid = start + Math.PI;\n    return arcPath(cx, cy, outer, inner, start, mid) + ' ' + arcPath(cx, cy, outer, inner, mid, end);\n  }\n\n  const large = span > Math.PI ? 1 : 0;\n  const [ox0, oy0] = polarPoint(cx, cy, outer, start);\n  const [ox1, oy1] = polarPoint(cx, cy, outer, end);\n\n  if (inner > 0) {\n    const [ix1, iy1] = polarPoint(cx, cy, inner, end);\n    const [ix0, iy0] = polarPoint(cx, cy, inner, start);\n    return (\n      'M ' + ox0 + ' ' + oy0 +\n      ' A ' + outer + ' ' + outer + ' 0 ' + large + ' 1 ' + ox1 + ' ' + oy1 +\n      ' L ' + ix1 + ' ' + iy1 +\n      ' A ' + inner + ' ' + inner + ' 0 ' + large + ' 0 ' + ix0 + ' ' + iy0 +\n      ' Z'\n    );\n  }\n\n  return (\n    'M ' + cx + ' ' + cy +\n    ' L ' + ox0 + ' ' + oy0 +\n    ' A ' + outer + ' ' + outer + ' 0 ' + large + ' 1 ' + ox1 + ' ' + oy1 +\n    ' Z'\n  );\n}\n\nconst chartPieVariants = cva('relative w-full', {\n  variants: {\n    variant: {\n      default: '',\n      card: 'rounded-lg border border-border bg-background p-4',\n    },\n  },\n  defaultVariants: { variant: 'default' },\n});\n\nexport type ChartPieProps = VariantProps<typeof chartPieVariants>;\n\n/**\n * A pie or donut drawn from hand-written SVG arcs.\n *\n * Slices are separated by a real 2px angular gap rather than a stroke, so what\n * divides them is surface rather than added ink. Colour is assigned by slice\n * label, so re-sorting or filtering the data never repaints a slice, and a\n * sixth slice falls back to a neutral rather than reusing `--chart-1`.\n *\n * Renders its own legend at two or more slices, a per-slice hover tooltip, and\n * the same accessible `tolle-chart-table` fallback as `tolle-chart`.\n * @new\n */\n@Component({\n  selector: 'tolle-chart-pie',\n  styles: [':host { display: block; }'],\n  standalone: true,\n  imports: [CommonModule, ChartTableComponent],\n  providers: [ChartService],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div [class]=\"computedClass\">\n      <div class=\"relative w-full\">\n        <svg\n          role=\"img\"\n          width=\"100%\"\n          [attr.height]=\"size\"\n          [attr.viewBox]=\"viewBox\"\n          [attr.aria-label]=\"ariaLabel || null\"\n          [attr.aria-describedby]=\"tableId\"\n          class=\"block w-full\"\n          (pointerleave)=\"onLeave()\"\n        >\n          <title>{{ ariaLabel }}</title>\n          <desc>{{ description || ariaLabel }}</desc>\n\n          <svg:path\n            *ngFor=\"let slice of slices; let i = index; trackBy: trackSlice\"\n            [attr.d]=\"slice.d\"\n            [attr.fill]=\"slice.color\"\n            [attr.fill-opacity]=\"activeIndex === i ? 1 : 0.85\"\n            (pointerenter)=\"onEnter(i)\"\n          ></svg:path>\n        </svg>\n\n        <div\n          *ngIf=\"activeSlice\"\n          role=\"status\"\n          aria-live=\"polite\"\n          class=\"pointer-events-none absolute z-10 min-w-[8rem] rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-md\"\n          [style.left.px]=\"tooltipLeft\"\n          [style.top.px]=\"tooltipTop\"\n        >\n          <div class=\"flex items-center gap-2 text-xs\">\n            <span class=\"h-2 w-2 shrink-0 rounded-[2px]\" [style.background]=\"activeSlice.color\"></span>\n            <span class=\"text-muted-foreground\">{{ activeSlice.label }}</span>\n            <span class=\"ml-auto font-medium tabular-nums text-foreground\">\n              {{ formatValue(activeSlice.value) }}\n            </span>\n          </div>\n          <p class=\"mt-0.5 text-right text-xs text-muted-foreground tabular-nums\">\n            {{ formatPercent(activeSlice.percent) }}\n          </p>\n        </div>\n      </div>\n\n      <ul *ngIf=\"slices.length > 1\" class=\"flex flex-wrap items-center justify-center gap-x-4 gap-y-1 pt-2 text-xs\">\n        <li *ngFor=\"let slice of slices; trackBy: trackSlice\" class=\"flex items-center gap-1.5\">\n          <span class=\"h-2 w-2 shrink-0 rounded-[2px]\" [style.background]=\"slice.color\"></span>\n          <span class=\"text-muted-foreground\">{{ slice.label }}</span>\n        </li>\n      </ul>\n\n      <tolle-chart-table\n        [tableId]=\"tableId\"\n        [visible]=\"showTable\"\n        [xHeader]=\"labelHeader\"\n        [caption]=\"ariaLabel || 'Chart data'\"\n      ></tolle-chart-table>\n    </div>\n  `,\n})\nexport class ChartPieComponent implements OnChanges {\n  /** Rows to plot, one slice each. @default [] */\n  @Input() data: Record<string, any>[] = [];\n  /** Row key holding each slice's numeric value. @default 'value' */\n  @Input() valueKey = 'value';\n  /** Row key holding each slice's label. @default 'label' */\n  @Input() labelKey = 'label';\n  /** Cuts a hole in the middle, making it a donut. @default false */\n  @Input() donut = false;\n  /** Hole size as a fraction of the outer radius, used when `donut` is set. @default 0.6 */\n  @Input() innerRadius = 0.6;\n  /** Width and height of the square plot in px. @default 240 */\n  @Input() size = 240;\n  /** Angular gap between slices, expressed in px of arc at the outer edge. @default 2 */\n  @Input() gap = 2;\n  /** Accessible name for the chart, used as the svg `<title>`. @default '' */\n  @Input() ariaLabel = '';\n  /** Longer summary used as the svg `<desc>`. Falls back to `ariaLabel`. @default '' */\n  @Input() description = '';\n  /** Shows the data table instead of leaving it visually hidden. @default false */\n  @Input() showTable = false;\n  /** Column header the table fallback gives the label column. @default 'Category' */\n  @Input() labelHeader = 'Category';\n  /** Column header the table fallback gives the value column. @default 'Value' */\n  @Input() valueHeader = 'Value';\n  /** Visual treatment of the chart frame. @default 'default' */\n  @Input() variant: ChartPieProps['variant'] = 'default';\n  /** Extra Tailwind classes merged onto the chart via `cn()` (last-wins). */\n  @Input() class = '';\n\n  /** Emitted with the hovered slice index, or null when the pointer leaves. */\n  @Output() activeIndexChange = new EventEmitter<number | null>();\n\n  private readonly cdr = inject(ChangeDetectorRef);\n  /** Only used to feed the shared table fallback; the pie owns its own colours. */\n  private readonly tableSource = inject(ChartService);\n  private readonly colors = new ChartColorScale();\n\n  /** Id of the table fallback, referenced by the svg's `aria-describedby`. */\n  readonly tableId = 'chart-pie-table-' + chartPieId++;\n\n  /** Index of the hovered slice, or null. */\n  activeIndex: number | null = null;\n\n  ngOnChanges(): void {\n    // Reserve palette slots in data order, so a slice keeps its colour when the\n    // data is later re-sorted or filtered.\n    this.colors.register(this.labels);\n    this.tableSource.configure({\n      data: this.data ?? [],\n      xKey: this.labelKey,\n      series: [{ key: this.valueKey, label: this.valueHeader }],\n    });\n    this._slices = this.computeSlices();\n  \n    // A bound `class` input is written through Angular's styling path,\n    // which does not mark an OnPush view dirty on its own.\n    this.cdr.markForCheck();\n  }\n\n  private get labels(): string[] {\n    return (this.data ?? []).map((row) => {\n      const raw = row?.[this.labelKey];\n      return raw == null ? '' : String(raw);\n    });\n  }\n\n  get viewBox(): string {\n    return '0 0 ' + this.size + ' ' + this.size;\n  }\n\n  private get outerRadius(): number {\n    return this.size / 2;\n  }\n\n  /**\n   * Resolved slices in data order, each already padded for the surface gap.\n   *\n   * Computed once per input change, NOT per read. Three template bindings read\n   * this each pass; when it rebuilt the array every time, `*ngFor` saw fresh\n   * identities and tore down every `<path>` on every change-detection run.\n   * Destroying the node under the pointer re-fires `pointerenter`, which calls\n   * `markForCheck`, which schedules another pass — the chart locked the page up.\n   */\n  get slices(): ChartPieSlice[] {\n    return this._slices;\n  }\n\n  private _slices: ChartPieSlice[] = [];\n\n  /** Identity for `*ngFor`, so a redraw patches attributes instead of replacing nodes. */\n  trackSlice = (_: number, slice: ChartPieSlice): string => slice.label;\n\n  private computeSlices(): ChartPieSlice[] {\n    const rows = this.data ?? [];\n    const values = rows.map((row) => {\n      const num = Number(row?.[this.valueKey]);\n      // A pie divides a whole; a negative share has no meaning in one.\n      return Number.isFinite(num) && num > 0 ? num : 0;\n    });\n    const total = values.reduce((sum, v) => sum + v, 0);\n    if (total <= 0) return [];\n\n    const cx = this.size / 2;\n    const cy = this.size / 2;\n    const outer = this.outerRadius;\n    const inner = this.donut ? outer * Math.min(0.95, Math.max(0, this.innerRadius)) : 0;\n    // Turn a px gap at the rim into the angle that subtends it.\n    const pad = outer > 0 ? this.gap / outer : 0;\n\n    const out: ChartPieSlice[] = [];\n    let cursor = 0;\n\n    for (let i = 0; i < rows.length; i++) {\n      const value = values[i];\n      if (value <= 0) continue;\n\n      const span = (value / total) * Math.PI * 2;\n      const start = cursor;\n      const end = cursor + span;\n      cursor = end;\n\n      // Never let the gap eat a slice: a sliver keeps a hairline of itself.\n      const usable = Math.max(span * 0.2, span - pad);\n      const inset = (span - usable) / 2;\n      const label = this.labels[i];\n      const mid = start + span / 2;\n      const [anchorX, anchorY] = polarPoint(cx, cy, (outer + inner) / 2, mid);\n\n      out.push({\n        label,\n        value,\n        percent: value / total,\n        color: this.colors.colorFor(label),\n        d: arcPath(cx, cy, outer, inner, start + inset, end - inset),\n        anchorX,\n        anchorY,\n      });\n    }\n\n    return out;\n  }\n\n  get activeSlice(): ChartPieSlice | null {\n    if (this.activeIndex === null) return null;\n    return this.slices[this.activeIndex] ?? null;\n  }\n\n  get tooltipLeft(): number {\n    const slice = this.activeSlice;\n    if (!slice) return 0;\n    // Flip toward the centre rather than let the readout leave the frame.\n    return slice.anchorX > this.size / 2\n      ? Math.max(0, slice.anchorX - 140)\n      : Math.min(this.size, slice.anchorX + 8);\n  }\n\n  get tooltipTop(): number {\n    return this.activeSlice ? this.activeSlice.anchorY : 0;\n  }\n\n  formatValue(value: number): string {\n    return value.toLocaleString('en-US');\n  }\n\n  formatPercent(percent: number): string {\n    return (percent * 100).toFixed(1) + '%';\n  }\n\n  onEnter(index: number): void {\n    if (this.activeIndex === index) return;\n    this.activeIndex = index;\n    this.activeIndexChange.emit(index);\n    this.cdr.markForCheck();\n  }\n\n  onLeave(): void {\n    if (this.activeIndex === null) return;\n    this.activeIndex = null;\n    this.activeIndexChange.emit(null);\n    this.cdr.markForCheck();\n  }\n\n  get computedClass() {\n    return cn(chartPieVariants({ variant: this.variant }), this.class);\n  }\n}\n"]}