@blokkli/editor 2.0.0-alpha.35 → 2.0.0-alpha.37

package/dist/modules/charts/runtime/blokkli/tools/chart_schemas.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { getColorIdAtIndex } from "../../helpers/index.js";
+import { getChartTypeRuntime, getDefaultTypeOptions } from "../../chartTypes/index.js";
+import { COLORS } from "#blokkli-build/charts-config";
+const SINGLE_SERIES_TYPES = ["pie", "donut", "radialBar"];
+export const chartTypeEnum = z.enum([
+  "bar",
+  "line",
+  "pie",
+  "area",
+  "donut",
+  "heatmap",
+  "radialBar",
+  "radar"
+]);
+const colorIds = Object.keys(COLORS);
+export const chartColorEnum = z.enum(colorIds);
+export const chartSeriesSchema = z.object({
+  name: z.string().describe("Series name (shown in legend)"),
+  color: chartColorEnum.optional().describe(
+    "Color ID from available chart colors. Auto-assigned if omitted."
+  ),
+  data: z.array(z.number()).describe("Data values, one per category")
+});
+export const chartDataSchema = z.object({
+  title: z.string().optional().default("").describe("Chart title"),
+  type: chartTypeEnum.describe("Chart type"),
+  categories: z.array(z.string()).min(1).describe("Category labels (x-axis or slice names)"),
+  series: z.array(chartSeriesSchema).min(1).describe("Data series"),
+  categoryColors: z.array(chartColorEnum).optional().describe(
+    "Color IDs per category (for pie/donut/radialBar). Auto-assigned if omitted."
+  ),
+  footnotes: z.array(z.string()).optional().default([]).describe(
+    "Footnote texts. Reference in categories/series names as {1}, {2}, etc."
+  ),
+  typeOptions: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).optional().describe(
+    "Type-specific rendering options. Use get_chart_type_options to see available keys."
+  )
+});
+export function validateChartData(data, colors) {
+  const colorIds2 = Object.keys(colors);
+  for (let i = 0; i < data.series.length; i++) {
+    const series = data.series[i];
+    if (series.data.length !== data.categories.length) {
+      return {
+        error: `Series "${series.name}" has ${series.data.length} data values but there are ${data.categories.length} categories. Each series must have exactly one value per category.`
+      };
+    }
+  }
+  for (let i = 0; i < data.series.length; i++) {
+    const series = data.series[i];
+    if (!series.color) {
+      series.color = getColorIdAtIndex(i, colors);
+    } else if (!colors[series.color]) {
+      return {
+        error: `Invalid color ID "${series.color}" on series "${series.name}". Available colors: ${colorIds2.join(", ")}`
+      };
+    }
+  }
+  const isSingleSeries = SINGLE_SERIES_TYPES.includes(data.type);
+  if (isSingleSeries) {
+    if (!data.categoryColors || data.categoryColors.length !== data.categories.length) {
+      data.categoryColors = data.categories.map(
+        (_, i) => getColorIdAtIndex(i, colors)
+      );
+    } else {
+      for (let i = 0; i < data.categoryColors.length; i++) {
+        const id = data.categoryColors[i];
+        if (!colors[id]) {
+          return {
+            error: `Invalid categoryColor ID "${id}" at index ${i}. Available colors: ${colorIds2.join(", ")}`
+          };
+        }
+      }
+    }
+  } else if (!data.categoryColors || data.categoryColors.length !== data.categories.length) {
+    data.categoryColors = data.categories.map(
+      (_, i) => getColorIdAtIndex(i, colors)
+    );
+  }
+  const defaults = getDefaultTypeOptions(data.type);
+  const typeDef = getChartTypeRuntime(data.type);
+  if (data.typeOptions && typeDef) {
+    for (const key of Object.keys(data.typeOptions)) {
+      if (!(key in typeDef.editor.options)) {
+        const availableKeys = Object.keys(typeDef.editor.options);
+        return {
+          error: `Invalid typeOption "${key}" for chart type "${data.type}". Available options: ${availableKeys.join(", ")}`
+        };
+      }
+    }
+  }
+  data.typeOptions = { ...defaults, ...data.typeOptions || {} };
+  if (!data.footnotes) {
+    data.footnotes = [];
+  }
+  return { data };
+}
+export function findChartOptionKey(ctx, uuid) {
+  const { blocks, definitions, selection } = ctx.app;
+  const block = blocks.getBlock(uuid);
+  if (!block) return { error: `Paragraph not found: ${uuid}` };
+  const bundle = block.library?.reusableBundle || block.bundle;
+  const selectionItem = selection.items.value.find((v) => v.uuid === uuid);
+  const definition = definitions.getBlockDefinition(
+    bundle,
+    selectionItem?.fieldListType ?? "default",
+    selectionItem?.parentBlockBundle
+  );
+  if (!definition?.options) {
+    return { error: `Paragraph "${uuid}" (${bundle}) has no chart option.` };
+  }
+  const chartEntry = Object.entries(definition.options).find(
+    ([_, opt]) => opt.type === "json" && "dataType" in opt && opt.dataType === "chart"
+  );
+  if (!chartEntry) {
+    return { error: `Paragraph "${uuid}" (${bundle}) has no chart option.` };
+  }
+  return { key: chartEntry[0] };
+}
+export function findChartBundle(ctx, allowedBundles) {
+  const { definitions } = ctx.app;
+  for (const bundle of allowedBundles) {
+    const def = definitions.getDefaultDefinition(bundle);
+    if (!def?.options) continue;
+    const entry = Object.entries(def.options).find(
+      ([_, opt]) => opt.type === "json" && "dataType" in opt && opt.dataType === "chart"
+    );
+    if (entry) {
+      return { bundle, key: entry[0] };
+    }
+  }
+  return {
+    error: `No block type with a chart option is allowed in this field.`
+  };
+}

package/dist/modules/charts/runtime/blokkli/tools/create_chart/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/charts/runtime/blokkli/tools/create_chart/index.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  mutationResultSchema,
+  parentSchema,
+  positionSchema
+} from "#blokkli/agent/app/tools/schemas";
+import { resolvePosition } from "#blokkli/agent/app/tools/helpers";
+import {
+  chartDataSchema,
+  validateChartData,
+  findChartBundle
+} from "../chart_schemas.js";
+import { COLORS } from "#blokkli-build/charts-config";
+const paramsSchema = z.object({
+  chart: chartDataSchema,
+  parent: parentSchema.describe("The parent entity to add the chart to"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "create_chart",
+  description: "Create a new chart on the page. Series colors are auto-assigned if omitted. For pie/donut/radialBar charts, only the first series is used and each category gets its own color (auto-assigned if categoryColors is omitted). Use get_chart_type_options to discover available typeOptions for the chosen chart type before setting them.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "created chart" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentCreateChartRunning", "Creating chart...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["addNewBlocks"],
+  execute(ctx, params) {
+    const { fields } = ctx.app;
+    const field = fields.find(params.parent.uuid, params.parent.field);
+    if (!field) {
+      return {
+        error: `Field not found: ${params.parent.field} on entity ${params.parent.uuid}`
+      };
+    }
+    const chartBundle = findChartBundle(ctx, field.allowedBundles);
+    if ("error" in chartBundle) {
+      return {
+        error: `No block type with a chart option is allowed in field "${params.parent.field}". Allowed bundles: ${field.allowedBundles.length ? field.allowedBundles.join(", ") : "none"}`
+      };
+    }
+    const chartData = {
+      title: params.chart.title,
+      type: params.chart.type,
+      categories: params.chart.categories,
+      series: params.chart.series.map((s) => ({
+        name: s.name,
+        color: s.color || "",
+        data: s.data
+      })),
+      categoryColors: params.chart.categoryColors || [],
+      footnotes: params.chart.footnotes,
+      typeOptions: params.chart.typeOptions || {}
+    };
+    const result = validateChartData(chartData, COLORS);
+    if ("error" in result) return result;
+    const resolved = resolvePosition(
+      ctx.app,
+      params.parent.uuid,
+      params.parent.field,
+      params.position
+    );
+    if ("error" in resolved) return resolved;
+    const { $t } = ctx.app;
+    const blockUuid = crypto.randomUUID();
+    return {
+      type: "add",
+      label: $t("aiAgentCreateChartDone", "Added chart"),
+      apply: (adapter) => adapter.addNewBlocks({
+        blocks: [
+          {
+            bundle: chartBundle.bundle,
+            blockUuid,
+            options: {
+              [chartBundle.key]: JSON.stringify(result.data)
+            }
+          }
+        ],
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid
+      })
+    };
+  }
+});

package/dist/modules/charts/runtime/blokkli/tools/get_chart_data/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/charts/runtime/blokkli/tools/get_chart_data/index.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  chartTypeEnum,
+  chartColorEnum,
+  chartSeriesSchema,
+  findChartOptionKey
+} from "../chart_schemas.js";
+import { COLORS } from "#blokkli-build/charts-config";
+import { getDefaultChartData } from "../../../helpers/index.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("UUID of the chart paragraph")
+});
+const resultSchema = z.object({
+  title: z.string().describe("Chart title"),
+  type: chartTypeEnum.describe("Chart type"),
+  categories: z.array(z.string()).describe("Category labels"),
+  series: z.array(chartSeriesSchema.required()).describe("Data series with colors"),
+  categoryColors: z.array(chartColorEnum).describe("Color IDs per category"),
+  footnotes: z.array(z.string()).describe("Footnote texts"),
+  typeOptions: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).describe("Current type-specific rendering options")
+});
+export default defineBlokkliAgentTool({
+  name: "get_chart_data",
+  description: "Get the current data of a chart. Returns the chart type, categories, series, colors, footnotes, and typeOptions. Use this to inspect a chart before updating it.",
+  category: "query",
+  volatile: true,
+  prunedSummary: (r) => `chart data (${r.type})`,
+  modes: ["readonly", "editing", "translating", "review"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentGetChartDataRunning", "Getting chart data...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { state, $t } = ctx.app;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
+    const item = state.getFieldListItem(params.uuid);
+    const rawData = item?.options?.[chartOption.key];
+    let data;
+    if (rawData) {
+      try {
+        data = JSON.parse(rawData);
+      } catch {
+        data = getDefaultChartData(COLORS);
+      }
+    } else {
+      data = getDefaultChartData(COLORS);
+    }
+    return {
+      result: {
+        title: data.title || "",
+        type: data.type,
+        categories: data.categories,
+        series: data.series,
+        categoryColors: data.categoryColors || [],
+        footnotes: data.footnotes || [],
+        typeOptions: data.typeOptions || {}
+      },
+      label: $t("aiAgentGetChartDataDone", "Got chart data"),
+      affectedUuids: [params.uuid]
+    };
+  }
+});

package/dist/modules/charts/runtime/blokkli/tools/get_chart_type_options/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/charts/runtime/blokkli/tools/get_chart_type_options/index.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { blockOptionsMapSchema } from "#blokkli/agent/app/tools/schemas";
+import { buildBlockOptionsMapFromDefinitions } from "#blokkli/agent/app/tools/helpers";
+import { getChartTypeRuntime } from "../../../chartTypes/index.js";
+import { chartTypeEnum } from "../chart_schemas.js";
+const paramsSchema = z.object({
+  type: chartTypeEnum.describe("The chart type to get options for")
+});
+const resultSchema = z.object({
+  type: z.string().describe("The chart type ID"),
+  options: blockOptionsMapSchema.describe("Available typeOptions")
+});
+export default defineBlokkliAgentTool({
+  name: "get_chart_type_options",
+  description: "Get available typeOptions for a chart type. Call this before setting typeOptions on create_chart or update_chart to know which keys are valid, their types, defaults, and allowed values.",
+  category: "query",
+  volatile: true,
+  lazy: true,
+  prunedSummary: (r) => `options for ${r.type}`,
+  modes: ["editing"],
+  label($t) {
+    return $t("aiAgentGetChartTypeOptionsRunning", "Getting chart options...");
+  },
+  paramsSchema,
+  resultSchema,
+  execute(_ctx, params) {
+    const def = getChartTypeRuntime(params.type);
+    if (!def) {
+      return { error: `Unknown chart type: ${params.type}` };
+    }
+    return {
+      result: {
+        type: params.type,
+        options: buildBlockOptionsMapFromDefinitions(def.editor.options)
+      },
+      label: `Chart options for "${def.editor.label}"`
+    };
+  }
+});

package/dist/modules/charts/runtime/blokkli/tools/update_chart/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/charts/runtime/blokkli/tools/update_chart/index.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "#blokkli/agent/app/tools/schemas";
+import {
+  chartTypeEnum,
+  chartColorEnum,
+  chartSeriesSchema,
+  validateChartData,
+  findChartOptionKey
+} from "../chart_schemas.js";
+import { COLORS } from "#blokkli-build/charts-config";
+import { getDefaultChartData } from "../../../helpers/index.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("UUID of the chart paragraph to update"),
+  title: z.string().optional().describe("Chart title"),
+  type: chartTypeEnum.optional().describe("Chart type"),
+  categories: z.array(z.string()).min(1).optional().describe(
+    "Category labels (x-axis or slice names). Replaces all existing categories."
+  ),
+  series: z.array(chartSeriesSchema).min(1).optional().describe("Data series. Replaces all existing series."),
+  categoryColors: z.array(chartColorEnum).optional().describe(
+    "Color IDs per category (for pie/donut/radialBar). Auto-assigned if omitted."
+  ),
+  footnotes: z.array(z.string()).optional().describe(
+    "Footnote texts. Reference in categories/series names as {1}, {2}, etc."
+  ),
+  typeOptions: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).optional().describe(
+    "Type-specific rendering options. Use get_chart_type_options to see available keys."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "update_chart",
+  description: "Update an existing chart. Provide only the properties you want to change \u2014 they will be merged with the current chart data. Arrays (series, categories, footnotes) are replaced entirely when provided, not merged element-by-element.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "updated chart" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentUpdateChartRunning", "Updating chart...");
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["updateOptions"],
+  execute(ctx, params) {
+    const { state } = ctx.app;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
+    let current;
+    const item = state.getFieldListItem(params.uuid);
+    const rawData = item?.options?.[chartOption.key];
+    if (rawData) {
+      try {
+        current = JSON.parse(rawData);
+      } catch {
+        current = getDefaultChartData(COLORS);
+      }
+    } else {
+      current = getDefaultChartData(COLORS);
+    }
+    const merged = {
+      title: params.title !== void 0 ? params.title : current.title,
+      type: params.type !== void 0 ? params.type : current.type,
+      categories: params.categories !== void 0 ? params.categories : current.categories,
+      series: params.series !== void 0 ? params.series.map((s) => ({
+        name: s.name,
+        color: s.color || "",
+        data: s.data
+      })) : current.series,
+      categoryColors: params.categoryColors !== void 0 ? params.categoryColors : current.categoryColors,
+      footnotes: params.footnotes !== void 0 ? params.footnotes : current.footnotes,
+      typeOptions: params.typeOptions !== void 0 ? params.typeOptions : current.typeOptions || {}
+    };
+    const result = validateChartData(merged, COLORS);
+    if ("error" in result) return result;
+    const { $t } = ctx.app;
+    return {
+      type: "options",
+      label: $t("aiAgentUpdateChartDone", "Updated chart"),
+      affectedUuids: [params.uuid],
+      apply: (adapter) => adapter.updateOptions([
+        {
+          uuid: params.uuid,
+          key: chartOption.key,
+          value: JSON.stringify(result.data)
+        }
+      ])
+    };
+  }
+});

package/dist/modules/charts/runtime/chartTypes/area.d.ts

@@ -0,0 +1,7 @@
+import type { XAxisTypeOptions, DataLabelsTypeOptions, LegendTypeOptions, GridTypeOptions, StrokeWidthTypeOptions } from './shared.js';
+export type TypeOptions = {
+    curved: boolean;
+    markers: boolean;
+} & XAxisTypeOptions & DataLabelsTypeOptions & LegendTypeOptions & GridTypeOptions & StrokeWidthTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
+export default _default;

package/dist/modules/charts/runtime/chartTypes/area.js

@@ -0,0 +1,68 @@
+import { defineChartType } from "./define.js";
+import {
+  xAxisOptions,
+  buildXAxisLabelOptions,
+  dataLabelsOptions,
+  buildDataLabelsOptions,
+  legendOptions,
+  buildLegendOptions,
+  gridOptions,
+  buildGridOptions,
+  strokeWidthOptions,
+  buildStrokeWidthOptions,
+  mergeShared
+} from "./shared.js";
+export default defineChartType(($t) => {
+  const shared = mergeShared(
+    xAxisOptions($t),
+    dataLabelsOptions($t),
+    legendOptions($t),
+    gridOptions($t),
+    strokeWidthOptions($t)
+  );
+  return {
+    id: "area",
+    hasMultipleSeries: true,
+    hasSeriesColors: true,
+    hasCategoryColors: false,
+    buildChartOptions(ctx) {
+      const strokeWidth = buildStrokeWidthOptions(ctx.typeOptions);
+      return {
+        stroke: {
+          curve: ctx.typeOptions.curved ? "smooth" : "straight",
+          ...strokeWidth.stroke
+        },
+        markers: { size: ctx.typeOptions.markers ? 5 : 0 },
+        xaxis: {
+          categories: ctx.categories,
+          ...buildXAxisLabelOptions(ctx.typeOptions)
+        },
+        ...buildDataLabelsOptions(ctx.typeOptions),
+        ...buildLegendOptions(ctx.typeOptions),
+        ...buildGridOptions(ctx.typeOptions)
+      };
+    },
+    buildSeries(ctx) {
+      return ctx.series.map((s) => ({ name: s.name, data: s.data }));
+    },
+    editor: {
+      label: $t("chartsTypeArea", "Area"),
+      icon: "bk_mdi_area_chart",
+      options: {
+        curved: {
+          type: "checkbox",
+          label: $t("chartsAreaCurved", "Smooth curves"),
+          default: false,
+          group: "display"
+        },
+        markers: {
+          type: "checkbox",
+          label: $t("chartsAreaMarkers", "Show markers"),
+          default: false,
+          group: "display"
+        },
+        ...shared.options
+      }
+    }
+  };
+});

package/dist/modules/charts/runtime/chartTypes/bar.d.ts

@@ -0,0 +1,8 @@
+import type { XAxisTypeOptions, DataLabelsTypeOptions, LegendTypeOptions, GridTypeOptions } from './shared.js';
+export type TypeOptions = {
+    stacked: boolean;
+    horizontal: boolean;
+    borderRadius: string;
+} & XAxisTypeOptions & DataLabelsTypeOptions & LegendTypeOptions & GridTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
+export default _default;

package/dist/modules/charts/runtime/chartTypes/bar.js

@@ -0,0 +1,76 @@
+import { defineChartType } from "./define.js";
+import {
+  xAxisOptions,
+  buildXAxisLabelOptions,
+  dataLabelsOptions,
+  buildDataLabelsOptions,
+  legendOptions,
+  buildLegendOptions,
+  gridOptions,
+  buildGridOptions,
+  mergeShared
+} from "./shared.js";
+export default defineChartType(($t) => {
+  const shared = mergeShared(
+    xAxisOptions($t),
+    dataLabelsOptions($t),
+    legendOptions($t),
+    gridOptions($t)
+  );
+  return {
+    id: "bar",
+    hasMultipleSeries: true,
+    hasSeriesColors: true,
+    hasCategoryColors: false,
+    buildChartOptions(ctx) {
+      return {
+        chart: { stacked: !!ctx.typeOptions.stacked },
+        plotOptions: {
+          bar: {
+            horizontal: !!ctx.typeOptions.horizontal,
+            borderRadius: Number(ctx.typeOptions.borderRadius) || 0
+          }
+        },
+        xaxis: {
+          categories: ctx.categories,
+          ...buildXAxisLabelOptions(ctx.typeOptions)
+        },
+        ...buildDataLabelsOptions(ctx.typeOptions),
+        ...buildLegendOptions(ctx.typeOptions),
+        ...buildGridOptions(ctx.typeOptions)
+      };
+    },
+    buildSeries(ctx) {
+      return ctx.series.map((s) => ({ name: s.name, data: s.data }));
+    },
+    editor: {
+      label: $t("chartsTypeBar", "Bar"),
+      icon: "bk_mdi_bar_chart",
+      options: {
+        stacked: {
+          type: "checkbox",
+          label: $t("chartsBarStacked", "Stacked"),
+          default: false,
+          group: "display"
+        },
+        horizontal: {
+          type: "checkbox",
+          label: $t("chartsBarHorizontal", "Horizontal"),
+          default: false,
+          group: "display"
+        },
+        borderRadius: {
+          type: "radios",
+          label: $t("chartsBorderRadius", "Corner radius"),
+          default: "0",
+          options: {
+            "0": $t("chartsBorderRadiusNone", "None"),
+            "4": $t("chartsBorderRadiusSmall", "Small"),
+            "8": $t("chartsBorderRadiusLarge", "Large")
+          }
+        },
+        ...shared.options
+      }
+    }
+  };
+});

package/dist/modules/charts/runtime/chartTypes/define.d.ts

@@ -0,0 +1,2 @@
+import type { ChartTypeFactory } from './types.js';
+export declare function defineChartType<T extends Record<string, unknown>>(factory: ChartTypeFactory<T>): ChartTypeFactory<T>;

package/dist/modules/charts/runtime/chartTypes/define.js

@@ -0,0 +1,3 @@
+export function defineChartType(factory) {
+  return factory;
+}

package/dist/modules/charts/runtime/chartTypes/donut.d.ts

@@ -0,0 +1,6 @@
+export type TypeOptions = {
+    showTotal: boolean;
+    showLabels: boolean;
+};
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
+export default _default;

package/dist/modules/charts/runtime/chartTypes/donut.js

@@ -0,0 +1,45 @@
+import { defineChartType } from "./define.js";
+export default defineChartType(($t) => ({
+  id: "donut",
+  hasMultipleSeries: false,
+  hasSeriesColors: false,
+  hasCategoryColors: true,
+  buildChartOptions(ctx) {
+    const show = !!ctx.typeOptions.showTotal;
+    return {
+      labels: ctx.categories,
+      dataLabels: { enabled: !!ctx.typeOptions.showLabels },
+      plotOptions: {
+        pie: {
+          donut: {
+            labels: {
+              show,
+              total: { show }
+            }
+          }
+        }
+      }
+    };
+  },
+  buildSeries(ctx) {
+    return ctx.series[0]?.data || [];
+  },
+  editor: {
+    label: $t("chartsTypeDonut", "Donut"),
+    icon: "bk_mdi_donut_large",
+    options: {
+      showTotal: {
+        type: "checkbox",
+        label: $t("chartsDonutShowTotal", "Show total"),
+        default: false,
+        group: "display"
+      },
+      showLabels: {
+        type: "checkbox",
+        label: $t("chartsDonutShowLabels", "Show labels"),
+        default: true,
+        group: "labels"
+      }
+    }
+  }
+}));

package/dist/modules/charts/runtime/chartTypes/heatmap.d.ts

@@ -0,0 +1,4 @@
+import type { XAxisTypeOptions, LegendTypeOptions, GridTypeOptions } from './shared.js';
+export type TypeOptions = XAxisTypeOptions & LegendTypeOptions & GridTypeOptions;
+declare const _default: import("./types.js").ChartTypeFactory<TypeOptions>;
+export default _default;