ggaction 0.0.13 → 0.0.16

package/src/core/programState.js

@@ -4,6 +4,7 @@ import {
   isOwned,
   isPlainObject
 } from "./immutable.js";
+import { removeMaterializationConfig } from "./materializationState.js";
 
 export function ownProgramState(value) {
   return isOwned(value) ? value : cloneAndFreeze(value);
@@ -22,7 +23,26 @@ export function ownChildPrograms(children, ProgramClass) {
     if (!(program instanceof ProgramClass)) {
       throw new TypeError(`ChartProgram child "${id}" must be a ChartProgram.`);
     }
-    owned[id] = program;
+    Object.defineProperty(owned, id, { value: program, enumerable: true });
   }
   return freezeOwned(owned);
 }
+
+// Semantic entries, resolved scale caches, and physical current-resource IDs
+// are removed by editSemantic. A logical data owner also retains its own ID
+// and replay configuration; release those non-semantic references after the
+// domain's dependency validation and before the primitive deletion.
+export function releaseNamedResourceOwnership(program, { kind, id, dataOwner }) {
+  if (kind !== "data") return program;
+  const materializationConfigs = dataOwner === undefined
+    ? program.materializationConfigs
+    : removeMaterializationConfig(
+        program.materializationConfigs,
+        ["data", dataOwner.family, dataOwner.owner]
+      ).value;
+  const context = program.context.currentData === id
+    ? freezeOwned({ ...program.context, currentData: undefined })
+    : program.context;
+  if (context === program.context && materializationConfigs === program.materializationConfigs) return program;
+  return program._clone({ context, materializationConfigs });
+}

package/src/core/resourceReferences.js

@@ -0,0 +1,341 @@
+import { freezeOwned, isPlainObject } from "./immutable.js";
+import { validateUserId } from "./identifiers.js";
+
+export const RESOURCE_KINDS = Object.freeze([
+  "data", "scale", "coordinate", "mark", "selection"
+]);
+
+const DATA_VALUE_KEYS = new Set([
+  "data", "dataset", "dataId", "filteredData", "originalData",
+  "outlierDataId", "profileId", "summaryId"
+]);
+const DATA_SOURCE_CONFIGS = new Set([
+  "boxPlot", "density", "ecdfPlot", "endpointPlot", "errorBand", "errorBar",
+  "gradientPlot", "horizon", "intervalPlot", "markFilter", "raincloudPlot",
+  "regression", "violinPlot"
+]);
+const MARK_ID_KEYS = new Set([
+  "bandId", "bodyId", "centerId", "connectorId", "intervalId", "lineId",
+  "lowerBoundaryId", "lowerCapId", "medianId", "outlierId", "startId",
+  "stemId", "upperBoundaryId", "upperCapId", "whiskerId"
+]);
+
+function ownedPath(path) {
+  return freezeOwned([...path]);
+}
+
+function reference(kind, id, ownerKind, ownerId, path, strength = "live") {
+  if (typeof id !== "string" || id.length === 0) return undefined;
+  return freezeOwned({
+    kind,
+    id,
+    ownerKind,
+    ownerId,
+    path: ownedPath(path),
+    strength
+  });
+}
+
+function append(references, value) {
+  if (value !== undefined) references.push(value);
+}
+
+function collectKnownKeys(value, path, visit) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectKnownKeys(item, [...path, index], visit));
+    return;
+  }
+  if (!isPlainObject(value)) return;
+  for (const [key, child] of Object.entries(value)) {
+    visit(key, child, [...path, key], path);
+    collectKnownKeys(child, [...path, key], visit);
+  }
+}
+
+export function canonicalResourcePath(path) {
+  if (!Array.isArray(path)) {
+    throw new TypeError("Resource reference path must be an array.");
+  }
+  return path.map(part => {
+    if (Number.isInteger(part) && part >= 0) return `[${part}]`;
+    if (typeof part !== "string" || part.length === 0) {
+      throw new TypeError("Resource reference path parts must be names or indexes.");
+    }
+    return `.${part}`;
+  }).join("");
+}
+
+export function collectSemanticDataReferences(program) {
+  const references = [];
+  for (const layer of program.semanticSpec.layers) {
+    append(references, reference("data", layer.data, "layer", layer.id, ["data"]));
+  }
+  for (const dataset of program.semanticSpec.datasets) {
+    append(references, reference(
+      "data", dataset.source, "dataset", dataset.id, ["source"]
+    ));
+  }
+  return freezeOwned(references);
+}
+
+export function collectSemanticScaleReferences(program) {
+  const references = [];
+  for (const layer of program.semanticSpec.layers) {
+    for (const [channel, encoding] of Object.entries(layer.encoding ?? {})) {
+      append(references, reference(
+        "scale", encoding?.scale, "layer", layer.id,
+        ["encoding", channel, "scale"]
+      ));
+      if (channel === "parallel") {
+        for (const [index, dimension] of (encoding?.dimensions ?? []).entries()) {
+          append(references, reference(
+            "scale", dimension.scale, "layer", layer.id,
+            ["encoding", "parallel", "dimensions", index, "scale"]
+          ));
+        }
+      }
+    }
+  }
+  collectKnownKeys(program.semanticSpec.guides, [], (key, value, path) => {
+    if (key === "scale") {
+      append(references, reference(
+        "scale", value, "semanticGuide", "guides", path
+      ));
+    } else if (key === "scales" && Array.isArray(value)) {
+      value.forEach((id, index) => append(references, reference(
+        "scale", id, "semanticGuide", "guides", [...path, index]
+      )));
+    }
+  });
+  return freezeOwned(references);
+}
+
+export function collectSemanticCoordinateReferences(program) {
+  const references = [];
+  for (const layer of program.semanticSpec.layers) {
+    append(references, reference(
+      "coordinate", layer.coordinate, "layer", layer.id, ["coordinate"]
+    ));
+  }
+  collectKnownKeys(program.semanticSpec.guides, [], (key, value, path) => {
+    if (key === "coordinate") {
+      append(references, reference(
+        "coordinate", value, "semanticGuide", "guides", path
+      ));
+    }
+  });
+  return freezeOwned(references);
+}
+
+export function collectMarkConfigReferences(program) {
+  const references = [];
+  for (const layer of program.semanticSpec.layers) {
+    append(references, reference(
+      "mark", layer.source, "layer", layer.id, ["source"]
+    ));
+  }
+  for (const [ownerId, config] of Object.entries(program.markConfigs)) {
+    collectKnownKeys(config, [], (key, value, path, parentPath) => {
+      if (DATA_VALUE_KEYS.has(key)) {
+        append(references, reference("data", value, "markConfig", ownerId, path));
+      }
+      const root = parentPath[0];
+      if (key === "source" && DATA_SOURCE_CONFIGS.has(root)) {
+        append(references, reference("data", value, "markConfig", ownerId, path));
+      }
+      if (key === "coordinate") {
+        append(references, reference(
+          "coordinate", value, "markConfig", ownerId, path
+        ));
+      }
+      const reservedScale = root === "regression" && key === "colorScale" && config.regression.groupBy === undefined;
+      if (!reservedScale && (key === "scale" || key.endsWith("Scale")) && typeof value === "string") {
+        append(references, reference("scale", value, "markConfig", ownerId, path));
+      } else if (key === "scale" && isPlainObject(value)) {
+        append(references, reference(
+          "scale", value.id, "markConfig", ownerId, [...path, "id"]
+        ));
+      }
+      const inactiveMark = (root === "boxPlot" && key === "outlierId" && !Object.hasOwn(program.markConfigs, value)) ||
+        (root === "errorBar" && ["lowerCapId", "upperCapId"].includes(key) && config.errorBar.caps === false) ||
+        (root === "errorBand" && ["lowerBoundaryId", "upperBoundaryId"].includes(key) &&
+          !Object.hasOwn(program.markConfigs, value));
+      if (MARK_ID_KEYS.has(key) && !inactiveMark) {
+        append(references, reference("mark", value, "markConfig", ownerId, path));
+      }
+      if (
+        (root === "errorBandBoundary" && key === "owner") ||
+        (parentPath.length === 0 && key === "boxSpanOwner") ||
+        (root === "raincloudPlot" && (
+          key === "ownerId" || parentPath[1] === "childIds" ||
+          parentPath[1] === "ownedChildIds"
+        ))
+      ) {
+        append(references, reference("mark", value, "markConfig", ownerId, path));
+      }
+    });
+    append(references, reference(
+      "mark", config.statisticalReference?.source,
+      "markConfig", ownerId, ["statisticalReference", "source"]
+    ));
+    for (const [index, id] of (
+      config.raincloudPlot?.ownedChildIds ?? []
+    ).entries()) {
+      append(references, reference(
+        "mark", id, "markConfig", ownerId,
+        ["raincloudPlot", "ownedChildIds", index]
+      ));
+    }
+    const selection = config.labelAuthoring?.selection;
+    if (selection?.kind === "named") {
+      append(references, reference(
+        "selection", selection.id, "markConfig", ownerId,
+        ["labelAuthoring", "selection", "id"]
+      ));
+    }
+  }
+  return freezeOwned(references);
+}
+
+export function collectGuideConfigReferences(program) {
+  const references = [];
+  for (const [family, configs] of Object.entries(program.guideConfigs ?? {})) {
+    collectKnownKeys(configs, [], (key, value, path, parentPath) => {
+      const ownerId = parentPath.length === 0 ? family : parentPath.join(".");
+      const relativePath = parentPath.length === 0
+        ? path
+        : path.slice(parentPath.length);
+      if (key === "scale") {
+        append(references, reference(
+          "scale", value, family, ownerId, relativePath
+        ));
+      } else if (key === "scales" && Array.isArray(value)) {
+        value.forEach((id, index) => append(references, reference(
+          "scale", id, family, ownerId, [...relativePath, index]
+        )));
+      } else if (key === "coordinate") {
+        append(references, reference(
+          "coordinate", value, family, ownerId, relativePath
+        ));
+      } else if (key === "target") {
+        append(references, reference(
+          "mark", value, family, ownerId, relativePath
+        ));
+      }
+    });
+  }
+  return freezeOwned(references);
+}
+
+export function collectSelectionReferences(program) {
+  const references = [];
+  for (const [id, config] of Object.entries(
+    program.materializationConfigs.selections ?? {}
+  )) {
+    append(references, reference(
+      "mark", config.target, "selection", id, ["target"]
+    ));
+  }
+  for (const [id, config] of Object.entries(
+    program.materializationConfigs.highlights ?? {}
+  )) {
+    append(references, reference(
+      "mark", config.target, "highlight", id, ["target"]
+    ));
+    append(references, reference(
+      "selection", config.selection, "highlight", id, ["selection"]
+    ));
+  }
+  return freezeOwned(references);
+}
+
+export function collectDataOwnerReferences(program) {
+  const references = [];
+  for (const [family, owners] of Object.entries(
+    program.materializationConfigs.data ?? {}
+  )) {
+    for (const [owner, config] of Object.entries(owners ?? {})) {
+      for (const key of ["current", "source", "previous"]) {
+        append(references, reference(
+          "data", config?.[key], "dataOwner", owner,
+          ["data", family, owner, key]
+        ));
+      }
+    }
+  }
+  return freezeOwned(references);
+}
+
+export function collectCompositionReferences(program) {
+  const references = [];
+  const composition = program.compositionSpec;
+  if (composition?.type !== "facet") return freezeOwned(references);
+  append(references, reference(
+    "data", composition.facet.data, "composition", composition.id,
+    ["facet", "data"]
+  ));
+  append(references, reference(
+    "mark", composition.facet.repeat?.target, "composition", composition.id,
+    ["facet", "repeat", "target"]
+  ));
+  return freezeOwned(references);
+}
+
+export function collectContextReferences(program) {
+  const references = [];
+  for (const [key, kind] of Object.entries({
+    currentData: "data",
+    currentScale: "scale",
+    currentCoordinate: "coordinate",
+    currentMark: "mark",
+    currentSelection: "selection"
+  })) {
+    append(references, reference(
+      kind, program.context[key], "context", "program", [key], "context"
+    ));
+  }
+  return freezeOwned(references);
+}
+
+function referenceKey(value) {
+  return [
+    value.kind, value.id, value.ownerKind, value.ownerId,
+    canonicalResourcePath(value.path), value.strength
+  ].join("\u0000");
+}
+
+function compareReferences(left, right) {
+  const leftKey = [
+    left.ownerKind, left.ownerId, canonicalResourcePath(left.path),
+    left.kind, left.id, left.strength
+  ].join("\u0000");
+  const rightKey = [
+    right.ownerKind, right.ownerId, canonicalResourcePath(right.path),
+    right.kind, right.id, right.strength
+  ].join("\u0000");
+  return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+}
+
+export function collectResourceReferences(program, { kind, id }) {
+  if (!RESOURCE_KINDS.includes(kind)) {
+    throw new Error(`Unknown resource kind "${kind}".`);
+  }
+  const target = validateUserId(id, "Resource id");
+  const combined = collectAllResourceReferences(program).filter(value => value.kind === kind && value.id === target);
+  const unique = new Map(combined.map(value => [referenceKey(value), value]));
+  return freezeOwned([...unique.values()].sort(compareReferences));
+}
+
+export function collectAllResourceReferences(program) {
+  return [
+    ...collectSemanticDataReferences(program),
+    ...collectSemanticScaleReferences(program),
+    ...collectSemanticCoordinateReferences(program),
+    ...collectMarkConfigReferences(program),
+    ...collectGuideConfigReferences(program),
+    ...collectSelectionReferences(program),
+    ...collectDataOwnerReferences(program),
+    ...collectCompositionReferences(program),
+    ...collectContextReferences(program)
+  ];
+}

package/src/core/textMetricProfile.js

@@ -0,0 +1,28 @@
+import { cloneAndFreeze } from "./immutable.js";
+import { validateUserId } from "./identifiers.js";
+import { validateOptionObject, validatePositiveFinite, validateNonNegativeFinite, validateNonEmptyString } from "./validation.js";
+
+import { textMetricKey } from "./font.js";
+
+export function normalizeTextMetricProfile(profile) {
+  validateOptionObject(profile, ["schemaVersion", "id", "measurements"], "Text metrics profile");
+  if (profile.schemaVersion !== 1) throw new Error("Text metrics require schemaVersion 1.");
+  validateUserId(profile.id, "Text metrics profile id");
+  if (!Array.isArray(profile.measurements)) throw new TypeError("Text metrics measurements must be an array.");
+  const seen = new Set();
+  for (const measurement of profile.measurements) {
+    validateOptionObject(measurement, ["text", "fontFamily", "fontSize", "fontWeight", "width"], "Text measurement");
+    if (typeof measurement.text !== "string") throw new TypeError("Text measurement text must be a string.");
+    validateNonEmptyString(measurement.fontFamily, "Text measurement fontFamily");
+    validatePositiveFinite(measurement.fontSize, "Text measurement fontSize");
+    validateNonNegativeFinite(measurement.width, "Text measurement width");
+    if (!Number.isInteger(measurement.fontWeight) || measurement.fontWeight < 100 ||
+        measurement.fontWeight > 900 || measurement.fontWeight % 100 !== 0) {
+      throw new RangeError("Text measurement fontWeight must be 100–900 in steps of 100.");
+    }
+    const key = textMetricKey(measurement);
+    if (seen.has(key)) throw new Error("Duplicate text measurement combination.");
+    seen.add(key);
+  }
+  return cloneAndFreeze(profile);
+}

package/src/core/textMetrics.js

@@ -1,3 +1,21 @@
+import { DEFAULT_FONT_FAMILY, textMetricFontWeight, textMetricKey } from "./font.js";
+
+import { isOwned } from "./immutable.js";
+
+const measurementIndexes = new WeakMap();
+
+function measuredWidth(profile, text, style) {
+  if (profile === undefined) return undefined;
+  let index = measurementIndexes.get(profile);
+  if (index === undefined) {
+    index = new Map(profile.measurements.map(measurement =>
+      [textMetricKey(measurement), measurement.width]));
+    if (isOwned(profile)) measurementIndexes.set(profile, index);
+  }
+  return index.get(textMetricKey({ text, fontFamily: style.fontFamily ?? DEFAULT_FONT_FAMILY,
+    fontSize: style.fontSize, fontWeight: textMetricFontWeight(style.fontWeight) }));
+}
+
 function codePointWidth(codePoint) {
   if (/\s/u.test(codePoint)) return 0.28;
   if (/[iIl.,:;!'|]/u.test(codePoint)) return 0.27;
@@ -25,7 +43,8 @@ export function textBoundsFitCanvas(bounds, canvas) {
 
 export function measureTextWidth(
   text,
-  { fontSize, fontFamily, fontWeight } = {}
+  { fontSize, fontFamily, fontWeight } = {},
+  profile
 ) {
   if (typeof text !== "string") {
     throw new TypeError("Text measurement requires a string.");
@@ -33,6 +52,8 @@ export function measureTextWidth(
   if (!Number.isFinite(fontSize) || fontSize <= 0) {
     throw new RangeError("Text measurement requires a positive fontSize.");
   }
+  const measured = measuredWidth(profile, text, { fontSize, fontFamily, fontWeight });
+  if (measured !== undefined) return measured;
   let joined = false;
   let width = 0;
   for (const codePoint of text) {
@@ -76,11 +97,11 @@ export function resolveTextBounds({
   textAlign = "left",
   textBaseline = "alphabetic",
   rotation = 0
-} = {}) {
+} = {}, profile) {
   if (![x, y, rotation].every(Number.isFinite)) {
     throw new TypeError("Text bounds require finite x, y, and rotation values.");
   }
-  const width = measureTextWidth(text, { fontSize, fontFamily, fontWeight });
+  const width = measureTextWidth(text, { fontSize, fontFamily, fontWeight }, profile);
   const [left, right] = textAlign === "center"
     ? [-width / 2, width / 2]
     : ["right", "end"].includes(textAlign) ? [-width, 0] : [0, width];

package/src/core/validation.js

@@ -1,15 +1,27 @@
+import { annotateError } from "./diagnostics.js";
 import { isPlainObject } from "./immutable.js";
 
 export const MAX_GENERATED_ITEMS = 10_000;
 export const MAX_WORK_ITEMS = 10_000_000;
 
+export function validateDataRows(values, label = "Dataset") {
+  if (!Array.isArray(values)) {
+    throw annotateError(new TypeError(`${label} requires values to be an array.`), { code: "invalid-value", optionPath: "values" });
+  }
+  for (let index = 0; index < values.length; index += 1) {
+    if (!Object.hasOwn(values, index) || !isPlainObject(values[index])) {
+      throw annotateError(new TypeError(`${label} requires every row to be a plain object; invalid row at index ${index}.`), { code: "invalid-value", optionPath: `values[${index}]` });
+    }
+  }
+}
+
 export function validateGeneratedItemLimit(
   value,
   label,
   maximum = MAX_GENERATED_ITEMS
 ) {
   if (value > maximum) {
-    throw new RangeError(`${label} must not exceed ${maximum}.`);
+    throw annotateError(new RangeError(`${label} must not exceed ${maximum}.`), { code: "resource-limit", optionPath: label, limit: maximum, actual: value });
   }
   return value;
 }
@@ -21,7 +33,7 @@ export function validateWorkLimit(value, label) {
 export function validateKeys(value, supported, label) {
   for (const key of Object.keys(value)) {
     if (!supported.includes(key)) {
-      throw new Error(`Unknown ${label} option "${key}".`);
+      throw annotateError(new Error(`Unknown ${label} option "${key}".`), { code: "invalid-option", optionPath: key });
     }
   }
 }
@@ -33,18 +45,18 @@ export function validateOptionObject(value, supported, label, {
   emptyError = TypeError
 } = {}) {
   if (!isPlainObject(value)) {
-    throw new TypeError(plainObjectMessage);
+    throw annotateError(new TypeError(plainObjectMessage), { code: "invalid-option" });
   }
   if (supported !== undefined) validateKeys(value, supported, label);
   if (!allowEmpty && Object.keys(value).length === 0) {
-    throw new emptyError(emptyMessage);
+    throw annotateError(new emptyError(emptyMessage), { code: "invalid-option" });
   }
   return value;
 }
 
 export function noOptions(args, operation) {
   if (!isPlainObject(args) || Object.keys(args).length > 0) {
-    throw new Error(`${operation} does not accept options.`);
+    throw annotateError(new Error(`${operation} does not accept options.`), { code: "invalid-option", operation });
   }
 }
 
@@ -59,30 +71,30 @@ export function sameOrderedValues(left, right) {
 
 export function validateNonEmptyString(value, label) {
   if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
+    throw annotateError(new TypeError(`${label} must be a non-empty string.`), { code: "invalid-value", optionPath: label });
   }
   return value;
 }
 
 export function validateUnitInterval(value, label) {
   if (!Number.isFinite(value) || value < 0 || value > 1) {
-    throw new RangeError(
+    throw annotateError(new RangeError(
       `${label} must be between 0 and 1 (values from 0 to 1).`
-    );
+    ), { code: "invalid-value", optionPath: label });
   }
   return value;
 }
 
 export function validatePositiveFinite(value, label) {
   if (!Number.isFinite(value) || value <= 0) {
-    throw new RangeError(`${label} must be a positive finite number.`);
+    throw annotateError(new RangeError(`${label} must be a positive finite number.`), { code: "invalid-value", optionPath: label });
   }
   return value;
 }
 
 export function validateNonNegativeFinite(value, label) {
   if (!Number.isFinite(value) || value < 0) {
-    throw new RangeError(`${label} must be a non-negative finite number.`);
+    throw annotateError(new RangeError(`${label} must be a non-negative finite number.`), { code: "invalid-value", optionPath: label });
   }
   return value;
 }

package/src/core/vocabulary.js

@@ -13,13 +13,13 @@ export const MARK_TYPES = Object.freeze([
 export const MARK_GRAPHIC_TYPES = Object.freeze({
   point: Object.freeze(["circle", "rect", "path", "collection"]),
   line: Object.freeze(["path"]),
-  bar: Object.freeze(["rect"]),
+  bar: Object.freeze(["rect", "collection"]),
   area: Object.freeze(["path"]),
   arc: Object.freeze(["path"]),
   rule: Object.freeze(["line"]),
   tick: Object.freeze(["line"]),
   text: Object.freeze(["text"]),
-  rect: Object.freeze(["rect"])
+  rect: Object.freeze(["rect", "collection"])
 });
 
 export const ENCODING_CHANNELS = Object.freeze([
@@ -32,6 +32,7 @@ export const ENCODING_CHANNELS = Object.freeze([
   "theta",
   "radius",
   "color",
+  "stroke",
   "strokeDash",
   "strokeWidth",
   "size",
@@ -155,13 +156,21 @@ export const FACET_SCALE_CHANNELS = Object.freeze([
   "y",
   "xOffset",
   "yOffset",
+  "theta",
+  "r",
   "color",
+  "stroke",
   "size",
   "shape",
   "opacity",
-  "strokeDash"
+  "strokeDash",
+  "parallelDimensions"
 ]);
 
+export function facetSemanticChannel(channel) {
+  return channel === "r" ? "radius" : channel;
+}
+
 export const FACET_SCALE_RESOLUTIONS = Object.freeze([
   "shared",
   "independent"
@@ -198,6 +207,7 @@ export const STACK_MODES = Object.freeze(["zero", "normalize", "center"]);
 
 export const CATEGORICAL_LEGEND_CHANNELS = Object.freeze([
   "color",
+  "stroke",
   "strokeDash",
   "shape"
 ]);
@@ -212,9 +222,12 @@ export const LEGEND_CHANNELS = Object.freeze([
 export const LEGEND_CONFIG_KINDS = Object.freeze([
   "series",
   "color",
+  "stroke",
   "size",
   "gradient",
   "interval",
+  "strokeGradient",
+  "strokeInterval",
   "opacity",
   "strokeWidth"
 ]);

package/src/diagnostics.js

@@ -0,0 +1 @@
+export { getErrorDetails } from "./core/diagnostics.js";

package/src/grammar/bars/aggregate.js

@@ -58,12 +58,14 @@ export function deriveBarAggregates(rows, layer) {
       category: categoryValue,
       ...(identity === undefined ? {} : { series: seriesValue }),
       ...(colorValues === undefined ? {} : { color: colorValue }),
-      rows: []
+      rows: [],
+      sourceIndices: []
     };
     if (identity !== undefined && colorValues !== undefined && group.color !== colorValue) {
       throw new Error("Bar color requires one categorical value within each aggregate cell.");
     }
     group.rows.push(rows[index]);
+    group.sourceIndices.push(index);
     groups.set(key, group);
   }
 
@@ -83,6 +85,7 @@ export function deriveBarAggregates(rows, layer) {
       y: channels.category === "y" ? group.category : value,
       ...(color === undefined ? {} : { color: aggregateColor }),
       ...(identity === undefined ? {} : { series: group.series }),
+      sourceIndices: group.sourceIndices,
       count: group.rows.length
     }];
   });