ggaction 0.0.12 → 0.0.13

package/src/materialization/selection/items/bar.js

@@ -1,4 +1,5 @@
-import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
+import { deriveSeriesBarCells } from "../../../grammar/bars/aggregate.js";
+import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
 import {
   BAR_GRAINS,
   resolveBarChannels,
@@ -7,7 +8,6 @@ import {
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
 import { numericExtent } from "../../../grammar/numeric.js";
-import { layoutSeriesPartition } from "../../../grammar/seriesLayout.js";
 import {
   readNominalField,
   readTemporalField
@@ -24,7 +24,7 @@ import {
 
 function categoryValues(rows, encoding) {
   return encoding.fieldType === "temporal"
-    ? readTemporalField(rows, encoding.field)
+    ? readTemporalField(rows, encoding.field, encoding.temporalUnit)
     : readNominalField(rows, encoding.field);
 }
 
@@ -36,20 +36,17 @@ function aggregateMembers(rows, layer, cell, channels) {
   const colors = !["nominal", "ordinal"].includes(color?.fieldType)
     ? undefined
     : readNominalField(rows, color.field);
+  const identity = layer.encoding?.group === undefined ? undefined : readSeriesIdentity(rows, layer);
   return rows.filter((_, index) =>
     categories[index] === categoryValue &&
-    (colors === undefined || colors[index] === cell.color)
+    (identity === undefined ? colors === undefined || colors[index] === cell.color : identity.values[index] === cell.series)
   );
 }
 
 function aggregateCellDefinitions(program, layer, dataset) {
   const channels = resolveBarChannels(layer);
-  const derived = deriveBarAggregates(dataset.values, layer).values;
   const categoryEncoding = layer.encoding[channels.category];
   const categoryScale = program.resolvedScales[categoryEncoding.scale];
-  const measureScale = program.resolvedScales[
-    layer.encoding[channels.measure].scale
-  ];
   const colorEncoding = layer.encoding?.color;
   const colorScale = program.resolvedScales[colorEncoding?.scale];
   const offsetChannel = resolveBarOffsetChannel(layer);
@@ -67,70 +64,17 @@ function aggregateCellDefinitions(program, layer, dataset) {
         ...(cell.color === undefined ? {} : { color: cell.color }),
         ...(layer.encoding?.[offsetChannel] === undefined
           ? {}
-          : { [offsetChannel]: cell.color })
+          : { [offsetChannel]: cell.series ?? cell.color })
       },
       members
     };
   }
 
-  if (colorEncoding?.fieldType === "quantitative") {
-    const cells = new Map(derived.map(cell => [
-      cell[channels.category],
-      cell
-    ]));
-    const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
-      ? categoryScale.domain
-      : [...new Set(derived.map(cell => cell[channels.category]))]
-          .sort((left, right) => left - right);
-    return categories.flatMap(category => {
-      const cell = cells.get(category);
-      return cell === undefined
-        ? []
-        : [definition(cell, measureScale.domain[0], cell[channels.measure])];
-    });
-  }
-
-  if (layout === "group" && offsetScale !== undefined) {
-    const categoryIndex = new Map(
-      categoryScale.domain.map((value, index) => [value, index])
-    );
-    const offsetIndex = new Map(
-      offsetScale.domain.map((value, index) => [value, index])
-    );
-    const cells = [...derived].sort((left, right) =>
-      categoryIndex.get(left[channels.category]) -
-        categoryIndex.get(right[channels.category]) ||
-      offsetIndex.get(left.color) - offsetIndex.get(right.color)
-    );
-    return cells.map(cell => definition(
-      cell,
-      measureScale.domain[0],
-      cell[channels.measure]
-    ));
-  }
-
-  const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
-    ? categoryScale.domain
-    : [...new Set(derived.map(cell => cell[channels.category]))]
-        .sort((left, right) => left - right);
-  const series = colorScale?.domain ?? [undefined];
-  const lookup = new Map(derived.map(cell => [
-    JSON.stringify([cell[channels.category], cell.color]),
-    cell
-  ]));
-  const baseline = layout === "overlay" ? measureScale.domain[0] : 0;
-  return categories.flatMap(category => {
-    const cells = series.map(color =>
-      lookup.get(JSON.stringify([category, color]))
-    );
-    const values = cells.map(cell => cell?.[channels.measure] ?? 0);
-    return layoutSeriesPartition(values, layout, { baseline }).flatMap(segment => {
-      const cell = cells[segment.index];
-      return cell === undefined
-        ? []
-        : [definition(cell, segment.start, segment.end)];
-    });
-  });
+  const categories = categoryScale.type === "time" ? undefined : categoryScale.domain;
+  const series = layout === "group" ? offsetScale?.domain
+    : layer.encoding.group === undefined && colorEncoding?.fieldType !== "quantitative" ? colorScale?.domain : undefined;
+  return deriveSeriesBarCells(dataset.values, layer, categories, series)
+    .map(({ cell, start, end }) => definition(cell, start, end));
 }
 
 function histogramDefinitions(program, layer, dataset) {
@@ -145,7 +89,7 @@ function histogramDefinitions(program, layer, dataset) {
   });
   const colorScale = program.resolvedScales[colorEncoding?.scale];
   return segments.map(segment => {
-    const colorValue = colorScale?.domain[segment.category];
+    const colorValue = segment.colorValue ?? colorScale?.domain[segment.category];
     return {
       fields: uniqueFields(segment.members),
       channels: {

package/src/materialization/selection/items/common.js

@@ -1,3 +1,4 @@
+import { normalizeTemporalValue } from "../../../grammar/scales/fields.js";
 import { cloneAndFreeze, isPlainObject } from "../../../core/immutable.js";
 import {
   MARK_GRAPHIC_PROPERTIES,
@@ -16,8 +17,13 @@ function graphicId(layer, index) {
 
 function encodingValue(row, encoding) {
   if (encoding === undefined) return undefined;
-  if (Object.hasOwn(encoding, "field")) return row?.[encoding.field];
-  return encoding.datum;
+  const value = Object.hasOwn(encoding, "field") ? row?.[encoding.field] : encoding.datum;
+  if (encoding.fieldType !== "temporal") return value;
+  try {
+    return normalizeTemporalValue(value, encoding.field, 0, encoding.temporalUnit);
+  } catch {
+    return undefined;
+  }
 }
 
 export function channelMapFromRow(row, layer) {

package/src/materialization/selection/items/path.js

@@ -25,20 +25,10 @@ function rowsForSeries(rows, key) {
 
 function seriesDefinitions(layer, rows, series) {
   return series.map(item => {
-    const members = rowsForSeries(rows, item.key);
+    const members = item.sourceIndices === undefined ? rowsForSeries(rows, item.key)
+      : item.sourceIndices.map(index => rows[index]);
     const fields = { ...uniqueFields(members), ...item.key };
-    const channels = Object.fromEntries(
-      Object.entries(layer.encoding ?? {}).flatMap(([channel, encoding]) => {
-        if (encoding.field === undefined) {
-          return Object.hasOwn(encoding, "datum")
-            ? [[channel, encoding.datum]]
-            : [];
-        }
-        return Object.hasOwn(fields, encoding.field)
-          ? [[channel, fields[encoding.field]]]
-          : [];
-      })
-    );
+    const channels = channelMapFromRow(fields, layer);
     return { fields, channels, members };
   });
 }

package/src/materialization/selection/items/rect.js

@@ -1,10 +1,12 @@
+import { rectUsesFields } from "../../../grammar/rects.js";
 import { resolveRectRows } from "../../rect.js";
 import {
   channelMapFromRow,
   concreteProperties,
   finalizeItems,
   itemKey,
-  ownFields
+  ownFields,
+  uniqueFields
 } from "./common.js";
 
 function resolveGradientPlotItems(program, layer, dataset) {
@@ -33,12 +35,13 @@ export function resolveRectItems(program, layer, dataset) {
     return resolveGradientPlotItems(program, layer, dataset);
   }
   const rows = resolveRectRows(program, layer, dataset);
+  const hasField = rectUsesFields(layer);
   const definitions = rows.map((item, graphicIndex) => ({
     key: itemKey(layer, "rect", item.sourceIndex),
-    fields: ownFields(item.row),
-    channels: item.channels,
+    fields: hasField ? ownFields(item.row) : uniqueFields(dataset.values),
+    channels: channelMapFromRow(item.row, layer),
     properties: concreteProperties(graphic.items[graphicIndex]?.properties),
-    members: [item.row]
+    members: hasField ? [item.row] : dataset.values
   }));
   return finalizeItems(program, layer, "rect", definitions, "rect");
 }

package/src/materialization/text.js

@@ -1,5 +1,8 @@
 import { resolveBarChannels } from "../grammar/bars/policy.js";
+import { resolveMarkLabelValues } from "../grammar/markLabels.js";
 import { formatTextValue } from "../grammar/text.js";
+import { normalizePositionDatum } from "../grammar/positionDatum.js";
+import { mapOrdinalPositionValues } from "../grammar/scales/index.js";
 import { findDataset } from "../selectors/datasets.js";
 import { findLayer } from "../selectors/layers.js";
 import { resolveMarkItems } from "./selection/policies/index.js";
@@ -7,6 +10,14 @@ import { mapScaleConsumerValues } from "./scales/map.js";
 import { resolveRowEncodingValues } from "./rowEncoding.js";
 
 function sourceValue(item, source, field) {
+  const measure = source.mark.type === "bar" ? resolveBarChannels(source).measure
+    : source.mark.type === "arc" ? "radius" : undefined;
+  const encoding = source.encoding?.[measure];
+  if (encoding?.field === field && encoding.aggregate != null && item.channels[measure] !== undefined) {
+    return source.mark.type === "bar"
+      ? item.channels[`${measure}2`] ?? item.channels[measure]
+      : item.channels[measure];
+  }
   if (Object.hasOwn(item.fields, field)) return item.fields[field];
   for (const [channel, encoding] of Object.entries(source.encoding ?? {})) {
     if (encoding?.field !== field || item.channels[channel] === undefined) continue;
@@ -18,6 +29,10 @@ function sourceValue(item, source, field) {
   if (item.members.length === 1 && Object.hasOwn(item.members[0], field)) {
     return item.members[0][field];
   }
+  if (source.mark.type === "line" && item.members.length > 0) {
+    const endpoint = item.members.at(-1);
+    if (Object.hasOwn(endpoint, field)) return endpoint[field];
+  }
   return undefined;
 }
 
@@ -54,6 +69,17 @@ function sourceAnchor(program, source, item) {
       y: item.properties.y2
     };
   }
+  if (source.mark.type === "line") {
+    const graphicId = item.graphicIds?.[0];
+    const graphic = program.graphicSpec.objects[source.id]?.items?.find(
+      candidate => candidate.id === graphicId
+    );
+    const commands = graphic?.properties?.commands;
+    const endpoint = Array.isArray(commands)
+      ? [...commands].reverse().find(command => Number.isFinite(command.x) && Number.isFinite(command.y))
+      : undefined;
+    return { x: endpoint?.x, y: endpoint?.y };
+  }
   return { x: item.properties.x, y: item.properties.y };
 }
 
@@ -122,12 +148,14 @@ function resolveSourceTextItems(program, layer, config) {
     throw new Error(`Text mark "${layer.id}" requires source layer "${layer.source}".`);
   }
   const items = resolveMarkItems(program, source.id);
-  return items.flatMap(item => {
+  const values = layer.encoding.text.content === undefined ? undefined
+    : resolveMarkLabelValues(source, items, layer.encoding.text);
+  return items.flatMap((item, index) => {
     const anchor = sourceAnchor(program, source, item);
     const concrete = concreteItem(
       sourceTextConfig(config, source, item),
       anchor,
-      contentValue(layer.encoding.text, item, source),
+      values === undefined ? contentValue(layer.encoding.text, item, source) : values[index],
       layer.encoding.text.format
     );
     return concrete === undefined ? [] : [{ graphic: concrete, anchor }];
@@ -139,10 +167,41 @@ function resolveRowTextItems(program, layer, config) {
   if (dataset === undefined) {
     throw new Error(`Text mark "${layer.id}" requires an existing dataset.`);
   }
-  const x = resolveRowEncodingValues(program, layer, dataset, "x");
-  const y = resolveRowEncodingValues(program, layer, dataset, "y");
+  const encodings = [layer.encoding?.x, layer.encoding?.y, layer.encoding?.text];
+  const length = encodings.some(encoding => encoding !== undefined && Object.hasOwn(encoding, "field"))
+    ? dataset.values.length
+    : 1;
+  const positionValues = channel => {
+    const encoding = layer.encoding?.[channel];
+    if (encoding === undefined) return undefined;
+    if (Object.hasOwn(encoding, "field")) {
+      return resolveRowEncodingValues(program, layer, dataset, channel);
+    }
+    const scale = program.resolvedScales[encoding.scale];
+    if (scale === undefined) {
+      throw new Error(
+        `text mark "${layer.id}" requires resolved ${channel} scale "${encoding.scale}".`
+      );
+    }
+    const datum = normalizePositionDatum(
+      encoding.datum,
+      encoding.fieldType,
+      channel,
+      encoding.temporalUnit,
+      "Text"
+    );
+    const mapped = ["nominal", "ordinal"].includes(encoding.fieldType)
+      ? mapOrdinalPositionValues([datum], scale)
+      : mapScaleConsumerValues([datum], scale, channel);
+    return Array.from({ length }, () => mapped[0]);
+  };
+  const x = positionValues("x");
+  const y = positionValues("y");
   if (x === undefined || y === undefined) return [];
-  return dataset.values.flatMap((row, index) => {
+  const rows = length === 1 && dataset.values.length === 0
+    ? [undefined]
+    : dataset.values.slice(0, length);
+  return rows.flatMap((row, index) => {
     const concrete = concreteItem(
       config,
       { x: x[index], y: y[index] },

package/src/mcp/adapter.js

@@ -203,8 +203,8 @@ export function readKnowledgeResource(uri, { allowedDocs = [] } = {}) {
   throw new KnowledgeResourceError(`Unknown knowledge resource URI: ${uri}`);
 }
 
-if (cardsArtifact.schemaVersion !== 2 || resourcesArtifact.schemaVersion !== 2) {
-  throw new Error("MCP action cards and resources must use schemaVersion 2.");
+if (cardsArtifact.schemaVersion !== 3 || resourcesArtifact.schemaVersion !== 2) {
+  throw new Error("MCP action cards must use schemaVersion 3 and resources must use schemaVersion 2.");
 }
 if (resourcesArtifact.packageVersion !== cardsArtifact.packageVersion) {
   throw new Error("MCP action cards and resources must use one packageVersion.");

package/src/selectors/datasets.js

@@ -15,3 +15,16 @@ export function requireDataset(program, id, label = `Dataset "${id}"`) {
   if (dataset === undefined) throw new Error(`${label} does not exist.`);
   return dataset;
 }
+
+export function requireMaterializedDataset(program, id) {
+  const dataset = findDataset(program, id);
+  if (dataset === undefined) throw new Error(`Unknown dataset "${id}".`);
+  if (!Array.isArray(dataset.values)) {
+    throw new Error(
+      `Dataset "${id}" requires materialized values. ` +
+      "createDerivedData stores a definition only; use the corresponding " +
+      "value-producing data action before creating a chart or mark."
+    );
+  }
+  return dataset;
+}

package/src/selectors/layers.js

@@ -16,17 +16,18 @@ export function resolveEligibleLayer(program, {
   target,
   predicate,
   label,
+  targetOption = "target",
   current = program.context.currentMark
 }) {
   const candidates = program.semanticSpec.layers.filter(predicate);
   if (target !== undefined) {
     const selected = candidates.find(layer => layer.id === target);
-    if (selected === undefined) throw new Error(`Unknown ${label} target "${target}".`);
+    if (selected === undefined) throw new Error(`Unknown ${label} ${targetOption} "${target}".`);
     return selected;
   }
   const selected = candidates.find(layer => layer.id === current);
   if (selected !== undefined) return selected;
   if (candidates.length === 1) return candidates[0];
   if (candidates.length === 0) throw new Error(`${label} requires an eligible layer.`);
-  throw new Error(`${label} target is ambiguous; provide target.`);
+  throw new Error(`${label} ${targetOption} is ambiguous; provide ${targetOption}.`);
 }

package/src/selectors/scales.js

@@ -19,3 +19,9 @@ export function requireResolvedScale(program, id, type) {
   }
   return scale;
 }
+
+export function hasSemanticScaleReferences(spec, id) {
+  const referenced = value => value !== null && typeof value === "object" && Object.entries(value).some(([key, child]) =>
+    (key === "scale" && child === id) || (key === "scales" && Array.isArray(child) && child.includes(id)) || referenced(child));
+  return referenced(spec.layers) || referenced(spec.guides);
+}

package/src/theme/defaults.js

@@ -13,5 +13,44 @@ export const DEFAULT_COLORS = Object.freeze({
   border: "#cbd5e1",
   sizeSymbol: "#94a3b8",
   regressionBand: "#111111",
+  boxLine: "#111111",
+  boxMedian: "#1f2937",
+  referenceLine: "#64748b",
+  referenceBand: "#94a3b8",
+  gradientCenter: "#0f172a",
   highlight: "#dc2626"
 });
+
+export const THEME_NAMES = Object.freeze(["light", "dark"]);
+
+export const THEME_TOKENS = Object.freeze({
+  light: Object.freeze({
+    background: "white",
+    ...DEFAULT_COLORS,
+    fontFamily: DEFAULT_FONT_FAMILY
+  }),
+  dark: Object.freeze({
+    background: "#0f172a",
+    mark: "#60a5fa",
+    text: "#e2e8f0",
+    strongText: "#f8fafc",
+    mutedText: "#94a3b8",
+    axis: "#cbd5e1",
+    axisTitle: "#f1f5f9",
+    grid: "#334155",
+    border: "#475569",
+    sizeSymbol: "#94a3b8",
+    regressionBand: "#f8fafc",
+    boxLine: "#f8fafc",
+    boxMedian: "#f8fafc",
+    referenceLine: "#94a3b8",
+    referenceBand: "#94a3b8",
+    gradientCenter: "#f8fafc",
+    highlight: DEFAULT_COLORS.highlight,
+    fontFamily: DEFAULT_FONT_FAMILY
+  })
+});
+
+export function themeTokens(name = "light") {
+  return THEME_TOKENS[name];
+}

package/types/basic.d.ts

@@ -1,4 +1,4 @@
-import type { ChartProgram } from "./program.js";
+import type { ChartProgram, BasicSeriesLayoutOptions } from "./program.js";
 
 export type {
   AxisLabelOptions,
@@ -6,7 +6,9 @@ export type {
   AxisTickOptions,
   AxisTicksAndLabelsOptions,
   AxisTitleOptions,
+  ApplyThemeOptions,
   BarWidthOptions,
+  BasicSeriesLayoutOptions,
   Bin2DDataOptions,
   CanvasOptions,
   ColorEncodingOptions,
@@ -21,6 +23,7 @@ export type {
   CreateScatterPlotOptions,
   CreateScaleOptions,
   GraphicSpec,
+  GroupEncodingOptions,
   GridDirectionOptions,
   HistogramEncodingOptions,
   LegendOptions,
@@ -30,6 +33,8 @@ export type {
   SecondaryPositionEncodingOptions,
   SemanticSpec,
   StrokeDashEncodingOptions,
+  TemporalInputUnit,
+  ThemeName,
   TraceNode,
   XAxisPosition,
   XOffsetEncodingOptions,
@@ -47,6 +52,8 @@ type BasicStateKey =
 
 type BasicMethodKey =
   | "createCanvas"
+  | "applyTheme"
+  | "removeTheme"
   | "createData"
   | "createPointMark"
   | "createLineMark"
@@ -57,6 +64,7 @@ type BasicMethodKey =
   | "encodeX2"
   | "encodeY2"
   | "encodeGroup"
+  | "encodePointRadius"
   | "encodeColor"
   | "encodeStrokeDash"
   | "encodeSize"
@@ -97,7 +105,8 @@ type RebindMethod<T> = T extends (...args: infer Args) => ChartProgram
 
 export type BasicChartProgram =
   Pick<ChartProgram, BasicStateKey> &
-  { readonly [Key in BasicMethodKey]: RebindMethod<ChartProgram[Key]> };
+  { readonly [Key in BasicMethodKey]: RebindMethod<ChartProgram[Key]> } &
+  { readonly layoutSeries: (options: BasicSeriesLayoutOptions) => BasicChartProgram };
 
 export function chart(): BasicChartProgram;
 export function render(