ggaction 0.0.12 → 0.0.13

package/src/actions/charts/interval-regression.js

@@ -0,0 +1,169 @@
+import { action } from "../../core/action.js";
+import { validateNonNegativeFinite } from "../../core/validation.js";
+import { findDataset } from "../../selectors/datasets.js";
+import {
+  applyFacadeGuides,
+  normalizeAppearance,
+  normalizeEncoding,
+  normalizeFieldEncoding,
+  normalizeGuides,
+  resolveFacadeData,
+  resolveFacadeId,
+  targetArgs,
+  validateFacadeOptions
+} from "./shared.js";
+
+const INTERVAL_OPTIONS = Object.freeze([
+  "id", "data", "coordinate", "x", "y", "xOffset", "yOffset", "groupBy",
+  "color", "point", "errorBar", "guides"
+]);
+const POINT_OPTIONS = Object.freeze([
+  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius"
+]);
+const ERROR_BAR_OPTIONS = Object.freeze([
+  "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
+]);
+
+function intervalChannel(value, operation, channel, id) {
+  const encoding = normalizeFieldEncoding(value, `${operation} ${channel}`);
+  return {
+    ...encoding,
+    scale: {
+      ...(encoding.scale ?? {}),
+      id: encoding.scale?.id ?? `${id}${channel.toUpperCase()}`
+    }
+  };
+}
+
+function centerField(program, config) {
+  if (config.intervalMode === "explicit") return config.centerField;
+  const dataset = findDataset(program, config.data);
+  const transform = dataset?.transform?.[0];
+  if (transform?.type !== "interval") {
+    throw new Error(`Interval plot requires interval provenance for dataset "${config.data}".`);
+  }
+  return transform.as.center;
+}
+
+function applyIntervalPointPositions(program, id, config) {
+  const vertical = config.orientation === "vertical";
+  const positionChannel = vertical ? "x" : "y";
+  const intervalChannelName = vertical ? "y" : "x";
+  let next = program[positionChannel === "x" ? "encodeX" : "encodeY"]({
+    target: id,
+    field: config.positionField,
+    fieldType: config.positionFieldType,
+    ...(config.positionTemporalUnit === undefined
+      ? {}
+      : { temporalUnit: config.positionTemporalUnit }),
+    coordinate: config.coordinate,
+    scale: { id: config.positionScale }
+  });
+  next = next[intervalChannelName === "x" ? "encodeX" : "encodeY"]({
+    target: id,
+    field: centerField(next, config),
+    fieldType: "quantitative",
+    coordinate: config.coordinate,
+    scale: { id: config.intervalScale }
+  });
+  if (config.offset !== undefined) {
+    next = next[config.offset.channel === "xOffset" ? "encodeXOffset" : "encodeYOffset"]({
+      target: id,
+      field: config.offset.field,
+      fieldType: config.offset.fieldType,
+      scale: { id: config.offset.scale },
+      paddingInner: config.offset.paddingInner,
+      paddingOuter: config.offset.paddingOuter
+    });
+  }
+  return next;
+}
+
+export const createIntervalPlot = action(
+  {
+    op: "createIntervalPlot",
+    description: "Create a center point and matching statistical or explicit interval."
+  },
+  function (args = {}) {
+    const operation = "createIntervalPlot";
+    validateFacadeOptions(args, INTERVAL_OPTIONS, operation);
+    const id = resolveFacadeId(this, args.id, { defaultId: "intervalPlot", operation });
+    const data = resolveFacadeData(this, args.data, operation);
+    const x = intervalChannel(args.x, operation, "x", id);
+    const y = intervalChannel(args.y, operation, "y", id);
+    const point = normalizeAppearance(args.point, POINT_OPTIONS, `${operation} point`);
+    const { radius, ...pointAppearance } = point;
+    if (radius !== undefined) validateNonNegativeFinite(radius, `${operation} point radius`);
+    const errorBar = normalizeAppearance(
+      args.errorBar,
+      ERROR_BAR_OPTIONS,
+      `${operation} errorBar`
+    );
+    const color = normalizeEncoding(args.color, `${operation} color`);
+    const guides = normalizeGuides(args.guides, operation);
+    const intervalId = `${id}Interval`;
+
+    let next = this.createErrorBar({
+      id: intervalId,
+      data,
+      x,
+      y,
+      ...(args.xOffset === undefined ? {} : { xOffset: args.xOffset }),
+      ...(args.yOffset === undefined ? {} : { yOffset: args.yOffset }),
+      ...(Object.hasOwn(args, "groupBy") ? { groupBy: args.groupBy } : {}),
+      ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+      ...errorBar
+    });
+    const config = next.markConfigs[intervalId]?.errorBar;
+    if (config === undefined) {
+      throw new Error(`Interval plot child "${intervalId}" has no interval owner configuration.`);
+    }
+    next = next.createPointMark({ id, data: config.data, ...pointAppearance });
+    next = applyIntervalPointPositions(next, id, config);
+    if (radius !== undefined) next = next.encodePointRadius({ target: id, value: radius });
+    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    next = next._withMarkConfig(id, {
+      ...next.markConfigs[id],
+      intervalPlot: { intervalId, materialized: true }
+    });
+    return applyFacadeGuides(next, guides, id, guides);
+  }
+);
+
+const REGRESSION_OPTIONS = Object.freeze([
+  "id", "data", "coordinate", "x", "y", "color", "size", "shape", "point",
+  "groupBy", "method", "degree", "span", "confidenceMethod", "level", "confidence",
+  "interval", "band", "line", "guides"
+]);
+
+export const createRegressionPlot = action(
+  {
+    op: "createRegressionPlot",
+    description: "Create a scatter plot with a fitted regression line and optional interval band."
+  },
+  function (args = {}) {
+    const operation = "createRegressionPlot";
+    validateFacadeOptions(args, REGRESSION_OPTIONS, operation);
+    const id = resolveFacadeId(this, args.id, { defaultId: "regressionPlot", operation });
+    const data = resolveFacadeData(this, args.data, operation);
+    const guides = normalizeGuides(args.guides, operation);
+    let next = this.createScatterPlot({
+      id,
+      data,
+      x: args.x,
+      y: args.y,
+      ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+      ...(args.color === undefined ? {} : { color: args.color }),
+      ...(args.size === undefined ? {} : { size: args.size }),
+      ...(args.shape === undefined ? {} : { shape: args.shape }),
+      ...(args.point === undefined ? {} : { point: args.point }),
+      guides: false
+    });
+    const regression = Object.fromEntries([
+      "groupBy", "method", "degree", "span", "confidenceMethod", "level",
+      "confidence", "interval", "band", "line"
+    ].filter(key => Object.hasOwn(args, key)).map(key => [key, args[key]]));
+    next = next.createRegression({ target: id, ...regression });
+    return applyFacadeGuides(next, guides, id, guides);
+  }
+);

package/src/actions/charts/line.js

@@ -1,5 +1,5 @@
 import { action } from "../../core/action.js";
-import { validateNonEmptyString } from "../../core/validation.js";
+import { normalizeGroupFields } from "../../grammar/pathSeries.js";
 import {
   applyFacadeGuides,
   normalizeAppearance,
@@ -50,20 +50,20 @@ export const createLinePlot = action(
     const strokeDash = normalizeStrokeDashEncoding(args.strokeDash);
     const groupBy = args.groupBy === undefined
       ? undefined
-      : validateNonEmptyString(args.groupBy, "createLinePlot groupBy");
+      : normalizeGroupFields(args.groupBy);
     const guides = normalizeGuides(args.guides, "createLinePlot");
 
     let next = this
       .createLineMark({ id, data, ...line })
       .encodeX(positionArgs(x, { target: id, coordinate: args.coordinate }))
       .encodeY(positionArgs(y, { target: id, coordinate: args.coordinate }));
-    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
     if (groupBy !== undefined) {
-      next = next.encodeGroup({ field: groupBy, target: id });
+      next = next.encodeGroup({ fields: groupBy, target: id });
     }
+    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
     if (strokeDash !== undefined) {
       next = next.encodeStrokeDash(targetArgs(strokeDash, id));
     }
-    return applyFacadeGuides(next, guides);
+    return applyFacadeGuides(next, guides, id);
   }
 );

package/src/actions/charts/parallel.js

@@ -105,6 +105,6 @@ export const createParallelCoordinates = action(
     if (strokeDash !== undefined) {
       next = next.encodeStrokeDash(targetArgs(strokeDash, id));
     }
-    return applyFacadeGuides(next, guides);
+    return applyFacadeGuides(next, guides, id);
   }
 );

package/src/actions/charts/pie.js

@@ -0,0 +1,44 @@
+import { action } from "../../core/action.js";
+import {
+  applyFacadeGuides, normalizeAppearance, normalizeCategoricalColor, normalizeCategoricalGuides,
+  normalizeArcCategory, normalizeCategoryAggregate, omitUndefinedOptions,
+  resolveFacadeData, resolveFacadeId, validateFacadeOptions
+} from "./shared.js";
+
+const OPERATION = "createPiePlot";
+const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
+const ARC_OPTIONS = ["innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth"];
+function guideOptions(value, color) {
+  const guides = normalizeCategoricalGuides(value, OPERATION, color);
+  if (guides === false) return false;
+  for (const key of ["axes", "grid"]) {
+    if (guides[key] !== undefined && guides[key] !== false) {
+      throw new TypeError(`${OPERATION} guides.${key} only accepts false.`);
+    }
+  }
+  return { ...guides, axes: false, grid: false };
+}
+
+export const createPiePlot = action({
+  op: OPERATION, description: "Create a categorical count or weighted-sum pie or donut plot."
+}, function (args = {}) {
+  validateFacadeOptions(args, OPTIONS, OPERATION);
+  const id = resolveFacadeId(this, args.id, { defaultId: "piePlot", operation: OPERATION });
+  const data = resolveFacadeData(this, args.data, OPERATION);
+  const category = normalizeArcCategory(args.category, OPERATION);
+  const aggregate = normalizeCategoryAggregate(args, OPERATION);
+  const arc = omitUndefinedOptions(normalizeAppearance(args.arc, ARC_OPTIONS, `${OPERATION} arc`));
+  const color = args.color === false ? undefined
+    : normalizeCategoricalColor(args.color === undefined ? category.field : args.color, `${OPERATION} color`);
+  if (color !== undefined && arc.fill !== undefined) {
+    throw new Error(`${OPERATION} arc.fill cannot be combined with color; use color:false.`);
+  }
+  const guides = guideOptions(args.guides, color);
+  let next = this.createArcMark({ id, data, ...arc }).encodeTheta({
+    ...category, target: id, aggregate,
+    ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+    ...(aggregate === "sum" ? { weight: args.value } : {})
+  });
+  if (color !== undefined) next = next.encodeColor({ ...color, target: id });
+  return applyFacadeGuides(next, guides, id, args.guides ?? {});
+});

package/src/actions/charts/polar.js

@@ -0,0 +1,123 @@
+import { action } from "../../core/action.js";
+import { validateNonNegativeFinite, validateOptionObject } from
+  "../../core/validation.js";
+import { normalizeGroupFields } from "../../grammar/pathSeries.js";
+import {
+  applyFacadeGuides,
+  normalizeAppearance,
+  normalizeEncoding,
+  normalizeFieldEncoding,
+  normalizeGuides,
+  normalizeStrokeDashEncoding,
+  positionArgs,
+  resolveFacadeData,
+  resolveFacadeId,
+  targetArgs,
+  validateFacadeOptions
+} from "./shared.js";
+
+const POSITION_OPTIONS = Object.freeze([
+  "field", "fieldType", "temporalUnit", "scale"
+]);
+const POINT_OPTIONS = Object.freeze([
+  "shape", "fill", "opacity", "stroke", "strokeWidth", "radius"
+]);
+const LINE_OPTIONS = Object.freeze([
+  "strokeWidth", "curve", "stroke", "opacity", "closed"
+]);
+
+function position(value, operation, channel) {
+  const resolved = normalizeFieldEncoding(value, `${operation} ${channel}`);
+  validateOptionObject(
+    resolved,
+    channel === "theta" ? POSITION_OPTIONS : ["field", "fieldType", "scale"],
+    `${operation} ${channel}`
+  );
+  return resolved;
+}
+
+export const createPolarScatterPlot = action(
+  {
+    op: "createPolarScatterPlot",
+    description: "Create a Polar scatter plot with distinct radial position and glyph size."
+  },
+  function (args = {}) {
+    const operation = "createPolarScatterPlot";
+    validateFacadeOptions(args, [
+      "id", "data", "coordinate", "theta", "radius", "color", "size",
+      "shape", "point", "guides"
+    ], operation);
+    const id = resolveFacadeId(this, args.id, {
+      defaultId: "polarScatterPlot",
+      operation
+    });
+    const data = resolveFacadeData(this, args.data, operation);
+    const theta = position(args.theta, operation, "theta");
+    const radiusPosition = position(args.radius, operation, "radius");
+    const color = normalizeEncoding(args.color, `${operation} color`);
+    const size = normalizeEncoding(args.size, `${operation} size`);
+    const shape = normalizeEncoding(args.shape, `${operation} shape`);
+    const { radius, ...point } = normalizeAppearance(
+      args.point,
+      POINT_OPTIONS,
+      `${operation} point`
+    );
+    const guides = normalizeGuides(args.guides, operation);
+    if (radius !== undefined) {
+      validateNonNegativeFinite(radius, `${operation} point radius`);
+      if (size !== undefined) {
+        throw new Error(`${operation} point radius conflicts with size.`);
+      }
+    }
+
+    let next = this
+      .createPointMark({ id, data, ...point })
+      .encodeTheta(positionArgs(theta, { target: id, coordinate: args.coordinate }))
+      .encodeR(positionArgs(radiusPosition, { target: id, coordinate: args.coordinate }));
+    if (radius !== undefined) next = next.encodePointRadius({ target: id, value: radius });
+    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    if (size !== undefined) next = next.encodeSize(targetArgs(size, id));
+    if (shape !== undefined) next = next.encodeShape(targetArgs(shape, id));
+    return applyFacadeGuides(next, guides, id);
+  }
+);
+
+export const createPolarLinePlot = action(
+  {
+    op: "createPolarLinePlot",
+    description: "Create an open or explicitly closed Polar line plot."
+  },
+  function (args = {}) {
+    const operation = "createPolarLinePlot";
+    validateFacadeOptions(args, [
+      "id", "data", "coordinate", "theta", "radius", "color", "groupBy",
+      "strokeDash", "line", "guides"
+    ], operation);
+    const id = resolveFacadeId(this, args.id, {
+      defaultId: "polarLinePlot",
+      operation
+    });
+    const data = resolveFacadeData(this, args.data, operation);
+    const theta = position(args.theta, operation, "theta");
+    const radius = position(args.radius, operation, "radius");
+    const color = normalizeEncoding(args.color, `${operation} color`);
+    const strokeDash = normalizeStrokeDashEncoding(
+      args.strokeDash,
+      `${operation} strokeDash`
+    );
+    const groupBy = args.groupBy === undefined
+      ? undefined
+      : normalizeGroupFields(args.groupBy);
+    const line = normalizeAppearance(args.line, LINE_OPTIONS, `${operation} line`);
+    const guides = normalizeGuides(args.guides, operation);
+
+    let next = this
+      .createLineMark({ id, data, ...line })
+      .encodeTheta(positionArgs(theta, { target: id, coordinate: args.coordinate }))
+      .encodeR(positionArgs(radius, { target: id, coordinate: args.coordinate }));
+    if (groupBy !== undefined) next = next.encodeGroup({ target: id, fields: groupBy });
+    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    if (strokeDash !== undefined) next = next.encodeStrokeDash(targetArgs(strokeDash, id));
+    return applyFacadeGuides(next, guides, id);
+  }
+);

package/src/actions/charts/radar.js

@@ -0,0 +1,299 @@
+import { action } from "../../core/action.js";
+import { isPlainObject } from "../../core/immutable.js";
+import { validateNonEmptyString, validateOptionObject } from
+  "../../core/validation.js";
+import { normalizeGroupFields } from "../../grammar/pathSeries.js";
+import { readNominalField, readQuantitativeField } from
+  "../../grammar/scales/fields.js";
+import { findDataset } from "../../selectors/datasets.js";
+import {
+  normalizeAppearance,
+  normalizeEncoding,
+  normalizeFieldEncoding,
+  normalizeGuides,
+  normalizeStrokeDashEncoding,
+  omitUndefinedOptions,
+  resolveFacadeData,
+  resolveFacadeId,
+  validateFacadeOptions
+} from "./shared.js";
+
+const OPTIONS = Object.freeze([
+  "id", "data", "coordinate", "category", "value", "wide", "groupBy",
+  "order", "color", "strokeDash", "line", "guides"
+]);
+const CATEGORY_OPTIONS = Object.freeze(["field", "fieldType", "scale"]);
+const VALUE_OPTIONS = Object.freeze(["field", "fieldType", "scale"]);
+const CATEGORY_SCALE_OPTIONS = Object.freeze([
+  "id", "type", "domain", "range", "reverse", "paddingInner", "paddingOuter",
+  "padding", "align"
+]);
+const WIDE_OPTIONS = Object.freeze(["fields", "as"]);
+const WIDE_AS_OPTIONS = Object.freeze(["key", "value"]);
+const LINE_OPTIONS = Object.freeze([
+  "strokeWidth", "curve", "stroke", "opacity", "closed"
+]);
+
+function normalizeCategory(value, operation) {
+  const category = normalizeFieldEncoding(value, `${operation} category`);
+  validateOptionObject(category, CATEGORY_OPTIONS, `${operation} category`);
+  validateNonEmptyString(category.field, `${operation} category field`);
+  const fieldType = category.fieldType ?? "nominal";
+  if (!["nominal", "ordinal"].includes(fieldType)) {
+    throw new TypeError(`${operation} category must be nominal or ordinal.`);
+  }
+  if (category.scale !== undefined) {
+    validateOptionObject(
+      category.scale,
+      CATEGORY_SCALE_OPTIONS,
+      `${operation} category.scale`
+    );
+    if (
+      category.scale.type !== undefined &&
+      !["band", "point"].includes(category.scale.type)
+    ) {
+      throw new TypeError(`${operation} category.scale.type must be band or point.`);
+    }
+  }
+  return {
+    ...omitUndefinedOptions(category),
+    fieldType,
+    ...(category.scale === undefined
+      ? {}
+      : { scale: omitUndefinedOptions(category.scale) })
+  };
+}
+
+function normalizeValue(value, operation) {
+  const result = normalizeFieldEncoding(value, `${operation} value`);
+  validateOptionObject(result, VALUE_OPTIONS, `${operation} value`);
+  validateNonEmptyString(result.field, `${operation} value field`);
+  if (result.fieldType !== undefined && result.fieldType !== "quantitative") {
+    throw new TypeError(`${operation} value must be quantitative.`);
+  }
+  return { ...omitUndefinedOptions(result), fieldType: "quantitative" };
+}
+
+function normalizeWide(value, id, operation) {
+  if (!isPlainObject(value)) {
+    throw new TypeError(`${operation} wide must be a plain object.`);
+  }
+  validateOptionObject(value, WIDE_OPTIONS, `${operation} wide`);
+  if (!Array.isArray(value.fields) || value.fields.length < 3) {
+    throw new Error(`${operation} wide.fields must contain at least three fields.`);
+  }
+  const fields = [...value.fields];
+  for (const field of fields) validateNonEmptyString(field, `${operation} wide field`);
+  if (new Set(fields).size !== fields.length) {
+    throw new Error(`${operation} wide.fields must be unique.`);
+  }
+  const aliases = value.as === undefined ? {} : value.as;
+  if (!isPlainObject(aliases)) {
+    throw new TypeError(`${operation} wide.as must be a plain object.`);
+  }
+  validateOptionObject(aliases, WIDE_AS_OPTIONS, `${operation} wide.as`);
+  const key = aliases.key ?? `${id}Dimension`;
+  const foldedValue = aliases.value ?? `${id}Value`;
+  validateNonEmptyString(key, `${operation} wide.as.key`);
+  validateNonEmptyString(foldedValue, `${operation} wide.as.value`);
+  if (key === foldedValue || fields.includes(key) || fields.includes(foldedValue)) {
+    throw new Error(`${operation} wide aliases must be distinct from selected fields.`);
+  }
+  return { fields, as: { key, value: foldedValue } };
+}
+
+function orderedCategories(rows, field, requested, operation) {
+  const observed = [...new Set(readNominalField(rows, field))];
+  if (!Array.isArray(requested) && requested !== undefined) {
+    throw new TypeError(`${operation} order must be an array.`);
+  }
+  const order = requested === undefined ? observed : [...requested];
+  if (order.length < 3 || new Set(order).size !== order.length) {
+    throw new Error(`${operation} order must contain at least three distinct categories.`);
+  }
+  const observedSet = new Set(observed);
+  if (
+    order.length !== observed.length ||
+    order.some(value => !observedSet.has(value))
+  ) {
+    throw new Error(`${operation} order must contain every category exactly once.`);
+  }
+  return order;
+}
+
+function seriesKey(row, fields) {
+  return JSON.stringify(fields.map(field => row[field]));
+}
+
+function radarSeriesFields(groupBy, color, strokeDash, operation) {
+  if (groupBy.length > 0) return groupBy;
+  const colorField = color?.field;
+  const dashField = strokeDash?.field;
+  if (
+    colorField !== undefined && dashField !== undefined &&
+    colorField !== dashField
+  ) {
+    throw new Error(
+      `${operation} color and strokeDash fields must match unless groupBy defines the series.`
+    );
+  }
+  const field = colorField ?? dashField;
+  return field === undefined ? [] : [field];
+}
+
+function validateRadarRows(rows, { category, value, groupBy, order }, operation) {
+  readQuantitativeField(rows, value);
+  for (const field of groupBy) readNominalField(rows, field);
+  const expected = new Set(order);
+  const series = new Map();
+  for (const row of rows) {
+    const key = seriesKey(row, groupBy);
+    const categories = series.get(key) ?? new Set();
+    const current = row[category];
+    if (!expected.has(current)) {
+      throw new Error(`${operation} found a category outside order.`);
+    }
+    if (categories.has(current)) {
+      throw new Error(`${operation} requires one row per series and category.`);
+    }
+    categories.add(current);
+    series.set(key, categories);
+  }
+  if (series.size === 0) throw new Error(`${operation} requires radar rows.`);
+  for (const categories of series.values()) {
+    if (
+      categories.size !== order.length ||
+      order.some(value => !categories.has(value))
+    ) {
+      throw new Error(`${operation} requires every category in every series.`);
+    }
+  }
+}
+
+function scaleWithOrder(category, order, operation) {
+  const scale = category.scale ?? {};
+  if (
+    scale.domain !== undefined && scale.domain !== "auto" &&
+    (!Array.isArray(scale.domain) ||
+      scale.domain.length !== order.length ||
+      scale.domain.some((value, index) => value !== order[index]))
+  ) {
+    throw new Error(`${operation} category.scale.domain conflicts with order.`);
+  }
+  return { ...category, scale: { ...scale, domain: order } };
+}
+
+export const createRadarPlot = action(
+  {
+    op: "createRadarPlot",
+    description: "Create a closed Radar plot from long rows or an explicit wide fold."
+  },
+  function (args = {}) {
+    const operation = "createRadarPlot";
+    validateFacadeOptions(args, OPTIONS, operation);
+    const hasWide = args.wide !== undefined;
+    const hasCategory = args.category !== undefined;
+    const hasValue = args.value !== undefined;
+    if (
+      (hasWide && (hasCategory || hasValue)) ||
+      (!hasWide && (!hasCategory || !hasValue))
+    ) {
+      throw new Error(
+        `${operation} requires category and value, or wide, but not both.`
+      );
+    }
+    const longForm = !hasWide;
+    const id = resolveFacadeId(this, args.id, {
+      defaultId: "radarPlot",
+      operation
+    });
+    const source = resolveFacadeData(this, args.data, operation);
+    const sourceRows = findDataset(this, source).values;
+    const groupBy = args.groupBy === undefined
+      ? []
+      : normalizeGroupFields(args.groupBy);
+    const color = normalizeEncoding(args.color, `${operation} color`);
+    const strokeDash = normalizeStrokeDashEncoding(
+      args.strokeDash,
+      `${operation} strokeDash`
+    );
+    const seriesFields = radarSeriesFields(
+      groupBy,
+      color,
+      strokeDash,
+      operation
+    );
+    const line = normalizeAppearance(args.line, LINE_OPTIONS, `${operation} line`);
+    if (line.closed === false) {
+      throw new Error(`${operation} requires a closed line.`);
+    }
+    const guides = normalizeGuides(args.guides, operation);
+
+    let next = this;
+    let data = source;
+    let category;
+    let radarValue;
+    let order;
+    if (longForm) {
+      category = normalizeCategory(args.category, operation);
+      radarValue = normalizeValue(args.value, operation);
+      order = orderedCategories(sourceRows, category.field, args.order, operation);
+      validateRadarRows(sourceRows, {
+        category: category.field,
+        value: radarValue.field,
+        groupBy: seriesFields,
+        order
+      }, operation);
+    } else {
+      const wide = normalizeWide(args.wide, id, operation);
+      if (sourceRows.length > 1 && groupBy.length === 0) {
+        throw new Error(`${operation} wide rows require groupBy as series identity.`);
+      }
+      for (const field of wide.fields) readQuantitativeField(sourceRows, field);
+      for (const field of groupBy) readNominalField(sourceRows, field);
+      if (!Array.isArray(args.order) && args.order !== undefined) {
+        throw new TypeError(`${operation} order must be an array.`);
+      }
+      order = args.order === undefined ? wide.fields : [...args.order];
+      if (
+        order.length !== wide.fields.length ||
+        new Set(order).size !== order.length ||
+        order.some(field => !wide.fields.includes(field))
+      ) {
+        throw new Error(
+          `${operation} order must contain every wide field exactly once.`
+        );
+      }
+      data = `${id}FoldData`;
+      next = next.createFoldData({
+        id: data,
+        source,
+        fields: wide.fields,
+        as: wide.as
+      });
+      const foldedRows = findDataset(next, data).values;
+      category = { field: wide.as.key, fieldType: "nominal" };
+      radarValue = { field: wide.as.value, fieldType: "quantitative" };
+      validateRadarRows(foldedRows, {
+        category: category.field,
+        value: radarValue.field,
+        groupBy: seriesFields,
+        order
+      }, operation);
+    }
+
+    category = scaleWithOrder(category, order, operation);
+    return next.createPolarLinePlot({
+      id,
+      data,
+      ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+      theta: category,
+      radius: radarValue,
+      ...(groupBy.length === 0 ? {} : { groupBy }),
+      ...(color === undefined ? {} : { color }),
+      ...(strokeDash === undefined ? {} : { strokeDash }),
+      line: { ...line, closed: true },
+      guides
+    });
+  }
+);