@revenexx/editor 0.1.0

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

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import {
+  chartTypeEnum,
+  chartColorEnum,
+  chartSeriesSchema,
+  findChartOptionKey,
+  numberFormatSchema,
+  dateFormatSchema
+} from "../chart_schemas.js";
+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(), 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 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", {
+      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);
+    const rawData = state.mutatedOptions[params.uuid]?.[chartOption.key] || item?.options?.[chartOption.key];
+    let data;
+    if (rawData) {
+      try {
+        data = JSON.parse(rawData);
+      } catch {
+        data = getDefaultChartData(options);
+      }
+    } else {
+      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: {
+        title: data.title || "",
+        type: data.type,
+        categories: data.categories,
+        series: data.series,
+        categoryColors: data.categoryColors || [],
+        footnotes: data.footnotes || [],
+        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.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,42 @@
+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 "../../../chart-types/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", {
+      more: true
+    });
+  },
+  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_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.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,112 @@
+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,
+  numberFormatSchema,
+  dateFormatSchema
+} from "../chart_schemas.js";
+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. 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(), 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({
+  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", { 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.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 = {
+      ...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, options);
+    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/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 };
+}

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

@@ -0,0 +1,43 @@
+import type { ChartOption, TranslateFunction } from '../../../types.js';
+type SharedOptions = {
+    options: Record<string, ChartOption>;
+};
+/**
+ * Shared x-axis label options for chart types that display an x-axis.
+ */
+export declare function xAxisOptions($t: TranslateFunction): SharedOptions;
+/**
+ * Data labels option — show values directly on chart elements.
+ */
+export declare function dataLabelsOptions($t: TranslateFunction): SharedOptions;
+/**
+ * Y-axis manual start value option.
+ *
+ * When unset (`undefined`) the chart auto-scales from the data minimum.
+ * When set, chart types may force the Y axis to start at the given value.
+ */
+export declare function yAxisMinOptions($t: TranslateFunction): SharedOptions;
+/**
+ * Legend position option for multi-series chart types.
+ */
+export declare function legendOptions($t: TranslateFunction): SharedOptions;
+/**
+ * Grid lines option for chart types with axes.
+ */
+export declare function gridOptions($t: TranslateFunction): SharedOptions;
+/**
+ * Runtime category filter — when enabled, the chart wrapper renders a
+ * `<select>` above the chart so viewers can pick one category at a time.
+ * The wrapper pivots the payload to a 1-series × N-bar shape and passes
+ * the original series colors as per-bar colors via `categoryHexColors`.
+ */
+export declare function categoryFilterOptions($t: TranslateFunction): SharedOptions;
+/**
+ * Stroke width option for line-based chart types.
+ */
+export declare function strokeWidthOptions($t: TranslateFunction): SharedOptions;
+/**
+ * Merge multiple shared option sets into one.
+ */
+export declare function mergeShared(...sets: SharedOptions[]): SharedOptions;
+export {};

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

@@ -0,0 +1,110 @@
+export function xAxisOptions($t) {
+  return {
+    options: {
+      xaxisRotation: {
+        type: "radios",
+        label: $t("chartsXAxisRotation", "Label rotation"),
+        default: "auto",
+        options: {
+          auto: $t("auto", "Auto"),
+          "-45": "-45\xB0",
+          "-90": "-90\xB0"
+        }
+      }
+    }
+  };
+}
+export function dataLabelsOptions($t) {
+  return {
+    options: {
+      dataLabels: {
+        type: "checkbox",
+        label: $t("chartsDataLabels", "Data labels"),
+        default: false,
+        group: "labels"
+      }
+    }
+  };
+}
+export function yAxisMinOptions($t) {
+  return {
+    options: {
+      yaxisMin: {
+        type: "number",
+        nullable: true,
+        label: $t("chartsYAxisMin", "Y-axis start"),
+        group: "display"
+      }
+    }
+  };
+}
+export function legendOptions($t) {
+  return {
+    options: {
+      legendPosition: {
+        type: "radios",
+        label: $t("chartsLegendPosition", "Legend position"),
+        default: "bottom",
+        options: {
+          bottom: $t("chartsPositionBottom", "Bottom"),
+          top: $t("chartsPositionTop", "Top"),
+          right: $t("chartsPositionRight", "Right")
+        }
+      }
+    }
+  };
+}
+export function gridOptions($t) {
+  return {
+    options: {
+      gridLines: {
+        type: "checkbox",
+        label: $t("chartsGridLines", "Grid lines"),
+        default: true,
+        group: "display"
+      }
+    }
+  };
+}
+export function categoryFilterOptions($t) {
+  return {
+    options: {
+      categoryFilter: {
+        type: "checkbox",
+        label: $t("chartsCategoryFilter", "Filterable category axis"),
+        default: false,
+        group: "filter"
+      },
+      categoryFilterLabel: {
+        type: "text",
+        label: $t("chartsCategoryFilterLabel", "Filter label"),
+        default: "",
+        group: "filter",
+        shouldRender: ({ options }) => options.categoryFilter === true
+      }
+    }
+  };
+}
+export function strokeWidthOptions($t) {
+  return {
+    options: {
+      strokeWidth: {
+        type: "radios",
+        label: $t("chartsStrokeWidth", "Line thickness"),
+        default: "2",
+        options: {
+          "2": $t("chartsStrokeThin", "Thin"),
+          "4": $t("chartsStrokeMedium", "Medium"),
+          "6": $t("chartsStrokeThick", "Thick")
+        }
+      }
+    }
+  };
+}
+export function mergeShared(...sets) {
+  const options = {};
+  for (const set of sets) {
+    Object.assign(options, set.options);
+  }
+  return { options };
+}

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

@@ -0,0 +1,21 @@
+import type { ChartTypeDefinition, TranslateFunction } from '../types.js';
+export type { ChartTypeOptionsMap, ChartTypeId, } from '#blokkli-build/charts-definitions';
+/**
+ * Get a chart type definition using fallback labels (no real translations).
+ * Used by agent tools that don't have access to `$t`.
+ */
+export declare function getChartTypeRuntime(id: string): ChartTypeDefinition | undefined;
+/**
+ * Get all chart type definitions with translated labels.
+ * Used by editor components only.
+ */
+export declare function getChartTypes($t: TranslateFunction): ChartTypeDefinition[];
+/**
+ * Get a single chart type definition with translated labels.
+ * Used by editor components only.
+ */
+export declare function getChartType(id: string, $t: TranslateFunction): ChartTypeDefinition | undefined;
+/**
+ * Get the default type options for a chart type.
+ */
+export declare function getDefaultTypeOptions(id: string): Record<string, unknown>;

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

@@ -0,0 +1,25 @@
+import { definitions } from "#blokkli-build/charts-definitions";
+const noopT = (_key, fallback) => fallback;
+function resolve(entry, $t) {
+  return { id: entry.id, ...entry.factory($t) };
+}
+export function getChartTypeRuntime(id) {
+  const entry = definitions.find((d) => d.id === id);
+  return entry ? resolve(entry, noopT) : void 0;
+}
+export function getChartTypes($t) {
+  return definitions.map((entry) => resolve(entry, $t));
+}
+export function getChartType(id, $t) {
+  const entry = definitions.find((d) => d.id === id);
+  return entry ? resolve(entry, $t) : void 0;
+}
+export function getDefaultTypeOptions(id) {
+  const def = getChartTypeRuntime(id);
+  if (!def) return {};
+  const defaults = {};
+  for (const [key, opt] of Object.entries(def.editor.options)) {
+    defaults[key] = opt.default;
+  }
+  return defaults;
+}

package/dist/modules/charts/runtime/components/ChartRenderer/index.d.vue.ts

@@ -0,0 +1,21 @@
+import type { BlokkliChartData, ChartDataSourcePayload } from '../../types.js';
+type __VLS_Props = BlokkliChartData & {
+    /**
+     * Override the language used to resolve translated strings. When unset,
+     * the language comes from the surrounding BlokkliProvider context.
+     */
+    languageOverride?: string;
+    /**
+     * Data fetched at runtime for a dynamic data source. Required when
+     * `props.dataSource` is set; otherwise ignored.
+     *
+     * The integrator's chart block component is responsible for fetching
+     * (e.g. via `useFetch` / `useLazyFetch`) and passing the result here.
+     * For large payloads, prefer `useLazyFetch` or `useAsyncData` with
+     * `server: false` to avoid bloating SSR HTML.
+     */
+    dynamicData?: ChartDataSourcePayload | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;