ggaction 0.0.12 → 0.0.15

package/src/grammar/markLabelSelection.js

@@ -0,0 +1,57 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { validateUserId } from "../core/identifiers.js";
+import { normalizeMarkSelector } from "./markSelection.js";
+
+function hasOwn(value, key) {
+  return Object.hasOwn(value, key);
+}
+
+function normalizeNamedSelection(id) {
+  return cloneAndFreeze({
+    kind: "named",
+    id: validateUserId(id, "Label selection id")
+  });
+}
+
+function normalizeInlineSelection(selector) {
+  return cloneAndFreeze({
+    kind: "inline",
+    selector: normalizeMarkSelector(selector)
+  });
+}
+
+export function normalizeLabelSelectionCreate(options) {
+  if (!isPlainObject(options)) {
+    throw new TypeError("createMarkLabels options must be a plain object.");
+  }
+  const hasSelect = hasOwn(options, "select");
+  const hasSelection = hasOwn(options, "selection");
+  if (hasSelect && hasSelection) {
+    throw new Error("createMarkLabels accepts select or selection, not both.");
+  }
+  if (hasSelect) return normalizeInlineSelection(options.select);
+  if (hasSelection) return normalizeNamedSelection(options.selection);
+  return cloneAndFreeze({ kind: "all" });
+}
+
+export function normalizeLabelSelectionEdit(options) {
+  if (!isPlainObject(options)) {
+    throw new TypeError("editMarkLabelSelection options must be a plain object.");
+  }
+  const requested = ["select", "selection", "all"].filter(key =>
+    hasOwn(options, key)
+  );
+  if (requested.length !== 1) {
+    throw new Error(
+      "editMarkLabelSelection requires exactly one of select, selection, or all."
+    );
+  }
+  if (requested[0] === "select") return normalizeInlineSelection(options.select);
+  if (requested[0] === "selection") {
+    return normalizeNamedSelection(options.selection);
+  }
+  if (options.all !== true) {
+    throw new TypeError("editMarkLabelSelection all must be true.");
+  }
+  return cloneAndFreeze({ kind: "all" });
+}

package/src/grammar/markLabels.js

@@ -0,0 +1,110 @@
+import { aggregateRows } from "./aggregate.js";
+import { BAR_GRAINS, resolveBarChannels, resolveBarGrain } from "./bars/policy.js";
+import { stableFiniteSum } from "./numeric.js";
+import {
+  readStatisticalWeights,
+  statisticalWeightTotal,
+  summarizeStatisticalWeights
+} from "./weightedStatistics.js";
+
+const CONTENTS = new Set(["category", "value", "share"]);
+const NORMALIZATIONS = new Set(["source", "category"]);
+
+export function validateMarkLabelContent(content) {
+  if (!CONTENTS.has(content)) throw new Error(`Unsupported text content "${content}".`);
+  return content;
+}
+
+export function validateMarkLabelNormalization(normalizeBy) {
+  if (!NORMALIZATIONS.has(normalizeBy)) throw new Error(`Unsupported text normalizeBy "${normalizeBy}".`);
+  return normalizeBy;
+}
+
+export function normalizeMarkLabelContent(source, { content, normalizeBy }) {
+  validateMarkLabelContent(content);
+  if (!["bar", "arc"].includes(source?.mark?.type)) {
+    throw new Error("Semantic text content requires a Bar or Arc source; use field or value for other marks.");
+  }
+  if (content !== "share" && normalizeBy !== undefined) {
+    throw new Error("Text normalizeBy is only supported with share content.");
+  }
+  const normalization = content === "share" ? normalizeBy ?? "source" : undefined;
+  if (normalization !== undefined) validateMarkLabelNormalization(normalization);
+  if (normalization === "category" && source.mark.type !== "bar") {
+    throw new Error("Category share normalization requires a Bar source.");
+  }
+  if (source.mark.type === "bar") {
+    const grain = resolveBarGrain(source);
+    if (grain === BAR_GRAINS.ranged) {
+      throw new Error("Ranged Bar text requires an explicit field or value.");
+    }
+    if (content === "category" && grain === BAR_GRAINS.histogram) {
+      throw new Error("Histogram categories are intervals; use an explicit text field or value.");
+    }
+  } else if (content === "category" && source.encoding?.theta?.fieldType === "quantitative") {
+    throw new Error("Category text requires categorical Arc theta.");
+  }
+  return { content, ...(normalization === undefined ? {} : { normalizeBy: normalization }) };
+}
+
+function itemValue(source, item) {
+  if (source.mark.type === "bar") {
+    if (resolveBarGrain(source) === BAR_GRAINS.histogram) {
+      const weight = source.encoding.x.weight;
+      if (weight === undefined || item.members.length === 0) return item.members.length;
+      const weighted = readStatisticalWeights(item.members, weight, "Histogram label");
+      return statisticalWeightTotal(
+        summarizeStatisticalWeights(
+          weighted.entries,
+          weighted.definition.kind,
+          "Histogram label"
+        ),
+        "Histogram label value"
+      );
+    }
+    const measure = source.encoding[resolveBarChannels(source).measure];
+    return measure.aggregate === "count" ? item.members.length
+      : aggregateRows(item.members, measure.field, measure.aggregate);
+  }
+  if (source.encoding?.radius !== undefined) return item.channels.radius;
+  const theta = source.encoding.theta;
+  if (theta.fieldType === "quantitative") return item.channels.theta;
+  return theta.aggregate === "count" ? item.members.length
+    : aggregateRows(item.members, theta.weight, "sum");
+}
+
+function categoryValue(source, item) {
+  return item.channels[source.mark.type === "arc" ? "theta" : resolveBarChannels(source).category];
+}
+
+function categoryKey(source, item) {
+  return JSON.stringify(resolveBarGrain(source) === BAR_GRAINS.histogram
+    ? [item.channels.x, item.channels.x2]
+    : [categoryValue(source, item)]);
+}
+
+export function resolveMarkLabelValues(source, items, options) {
+  const config = normalizeMarkLabelContent(source, options);
+  if (config.content === "category") return items.map(item => categoryValue(source, item));
+  const values = items.map(item => itemValue(source, item));
+  if (config.content === "value" || items.length === 0) return values;
+  if (values.some(value => !Number.isFinite(value) || value < 0)) {
+    throw new Error("Share labels require finite non-negative source values.");
+  }
+  const groups = new Map();
+  items.forEach((item, index) => {
+    const key = config.normalizeBy === "source" ? "source" : categoryKey(source, item);
+    const group = groups.get(key) ?? [];
+    group.push(index);
+    groups.set(key, group);
+  });
+  const shares = [];
+  for (const indices of groups.values()) {
+    const maximum = indices.reduce((max, index) => Math.max(max, values[index]), 0);
+    if (maximum === 0) throw new Error("Share label denominator must be positive.");
+    // Ratios remain defined even when the unscaled sum would overflow.
+    const total = stableFiniteSum(indices.map(index => values[index] / maximum), "Share label denominator");
+    for (const index of indices) shares[index] = (values[index] / maximum) / total;
+  }
+  return shares;
+}

package/src/grammar/normalize.js

@@ -0,0 +1,366 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import {
+  inverseLerp,
+  numericExtent,
+  requireFiniteResult,
+  stableFiniteDeviation,
+  stableFiniteSum
+} from "./numeric.js";
+
+const TRANSFORM_KEYS = Object.freeze([
+  "type", "field", "as", "groupBy", "method", "variance",
+  "zeroDenominator", "baseline", "sortBy"
+]);
+const METHODS = Object.freeze([
+  "share", "zscore", "minmax", "index", "change", "percentChange"
+]);
+const ZERO_POLICIES = Object.freeze(["error", "null", "zero"]);
+const SORT_KEYS = Object.freeze(["field", "order"]);
+const ORDERS = Object.freeze(["ascending", "descending"]);
+const BASELINE_KEYS = Object.freeze(["position", "value"]);
+const BASELINE_METHODS = new Set(["index", "change", "percentChange"]);
+
+function rejectUnknownKeys(value, supported, label) {
+  const unknown = Object.keys(value).find(key => !supported.includes(key));
+  if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
+}
+
+function requireField(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+
+function normalizeGroupBy(value) {
+  if (value === undefined) return [];
+  return Array.isArray(value) ? [...value] : [value];
+}
+
+function validateGroupBy(groupBy) {
+  if (!Array.isArray(groupBy) || groupBy.some(field =>
+    typeof field !== "string" || field.length === 0
+  )) {
+    throw new TypeError("Normalize groupBy must contain field names.");
+  }
+  if (new Set(groupBy).size !== groupBy.length) {
+    throw new Error("Normalize groupBy fields must be unique.");
+  }
+}
+
+function normalizeSortBy(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) return value;
+  return value.map(sort => isPlainObject(sort)
+    ? { ...sort, order: sort.order ?? "ascending" }
+    : sort
+  );
+}
+
+function validateSortBy(sortBy) {
+  if (!Array.isArray(sortBy)) throw new TypeError("Normalize sortBy must be an array.");
+  const fields = [];
+  sortBy.forEach((sort, index) => {
+    if (!isPlainObject(sort)) {
+      throw new TypeError(`Normalize sortBy[${index}] must be a plain object.`);
+    }
+    rejectUnknownKeys(sort, SORT_KEYS, `normalize sortBy[${index}]`);
+    fields.push(requireField(sort.field, `Normalize sortBy[${index}].field`));
+    if (!ORDERS.includes(sort.order)) {
+      throw new Error(`Unsupported normalize sort order "${sort.order}".`);
+    }
+  });
+  if (new Set(fields).size !== fields.length) {
+    throw new Error("Normalize sortBy fields must be unique.");
+  }
+}
+
+function normalizeBaseline(value) {
+  if (!isPlainObject(value)) return value;
+  return { ...value };
+}
+
+function validateBaseline(baseline, sortBy) {
+  if (!isPlainObject(baseline)) {
+    throw new TypeError("Normalize baseline must be a plain object.");
+  }
+  rejectUnknownKeys(baseline, BASELINE_KEYS, "normalize baseline");
+  const modes = BASELINE_KEYS.filter(key => Object.hasOwn(baseline, key));
+  if (modes.length !== 1) {
+    throw new Error("Normalize baseline requires exactly one of position or value.");
+  }
+  if (modes[0] === "value") {
+    if (!Number.isFinite(baseline.value)) {
+      throw new TypeError("Normalize baseline value must be finite.");
+    }
+  } else {
+    if (!["first", "last"].includes(baseline.position)) {
+      throw new Error("Normalize baseline position must be first or last.");
+    }
+    if (sortBy.length === 0) {
+      throw new Error("Normalize baseline position requires non-empty sortBy.");
+    }
+  }
+}
+
+export function validateNormalizeTransform(transform) {
+  if (!isPlainObject(transform)) {
+    throw new TypeError("Normalize transform must be a plain object.");
+  }
+  rejectUnknownKeys(transform, TRANSFORM_KEYS, "normalize transform");
+  if (transform.type !== "normalize") {
+    throw new Error(`Unsupported normalize transform "${transform.type}".`);
+  }
+  requireField(transform.field, "Normalize field");
+  requireField(transform.as, "Normalize output field");
+  validateGroupBy(transform.groupBy);
+  if (!METHODS.includes(transform.method)) {
+    throw new Error(`Unsupported normalize method "${transform.method}".`);
+  }
+
+  const hasVariance = Object.hasOwn(transform, "variance");
+  const hasZero = Object.hasOwn(transform, "zeroDenominator");
+  const hasBaseline = Object.hasOwn(transform, "baseline");
+  const hasSort = Object.hasOwn(transform, "sortBy");
+  if (transform.method === "zscore") {
+    if (!["population", "sample"].includes(transform.variance)) {
+      throw new Error("Normalize zscore variance must be population or sample.");
+    }
+  } else if (hasVariance) {
+    throw new Error(`Normalize variance is not available for ${transform.method}.`);
+  }
+  if (hasZero && !ZERO_POLICIES.includes(transform.zeroDenominator)) {
+    throw new Error(`Unsupported normalize zeroDenominator "${transform.zeroDenominator}".`);
+  }
+  if (transform.method === "change" && hasZero) {
+    throw new Error("Normalize zeroDenominator is not available for change.");
+  }
+  if (BASELINE_METHODS.has(transform.method)) {
+    validateSortBy(transform.sortBy);
+    validateBaseline(transform.baseline, transform.sortBy);
+  } else {
+    if (hasBaseline) {
+      throw new Error(`Normalize baseline is not available for ${transform.method}.`);
+    }
+    if (hasSort) {
+      throw new Error(`Normalize sortBy is not available for ${transform.method}.`);
+    }
+  }
+  return transform;
+}
+
+export function normalizeNormalizeTransform(args = {}) {
+  const {
+    field,
+    as,
+    groupBy,
+    method,
+    variance,
+    zeroDenominator,
+    baseline,
+    sortBy
+  } = args;
+  const transform = {
+    type: "normalize",
+    field,
+    as,
+    groupBy: normalizeGroupBy(groupBy),
+    method
+  };
+  if (method === "zscore") transform.variance = variance ?? "population";
+  else if (Object.hasOwn(args, "variance")) transform.variance = variance;
+  if (method !== "change") transform.zeroDenominator = zeroDenominator ?? "error";
+  else if (Object.hasOwn(args, "zeroDenominator")) {
+    transform.zeroDenominator = zeroDenominator;
+  }
+  if (BASELINE_METHODS.has(method)) {
+    transform.baseline = normalizeBaseline(baseline ?? { position: "first" });
+    transform.sortBy = normalizeSortBy(sortBy);
+  } else {
+    if (Object.hasOwn(args, "baseline")) transform.baseline = normalizeBaseline(baseline);
+    if (Object.hasOwn(args, "sortBy")) transform.sortBy = normalizeSortBy(sortBy);
+  }
+  validateNormalizeTransform(transform);
+  return cloneAndFreeze(transform);
+}
+
+function scalarKey(value, label) {
+  if (value === null) return "null";
+  if (typeof value === "string") return `string:${value.length}:${value}`;
+  if (typeof value === "boolean") return `boolean:${value}`;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return `number:${Object.is(value, -0) ? 0 : value}`;
+  }
+  throw new TypeError(
+    `${label} must contain null, strings, booleans, or finite numbers.`
+  );
+}
+
+function compareScalar(left, right, label) {
+  const leftMissing = left === null || left === undefined;
+  const rightMissing = right === null || right === undefined;
+  if (leftMissing || rightMissing) {
+    if (leftMissing && rightMissing) return 0;
+    return leftMissing ? 1 : -1;
+  }
+  if (typeof left !== typeof right ||
+    !["number", "string", "boolean"].includes(typeof left) ||
+    typeof left === "number" && (!Number.isFinite(left) || !Number.isFinite(right))) {
+    throw new TypeError(`${label} must contain one comparable primitive type.`);
+  }
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+function compareEntries(left, right, sortBy) {
+  for (const sort of sortBy) {
+    const comparison = compareScalar(
+      left.row[sort.field],
+      right.row[sort.field],
+      `Normalize sort field "${sort.field}"`
+    );
+    if (comparison !== 0) return sort.order === "ascending" ? comparison : -comparison;
+  }
+  return left.index - right.index;
+}
+
+function validateRows(rows, transform) {
+  if (!Array.isArray(rows) || !rows.every(isPlainObject)) {
+    throw new TypeError("Normalize source rows must be plain objects.");
+  }
+  if (rows.length === 0) return;
+  const fields = [
+    transform.field,
+    ...transform.groupBy,
+    ...(transform.sortBy ?? []).map(sort => sort.field)
+  ];
+  rows.forEach((row, index) => {
+    if (Object.hasOwn(row, transform.as)) {
+      throw new Error(`Normalize output field "${transform.as}" already exists.`);
+    }
+    for (const field of fields) {
+      if (!Object.hasOwn(row, field)) {
+        throw new Error(`Normalize source does not contain field "${field}" at row ${index}.`);
+      }
+    }
+    if (!Number.isFinite(row[transform.field])) {
+      throw new TypeError(
+        `Normalize field "${transform.field}" must contain finite numbers at row ${index}.`
+      );
+    }
+    for (const field of transform.groupBy) {
+      scalarKey(row[field], `Normalize group field "${field}"`);
+    }
+    for (const sort of transform.sortBy ?? []) {
+      compareScalar(
+        row[sort.field],
+        row[sort.field],
+        `Normalize sort field "${sort.field}"`
+      );
+    }
+  });
+}
+
+function groupRows(rows, transform) {
+  const groups = new Map();
+  rows.forEach((row, index) => {
+    const key = transform.groupBy.length === 0
+      ? "all"
+      : transform.groupBy.map(field =>
+        scalarKey(row[field], `Normalize group field "${field}"`)
+      ).join("\0");
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push({ row, index });
+  });
+  return [...groups.values()];
+}
+
+function zeroResult(policy, method) {
+  if (policy === "null") return null;
+  if (policy === "zero") return 0;
+  throw new RangeError(`Normalize ${method} denominator is zero.`);
+}
+
+function finiteOutput(value, method) {
+  return requireFiniteResult(value, `Normalize ${method} output`);
+}
+
+function zscore(value, mean, deviation, method) {
+  const difference = value - mean;
+  return finiteOutput(
+    Number.isFinite(difference) ? difference / deviation : value / deviation - mean / deviation,
+    method
+  );
+}
+
+function applyGroup(group, transform, outputs) {
+  const values = group.map(entry => entry.row[transform.field]);
+  if (transform.method === "share" && values.some(value => value < 0)) {
+    throw new RangeError("Normalize share does not accept negative values.");
+  }
+  if (transform.method === "share") {
+    const total = stableFiniteSum(values, "Normalize share sum");
+    group.forEach((entry, index) => {
+      outputs[entry.index] = total === 0
+        ? zeroResult(transform.zeroDenominator, transform.method)
+        : finiteOutput(values[index] / total, transform.method);
+    });
+    return;
+  }
+  if (transform.method === "minmax") {
+    const [minimum, maximum] = numericExtent(values);
+    group.forEach((entry, index) => {
+      outputs[entry.index] = minimum === maximum
+        ? zeroResult(transform.zeroDenominator, transform.method)
+        : finiteOutput(inverseLerp(values[index], minimum, maximum), transform.method);
+    });
+    return;
+  }
+  if (transform.method === "zscore") {
+    if (transform.variance === "sample" && values.length < 2) {
+      throw new RangeError("Normalize sample zscore requires at least two values.");
+    }
+    const { mean, deviation } = stableFiniteDeviation(values, {
+      sample: transform.variance === "sample",
+      label: "Normalize zscore deviation"
+    });
+    group.forEach((entry, index) => {
+      outputs[entry.index] = deviation === 0
+        ? zeroResult(transform.zeroDenominator, transform.method)
+        : zscore(values[index], mean, deviation, transform.method);
+    });
+    return;
+  }
+
+  const sorted = [...group].sort((left, right) =>
+    compareEntries(left, right, transform.sortBy)
+  );
+  const baseline = Object.hasOwn(transform.baseline, "value")
+    ? transform.baseline.value
+    : sorted[transform.baseline.position === "first" ? 0 : sorted.length - 1]
+      .row[transform.field];
+  group.forEach(entry => {
+    const value = entry.row[transform.field];
+    if (transform.method === "change") {
+      outputs[entry.index] = finiteOutput(value - baseline, transform.method);
+    } else if (baseline === 0) {
+      outputs[entry.index] = zeroResult(transform.zeroDenominator, transform.method);
+    } else if (transform.method === "index") {
+      outputs[entry.index] = finiteOutput(value / baseline * 100, transform.method);
+    } else {
+      outputs[entry.index] = finiteOutput(value / baseline - 1, transform.method);
+    }
+  });
+}
+
+export function deriveNormalizedRows(rows, transform) {
+  validateNormalizeTransform(transform);
+  validateRows(rows, transform);
+  if (rows.length === 0) return cloneAndFreeze([]);
+  const outputs = new Array(rows.length);
+  for (const group of groupRows(rows, transform)) applyGroup(group, transform, outputs);
+  return cloneAndFreeze(rows.map((row, index) => ({
+    ...row,
+    [transform.as]: outputs[index]
+  })));
+}

package/src/grammar/parallelAxisTitles.js

@@ -0,0 +1,16 @@
+import { validateNonEmptyString, validateOptionObject } from "../core/validation.js";
+
+export function validateParallelAxisTitles(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new TypeError("Parallel axis titles must be a non-empty field/text array.");
+  }
+  const fields = new Set();
+  for (const title of value) {
+    validateOptionObject(title, ["field", "text"], "Parallel axis title");
+    validateNonEmptyString(title.field, "Parallel axis title field");
+    validateNonEmptyString(title.text, "Parallel axis title text");
+    if (fields.has(title.field)) throw new Error("Parallel axis titles require unique fields.");
+    fields.add(title.field);
+  }
+  return value;
+}

package/src/grammar/pathSeries.js

@@ -0,0 +1,109 @@
+import { validateNonEmptyString } from "../core/validation.js";
+import {
+  readNominalField,
+  readQuantitativeField,
+  readScaleField
+} from "./scales/fields.js";
+
+export function normalizeGroupFields(value) {
+  const fields = Array.isArray(value) ? [...value] : [value];
+  for (const field of fields) validateNonEmptyString(field, "Path group field");
+  if (fields.length === 0 || new Set(fields).size !== fields.length) {
+    throw new Error("Path group fields must be non-empty and unique.");
+  }
+  return fields;
+}
+
+export function pathGroupFields(layer) {
+  const group = layer.encoding?.group;
+  if (group !== undefined) {
+    if (group.fieldType !== "nominal") {
+      throw new Error(`Path group on mark "${layer.id}" must be nominal.`);
+    }
+    if (Object.hasOwn(group, "field") && Object.hasOwn(group, "fields")) {
+      throw new Error("Path group requires exactly one of field or fields.");
+    }
+    return normalizeGroupFields(group.fields ?? group.field);
+  }
+  if (layer.mark?.type !== "line") return [];
+  const color = layer.encoding?.color?.field;
+  const dash = layer.encoding?.strokeDash?.field;
+  if (color !== undefined && dash !== undefined && color !== dash) {
+    throw new Error("Line color field must match strokeDash field unless encodeGroup defines the series.");
+  }
+  return color === undefined && dash === undefined ? [] : [color ?? dash];
+}
+
+export function readPathSeriesFields(rows, layer) {
+  const fields = pathGroupFields(layer);
+  for (const field of fields) readNominalField(rows, field);
+  return fields;
+}
+
+function seriesValueIndex(rows, fields, field, channel, encoding = {}) {
+  const quantitative = channel === "strokeWidth" || channel === "opacity";
+  const values = channel === "stroke"
+    ? readScaleField(rows, field, encoding.fieldType ?? "nominal", {
+        temporalUnit: encoding.temporalUnit
+      })
+    : quantitative
+    ? readQuantitativeField(rows, field)
+    : readNominalField(rows, field);
+  const result = new Map();
+  rows.forEach((row, index) => {
+    const key = JSON.stringify(fields.map(field => row[field]));
+    const value = values[index];
+    if (channel === "strokeWidth" && value < 0) {
+      throw new RangeError(`Line strokeWidth field "${field}" cannot contain negative values.`);
+    }
+    if (result.has(key) && result.get(key) !== value) {
+      throw new Error(`Path ${channel} field "${field}" must have one value within each series.`);
+    }
+    result.set(key, value);
+  });
+  return result;
+}
+
+export function derivePathSeriesFieldValues(
+  rows,
+  series,
+  field,
+  channel,
+  encoding
+) {
+  const fields = Object.keys(series[0]?.key ?? {});
+  const values = seriesValueIndex(rows, fields, field, channel, encoding);
+  return series.map(item => values.get(JSON.stringify(Object.values(item.key))));
+}
+
+export function validatePathSeriesAppearance(rows, layer) {
+  if (!["line", "area"].includes(layer.mark?.type) ||
+      layer.encoding?.parallel !== undefined) return;
+  const grouping = readPathSeriesFields(rows, layer);
+  const channels = layer.mark.type === "line"
+    ? ["color", "stroke", "strokeDash", "strokeWidth", "opacity"]
+    : ["color", "stroke"];
+  for (const channel of channels) {
+    const encoding = layer.encoding?.[channel];
+    if (encoding?.field === undefined) continue;
+    const allowed = ["color", "stroke"].includes(channel)
+      ? channel === "color"
+        ? ["nominal", "ordinal"]
+        : ["nominal", "ordinal", "quantitative", "temporal"]
+      : channel === "strokeDash" ? ["nominal"] : ["quantitative"];
+    if (!allowed.includes(encoding.fieldType)) {
+      throw new Error(`Path ${channel} encoding has an unsupported field type.`);
+    }
+    seriesValueIndex(rows, grouping, encoding.field, channel, encoding);
+  }
+  return grouping;
+}
+
+export function readSeriesIdentity(rows, layer) {
+  const group = layer.encoding?.group;
+  const fields = group === undefined ? [] : normalizeGroupFields(group.fields ?? group.field);
+  for (const field of fields) readNominalField(rows, field);
+  const values = rows.map(row => fields.length === 0 ? undefined : fields.length === 1
+    ? row[fields[0]] : JSON.stringify(fields.map(field => row[field])));
+  return { fields, values, domain: [...new Set(values)] };
+}