@contractspec/lib.presentation-runtime-core 3.7.5 → 3.8.0

package/dist/visualization.echarts.js

@@ -0,0 +1,149 @@
+// @bun
+// src/visualization.echarts.ts
+function buildVisualizationEChartsOption(model) {
+  const thresholdLines = model.thresholds.map((threshold) => ({
+    yAxis: threshold.value,
+    name: threshold.label,
+    lineStyle: {
+      color: threshold.color ?? "#ef4444",
+      type: "dashed"
+    }
+  }));
+  const annotationLines = model.annotations.filter((annotation) => annotation.kind === "line" && annotation.y != null).map((annotation) => toMarkLine(annotation));
+  switch (model.kind) {
+    case "cartesian":
+      const cartesianSeries = model.series.map((series) => ({
+        name: series.label,
+        type: resolveCartesianSeriesType(series.type),
+        smooth: series.smooth,
+        stack: series.stack,
+        areaStyle: series.type === "area" ? {} : undefined,
+        itemStyle: series.color ? { color: series.color } : undefined,
+        lineStyle: series.color ? { color: series.color } : undefined,
+        data: series.points.filter((point) => point.y != null).map((point) => [point.x, point.y]),
+        markLine: thresholdLines.length || annotationLines.length ? { data: [...thresholdLines, ...annotationLines] } : undefined
+      }));
+      return {
+        color: model.palette,
+        tooltip: model.tooltip === false ? undefined : { trigger: "axis" },
+        legend: { show: model.legend ?? model.series.length > 1 },
+        xAxis: { type: model.xAxis?.type === "time" ? "time" : "category" },
+        yAxis: { type: "value", name: model.yAxis?.label },
+        series: cartesianSeries
+      };
+    case "pie":
+      const pieSeries = [
+        {
+          type: "pie",
+          radius: ["0%", "70%"],
+          data: model.series[0]?.points.filter((point) => point.value != null).map((point) => ({
+            name: point.name ?? "",
+            value: point.value
+          })) ?? []
+        }
+      ];
+      return {
+        color: model.palette,
+        tooltip: model.tooltip === false ? undefined : { trigger: "item" },
+        series: pieSeries
+      };
+    case "heatmap":
+      const heatmapSeries = [
+        {
+          type: "heatmap",
+          data: model.series[0]?.points.filter((point) => point.value != null && point.name != null).map((point) => [point.x, point.name, point.value]) ?? []
+        }
+      ];
+      return {
+        color: model.palette,
+        tooltip: model.tooltip === false ? undefined : { position: "top" },
+        xAxis: {
+          type: "category",
+          data: uniqueValues(model.series[0]?.points.map((point) => point.x))
+        },
+        yAxis: {
+          type: "category",
+          data: uniqueValues(model.series[0]?.points.map((point) => point.name))
+        },
+        visualMap: {
+          min: 0,
+          max: maxValue(model.series[0]?.points.map((point) => point.value)),
+          calculable: true,
+          orient: "horizontal",
+          left: "center",
+          bottom: 0
+        },
+        series: heatmapSeries
+      };
+    case "funnel":
+      const funnelSeries = [
+        {
+          type: "funnel",
+          data: model.series[0]?.points.filter((point) => point.value != null).map((point) => ({
+            name: point.name ?? "",
+            value: point.value
+          })) ?? []
+        }
+      ];
+      return {
+        color: model.palette,
+        tooltip: model.tooltip === false ? undefined : { trigger: "item" },
+        series: funnelSeries
+      };
+    case "geo":
+      if (!model.geo || model.geo.mode === "slippy-map" || !model.geo.geoJson) {
+        return {};
+      }
+      const geoSeries = [
+        {
+          type: model.geo.variant === "heatmap" ? "heatmap" : "scatter",
+          coordinateSystem: "geo",
+          data: model.series[0]?.points.filter((point) => point.longitude != null && point.latitude != null && point.value != null).map((point) => ({
+            name: point.name ?? "",
+            value: [
+              point.longitude,
+              point.latitude,
+              point.value
+            ]
+          })) ?? []
+        }
+      ];
+      return {
+        color: model.palette,
+        tooltip: model.tooltip === false ? undefined : { trigger: "item" },
+        geo: {
+          map: "contractspec-visualization-geo",
+          roam: true
+        },
+        series: geoSeries
+      };
+    default:
+      return {};
+  }
+}
+function uniqueValues(values) {
+  return Array.from(new Set((values ?? []).filter((value) => value != null).map(String)));
+}
+function maxValue(values) {
+  return Math.max(...(values ?? []).map((value) => value ?? 0), 1);
+}
+function toMarkLine(annotation) {
+  return {
+    yAxis: annotation.y,
+    name: annotation.label,
+    lineStyle: {
+      color: annotation.color ?? "#2563eb",
+      type: "solid"
+    }
+  };
+}
+function resolveCartesianSeriesType(type) {
+  if (type === "bar")
+    return "bar";
+  if (type === "scatter")
+    return "scatter";
+  return "line";
+}
+export {
+  buildVisualizationEChartsOption
+};

package/dist/visualization.js

@@ -0,0 +1,308 @@
+// @bun
+// src/visualization.utils.ts
+function formatVisualizationValue(value, format) {
+  if (value == null)
+    return "\u2014";
+  if (format === "currency" && typeof value === "number") {
+    return new Intl.NumberFormat(undefined, {
+      style: "currency",
+      currency: "USD"
+    }).format(value);
+  }
+  if (format === "percentage" && typeof value === "number") {
+    return `${(value * 100).toFixed(1)}%`;
+  }
+  if ((format === "date" || format === "dateTime") && value) {
+    const date = value instanceof Date ? value : new Date(String(value));
+    return Number.isNaN(date.getTime()) ? String(value) : new Intl.DateTimeFormat(undefined, {
+      dateStyle: "medium",
+      timeStyle: format === "dateTime" ? "short" : undefined
+    }).format(date);
+  }
+  return String(value);
+}
+function resolveVisualizationRows(data, resultPath) {
+  const value = resultPath ? getAtPath(data, resultPath) : data;
+  const candidate = value ?? data;
+  if (Array.isArray(candidate))
+    return candidate.map(asRow);
+  if (Array.isArray(getAtPath(candidate, "items"))) {
+    return getAtPath(candidate, "items").map(asRow);
+  }
+  if (Array.isArray(getAtPath(candidate, "rows"))) {
+    return getAtPath(candidate, "rows").map(asRow);
+  }
+  if (Array.isArray(getAtPath(candidate, "data"))) {
+    return getAtPath(candidate, "data").map(asRow);
+  }
+  return candidate && typeof candidate === "object" ? [asRow(candidate)] : [];
+}
+function getAtPath(source, path) {
+  if (!path || source == null)
+    return source;
+  return path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean).reduce((current, segment) => {
+    if (current == null || typeof current !== "object")
+      return;
+    return current[segment];
+  }, source);
+}
+function toNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function asRow(value) {
+  return value && typeof value === "object" ? value : { value };
+}
+
+// src/visualization.model.helpers.ts
+function createVisualizationMaps(spec) {
+  return {
+    dimensions: new Map((spec.visualization.dimensions ?? []).map((dimension) => [
+      dimension.key,
+      dimension
+    ])),
+    measures: new Map((spec.visualization.measures ?? []).map((measure) => [
+      measure.key,
+      measure
+    ]))
+  };
+}
+function createVisualizationBaseModel(spec, rows, maps) {
+  const config = spec.visualization;
+  return {
+    kind: config.kind,
+    title: config.title ?? spec.meta.title,
+    description: config.description ?? spec.meta.description,
+    summary: `${spec.meta.title ?? spec.meta.key}: ${rows.length} row${rows.length === 1 ? "" : "s"}`,
+    warnings: rows.length === 0 ? ["No visualization rows available."] : [],
+    palette: config.palette,
+    legend: config.legend,
+    tooltip: config.tooltip,
+    drilldown: config.drilldown,
+    thresholds: config.thresholds ?? [],
+    annotations: (config.annotations ?? []).map((annotation) => resolveAnnotation(annotation, rows[0] ?? {})),
+    table: createTable(config.table?.caption, config, rows)
+  };
+}
+function createMeasureSeries(measureKey, measures, rows, dimension, config) {
+  const measure = measures.get(measureKey);
+  if (!measure)
+    return null;
+  return {
+    key: config?.key ?? measure.key,
+    label: config?.label ?? measure.label,
+    type: config?.type,
+    color: config?.color ?? measure.color,
+    stack: config?.stack,
+    smooth: config?.smooth,
+    points: rows.map((row, index) => ({
+      id: `${measure.key}-${index}`,
+      raw: row,
+      x: dimension ? readDimensionValue(row, dimension) : index,
+      y: numericValue(row, measure),
+      value: numericValue(row, measure)
+    }))
+  };
+}
+function defaultSeries(keys) {
+  return keys.map((key) => ({ key, label: key, measure: key }));
+}
+function createAxis(dimension) {
+  if (!dimension)
+    return;
+  return {
+    key: dimension.key,
+    label: dimension.label,
+    type: dimension.type === "time" ? "time" : dimension.type === "number" ? "number" : "category",
+    format: dimension.format
+  };
+}
+function createValueAxis(key, measures) {
+  const measure = key ? measures.get(key) : undefined;
+  if (!measure)
+    return;
+  return {
+    key: measure.key,
+    label: measure.label,
+    type: "number",
+    format: measure.format
+  };
+}
+function readValue(row, measure) {
+  return measure ? getAtPath(row, measure.dataPath) : undefined;
+}
+function readDimensionValue(row, dimension) {
+  return dimension ? getAtPath(row, dimension.dataPath) : undefined;
+}
+function numericValue(row, measure) {
+  return toNumber(readValue(row, measure));
+}
+function numericPathValue(row, dimension) {
+  return toNumber(readDimensionValue(row, dimension));
+}
+function stringValue(row, dimension) {
+  const value = readDimensionValue(row, dimension);
+  return value == null ? undefined : String(value);
+}
+function createTable(caption, config, rows) {
+  const dimensions = config.dimensions ?? [];
+  const measures = config.measures ?? [];
+  return {
+    caption,
+    columns: [
+      ...dimensions.map((dimension) => ({
+        key: dimension.key,
+        label: dimension.label
+      })),
+      ...measures.map((measure) => ({
+        key: measure.key,
+        label: measure.label
+      }))
+    ],
+    rows: rows.map((row) => ({
+      ...Object.fromEntries(dimensions.map((dimension) => [
+        dimension.key,
+        readDimensionValue(row, dimension)
+      ])),
+      ...Object.fromEntries(measures.map((measure) => [measure.key, readValue(row, measure)]))
+    }))
+  };
+}
+function resolveAnnotation(annotation, row) {
+  return {
+    key: annotation.key,
+    label: annotation.label,
+    kind: annotation.kind,
+    color: annotation.color,
+    x: annotation.xDataPath ? getAtPath(row, annotation.xDataPath) : undefined,
+    y: annotation.yDataPath ? toNumber(getAtPath(row, annotation.yDataPath)) : undefined,
+    start: annotation.startDataPath ? getAtPath(row, annotation.startDataPath) : undefined,
+    end: annotation.endDataPath ? getAtPath(row, annotation.endDataPath) : undefined
+  };
+}
+
+// src/visualization.model.builders.ts
+function buildMetricModel(base, config, rows, maps) {
+  const measure = maps.measures.get(config.measure);
+  const comparison = config.comparisonMeasure ? maps.measures.get(config.comparisonMeasure) : undefined;
+  const currentRow = rows.at(-1) ?? {};
+  const sparkline = config.sparkline ? createMeasureSeries(config.sparkline.measure ?? config.measure, maps.measures, rows, maps.dimensions.get(config.sparkline.dimension)) : null;
+  return {
+    ...base,
+    series: sparkline ? [sparkline] : [],
+    metric: {
+      label: measure?.label ?? config.measure,
+      value: readValue(currentRow, measure),
+      comparisonValue: comparison ? readValue(currentRow, comparison) : undefined,
+      format: measure?.format
+    }
+  };
+}
+function buildCartesianModel(base, config, rows, maps) {
+  const series = (config.series ?? defaultSeries(config.yMeasures ?? [])).map((seriesItem) => createMeasureSeries(seriesItem.measure, maps.measures, rows, maps.dimensions.get(config.xDimension), seriesItem)).filter((item) => Boolean(item));
+  return {
+    ...base,
+    series,
+    xAxis: createAxis(maps.dimensions.get(config.xDimension)),
+    yAxis: createValueAxis(config.yMeasures?.[0], maps.measures)
+  };
+}
+function buildDistributionModel(base, config, rows, maps) {
+  const nameDimension = maps.dimensions.get(config.nameDimension);
+  const valueMeasure = maps.measures.get(config.valueMeasure);
+  return {
+    ...base,
+    series: [
+      {
+        key: valueMeasure?.key ?? config.valueMeasure,
+        label: valueMeasure?.label ?? config.valueMeasure,
+        type: config.kind,
+        points: rows.map((row, index) => ({
+          id: `${config.kind}-${index}`,
+          raw: row,
+          name: stringValue(row, nameDimension),
+          value: numericValue(row, valueMeasure)
+        }))
+      }
+    ]
+  };
+}
+function buildHeatmapModel(base, config, rows, maps) {
+  const xDimension = maps.dimensions.get(config.xDimension);
+  const yDimension = maps.dimensions.get(config.yDimension);
+  const valueMeasure = maps.measures.get(config.valueMeasure);
+  return {
+    ...base,
+    series: [
+      {
+        key: config.valueMeasure,
+        label: valueMeasure?.label ?? config.valueMeasure,
+        type: "heatmap",
+        points: rows.map((row, index) => ({
+          id: `heatmap-${index}`,
+          raw: row,
+          name: stringValue(row, yDimension),
+          x: readDimensionValue(row, xDimension),
+          y: numericValue(row, valueMeasure),
+          value: numericValue(row, valueMeasure)
+        }))
+      }
+    ],
+    xAxis: createAxis(xDimension),
+    yAxis: createAxis(yDimension)
+  };
+}
+function buildGeoModel(base, config, rows, maps) {
+  return {
+    ...base,
+    series: [
+      {
+        key: "geo",
+        label: "Geo",
+        type: config.variant ?? "scatter",
+        points: rows.map((row, index) => ({
+          id: `geo-${index}`,
+          raw: row,
+          name: config.nameDimension ? stringValue(row, maps.dimensions.get(config.nameDimension)) : undefined,
+          value: config.valueMeasure ? numericValue(row, maps.measures.get(config.valueMeasure)) : undefined,
+          latitude: numericPathValue(row, maps.dimensions.get(config.latitudeDimension ?? "")),
+          longitude: numericPathValue(row, maps.dimensions.get(config.longitudeDimension ?? ""))
+        }))
+      }
+    ],
+    geo: {
+      mode: config.mode ?? "chart",
+      variant: config.variant ?? "scatter",
+      geoJson: config.geoJson
+    }
+  };
+}
+
+// src/visualization.model.ts
+function createVisualizationModel(spec, data) {
+  const rows = resolveVisualizationRows(data, spec.source.resultPath);
+  const maps = createVisualizationMaps(spec);
+  const base = createVisualizationBaseModel(spec, rows, maps);
+  switch (spec.visualization.kind) {
+    case "metric":
+      return buildMetricModel(base, spec.visualization, rows, maps);
+    case "cartesian":
+      return buildCartesianModel(base, spec.visualization, rows, maps);
+    case "pie":
+    case "funnel":
+      return buildDistributionModel(base, spec.visualization, rows, maps);
+    case "heatmap":
+      return buildHeatmapModel(base, spec.visualization, rows, maps);
+    case "geo":
+      return buildGeoModel(base, spec.visualization, rows, maps);
+  }
+}
+export {
+  formatVisualizationValue,
+  createVisualizationModel
+};

package/dist/visualization.model.builders.d.ts

@@ -0,0 +1,20 @@
+import type { VisualizationSpec } from '@contractspec/lib.contracts-spec/visualizations';
+import { type VisualizationModelMaps } from './visualization.model.helpers';
+import type { ContractVisualizationRenderModel } from './visualization.types';
+type VisualizationModelBase = Omit<ContractVisualizationRenderModel, 'series' | 'metric' | 'xAxis' | 'yAxis' | 'geo'>;
+export declare function buildMetricModel(base: VisualizationModelBase, config: Extract<VisualizationSpec['visualization'], {
+    kind: 'metric';
+}>, rows: Record<string, unknown>[], maps: VisualizationModelMaps): ContractVisualizationRenderModel;
+export declare function buildCartesianModel(base: VisualizationModelBase, config: Extract<VisualizationSpec['visualization'], {
+    kind: 'cartesian';
+}>, rows: Record<string, unknown>[], maps: VisualizationModelMaps): ContractVisualizationRenderModel;
+export declare function buildDistributionModel(base: VisualizationModelBase, config: Extract<VisualizationSpec['visualization'], {
+    kind: 'pie' | 'funnel';
+}>, rows: Record<string, unknown>[], maps: VisualizationModelMaps): ContractVisualizationRenderModel;
+export declare function buildHeatmapModel(base: VisualizationModelBase, config: Extract<VisualizationSpec['visualization'], {
+    kind: 'heatmap';
+}>, rows: Record<string, unknown>[], maps: VisualizationModelMaps): ContractVisualizationRenderModel;
+export declare function buildGeoModel(base: VisualizationModelBase, config: Extract<VisualizationSpec['visualization'], {
+    kind: 'geo';
+}>, rows: Record<string, unknown>[], maps: VisualizationModelMaps): ContractVisualizationRenderModel;
+export {};