@fusedashlabs/widgets 0.2.0 → 0.4.0

package/dist/components/polar-area-chart/lib/domain.js

@@ -0,0 +1,67 @@
+import { FD } from "../../../utils/fusedash-visual.js";
+function polarLabelAnchor(labelAngle) {
+  if (Math.abs(labelAngle) === Math.PI / 2) return "middle";
+  return labelAngle < Math.PI / 2 && labelAngle > -Math.PI / 2 ? "start" : "end";
+}
+function polarSectorAngles(count) {
+  if (count <= 0) return [];
+  const slice = Math.PI * 2 / count;
+  return Array.from({ length: count }, (_v, i) => ({
+    startAngle: i * slice,
+    endAngle: (i + 1) * slice
+  }));
+}
+function polarGroupedSectorAngles(categories, sectors) {
+  if (!categories.length || !sectors.length) return [];
+  const slice = Math.PI * 2 / categories.length;
+  const countByCategory = /* @__PURE__ */ new Map();
+  const indexInCategory = /* @__PURE__ */ new Map();
+  for (const sector of sectors) {
+    const next = countByCategory.get(sector.key) ?? 0;
+    indexInCategory.set(sector, next);
+    countByCategory.set(sector.key, next + 1);
+  }
+  return sectors.map((sector) => {
+    const categoryIndex = Math.max(0, categories.indexOf(sector.key));
+    const members = countByCategory.get(sector.key) ?? 1;
+    const offset = indexInCategory.get(sector) ?? 0;
+    const inner = slice / members;
+    const base = categoryIndex * slice;
+    return { startAngle: base + offset * inner, endAngle: base + (offset + 1) * inner };
+  });
+}
+function polarRadialTicks(maxValue, steps) {
+  if (!Number.isFinite(maxValue) || maxValue <= 0 || steps <= 0) return [];
+  return Array.from({ length: steps }, (_v, i) => (i + 1) * maxValue / steps);
+}
+function polarMaxValue(sectors) {
+  let max = 0;
+  for (const sector of sectors) {
+    if (sector.value > max) max = sector.value;
+  }
+  return max;
+}
+function polarLabelGutter(categories, plotWidth) {
+  const longest = categories.reduce((max, c) => Math.max(max, String(c).length), 0);
+  const estimated = longest * FD.polarCategoryLabelSize * FD.polarLabelCharWidth;
+  const ceiling = Math.min(
+    FD.polarLabelGutterMax,
+    Math.max(0, plotWidth) * FD.polarLabelGutterMaxFraction
+  );
+  return Math.max(FD.polarLabelGutterMin, Math.min(estimated, ceiling));
+}
+function polarOuterRadius(plotWidth, plotHeight, labelGutter) {
+  const byWidth = plotWidth / 2 - labelGutter - FD.polarCategoryLabelOffset;
+  const byHeight = plotHeight / 2 - FD.polarCategoryLabelOffset - FD.polarCategoryLabelSize / 2;
+  return Math.max(0, Math.min(byWidth, byHeight));
+}
+export {
+  polarGroupedSectorAngles,
+  polarLabelAnchor,
+  polarLabelGutter,
+  polarMaxValue,
+  polarOuterRadius,
+  polarRadialTicks,
+  polarSectorAngles
+};
+//# sourceMappingURL=domain.js.map

package/dist/components/polar-area-chart/lib/domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.js","sources":["../../../../src/components/polar-area-chart/lib/domain.ts"],"sourcesContent":["import { FD } from '../../../utils/fusedash-visual.js';\nimport type { PolarAreaSector } from './types.js';\n\n/** Text anchor for a category label, mirroring the client's angle test. */\nexport function polarLabelAnchor(labelAngle: number): 'start' | 'middle' | 'end' {\n  if (Math.abs(labelAngle) === Math.PI / 2) return 'middle';\n  return labelAngle < Math.PI / 2 && labelAngle > -Math.PI / 2 ? 'start' : 'end';\n}\n\n/**\n * Sector angles — client `xScale = scaleLinear([0, n] → [0, 2π])` evaluated at\n * `i` and `i + 1`. Angle 0 is 12 o'clock (d3 `arc` convention).\n */\nexport function polarSectorAngles(\n  count: number,\n): Array<{ startAngle: number; endAngle: number }> {\n  if (count <= 0) return [];\n  const slice = (Math.PI * 2) / count;\n  return Array.from({ length: count }, (_v, i) => ({\n    startAngle: i * slice,\n    endAngle: (i + 1) * slice,\n  }));\n}\n\n/**\n * Split each category's equal slice among the groups that have a value there.\n * Sector order must match `sectors` (category-major, then group order).\n */\nexport function polarGroupedSectorAngles(\n  categories: string[],\n  sectors: PolarAreaSector[],\n): Array<{ startAngle: number; endAngle: number }> {\n  if (!categories.length || !sectors.length) return [];\n  const slice = (Math.PI * 2) / categories.length;\n  const countByCategory = new Map<string, number>();\n  const indexInCategory = new Map<PolarAreaSector, number>();\n  for (const sector of sectors) {\n    const next = countByCategory.get(sector.key) ?? 0;\n    indexInCategory.set(sector, next);\n    countByCategory.set(sector.key, next + 1);\n  }\n  return sectors.map((sector) => {\n    const categoryIndex = Math.max(0, categories.indexOf(sector.key));\n    const members = countByCategory.get(sector.key) ?? 1;\n    const offset = indexInCategory.get(sector) ?? 0;\n    const inner = slice / members;\n    const base = categoryIndex * slice;\n    return { startAngle: base + offset * inner, endAngle: base + (offset + 1) * inner };\n  });\n}\n\n/** Radial grid / tick values: `maxValue * step / steps` for step 1…steps. */\nexport function polarRadialTicks(maxValue: number, steps: number): number[] {\n  if (!Number.isFinite(maxValue) || maxValue <= 0 || steps <= 0) return [];\n  return Array.from({ length: steps }, (_v, i) => ((i + 1) * maxValue) / steps);\n}\n\nexport function polarMaxValue(sectors: PolarAreaSector[]): number {\n  let max = 0;\n  for (const sector of sectors) {\n    if (sector.value > max) max = sector.value;\n  }\n  return max;\n}\n\n/**\n * Side room reserved for the category labels, measured off the longest one.\n * FuseDash sizes the disc from the raw box and lets long names run past the\n * SVG edge; chat widgets are far narrower, so — as with `punchcardLeftGutter`\n * and the bar-chart label gutter — the gutter is derived from the labels and\n * the disc shrinks into what is left.\n */\nexport function polarLabelGutter(categories: string[], plotWidth: number): number {\n  const longest = categories.reduce((max, c) => Math.max(max, String(c).length), 0);\n  const estimated = longest * FD.polarCategoryLabelSize * FD.polarLabelCharWidth;\n  const ceiling = Math.min(\n    FD.polarLabelGutterMax,\n    Math.max(0, plotWidth) * FD.polarLabelGutterMaxFraction,\n  );\n  return Math.max(FD.polarLabelGutterMin, Math.min(estimated, ceiling));\n}\n\n/** Disc radius that leaves room for the labels ring on all four sides. */\nexport function polarOuterRadius(\n  plotWidth: number,\n  plotHeight: number,\n  labelGutter: number,\n): number {\n  const byWidth = plotWidth / 2 - labelGutter - FD.polarCategoryLabelOffset;\n  const byHeight =\n    plotHeight / 2 - FD.polarCategoryLabelOffset - FD.polarCategoryLabelSize / 2;\n  return Math.max(0, Math.min(byWidth, byHeight));\n}\n"],"names":[],"mappings":";AAIO,SAAS,iBAAiB,YAAgD;AAC/E,MAAI,KAAK,IAAI,UAAU,MAAM,KAAK,KAAK,EAAG,QAAO;AACjD,SAAO,aAAa,KAAK,KAAK,KAAK,aAAa,CAAC,KAAK,KAAK,IAAI,UAAU;AAC3E;AAMO,SAAS,kBACd,OACiD;AACjD,MAAI,SAAS,EAAG,QAAO,CAAA;AACvB,QAAM,QAAS,KAAK,KAAK,IAAK;AAC9B,SAAO,MAAM,KAAK,EAAE,QAAQ,SAAS,CAAC,IAAI,OAAO;AAAA,IAC/C,YAAY,IAAI;AAAA,IAChB,WAAW,IAAI,KAAK;AAAA,EAAA,EACpB;AACJ;AAMO,SAAS,yBACd,YACA,SACiD;AACjD,MAAI,CAAC,WAAW,UAAU,CAAC,QAAQ,eAAe,CAAA;AAClD,QAAM,QAAS,KAAK,KAAK,IAAK,WAAW;AACzC,QAAM,sCAAsB,IAAA;AAC5B,QAAM,sCAAsB,IAAA;AAC5B,aAAW,UAAU,SAAS;AAC5B,UAAM,OAAO,gBAAgB,IAAI,OAAO,GAAG,KAAK;AAChD,oBAAgB,IAAI,QAAQ,IAAI;AAChC,oBAAgB,IAAI,OAAO,KAAK,OAAO,CAAC;AAAA,EAC1C;AACA,SAAO,QAAQ,IAAI,CAAC,WAAW;AAC7B,UAAM,gBAAgB,KAAK,IAAI,GAAG,WAAW,QAAQ,OAAO,GAAG,CAAC;AAChE,UAAM,UAAU,gBAAgB,IAAI,OAAO,GAAG,KAAK;AACnD,UAAM,SAAS,gBAAgB,IAAI,MAAM,KAAK;AAC9C,UAAM,QAAQ,QAAQ;AACtB,UAAM,OAAO,gBAAgB;AAC7B,WAAO,EAAE,YAAY,OAAO,SAAS,OAAO,UAAU,QAAQ,SAAS,KAAK,MAAA;AAAA,EAC9E,CAAC;AACH;AAGO,SAAS,iBAAiB,UAAkB,OAAyB;AAC1E,MAAI,CAAC,OAAO,SAAS,QAAQ,KAAK,YAAY,KAAK,SAAS,EAAG,QAAO,CAAA;AACtE,SAAO,MAAM,KAAK,EAAE,QAAQ,MAAA,GAAS,CAAC,IAAI,OAAQ,IAAI,KAAK,WAAY,KAAK;AAC9E;AAEO,SAAS,cAAc,SAAoC;AAChE,MAAI,MAAM;AACV,aAAW,UAAU,SAAS;AAC5B,QAAI,OAAO,QAAQ,IAAK,OAAM,OAAO;AAAA,EACvC;AACA,SAAO;AACT;AASO,SAAS,iBAAiB,YAAsB,WAA2B;AAChF,QAAM,UAAU,WAAW,OAAO,CAAC,KAAK,MAAM,KAAK,IAAI,KAAK,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC;AAChF,QAAM,YAAY,UAAU,GAAG,yBAAyB,GAAG;AAC3D,QAAM,UAAU,KAAK;AAAA,IACnB,GAAG;AAAA,IACH,KAAK,IAAI,GAAG,SAAS,IAAI,GAAG;AAAA,EAAA;AAE9B,SAAO,KAAK,IAAI,GAAG,qBAAqB,KAAK,IAAI,WAAW,OAAO,CAAC;AACtE;AAGO,SAAS,iBACd,WACA,YACA,aACQ;AACR,QAAM,UAAU,YAAY,IAAI,cAAc,GAAG;AACjD,QAAM,WACJ,aAAa,IAAI,GAAG,2BAA2B,GAAG,yBAAyB;AAC7E,SAAO,KAAK,IAAI,GAAG,KAAK,IAAI,SAAS,QAAQ,CAAC;AAChD;"}

package/dist/components/polar-area-chart/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { normalizePolarAreaData } from './normalize.js';
+export { polarLabelAnchor, polarLabelGutter, polarOuterRadius, polarMaxValue, polarRadialTicks, polarSectorAngles, polarGroupedSectorAngles, } from './domain.js';
+export type { PolarAreaChartData, PolarAreaLabelValue, PolarAreaLegendEntry, PolarAreaModel, PolarAreaPoint, PolarAreaSector, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/polar-area-chart/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/polar-area-chart/lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC"}

package/dist/components/polar-area-chart/lib/normalize.d.ts

@@ -0,0 +1,4 @@
+import { PolarAreaChartData, PolarAreaModel } from './types.js';
+/** Normalize chat / FuseDash WidgetItem payloads into polar-area sectors. */
+export declare function normalizePolarAreaData(input: PolarAreaChartData): PolarAreaModel;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/components/polar-area-chart/lib/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../src/components/polar-area-chart/lib/normalize.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,kBAAkB,EAGlB,cAAc,EAGf,MAAM,YAAY,CAAC;AAgOpB,6EAA6E;AAC7E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,cAAc,CAkBhF"}

package/dist/components/polar-area-chart/lib/normalize.js

@@ -0,0 +1,183 @@
+import { pickQualitativePalette, resolveFormattingColor } from "../../../utils/fuse-palette.js";
+import { isFuseWidgetPayload, firstField, rowsOf, resolveUniqueValuesOrder, filterTruthyValues } from "../../../utils/fuse-widget.js";
+import { polarMaxValue } from "./domain.js";
+import { resolveWidgetFormatting } from "../../../utils/chart-formatting/from-fuse-widget.js";
+const EMPTY = { sectors: [], categories: [], legend: [], maxValue: 0 };
+function isLabelValueArray(input) {
+  if (!Array.isArray(input) || input.length === 0) return false;
+  const first = input[0];
+  return first != null && typeof first === "object" && "label" in first && "value" in first;
+}
+function isPointsPayload(input) {
+  return !!input && typeof input === "object" && Array.isArray(input.points);
+}
+function legendKeysOf(widget) {
+  const uniqueValues = widget.uniqueValues ?? {};
+  const firstKey = Object.keys(uniqueValues)[0];
+  if (!firstKey) return [];
+  return filterTruthyValues((uniqueValues[firstKey] ?? []).map(String));
+}
+function buildLegend(keys, formatting) {
+  return keys.map((key) => ({
+    key,
+    label: key,
+    color: resolveFormattingColor(formatting, key, keys.length)
+  }));
+}
+function modelFromRows(rows, categories, legend, formatting) {
+  const colorByKey = new Map(legend.map((entry) => [entry.key, entry.color]));
+  const fallbackColor = resolveFormattingColor(formatting, "default", legend.length || 1);
+  const sectors = rows.map((row) => ({
+    key: row.key,
+    label: row.key,
+    value: row.value,
+    color: colorByKey.get(row.key) ?? fallbackColor
+  }));
+  return { sectors, categories, legend, maxValue: polarMaxValue(sectors) };
+}
+function categoriesOf(widget, xKey, dataKeys) {
+  var _a;
+  const fromUniqueValues = (((_a = widget.uniqueValues) == null ? void 0 : _a[xKey]) ?? []).map(String).filter((v) => dataKeys.includes(v));
+  return fromUniqueValues.length ? fromUniqueValues : dataKeys;
+}
+function fromGroupedFuseWidget(widget, xKey, yKey, groupBy) {
+  const parsed = [];
+  for (const row of rowsOf(widget)) {
+    const x = row[xKey];
+    const y = Number(row[yKey]);
+    const group = row[groupBy];
+    if (x == null || x === "" || group == null || group === "" || !Number.isFinite(y)) {
+      continue;
+    }
+    parsed.push({ key: String(x), group: String(group), value: y });
+  }
+  if (!parsed.length) return EMPTY;
+  const categories = categoriesOf(
+    widget,
+    xKey,
+    Array.from(new Set(parsed.map((row) => row.key)))
+  );
+  const groupKeys = resolveUniqueValuesOrder(
+    parsed.map((row) => row.group),
+    widget.uniqueValues,
+    groupBy
+  );
+  const formatting = resolveWidgetFormatting(widget);
+  const colorByGroup = new Map(
+    groupKeys.map((key) => [key, resolveFormattingColor(formatting, key, groupKeys.length)])
+  );
+  const totals = /* @__PURE__ */ new Map();
+  for (const row of parsed) {
+    const id = `${row.key}\0${row.group}`;
+    totals.set(id, (totals.get(id) ?? 0) + row.value);
+  }
+  const sectors = [];
+  for (const category of categories) {
+    for (const group of groupKeys) {
+      const value = totals.get(`${category}\0${group}`);
+      if (value == null) continue;
+      sectors.push({
+        key: category,
+        group,
+        label: category,
+        value,
+        color: colorByGroup.get(group) ?? resolveFormattingColor(formatting, group, groupKeys.length)
+      });
+    }
+  }
+  return {
+    sectors,
+    categories,
+    legend: buildLegend(groupKeys, formatting),
+    maxValue: polarMaxValue(sectors),
+    grouped: true,
+    xField: xKey,
+    yField: yKey,
+    groupField: groupBy,
+    axisDetails: widget.axisDetails ?? void 0
+  };
+}
+function fromFuseWidget(widget) {
+  var _a;
+  const xKey = firstField(widget.xAxe);
+  const yKey = firstField(widget.yAxe);
+  if (!xKey || !yKey) return EMPTY;
+  const groupBy = firstField(widget.groupBy);
+  if (groupBy) return fromGroupedFuseWidget(widget, xKey, yKey, groupBy);
+  const parsed = [];
+  for (const row of rowsOf(widget)) {
+    const x = row[xKey];
+    const y = Number(row[yKey]);
+    if (x == null || x === "" || !Number.isFinite(y)) continue;
+    parsed.push({ key: String(x), value: y });
+  }
+  if (!parsed.length) return EMPTY;
+  const categories = categoriesOf(
+    widget,
+    xKey,
+    Array.from(new Set(parsed.map((row) => row.key)))
+  );
+  const formatting = resolveWidgetFormatting(widget);
+  let rows = parsed;
+  if ((((_a = widget.formatting) == null ? void 0 : _a.length) ?? 0) > 1) {
+    const totals = /* @__PURE__ */ new Map();
+    for (const row of parsed) {
+      totals.set(row.key, (totals.get(row.key) ?? 0) + row.value);
+    }
+    rows = Array.from(totals, ([key, value]) => ({ key, value }));
+  }
+  const sorted = categories.flatMap(
+    (category) => rows.filter((row) => row.key === category)
+  );
+  const model = modelFromRows(
+    sorted,
+    categories,
+    buildLegend(legendKeysOf(widget), formatting),
+    formatting
+  );
+  return {
+    ...model,
+    xField: xKey,
+    yField: yKey,
+    axisDetails: widget.axisDetails ?? void 0
+  };
+}
+function fromLabelValue(input) {
+  const rows = input.map((row) => ({
+    key: String(row.label),
+    value: Number(row.value),
+    color: row.color
+  })).filter((row) => row.key && Number.isFinite(row.value));
+  if (!rows.length) return EMPTY;
+  const palette = pickQualitativePalette(0, rows.length);
+  const sectors = rows.map((row, index) => ({
+    key: row.key,
+    label: row.key,
+    value: row.value,
+    color: row.color ?? palette[index % palette.length]
+  }));
+  return {
+    sectors,
+    categories: sectors.map((sector) => sector.key),
+    legend: sectors.map(({ key, label, color }) => ({ key, label, color })),
+    maxValue: polarMaxValue(sectors)
+  };
+}
+function normalizePolarAreaData(input) {
+  if (!input) return EMPTY;
+  if (Array.isArray(input)) {
+    return isLabelValueArray(input) ? fromLabelValue(input) : EMPTY;
+  }
+  if (isFuseWidgetPayload(input)) return fromFuseWidget(input);
+  if (isPointsPayload(input)) {
+    return fromLabelValue(
+      input.points.map((point) => ({ label: String(point.x), value: Number(point.y) }))
+    );
+  }
+  if (Array.isArray(input.sectors)) return input;
+  return EMPTY;
+}
+export {
+  normalizePolarAreaData
+};
+//# sourceMappingURL=normalize.js.map

package/dist/components/polar-area-chart/lib/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","sources":["../../../../src/components/polar-area-chart/lib/normalize.ts"],"sourcesContent":["import { resolveWidgetFormatting } from '../../../utils/chart-formatting/index.js';\nimport {\n  pickQualitativePalette,\n  resolveFormattingColor,\n} from '../../../utils/fuse-palette.js';\nimport {\n  filterTruthyValues,\n  firstField,\n  isFuseWidgetPayload,\n  resolveUniqueValuesOrder,\n  rowsOf,\n  type FuseWidgetLike,\n} from '../../../utils/fuse-widget.js';\nimport { polarMaxValue } from './domain.js';\nimport type {\n  PolarAreaChartData,\n  PolarAreaLabelValue,\n  PolarAreaLegendEntry,\n  PolarAreaModel,\n  PolarAreaPoint,\n  PolarAreaSector,\n} from './types.js';\n\nconst EMPTY: PolarAreaModel = { sectors: [], categories: [], legend: [], maxValue: 0 };\n\nfunction isLabelValueArray(input: unknown): input is PolarAreaLabelValue[] {\n  if (!Array.isArray(input) || input.length === 0) return false;\n  const first = input[0] as Record<string, unknown>;\n  return first != null && typeof first === 'object' && 'label' in first && 'value' in first;\n}\n\nfunction isPointsPayload(input: unknown): input is { points: PolarAreaPoint[] } {\n  return (\n    !!input &&\n    typeof input === 'object' &&\n    Array.isArray((input as { points?: unknown }).points)\n  );\n}\n\n/**\n * Legend keys — client reads `uniqueValues[Object.keys(uniqueValues)[0]]` and\n * drops null-ish entries. On the polar mock that first key is the x-axis field,\n * so legend keys and sector keys line up.\n */\nfunction legendKeysOf(widget: FuseWidgetLike): string[] {\n  const uniqueValues = widget.uniqueValues ?? {};\n  const firstKey = Object.keys(uniqueValues)[0];\n  if (!firstKey) return [];\n  return filterTruthyValues((uniqueValues[firstKey] ?? []).map(String));\n}\n\nfunction buildLegend(\n  keys: string[],\n  formatting: FuseWidgetLike['formatting'],\n): PolarAreaLegendEntry[] {\n  return keys.map((key) => ({\n    key,\n    label: key,\n    color: resolveFormattingColor(formatting, key, keys.length),\n  }));\n}\n\nfunction modelFromRows(\n  rows: Array<{ key: string; value: number }>,\n  categories: string[],\n  legend: PolarAreaLegendEntry[],\n  formatting: FuseWidgetLike['formatting'],\n): PolarAreaModel {\n  const colorByKey = new Map(legend.map((entry) => [entry.key, entry.color]));\n  const fallbackColor = resolveFormattingColor(formatting, 'default', legend.length || 1);\n\n  const sectors: PolarAreaSector[] = rows.map((row) => ({\n    key: row.key,\n    label: row.key,\n    value: row.value,\n    color: colorByKey.get(row.key) ?? fallbackColor,\n  }));\n\n  return { sectors, categories, legend, maxValue: polarMaxValue(sectors) };\n}\n\nfunction categoriesOf(\n  widget: FuseWidgetLike,\n  xKey: string,\n  dataKeys: string[],\n): string[] {\n  const fromUniqueValues = (widget.uniqueValues?.[xKey] ?? [])\n    .map(String)\n    .filter((v) => dataKeys.includes(v));\n  return fromUniqueValues.length ? fromUniqueValues : dataKeys;\n}\n\nfunction fromGroupedFuseWidget(\n  widget: FuseWidgetLike,\n  xKey: string,\n  yKey: string,\n  groupBy: string,\n): PolarAreaModel {\n  const parsed: Array<{ key: string; group: string; value: number }> = [];\n  for (const row of rowsOf(widget)) {\n    const x = row[xKey];\n    const y = Number(row[yKey]);\n    const group = row[groupBy];\n    if (x == null || x === '' || group == null || group === '' || !Number.isFinite(y)) {\n      continue;\n    }\n    parsed.push({ key: String(x), group: String(group), value: y });\n  }\n  if (!parsed.length) return EMPTY;\n\n  const categories = categoriesOf(\n    widget,\n    xKey,\n    Array.from(new Set(parsed.map((row) => row.key))),\n  );\n  const groupKeys = resolveUniqueValuesOrder(\n    parsed.map((row) => row.group),\n    widget.uniqueValues,\n    groupBy,\n  );\n  const formatting = resolveWidgetFormatting(widget);\n  const colorByGroup = new Map(\n    groupKeys.map((key) => [key, resolveFormattingColor(formatting, key, groupKeys.length)]),\n  );\n\n  const totals = new Map<string, number>();\n  for (const row of parsed) {\n    const id = `${row.key}\\0${row.group}`;\n    totals.set(id, (totals.get(id) ?? 0) + row.value);\n  }\n\n  const sectors: PolarAreaSector[] = [];\n  for (const category of categories) {\n    for (const group of groupKeys) {\n      const value = totals.get(`${category}\\0${group}`);\n      if (value == null) continue;\n      sectors.push({\n        key: category,\n        group,\n        label: category,\n        value,\n        color: colorByGroup.get(group) ?? resolveFormattingColor(formatting, group, groupKeys.length),\n      });\n    }\n  }\n\n  return {\n    sectors,\n    categories,\n    legend: buildLegend(groupKeys, formatting),\n    maxValue: polarMaxValue(sectors),\n    grouped: true,\n    xField: xKey,\n    yField: yKey,\n    groupField: groupBy,\n    axisDetails: widget.axisDetails ?? undefined,\n  };\n}\n\nfunction fromFuseWidget(widget: FuseWidgetLike): PolarAreaModel {\n  const xKey = firstField(widget.xAxe);\n  const yKey = firstField(widget.yAxe);\n  if (!xKey || !yKey) return EMPTY;\n\n  const groupBy = firstField(widget.groupBy);\n  if (groupBy) return fromGroupedFuseWidget(widget, xKey, yKey, groupBy);\n\n  const parsed: Array<{ key: string; value: number }> = [];\n  for (const row of rowsOf(widget)) {\n    const x = row[xKey];\n    const y = Number(row[yKey]);\n    if (x == null || x === '' || !Number.isFinite(y)) continue;\n    parsed.push({ key: String(x), value: y });\n  }\n  if (!parsed.length) return EMPTY;\n\n  const categories = categoriesOf(\n    widget,\n    xKey,\n    Array.from(new Set(parsed.map((row) => row.key))),\n  );\n\n  // Colors come from resolved formatting so a widget that ships without a\n  // `formatting` array still gets the shared default palette (as scatter does).\n  const formatting = resolveWidgetFormatting(widget);\n\n  // Client aggregates the rows per category once the widget carries more than\n  // one formatting entry — otherwise every row keeps its own wedge. This gate\n  // reads the widget's own formatting, not the resolved one: generated entries\n  // would flip a formatting-less widget into aggregated mode.\n  let rows = parsed;\n  if ((widget.formatting?.length ?? 0) > 1) {\n    const totals = new Map<string, number>();\n    for (const row of parsed) {\n      totals.set(row.key, (totals.get(row.key) ?? 0) + row.value);\n    }\n    rows = Array.from(totals, ([key, value]) => ({ key, value }));\n  }\n\n  // Client `categories.flatMap(...)`: category order first, extras dropped.\n  const sorted = categories.flatMap((category) =>\n    rows.filter((row) => row.key === category),\n  );\n\n  const model = modelFromRows(\n    sorted,\n    categories,\n    buildLegend(legendKeysOf(widget), formatting),\n    formatting,\n  );\n\n  return {\n    ...model,\n    xField: xKey,\n    yField: yKey,\n    axisDetails: widget.axisDetails ?? undefined,\n  };\n}\n\nfunction fromLabelValue(input: PolarAreaLabelValue[]): PolarAreaModel {\n  const rows = input\n    .map((row) => ({\n      key: String(row.label),\n      value: Number(row.value),\n      color: row.color,\n    }))\n    .filter((row) => row.key && Number.isFinite(row.value));\n  if (!rows.length) return EMPTY;\n\n  const palette = pickQualitativePalette(0, rows.length);\n  const sectors: PolarAreaSector[] = rows.map((row, index) => ({\n    key: row.key,\n    label: row.key,\n    value: row.value,\n    color: row.color ?? palette[index % palette.length],\n  }));\n\n  return {\n    sectors,\n    categories: sectors.map((sector) => sector.key),\n    legend: sectors.map(({ key, label, color }) => ({ key, label, color })),\n    maxValue: polarMaxValue(sectors),\n  };\n}\n\n/** Normalize chat / FuseDash WidgetItem payloads into polar-area sectors. */\nexport function normalizePolarAreaData(input: PolarAreaChartData): PolarAreaModel {\n  if (!input) return EMPTY;\n\n  if (Array.isArray(input)) {\n    return isLabelValueArray(input) ? fromLabelValue(input) : EMPTY;\n  }\n\n  if (isFuseWidgetPayload(input)) return fromFuseWidget(input);\n\n  if (isPointsPayload(input)) {\n    return fromLabelValue(\n      input.points.map((point) => ({ label: String(point.x), value: Number(point.y) })),\n    );\n  }\n\n  if (Array.isArray((input as PolarAreaModel).sectors)) return input as PolarAreaModel;\n\n  return EMPTY;\n}\n"],"names":[],"mappings":"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"}

package/dist/components/polar-area-chart/lib/types.d.ts

@@ -0,0 +1,48 @@
+import { FuseWidgetLike } from '../../../utils/fuse-widget.js';
+/** One filled wedge of the disc — a single row of the (sorted) chart data. */
+export interface PolarAreaSector {
+    /** Category value (`widget.xAxe[0]`). */
+    key: string;
+    /** Group key when `groupBy` is set — also the color / legend key. */
+    group?: string;
+    label: string;
+    value: number;
+    color: string;
+}
+export interface PolarAreaLegendEntry {
+    key: string;
+    label: string;
+    color: string;
+}
+export interface PolarAreaModel {
+    sectors: PolarAreaSector[];
+    /**
+     * Radial spoke order — client `categories`: `uniqueValues[xAxe]` filtered to
+     * values present in the data, falling back to first-seen data order.
+     */
+    categories: string[];
+    legend: PolarAreaLegendEntry[];
+    maxValue: number;
+    /** True when wedges are split by `groupBy` inside each category. */
+    grouped?: boolean;
+    xField?: string;
+    yField?: string;
+    groupField?: string;
+    axisDetails?: Record<string, {
+        label?: string;
+        measure_unit_symbol?: string;
+    }>;
+}
+export type PolarAreaLabelValue = {
+    label: string;
+    value: number;
+    color?: string;
+};
+export type PolarAreaPoint = {
+    x: string | number;
+    y: number;
+};
+export type PolarAreaChartData = PolarAreaLabelValue[] | {
+    points: PolarAreaPoint[];
+} | PolarAreaModel | FuseWidgetLike | null | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/components/polar-area-chart/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/polar-area-chart/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAEpE,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChF;AAED,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnF,MAAM,MAAM,cAAc,GAAG;IAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/D,MAAM,MAAM,kBAAkB,GAC1B,mBAAmB,EAAE,GACrB;IAAE,MAAM,EAAE,cAAc,EAAE,CAAA;CAAE,GAC5B,cAAc,GACd,cAAc,GACd,IAAI,GACJ,SAAS,CAAC"}

package/dist/components/polar-area-chart/metadata.json.d.ts

@@ -0,0 +1,79 @@
+declare const _default: {
+  "id": "polar-area-chart",
+  "tag": "ui9000-polar-area-chart",
+  "title": "Polar Area Chart",
+  "description": "Chat-optimized polar area (coxcomb) chart rewritten in D3. Single (client aggregated) or grouped by groupBy. Legend above the plot.",
+  "chartTypeKeys": ["polarAreaChart"],
+  "source": "client/libs/shared/components/src/Widgets/PolarAreaChart/",
+  "stack": "d3",
+  "lazyImport": "@fusedashlabs/widgets/lazy/polar-area-chart",
+  "entry": "@fusedashlabs/widgets/polar-area-chart",
+  "usageConditions": {
+    "host": "mcp-chat",
+    "notFor": "fusedash-editor",
+    "mapsExcluded": true
+  },
+  "allowedActions": ["hover", "resize"],
+  "propsSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "data": {
+        "oneOf": [
+          {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["label", "value"],
+              "properties": {
+                "label": { "type": "string" },
+                "value": { "type": "number" },
+                "color": { "type": "string" }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "Chat points payload",
+            "required": ["points"],
+            "properties": {
+              "points": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "required": ["x", "y"],
+                  "properties": {
+                    "x": { "type": ["string", "number"] },
+                    "y": { "type": "number" }
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "description": "FuseDash WidgetItem-shaped payload",
+            "properties": {
+              "chartType": { "type": "string" },
+              "xAxe": { "type": "array", "items": { "type": "string" } },
+              "yAxe": { "type": "array", "items": { "type": "string" } },
+              "uniqueValues": { "type": "object" },
+              "formatting": { "type": "array" },
+              "data": { "type": "array" }
+            }
+          }
+        ]
+      },
+      "show-grid": { "type": "boolean" },
+      "show-legend": { "type": "boolean" },
+      "show-tooltip": { "type": "boolean" },
+      "scale": {
+        "type": "string",
+        "enum": ["compact", "default", "comfortable"]
+      }
+    }
+  }
+}
+;
+
+export default _default;

package/dist/components/polar-area-chart/metadata.json.js

@@ -0,0 +1,42 @@
+const id = "polar-area-chart";
+const tag = "ui9000-polar-area-chart";
+const title = "Polar Area Chart";
+const description = "Chat-optimized polar area (coxcomb) chart rewritten in D3. Single (client aggregated) or grouped by groupBy. Legend above the plot.";
+const chartTypeKeys = ["polarAreaChart"];
+const source = "client/libs/shared/components/src/Widgets/PolarAreaChart/";
+const stack = "d3";
+const lazyImport = "@fusedashlabs/widgets/lazy/polar-area-chart";
+const entry = "@fusedashlabs/widgets/polar-area-chart";
+const usageConditions = { "host": "mcp-chat", "notFor": "fusedash-editor", "mapsExcluded": true };
+const allowedActions = ["hover", "resize"];
+const propsSchema = { "$schema": "https://json-schema.org/draft/2020-12/schema", "type": "object", "properties": { "data": { "oneOf": [{ "type": "array", "items": { "type": "object", "required": ["label", "value"], "properties": { "label": { "type": "string" }, "value": { "type": "number" }, "color": { "type": "string" } } } }, { "type": "object", "description": "Chat points payload", "required": ["points"], "properties": { "points": { "type": "array", "items": { "type": "object", "required": ["x", "y"], "properties": { "x": { "type": ["string", "number"] }, "y": { "type": "number" } } } } } }, { "type": "object", "description": "FuseDash WidgetItem-shaped payload", "properties": { "chartType": { "type": "string" }, "xAxe": { "type": "array", "items": { "type": "string" } }, "yAxe": { "type": "array", "items": { "type": "string" } }, "uniqueValues": { "type": "object" }, "formatting": { "type": "array" }, "data": { "type": "array" } } }] }, "show-grid": { "type": "boolean" }, "show-legend": { "type": "boolean" }, "show-tooltip": { "type": "boolean" }, "scale": { "type": "string", "enum": ["compact", "default", "comfortable"] } } };
+const polarAreaMeta = {
+  id,
+  tag,
+  title,
+  description,
+  chartTypeKeys,
+  source,
+  stack,
+  lazyImport,
+  entry,
+  usageConditions,
+  allowedActions,
+  propsSchema
+};
+export {
+  allowedActions,
+  chartTypeKeys,
+  polarAreaMeta as default,
+  description,
+  entry,
+  id,
+  lazyImport,
+  propsSchema,
+  source,
+  stack,
+  tag,
+  title,
+  usageConditions
+};
+//# sourceMappingURL=metadata.json.js.map

package/dist/components/polar-area-chart/metadata.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/polar-area-chart/render/draw.d.ts

@@ -0,0 +1,25 @@
+import { ChartDimensions, WidgetTheme } from '../../../types/index.js';
+import { AxisLabelTooltipHandlers } from '../../../utils/axis-labels.js';
+import { PolarAreaModel, PolarAreaSector } from '../lib/types.js';
+export interface RenderPolarAreaChartOptions extends AxisLabelTooltipHandlers {
+    model: PolarAreaModel;
+    width: number;
+    height: number;
+    margin: ChartDimensions['margin'];
+    theme: WidgetTheme;
+    themeMode?: 'light' | 'dark';
+    showGrid?: boolean;
+    showTooltip?: boolean;
+    onHover?: (payload: {
+        sector: PolarAreaSector;
+        event: MouseEvent;
+    }) => void;
+    onLeave?: () => void;
+}
+/**
+ * FuseDash PolarAreaChart — D3 rewrite.
+ * One wedge per category, each reaching the radius of its value; the legend
+ * lives in the Lit shell.
+ */
+export declare function renderPolarAreaChart(container: HTMLElement, options: RenderPolarAreaChartOptions): void;
+//# sourceMappingURL=draw.d.ts.map

package/dist/components/polar-area-chart/render/draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draw.d.ts","sourceRoot":"","sources":["../../../../src/components/polar-area-chart/render/draw.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,+BAA+B,CAAC;AAUvC,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvE,MAAM,WAAW,2BAA4B,SAAQ,wBAAwB;IAC3E,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IAClC,KAAK,EAAE,WAAW,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,eAAe,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,KAAK,IAAI,CAAC;IAC5E,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AA8JD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,2BAA2B,GACnC,IAAI,CAiHN"}

package/dist/components/polar-area-chart/render/draw.js

@@ -0,0 +1,127 @@
+import { scaleLinear } from "d3-scale";
+import { select } from "d3-selection";
+import { arc } from "d3-shape";
+import { decorateManualAxisLabel } from "../../../utils/axis-labels.js";
+import { FD, formatCompactNumber } from "../../../utils/fusedash-visual.js";
+import { polarLabelGutter, polarRadialTicks, polarGroupedSectorAngles, polarSectorAngles, polarOuterRadius, polarLabelAnchor } from "../lib/domain.js";
+const SECTOR_CLASS = "polar-area-path";
+const TICK_CLASS = "polar-tick-group";
+function measureText(node, text, fontSize, cx, cy) {
+  var _a;
+  const box = (_a = node == null ? void 0 : node.getBBox) == null ? void 0 : _a.call(node);
+  if (box && box.width > 0) return box;
+  const width = text.length * fontSize * 0.6;
+  return { x: cx - width / 2, y: cy - fontSize / 2, width, height: fontSize };
+}
+function drawGridRings(parent, ticks, radial) {
+  parent.selectAll("circle").data(ticks).enter().append("circle").attr("r", (d) => radial(d)).attr("fill", "none").attr("stroke", FD.polarGridStroke).attr("stroke-opacity", (_d, i) => (i + 1) * FD.polarGridStepOpacity);
+}
+function drawSpokes(parent, categories, outer) {
+  const slice = Math.PI * 2 / categories.length;
+  for (let i = 0; i < categories.length; i += 1) {
+    const angle = slice * i - Math.PI / 2;
+    const x = outer * Math.cos(angle);
+    const y = outer * Math.sin(angle);
+    parent.append("line").attr("x1", 0).attr("y1", 0).attr("x2", x).attr("y2", y).attr("stroke", FD.polarGridStroke).attr("stroke-linejoin", "round").attr("stroke-linecap", "round").attr("stroke-dasharray", FD.polarSpokeDash);
+    parent.append("circle").attr("cx", x).attr("cy", y).attr("r", FD.polarSpokeCapRadius).attr("fill", FD.polarGridStroke);
+  }
+}
+function drawCategoryLabels(parent, categories, outer, halfWidth, handlers) {
+  const slice = Math.PI * 2 / categories.length;
+  const radius = outer + FD.polarCategoryLabelOffset;
+  categories.forEach((category, i) => {
+    const labelAngle = slice * i - Math.PI / 2 + slice / 2;
+    const x = radius * Math.cos(labelAngle);
+    const anchor = polarLabelAnchor(labelAngle);
+    const slotWidth = anchor === "start" ? halfWidth - x : anchor === "end" ? halfWidth + x : 2 * Math.min(halfWidth - x, halfWidth + x);
+    const text = parent.append("text").attr("x", x).attr("y", radius * Math.sin(labelAngle)).attr("text-anchor", anchor).attr("font-size", FD.polarCategoryLabelSize).attr("dominant-baseline", "central").attr("fill", FD.polarCategoryLabelFill);
+    decorateManualAxisLabel(text, category, {
+      ...handlers,
+      slotWidth,
+      fontSize: FD.polarCategoryLabelSize
+    });
+  });
+}
+function drawRadialTicks(parent, ticks, radial, theme, themeMode) {
+  const pillFill = theme.background && theme.background !== "transparent" ? theme.background : themeMode === "dark" ? FD.polarTickPillDark : FD.polarTickPill;
+  parent.selectAll("g").data(ticks).enter().append("g").attr("class", TICK_CLASS).each(function(value) {
+    const group = select(this);
+    const label = formatCompactNumber(value, 2);
+    const cy = -radial(value);
+    const text = group.append("text").attr("x", 0).attr("y", cy).attr("font-size", FD.polarCategoryLabelSize).attr("text-anchor", "middle").attr("dominant-baseline", "central").attr("fill", theme.text).text(label);
+    const box = measureText(text.node(), label, FD.polarCategoryLabelSize, 0, cy);
+    group.insert("rect", "text").attr("x", box.x - FD.polarTickPillPadX).attr("y", box.y - FD.polarTickPillPadY).attr("width", box.width + FD.polarTickPillPadX * 2).attr("height", box.height + FD.polarTickPillPadY * 2).attr("rx", FD.polarTickPillRadius).attr("ry", FD.polarTickPillRadius).attr("fill", pillFill);
+  });
+}
+function renderPolarAreaChart(container, options) {
+  const {
+    model,
+    width,
+    height,
+    margin,
+    theme,
+    themeMode = "light",
+    showGrid = true,
+    showTooltip = true,
+    onHover,
+    onLeave,
+    onAxisLabelHover,
+    onAxisLabelLeave
+  } = options;
+  container.replaceChildren();
+  const plotWidth = width - margin.left - margin.right;
+  const plotHeight = height - margin.top - margin.bottom;
+  const labelGutter = polarLabelGutter(model.categories, plotWidth);
+  const outerRadius = polarOuterRadius(plotWidth, plotHeight, labelGutter);
+  if (!model.sectors.length || outerRadius <= 0 || !model.maxValue) return;
+  const radial = scaleLinear().domain([0, model.maxValue]).rangeRound([0, outerRadius]).nice();
+  const gridOuter = radial(model.maxValue);
+  const ticks = polarRadialTicks(model.maxValue, FD.polarRadialSteps);
+  const svg = select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`);
+  const root = svg.append("g").attr("transform", `translate(${width / 2}, ${height / 2})`);
+  if (showGrid) {
+    const gridGroup = root.append("g").attr("class", "polar-grid").attr("pointer-events", "none");
+    drawGridRings(gridGroup, ticks, radial);
+    drawSpokes(gridGroup, model.categories, gridOuter);
+  }
+  if (outerRadius >= FD.polarMinLabelRadius) {
+    drawCategoryLabels(
+      root.append("g").attr("class", "polar-category-labels"),
+      model.categories,
+      gridOuter,
+      width / 2,
+      { onAxisLabelHover, onAxisLabelLeave }
+    );
+  }
+  const angles = model.grouped ? polarGroupedSectorAngles(model.categories, model.sectors) : polarSectorAngles(model.sectors.length);
+  const arcGen = arc().innerRadius(0).outerRadius((d) => radial(d.sector.value)).startAngle((d) => d.startAngle).endAngle((d) => d.endAngle);
+  const stroke = themeMode === "dark" ? FD.donutSliceStrokeDark : FD.donutSliceStroke;
+  const sectors = root.append("g").attr("class", "polar-sectors").selectAll("path").data(model.sectors.map((sector, i) => ({ sector, ...angles[i] }))).enter().append("path").attr("class", SECTOR_CLASS).attr("d", arcGen).attr("fill", (d) => d.sector.color).attr("opacity", FD.polarSectorOpacity).attr("stroke", stroke).attr("stroke-width", FD.donutSliceStrokeWidth);
+  const fitsTicks = outerRadius >= FD.polarRadialSteps * FD.polarTickPillRowHeight;
+  if (showGrid && fitsTicks) {
+    drawRadialTicks(
+      root.append("g").attr("class", "polar-ticks").attr("pointer-events", "none"),
+      ticks,
+      radial,
+      theme,
+      themeMode
+    );
+  }
+  if (!showTooltip || !onHover) return;
+  const dimmable = root.selectAll(`.${SECTOR_CLASS}, .${TICK_CLASS}`);
+  sectors.style("cursor", "pointer").on("mouseenter", function(event, datum) {
+    dimmable.attr("opacity", FD.polarSectorOpacityDimmed);
+    select(this).attr("opacity", 1);
+    onHover({ sector: datum.sector, event });
+  }).on("mousemove", (event, datum) => {
+    onHover({ sector: datum.sector, event });
+  }).on("mouseleave", () => {
+    sectors.attr("opacity", FD.polarSectorOpacity);
+    root.selectAll(`.${TICK_CLASS}`).attr("opacity", 1);
+    onLeave == null ? void 0 : onLeave();
+  });
+}
+export {
+  renderPolarAreaChart
+};
+//# sourceMappingURL=draw.js.map