@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

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

@@ -1,19 +1,11 @@
 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);
+import { getChartTypeRuntime, getDefaultTypeOptions } from "../../chart-types/index.js";
+import { colorOptions } from "#blokkli-build/editor-config";
+import { definitionIds } from "#blokkli-build/charts-definitions";
+const agentChartTypeIds = definitionIds.filter((id) => id !== "advanced");
+export const chartTypeEnum = z.enum(agentChartTypeIds);
+const colorIds = Object.keys(colorOptions);
 export const chartColorEnum = z.enum(colorIds);
 export const chartSeriesSchema = z.object({
   name: z.string().describe("Series name (shown in legend)"),
@@ -22,23 +14,83 @@ export const chartSeriesSchema = z.object({
   ),
   data: z.array(z.number()).describe("Data values, one per category")
 });
+export const chartTranslationSchema = z.object({
+  title: z.string().optional(),
+  categories: z.array(z.string()).optional(),
+  seriesNames: z.array(z.string()).optional(),
+  footnotes: z.array(z.string()).optional(),
+  prefix: z.string().optional(),
+  suffix: z.string().optional()
+});
+export const numberFormatSchema = z.object({
+  locale: z.string().optional().describe("BCP-47 locale tag (e.g. 'de-CH', 'en-US'). Empty = default."),
+  decimals: z.number().int().min(0).max(4).optional().describe("Forced fraction digits 0-4. Omit to let Intl decide."),
+  prefix: z.string().optional().describe("String before the number (e.g. 'CHF ')."),
+  suffix: z.string().optional().describe("String after the number (e.g. ' kg', '%')."),
+  notation: z.enum(["standard", "compact"]).optional().describe("'standard' for full numbers, 'compact' for short form (1.2M).")
+});
+export const dateFormatSchema = z.object({
+  style: z.enum([
+    "auto",
+    "none",
+    "monthYearShort",
+    "monthYearLong",
+    "monthOnly",
+    "monthYearNumeric",
+    "iso",
+    "dateShort",
+    "dateLong",
+    "yearOnly"
+  ]).optional().describe(
+    "Display style applied to category labels when they look like dates. Falls back to `auto`. Locale is reused from `numberFormat.locale`."
+  )
+});
 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."
+    "Color IDs per category. Only used by chart types with per-category colors (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."
+  typeOptions: z.record(
+    z.string(),
+    z.union([z.string(), z.boolean(), z.number(), z.null()])
+  ).optional().describe(
+    "Type-specific rendering options. Use get_chart_type_options to see available keys. Pass `null` to clear a nullable option (e.g. `yaxisMin`)."
+  ),
+  numberFormat: numberFormatSchema.optional().describe(
+    "Number formatting for axes, data labels and tooltips. Locale, decimals, prefix/suffix and notation."
+  ),
+  dateFormat: dateFormatSchema.optional().describe(
+    "How to format category labels detected as dates. Locale is reused from numberFormat.locale."
+  ),
+  translations: z.record(z.string(), chartTranslationSchema).optional().describe(
+    "Per-language translations of translatable strings, keyed by langcode. Managed in the editor; agents should not modify this."
   )
 });
-export function validateChartData(data, colors) {
-  const colorIds2 = Object.keys(colors);
+export const advancedConfigSchema = z.record(z.string(), z.unknown()).describe(
+  "Raw ECharts option object \u2014 same shape ECharts.setOption() accepts. Pass the structured object; no JSON-stringify needed."
+);
+export function validateAdvancedConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {
+      error: "Configuration must be a non-null JSON object, not an array."
+    };
+  }
+  if (Object.keys(value).length === 0) {
+    return {
+      error: "Configuration is empty. Provide at least a `series` (or similar) top-level key."
+    };
+  }
+  return { value };
+}
+export function validateChartData(data, options) {
+  const validIds = new Set(options.map((c) => c.id));
+  const availableIds = options.map((c) => c.id);
   for (let i = 0; i < data.series.length; i++) {
     const series = data.series[i];
     if (series.data.length !== data.categories.length) {
@@ -50,36 +102,31 @@ export function validateChartData(data, colors) {
   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]) {
+      series.color = getColorIdAtIndex(i, options);
+    } else if (!validIds.has(series.color)) {
       return {
-        error: `Invalid color ID "${series.color}" on series "${series.name}". Available colors: ${colorIds2.join(", ")}`
+        error: `Invalid color ID "${series.color}" on series "${series.name}". Available colors: ${availableIds.join(", ")}`
       };
     }
   }
-  const isSingleSeries = SINGLE_SERIES_TYPES.includes(data.type);
-  if (isSingleSeries) {
+  const typeDef = getChartTypeRuntime(data.type);
+  if (typeDef?.hasCategoryColors) {
     if (!data.categoryColors || data.categoryColors.length !== data.categories.length) {
       data.categoryColors = data.categories.map(
-        (_, i) => getColorIdAtIndex(i, colors)
+        (_, i) => getColorIdAtIndex(i, options)
       );
     } else {
       for (let i = 0; i < data.categoryColors.length; i++) {
         const id = data.categoryColors[i];
-        if (!colors[id]) {
+        if (!validIds.has(id)) {
           return {
-            error: `Invalid categoryColor ID "${id}" at index ${i}. Available colors: ${colorIds2.join(", ")}`
+            error: `Invalid categoryColor ID "${id}" at index ${i}. Available colors: ${availableIds.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)) {

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

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

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

@@ -0,0 +1,88 @@
+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 {
+  advancedConfigSchema,
+  validateAdvancedConfig,
+  findChartBundle
+} from "../chart_schemas.js";
+import { getDefaultChartData } from "../../../helpers/index.js";
+const paramsSchema = z.object({
+  config: advancedConfigSchema,
+  parent: parentSchema.describe("The parent entity to add the chart to"),
+  position: positionSchema
+});
+export default defineBlokkliAgentTool({
+  name: "create_advanced_chart",
+  description: "Create a new advanced chart that renders a raw ECharts option object. Use this only when the user needs a chart type or layout not covered by the structured chart types (bar, line, pie, area, donut, heatmap, radialBar, radar, agePyramid). For those, use create_chart instead.",
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "created advanced chart" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentCreateAdvancedChartRunning", "Creating advanced chart", {
+      more: true
+    });
+  },
+  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 validated = validateAdvancedConfig(params.config);
+    if ("error" in validated) return validated;
+    const base = getDefaultChartData(ctx.app.config.colorOptions.value);
+    const chartData = {
+      ...base,
+      type: "advanced",
+      advancedConfig: { parsed: validated.value }
+    };
+    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("aiAgentCreateAdvancedChartDone", "Added advanced chart"),
+      apply: (adapter) => adapter.addNewBlocks({
+        blocks: [
+          {
+            bundle: chartBundle.bundle,
+            blockUuid,
+            options: {
+              [chartBundle.key]: JSON.stringify(chartData)
+            }
+          }
+        ],
+        host: {
+          type: params.parent.type,
+          uuid: params.parent.uuid,
+          fieldName: params.parent.field
+        },
+        afterUuid: resolved.afterUuid
+      })
+    };
+  }
+});

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

@@ -11,7 +11,6 @@ import {
   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"),
@@ -25,7 +24,7 @@ export default defineBlokkliAgentTool({
   modes: ["editing"],
   lazy: true,
   label($t) {
-    return $t("aiAgentCreateChartRunning", "Creating chart...");
+    return $t("aiAgentCreateChartRunning", "Creating chart", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
@@ -55,9 +54,14 @@ export default defineBlokkliAgentTool({
       })),
       categoryColors: params.chart.categoryColors || [],
       footnotes: params.chart.footnotes,
-      typeOptions: params.chart.typeOptions || {}
+      typeOptions: params.chart.typeOptions || {},
+      ...params.chart.numberFormat ? { numberFormat: params.chart.numberFormat } : {},
+      ...params.chart.dateFormat ? { dateFormat: params.chart.dateFormat } : {}
     };
-    const result = validateChartData(chartData, COLORS);
+    const result = validateChartData(
+      chartData,
+      ctx.app.config.colorOptions.value
+    );
     if ("error" in result) return result;
     const resolved = resolvePosition(
       ctx.app,

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

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

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { advancedConfigSchema, findChartOptionKey } from "../chart_schemas.js";
+import { getDefaultChartData } from "../../../helpers/index.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("UUID of the advanced chart paragraph")
+});
+const resultSchema = z.object({
+  config: advancedConfigSchema.describe(
+    "The current ECharts option object stored on the chart."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "get_advanced_chart_config",
+  description: 'Read the raw ECharts option object from an advanced chart. Refuses charts whose type is not "advanced"; use get_chart_data for those.',
+  category: "query",
+  volatile: true,
+  lazy: true,
+  prunedSummary: () => "advanced chart config",
+  modes: ["readonly", "editing", "review"],
+  label($t) {
+    return $t(
+      "aiAgentGetAdvancedChartConfigRunning",
+      "Getting advanced chart config",
+      {
+        more: true
+      }
+    );
+  },
+  paramsSchema,
+  resultSchema,
+  execute(ctx, params) {
+    const { state, $t } = ctx.app;
+    const options = ctx.app.config.colorOptions.value;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
+    let current;
+    const item = state.getFieldListItem(params.uuid);
+    const rawData = state.mutatedOptions[params.uuid]?.[chartOption.key] || item?.options?.[chartOption.key];
+    if (rawData) {
+      try {
+        current = JSON.parse(rawData);
+      } catch {
+        current = getDefaultChartData(options);
+      }
+    } else {
+      current = getDefaultChartData(options);
+    }
+    if (current.type !== "advanced") {
+      return {
+        error: `Chart "${params.uuid}" is of type "${current.type}", not "advanced". Use get_chart_data for structured chart types.`
+      };
+    }
+    return {
+      result: {
+        config: current.advancedConfig?.parsed ?? {}
+      },
+      label: $t(
+        "aiAgentGetAdvancedChartConfigDone",
+        "Got advanced chart config"
+      ),
+      affectedUuids: [params.uuid]
+    };
+  }
+});

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

@@ -4,9 +4,10 @@ import {
   chartTypeEnum,
   chartColorEnum,
   chartSeriesSchema,
-  findChartOptionKey
+  findChartOptionKey,
+  numberFormatSchema,
+  dateFormatSchema
 } 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")
@@ -18,23 +19,37 @@ const resultSchema = z.object({
   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")
+  typeOptions: z.record(
+    z.string(),
+    z.union([z.string(), z.boolean(), z.number(), z.null()])
+  ).describe("Current type-specific rendering options"),
+  numberFormat: numberFormatSchema.optional().describe("Number formatting (if set on the chart)."),
+  dateFormat: dateFormatSchema.optional().describe("Date formatting (if set on the chart)."),
+  dataSource: z.object({
+    id: z.string(),
+    label: z.string()
+  }).optional().describe(
+    "Dynamic data source bound to this chart. When set, inline categories/series are ignored at render time and update_chart refuses to change them."
+  )
 });
 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.",
+  description: "Get the current data of a chart. Returns chart type, categories, series, colors, footnotes, typeOptions, optional number/date formatting, and any bound dynamic data source. 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...");
+    return $t("aiAgentGetChartDataRunning", "Getting chart data", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
     const { state, $t } = ctx.app;
+    const options = ctx.app.config.colorOptions.value;
     const chartOption = findChartOptionKey(ctx, params.uuid);
     if ("error" in chartOption) return chartOption;
     const item = state.getFieldListItem(params.uuid);
@@ -44,10 +59,15 @@ export default defineBlokkliAgentTool({
       try {
         data = JSON.parse(rawData);
       } catch {
-        data = getDefaultChartData(COLORS);
+        data = getDefaultChartData(options);
       }
     } else {
-      data = getDefaultChartData(COLORS);
+      data = getDefaultChartData(options);
+    }
+    if (data.type === "advanced") {
+      return {
+        error: `Chart "${params.uuid}" uses the "advanced" chart type, which stores raw ECharts JSON. Use get_advanced_chart_config to read it, update_advanced_chart to change it.`
+      };
     }
     return {
       result: {
@@ -57,7 +77,15 @@ export default defineBlokkliAgentTool({
         series: data.series,
         categoryColors: data.categoryColors || [],
         footnotes: data.footnotes || [],
-        typeOptions: data.typeOptions || {}
+        typeOptions: data.typeOptions || {},
+        ...data.numberFormat ? { numberFormat: data.numberFormat } : {},
+        ...data.dateFormat ? { dateFormat: data.dateFormat } : {},
+        ...data.dataSource ? {
+          dataSource: {
+            id: data.dataSource.id,
+            label: data.dataSource.label
+          }
+        } : {}
       },
       label: $t("aiAgentGetChartDataDone", "Got chart data"),
       affectedUuids: [params.uuid]

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

@@ -2,7 +2,7 @@ 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 { getChartTypeRuntime } from "../../../chart-types/index.js";
 import { chartTypeEnum } from "../chart_schemas.js";
 const paramsSchema = z.object({
   type: chartTypeEnum.describe("The chart type to get options for")
@@ -20,7 +20,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `options for ${r.type}`,
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentGetChartTypeOptionsRunning", "Getting chart options...");
+    return $t("aiAgentGetChartTypeOptionsRunning", "Getting chart options", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,

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

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

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

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { mutationResultSchema } from "#blokkli/agent/app/tools/schemas";
+import {
+  advancedConfigSchema,
+  validateAdvancedConfig,
+  findChartOptionKey
+} from "../chart_schemas.js";
+import { getDefaultChartData } from "../../../helpers/index.js";
+const paramsSchema = z.object({
+  uuid: z.string().describe("UUID of the advanced chart paragraph to update"),
+  config: advancedConfigSchema.describe(
+    "Full replacement ECharts option object. The previous config is overwritten."
+  )
+});
+export default defineBlokkliAgentTool({
+  name: "update_advanced_chart",
+  description: 'Replace the ECharts option object on an existing advanced chart. The config is a full replacement, not a partial merge \u2014 call get_advanced_chart_config first if you need to read-then-edit. Refuses charts whose type is not "advanced"; use update_chart for those.',
+  category: "mutation",
+  prunedSummary: (r) => r.success ? "updated advanced chart" : "rejected",
+  modes: ["editing"],
+  lazy: true,
+  label($t) {
+    return $t("aiAgentUpdateAdvancedChartRunning", "Updating advanced chart", {
+      more: true
+    });
+  },
+  paramsSchema,
+  resultSchema: mutationResultSchema,
+  requiredAdapterMethods: ["updateOptions"],
+  execute(ctx, params) {
+    const { state } = ctx.app;
+    const options = ctx.app.config.colorOptions.value;
+    const chartOption = findChartOptionKey(ctx, params.uuid);
+    if ("error" in chartOption) return chartOption;
+    let current;
+    const item = state.getFieldListItem(params.uuid);
+    const rawData = state.mutatedOptions[params.uuid]?.[chartOption.key] || item?.options?.[chartOption.key];
+    if (rawData) {
+      try {
+        current = JSON.parse(rawData);
+      } catch {
+        current = getDefaultChartData(options);
+      }
+    } else {
+      current = getDefaultChartData(options);
+    }
+    if (current.type !== "advanced") {
+      return {
+        error: `Chart "${params.uuid}" is of type "${current.type}", not "advanced". Use update_chart for structured chart types.`
+      };
+    }
+    const validated = validateAdvancedConfig(params.config);
+    if ("error" in validated) return validated;
+    const merged = {
+      ...current,
+      advancedConfig: { parsed: validated.value }
+    };
+    const { $t } = ctx.app;
+    return {
+      type: "options",
+      label: $t("aiAgentUpdateAdvancedChartDone", "Updated advanced chart"),
+      affectedUuids: [params.uuid],
+      apply: (adapter) => adapter.updateOptions([
+        {
+          uuid: params.uuid,
+          key: chartOption.key,
+          value: JSON.stringify(merged)
+        }
+      ])
+    };
+  }
+});

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

@@ -6,9 +6,10 @@ import {
   chartColorEnum,
   chartSeriesSchema,
   validateChartData,
-  findChartOptionKey
+  findChartOptionKey,
+  numberFormatSchema,
+  dateFormatSchema
 } 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"),
@@ -19,13 +20,22 @@ const paramsSchema = z.object({
   ),
   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."
+    "Color IDs per category. Only used by chart types with per-category colors (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."
+  typeOptions: z.record(
+    z.string(),
+    z.union([z.string(), z.boolean(), z.number(), z.null()])
+  ).optional().describe(
+    "Type-specific rendering options. Use get_chart_type_options to see available keys. Pass `null` to clear a nullable option (e.g. `yaxisMin`)."
+  ),
+  numberFormat: numberFormatSchema.optional().describe(
+    "Number formatting for axes, data labels and tooltips. Replaces the existing numberFormat."
+  ),
+  dateFormat: dateFormatSchema.optional().describe(
+    "How to format category labels detected as dates. Replaces the existing dateFormat."
   )
 });
 export default defineBlokkliAgentTool({
@@ -36,13 +46,14 @@ export default defineBlokkliAgentTool({
   modes: ["editing"],
   lazy: true,
   label($t) {
-    return $t("aiAgentUpdateChartRunning", "Updating chart...");
+    return $t("aiAgentUpdateChartRunning", "Updating chart", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
   requiredAdapterMethods: ["updateOptions"],
   execute(ctx, params) {
     const { state } = ctx.app;
+    const options = ctx.app.config.colorOptions.value;
     const chartOption = findChartOptionKey(ctx, params.uuid);
     if ("error" in chartOption) return chartOption;
     let current;
@@ -52,25 +63,37 @@ export default defineBlokkliAgentTool({
       try {
         current = JSON.parse(rawData);
       } catch {
-        current = getDefaultChartData(COLORS);
+        current = getDefaultChartData(options);
       }
     } else {
-      current = getDefaultChartData(COLORS);
+      current = getDefaultChartData(options);
+    }
+    if (current.dataSource) {
+      if (params.categories !== void 0 || params.series !== void 0) {
+        return {
+          error: `Chart "${params.uuid}" is bound to dynamic data source "${current.dataSource.label || current.dataSource.id}". Inline categories and series are ignored at render time. To change the data, unbind the data source in the editor first.`
+        };
+      }
     }
     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 || {}
+      ...current,
+      ...params.title !== void 0 ? { title: params.title } : {},
+      ...params.type !== void 0 ? { type: params.type } : {},
+      ...params.categories !== void 0 ? { categories: params.categories } : {},
+      ...params.series !== void 0 ? {
+        series: params.series.map((s) => ({
+          name: s.name,
+          color: s.color || "",
+          data: s.data
+        }))
+      } : {},
+      ...params.categoryColors !== void 0 ? { categoryColors: params.categoryColors } : {},
+      ...params.footnotes !== void 0 ? { footnotes: params.footnotes } : {},
+      ...params.typeOptions !== void 0 ? { typeOptions: params.typeOptions } : {},
+      ...params.numberFormat !== void 0 ? { numberFormat: params.numberFormat } : {},
+      ...params.dateFormat !== void 0 ? { dateFormat: params.dateFormat } : {}
     };
-    const result = validateChartData(merged, COLORS);
+    const result = validateChartData(merged, options);
     if ("error" in result) return result;
     const { $t } = ctx.app;
     return {

package/dist/modules/charts/runtime/chart-types/definition/index.d.ts

@@ -0,0 +1,7 @@
+import type { ChartTypeDefinitionEntry, ChartTypeFactory } from '../../types.js';
+/**
+ * Declare a chart type. The id is the first positional argument so the
+ * build-time `ChartTypeCollector` can statically extract it from the
+ * source file without executing the factory.
+ */
+export declare function defineChartType<T extends Record<string, unknown>>(id: string, factory: ChartTypeFactory<T>): ChartTypeDefinitionEntry<T>;

package/dist/modules/charts/runtime/chart-types/definition/index.js

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