ggaction 0.0.4 → 0.0.5

package/src/grammar/lineSeries.js

@@ -10,6 +10,7 @@ import {
   validateAggregateFieldType,
   validateAggregateFieldValues,
 } from "./aggregate.js";
+import { stableOrderPathValues } from "./pathOrder.js";
 
 const SERIES_CHANNELS = Object.freeze(["group", "color", "strokeDash"]);
 
@@ -101,6 +102,51 @@ function deriveCartesianLineSeries(rows, layer) {
       : readQuantitativeField(rows, y.field);
   const seriesFields = readSeriesFields(rows, layer);
 
+  const pathOrder = layer.encoding?.pathOrder;
+  if (pathOrder !== undefined) {
+    if (isAggregate) {
+      throw new Error(
+        `Line mark "${layer.id}" cannot combine aggregate y and path order.`
+      );
+    }
+    const orderValues = readQuantitativeField(rows, pathOrder.field);
+    const groups = new Map();
+    for (let index = 0; index < rows.length; index += 1) {
+      const dimensions = seriesFields.fields.map(
+        field => seriesFields.values.get(field)[index]
+      );
+      const key = groupKey(dimensions);
+      const series = groups.get(key) ?? {
+        key: Object.fromEntries(
+          seriesFields.fields.map((field, item) => [field, dimensions[item]])
+        ),
+        values: [],
+        orderValues: []
+      };
+      series.values.push({ x: xValues[index], y: yValues[index] });
+      series.orderValues.push(orderValues[index]);
+      groups.set(key, series);
+    }
+    const series = [...groups.values()].flatMap(item => {
+      const values = stableOrderPathValues(
+        item.values,
+        item.orderValues,
+        pathOrder.order
+      );
+      return values.length < 2 ? [] : [{ key: item.key, values }];
+    });
+    if (series.length === 0) {
+      throw new Error(
+        `Line series on mark "${layer.id}" requires at least two ordered points.`
+      );
+    }
+    return cloneAndFreeze({
+      xValues: series.flatMap(item => item.values.map(value => value.x)),
+      yValues: series.flatMap(item => item.values.map(value => value.y)),
+      series
+    });
+  }
+
   if (directTemporal) {
     const groups = new Map();
     for (let index = 0; index < rows.length; index += 1) {
@@ -249,6 +295,11 @@ function thetaOrder(values, fieldType, domain) {
 }
 
 export function derivePolarLineSeries(rows, layer, { thetaDomain } = {}) {
+  if (layer.encoding?.pathOrder !== undefined) {
+    throw new Error(
+      `Polar line mark "${layer.id}" does not support path order.`
+    );
+  }
   const { theta, radius } = requirePolarLineEncoding(layer);
   const thetaValues = readThetaValues(rows, theta);
   const radiusValues = readQuantitativeField(rows, radius.field);
@@ -303,3 +354,21 @@ export function deriveLineSeries(rows, layer, options) {
     ? derivePolarLineSeries(rows, layer, options)
     : deriveCartesianLineSeries(rows, layer);
 }
+
+export function deriveLineSeriesFieldValues(rows, layer, derived, field) {
+  const values = readQuantitativeField(rows, field);
+  if (values.some(value => value < 0)) {
+    throw new RangeError(`Line strokeWidth field "${field}" cannot contain negative values.`);
+  }
+  return cloneAndFreeze(derived.series.map(series => {
+    const matching = values.filter((_, index) => Object.entries(series.key)
+      .every(([key, value]) => rows[index]?.[key] === value));
+    const unique = [...new Set(matching)];
+    if (unique.length !== 1) {
+      throw new Error(
+        `Line strokeWidth field "${field}" must have one value within each series.`
+      );
+    }
+    return unique[0];
+  }));
+}

package/src/grammar/paint.js

@@ -0,0 +1,88 @@
+import { isPlainObject } from "../core/immutable.js";
+
+const PAINT_KEYS = Object.freeze(["type", "from", "to", "stops"]);
+const POINT_KEYS = Object.freeze(["x", "y"]);
+const STOP_KEYS = Object.freeze(["offset", "color"]);
+
+function hasExactKeys(value, keys) {
+  const actual = Object.keys(value);
+  return actual.length === keys.length && keys.every(key => Object.hasOwn(value, key));
+}
+
+function validateUnitPoint(value, label) {
+  if (!isPlainObject(value) || !hasExactKeys(value, POINT_KEYS)) {
+    throw new TypeError(`${label} must be a plain { x, y } object.`);
+  }
+  for (const key of POINT_KEYS) {
+    if (!Number.isFinite(value[key]) || value[key] < 0 || value[key] > 1) {
+      throw new RangeError(`${label}.${key} must be a finite number from 0 to 1.`);
+    }
+  }
+}
+
+function validateStop(stop, index) {
+  const label = `Linear gradient stops[${index}]`;
+  if (!isPlainObject(stop) || !hasExactKeys(stop, STOP_KEYS)) {
+    throw new TypeError(`${label} must be a plain { offset, color } object.`);
+  }
+  if (!Number.isFinite(stop.offset) || stop.offset < 0 || stop.offset > 1) {
+    throw new RangeError(`${label}.offset must be a finite number from 0 to 1.`);
+  }
+  if (typeof stop.color !== "string" || stop.color.length === 0) {
+    throw new TypeError(`${label}.color must be a non-empty string.`);
+  }
+}
+
+export function isLinearGradientPaint(value) {
+  return isPlainObject(value) && value.type === "linear-gradient";
+}
+
+export function validateFillPaint(value, label = "fill") {
+  if (typeof value === "string") {
+    if (value.length === 0) throw new TypeError(`${label} must be a non-empty string or linear gradient.`);
+    return value;
+  }
+  if (!isPlainObject(value) || !hasExactKeys(value, PAINT_KEYS)) {
+    throw new TypeError(`${label} must be a non-empty string or linear gradient.`);
+  }
+  if (value.type !== "linear-gradient") {
+    throw new Error(`Unsupported fill paint type "${value.type}".`);
+  }
+  validateUnitPoint(value.from, "Linear gradient from");
+  validateUnitPoint(value.to, "Linear gradient to");
+  if (value.from.x === value.to.x && value.from.y === value.to.y) {
+    throw new Error("Linear gradient from and to must differ.");
+  }
+  if (!Array.isArray(value.stops) || value.stops.length < 2) {
+    throw new TypeError("Linear gradient stops must contain at least two entries.");
+  }
+  value.stops.forEach(validateStop);
+  for (let index = 1; index < value.stops.length; index += 1) {
+    if (value.stops[index].offset < value.stops[index - 1].offset) {
+      throw new Error("Linear gradient stop offsets must be nondecreasing.");
+    }
+  }
+  return value;
+}
+
+export function resolveLinearGradientCoordinates(paint, bounds) {
+  validateFillPaint(paint, "Linear gradient paint");
+  if (!isLinearGradientPaint(paint)) {
+    throw new TypeError("Linear gradient coordinates require a structured paint.");
+  }
+  if (
+    !isPlainObject(bounds) ||
+    ![bounds.left, bounds.right, bounds.top, bounds.bottom].every(Number.isFinite) ||
+    bounds.left > bounds.right ||
+    bounds.top > bounds.bottom
+  ) {
+    throw new TypeError("Linear gradient bounds must be finite and ordered.");
+  }
+  const width = bounds.right - bounds.left;
+  const height = bounds.bottom - bounds.top;
+  const point = value => Object.freeze({
+    x: bounds.left + width * value.x,
+    y: bounds.top + height * value.y
+  });
+  return Object.freeze({ from: point(paint.from), to: point(paint.to) });
+}

package/src/grammar/parallelCoordinates.js

@@ -0,0 +1,213 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { validateUserId } from "../core/identifiers.js";
+import { validateOptionObject } from "../core/validation.js";
+import {
+  mapContinuousScaleValues,
+  mapOrdinalPositionValues,
+  validateSemanticFieldType
+} from "./scales/index.js";
+
+const DIMENSION_OPTIONS = Object.freeze([
+  "field", "fieldType", "title", "scale"
+]);
+const FIELD_TYPES = new Set(["quantitative", "ordinal"]);
+const MISSING_POLICIES = new Set(["break", "drop-row", "error"]);
+const DIMENSION_SCALE_OPTIONS = Object.freeze([
+  "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+  "base", "exponent", "constant", "paddingInner", "paddingOuter",
+  "padding", "align", "unknown"
+]);
+
+function nonEmptyString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+
+export function validateParallelKeyField(value) {
+  return nonEmptyString(value, "Parallel key field");
+}
+
+function inferFieldType(rows, field) {
+  const values = rows
+    .map(row => row[field])
+    .filter(value => value !== undefined && value !== null);
+  if (values.length === 0) {
+    throw new Error(`Cannot infer Parallel field type for "${field}".`);
+  }
+  if (values.every(Number.isFinite)) return "quantitative";
+  if (values.every(value => typeof value === "string")) return "ordinal";
+  throw new Error(
+    `Parallel dimension "${field}" requires an explicit compatible fieldType.`
+  );
+}
+
+function validateScaleOptions(value, index) {
+  if (value === undefined) return {};
+  if (!isPlainObject(value)) {
+    throw new TypeError(`Parallel dimension ${index} scale must be a plain object.`);
+  }
+  validateOptionObject(
+    value,
+    DIMENSION_SCALE_OPTIONS,
+    `Parallel dimension ${index} scale`
+  );
+  return { ...value };
+}
+
+export function validateParallelMissingPolicy(value) {
+  if (!MISSING_POLICIES.has(value)) {
+    throw new Error(`Unsupported Parallel missing policy "${value}".`);
+  }
+  return value;
+}
+
+export function validateParallelDimensions(dimensions, { normalized = false } = {}) {
+  if (!Array.isArray(dimensions) || dimensions.length < 2) {
+    throw new RangeError("Parallel coordinates require at least two dimensions.");
+  }
+  const fields = new Set();
+  for (const [index, dimension] of dimensions.entries()) {
+    if (!isPlainObject(dimension)) {
+      throw new TypeError(`Parallel dimension ${index} must be an object.`);
+    }
+    const supported = normalized
+      ? ["field", "fieldType", "title", "scale"]
+      : DIMENSION_OPTIONS;
+    validateOptionObject(dimension, supported, `Parallel dimension ${index}`);
+    const field = nonEmptyString(
+      dimension.field,
+      `Parallel dimension ${index} field`
+    );
+    if (fields.has(field)) {
+      throw new Error("Parallel dimensions must use unique fields.");
+    }
+    fields.add(field);
+    validateSemanticFieldType(dimension.fieldType);
+    if (!FIELD_TYPES.has(dimension.fieldType)) {
+      throw new Error(`Unsupported Parallel field type "${dimension.fieldType}".`);
+    }
+    nonEmptyString(dimension.title, `Parallel dimension ${index} title`);
+    validateUserId(dimension.scale, `Parallel dimension ${index} scale id`);
+  }
+  return dimensions;
+}
+
+export function normalizeParallelDimensions(rows, dimensions, target) {
+  if (!Array.isArray(dimensions) || dimensions.length < 2) {
+    throw new RangeError("Parallel coordinates require at least two dimensions.");
+  }
+  const normalized = dimensions.map((input, index) => {
+    const dimension = typeof input === "string" ? { field: input } : input;
+    if (!isPlainObject(dimension)) {
+      throw new TypeError(
+        `Parallel dimension ${index} must be a field string or plain object.`
+      );
+    }
+    validateOptionObject(
+      dimension,
+      DIMENSION_OPTIONS,
+      `Parallel dimension ${index}`
+    );
+    const field = nonEmptyString(
+      dimension.field,
+      `Parallel dimension ${index} field`
+    );
+    const fieldType = dimension.fieldType ?? inferFieldType(rows, field);
+    if (!FIELD_TYPES.has(fieldType)) {
+      throw new Error(`Unsupported Parallel field type "${fieldType}".`);
+    }
+    const scale = validateScaleOptions(dimension.scale, index);
+    return {
+      field,
+      fieldType,
+      title: dimension.title ?? field,
+      scale: `${target}-parallel-${index}`,
+      scaleOptions: scale
+    };
+  });
+  const fields = normalized.map(dimension => dimension.field);
+  if (new Set(fields).size !== fields.length) {
+    throw new Error("Parallel dimensions must use unique fields.");
+  }
+  return cloneAndFreeze(normalized);
+}
+
+function validDimensionValue(value, fieldType) {
+  return fieldType === "quantitative"
+    ? Number.isFinite(value)
+    : typeof value === "string" || Number.isFinite(value);
+}
+
+function commandsFromVertices(vertices) {
+  const commands = [];
+  let fragment = [];
+  const flush = () => {
+    if (fragment.length >= 2) {
+      fragment.forEach((point, index) => commands.push({
+        op: index === 0 ? "M" : "L",
+        x: point.x,
+        y: point.y
+      }));
+    }
+    fragment = [];
+  };
+  for (const vertex of vertices) {
+    if (vertex === undefined) flush();
+    else fragment.push(vertex);
+  }
+  flush();
+  return commands;
+}
+
+export function validateParallelRows(rows, dimensions, { key, missing }) {
+  const seen = new Set();
+  rows.forEach((row, index) => {
+    if (key !== undefined) {
+      const value = row[key];
+      if (value === undefined || value === null || value === "") {
+        throw new Error(`Parallel key is missing at row ${index}.`);
+      }
+      const token = `${typeof value}:${String(value)}`;
+      if (seen.has(token)) throw new Error(`Duplicate Parallel key "${value}".`);
+      seen.add(token);
+    }
+    const incomplete = dimensions.some(dimension =>
+      !validDimensionValue(row[dimension.field], dimension.fieldType)
+    );
+    if (incomplete && missing === "error") {
+      throw new Error(`Parallel row ${index} has a missing dimension.`);
+    }
+  });
+}
+
+export function materializeParallelRows(rows, dimensions, resolvedScales, bounds, {
+  key,
+  missing
+}) {
+  validateParallelRows(rows, dimensions, { key, missing });
+  const step = bounds.width / (dimensions.length - 1);
+  const items = [];
+  rows.forEach((row, sourceRowIndex) => {
+    const vertices = dimensions.map((dimension, index) => {
+      const value = row[dimension.field];
+      if (!validDimensionValue(value, dimension.fieldType)) return undefined;
+      const scale = resolvedScales[dimension.scale];
+      const mapped = dimension.fieldType === "quantitative"
+        ? mapContinuousScaleValues([value], scale)[0]
+        : mapOrdinalPositionValues([value], scale)[0];
+      return Number.isFinite(mapped)
+        ? { x: bounds.x + step * index, y: mapped, value, dimension: dimension.field }
+        : undefined;
+    });
+    const incomplete = vertices.some(vertex => vertex === undefined);
+    if (incomplete && missing === "drop-row") return;
+    items.push({
+      key: key === undefined ? `source:${sourceRowIndex}` : row[key],
+      sourceRowIndex,
+      commands: commandsFromVertices(vertices)
+    });
+  });
+  return cloneAndFreeze(items);
+}

package/src/grammar/pathOrder.js

@@ -0,0 +1,35 @@
+import { cloneAndFreeze } from "../core/immutable.js";
+
+export const PATH_ORDER_DIRECTIONS = Object.freeze([
+  "ascending",
+  "descending"
+]);
+
+export function validatePathOrderDirection(value) {
+  if (!PATH_ORDER_DIRECTIONS.includes(value)) {
+    throw new Error(`Unsupported path order "${value}".`);
+  }
+  return value;
+}
+
+export function stableOrderPathValues(values, orderValues, order = "ascending") {
+  validatePathOrderDirection(order);
+  if (!Array.isArray(values) || !Array.isArray(orderValues)) {
+    throw new TypeError("Path ordering requires value and order arrays.");
+  }
+  if (values.length !== orderValues.length) {
+    throw new Error("Path value and order arrays must have equal length.");
+  }
+  const direction = order === "ascending" ? 1 : -1;
+  const ordered = values.map((value, sourceIndex) => {
+    const orderValue = orderValues[sourceIndex];
+    if (!Number.isFinite(orderValue)) {
+      throw new TypeError("Path order values must be finite numbers.");
+    }
+    return { value, orderValue, sourceIndex };
+  }).sort((left, right) =>
+    direction * (left.orderValue - right.orderValue) ||
+    left.sourceIndex - right.sourceIndex
+  );
+  return cloneAndFreeze(ordered.map(item => item.value));
+}

package/src/grammar/pointShapes.js

@@ -162,3 +162,27 @@ export function createPointShapeGraphic({
     }
   };
 }
+
+export function resolvePointShapeExtent({ shape, area, strokeWidth = 0 }) {
+  const validated = validatePointShape(shape);
+  if (!Number.isFinite(area) || area < 0) {
+    throw new TypeError("Point shape area must be finite and non-negative.");
+  }
+  if (!Number.isFinite(strokeWidth) || strokeWidth < 0) {
+    throw new TypeError("Point shape strokeWidth must be finite and non-negative.");
+  }
+  const strokeExtent = strokeWidth / 2;
+  if (validated === "circle") {
+    const radius = Math.sqrt(area / Math.PI) + strokeExtent;
+    return cloneAndFreeze({ x: radius, y: radius });
+  }
+  if (validated === "square") {
+    const halfSide = Math.sqrt(area) / 2 + strokeExtent;
+    return cloneAndFreeze({ x: halfSide, y: halfSide });
+  }
+  const points = normalizePolygon(shapePolygon(validated), 0, 0, area);
+  return cloneAndFreeze({
+    x: Math.max(0, ...points.map(point => Math.abs(point.x))) + strokeExtent,
+    y: Math.max(0, ...points.map(point => Math.abs(point.y))) + strokeExtent
+  });
+}

package/src/grammar/rules.js

@@ -12,6 +12,7 @@ const ENDPOINT_CHANNELS = Object.freeze(["x", "y", "x2", "y2"]);
 const VALUE_CHANNELS = Object.freeze([
   ...ENDPOINT_CHANNELS,
   "strokeDash",
+  "strokeWidth",
   "opacity"
 ]);
 

package/src/grammar/scales/appearance.js

@@ -20,6 +20,7 @@ export const NAMED_DASH_PATTERNS = cloneAndFreeze({
 export { POINT_SHAPES } from "../pointShapes.js";
 export const DEFAULT_SIZE_RANGE = cloneAndFreeze([24, 196]);
 export const DEFAULT_OPACITY_RANGE = cloneAndFreeze([0.2, 1]);
+export const DEFAULT_STROKE_WIDTH_RANGE = cloneAndFreeze([1, 8]);
 
 export function validateColorRange(range) {
   if (range === "auto") return range;
@@ -123,6 +124,21 @@ export function validateOpacityRange(range) {
   return cloneAndFreeze(range);
 }
 
+export function validateStrokeWidthRange(range) {
+  if (range === "auto") return range;
+  if (
+    !Array.isArray(range) ||
+    range.length !== 2 ||
+    !range.every(value => Number.isFinite(value) && value >= 0) ||
+    range[0] > range[1]
+  ) {
+    throw new TypeError(
+      "StrokeWidth range must be an ascending pair of non-negative finite widths."
+    );
+  }
+  return cloneAndFreeze(range);
+}
+
 export function validateOpacityValue(value, label = "Opacity") {
   return validateUnitInterval(value, label);
 }
@@ -166,6 +182,11 @@ export function resolveOpacityRange(range) {
   return validated === "auto" ? DEFAULT_OPACITY_RANGE : validated;
 }
 
+export function resolveStrokeWidthRange(range) {
+  const validated = validateStrokeWidthRange(range);
+  return validated === "auto" ? DEFAULT_STROKE_WIDTH_RANGE : validated;
+}
+
 export function mapOrdinalValues(values, domain, range, options = {}) {
   const hasUnknown = Object.hasOwn(options, "unknown");
   const indices = new Map(domain.map((value, index) => [value, index]));

package/src/grammar/schemas/concreteGraphic.js

@@ -1,5 +1,6 @@
 import { isPlainObject } from "../../core/immutable.js";
 import { validatePathCommands } from "../pathCommands.js";
+import { validateFillPaint } from "../paint.js";
 import { validateGraphicProperty } from "./graphic.js";
 
 const FINITE_PROPERTIES = new Set([
@@ -10,7 +11,7 @@ const NON_NEGATIVE_PROPERTIES = new Set([
   "width", "height", "radius", "strokeWidth", "fontSize", "gap"
 ]);
 const STRING_PROPERTIES = new Set([
-  "background", "fill", "stroke", "fontFamily", "text", "textAlign",
+  "background", "stroke", "fontFamily", "text", "textAlign",
   "textBaseline"
 ]);
 const TEXT_ALIGNS = new Set(["left", "right", "center", "start", "end"]);
@@ -19,6 +20,15 @@ const TEXT_BASELINES = new Set([
 ]);
 
 export function validateConcreteGraphicValue(type, property, value) {
+  if (property === "fill") {
+    if (typeof value === "string") {
+      validateFillPaint(value, `${type}.fill`);
+    } else if (type === "rect" || type === "path") {
+      validateFillPaint(value, `${type}.fill`);
+    } else {
+      throw new TypeError(`${type}.fill must be a non-empty string.`);
+    }
+  }
   if (FINITE_PROPERTIES.has(property) && !Number.isFinite(value)) {
     throw new TypeError(`${type}.${property} must be a finite number.`);
   }

package/src/grammar/schemas/graphicBounds.js

@@ -1,4 +1,4 @@
-import { measureTextWidth } from "../../core/textMetrics.js";
+import { resolveTextBounds } from "../../core/textMetrics.js";
 import { findGraphic, requireGraphic } from "./graphicTree.js";
 
 function unionBounds(bounds) {
@@ -74,6 +74,17 @@ function pathPoints(commands) {
   return points;
 }
 
+export function resolvePathCommandBounds(commands) {
+  const points = pathPoints(commands);
+  if (points.length === 0) return undefined;
+  return {
+    left: Math.min(...points.map(point => point.x)),
+    right: Math.max(...points.map(point => point.x)),
+    top: Math.min(...points.map(point => point.y)),
+    bottom: Math.max(...points.map(point => point.y))
+  };
+}
+
 function primitiveBounds(type, properties = {}) {
   const strokeExtent = (properties.strokeWidth ?? 0) / 2;
   if (type === "circle") {
@@ -115,47 +126,18 @@ function primitiveBounds(type, properties = {}) {
       !Number.isFinite(properties.fontSize) ||
       typeof properties.text !== "string"
     ) return undefined;
-    const width = measureTextWidth(properties.text, properties);
-    const align = properties.textAlign ?? "left";
-    const left = align === "center" ? -width / 2 :
-      ["right", "end"].includes(align) ? -width : 0;
-    const baseline = properties.textBaseline ?? "alphabetic";
-    const [top, bottom] = baseline === "middle"
-      ? [-properties.fontSize / 2, properties.fontSize / 2]
-      : ["top", "hanging"].includes(baseline)
-        ? [0, properties.fontSize]
-        : ["bottom", "ideographic"].includes(baseline)
-          ? [-properties.fontSize, 0]
-          : [-properties.fontSize * 0.8, properties.fontSize * 0.2];
-    const rotation = properties.rotation ?? 0;
-    const cosine = Math.cos(rotation);
-    const sine = Math.sin(rotation);
-    const corners = [
-      [left, top],
-      [left + width, top],
-      [left + width, bottom],
-      [left, bottom]
-    ].map(([x, y]) => ({
-      x: properties.x + x * cosine - y * sine,
-      y: properties.y + x * sine + y * cosine
-    }));
-    return {
-      left: Math.min(...corners.map(point => point.x)),
-      right: Math.max(...corners.map(point => point.x)),
-      top: Math.min(...corners.map(point => point.y)),
-      bottom: Math.max(...corners.map(point => point.y))
-    };
+    return resolveTextBounds(properties);
   }
   if (type === "path") {
     const commands = properties.commands;
     if (!Array.isArray(commands)) return undefined;
-    const points = pathPoints(commands);
-    if (points.length === 0) return undefined;
+    const bounds = resolvePathCommandBounds(commands);
+    if (bounds === undefined) return undefined;
     return {
-      left: Math.min(...points.map(point => point.x)) - strokeExtent,
-      right: Math.max(...points.map(point => point.x)) + strokeExtent,
-      top: Math.min(...points.map(point => point.y)) - strokeExtent,
-      bottom: Math.max(...points.map(point => point.y)) + strokeExtent
+      left: bounds.left - strokeExtent,
+      right: bounds.right + strokeExtent,
+      top: bounds.top - strokeExtent,
+      bottom: bounds.bottom + strokeExtent
     };
   }
   return undefined;

package/src/grammar/schemas/semanticPath.js

@@ -6,7 +6,7 @@ import {
 } from "../../core/vocabulary.js";
 
 const ENCODING_PATHS = Object.freeze([
-  ...ENCODING_CHANNELS.flatMap(channel => [
+  ...ENCODING_CHANNELS.filter(channel => channel !== "pathOrder").flatMap(channel => [
     `encoding.${channel}.field`,
     `encoding.${channel}.datum`,
     `encoding.${channel}.fieldType`,
@@ -20,8 +20,15 @@ const ENCODING_PATHS = Object.freeze([
   "encoding.x.bin.boundaries",
   "encoding.color.layout",
   "encoding.color.aggregate",
+  "encoding.pathOrder.field",
+  "encoding.pathOrder.fieldType",
+  "encoding.pathOrder.order",
   "encoding.theta.aggregate",
+  "encoding.theta.weight",
   "encoding.text.format",
+  "encoding.parallel.dimensions",
+  "encoding.parallel.key",
+  "encoding.parallel.missing",
   ...CARTESIAN_POSITION_CHANNELS.flatMap(channel => [
     `encoding.${channel}.aggregate`,
     `encoding.${channel}.stack`
@@ -36,7 +43,8 @@ const ENTITY_PATHS = Object.freeze({
   layer: {
     collection: "layers",
     removableContainers: new Set(
-      ENCODING_CHANNELS.map(channel => `encoding.${channel}`)
+      [...ENCODING_CHANNELS.map(channel => `encoding.${channel}`),
+        "encoding.parallel"]
     ),
     properties: new Set([
       "data",
@@ -74,10 +82,15 @@ const GUIDE_PATHS = new Set([
   "axis.radius.scale",
   "axis.radius.coordinate",
   "axis.radius.title",
+  "axis.parallel.target",
+  "axis.parallel.coordinate",
+  "axis.parallel.scales",
   "legend.color.scale",
   "legend.color.title",
   "legend.size.scale",
   "legend.size.title",
+  "legend.strokeWidth.scale",
+  "legend.strokeWidth.title",
   "legend.opacity.scale",
   "legend.opacity.title",
   "legend.series.channels",
@@ -98,12 +111,14 @@ const GUIDE_REMOVABLE_CONTAINERS = new Set([
   "axis.y",
   "axis.theta",
   "axis.radius",
+  "axis.parallel",
   "grid.horizontal",
   "grid.vertical",
   "grid.theta",
   "grid.radial",
   "legend.color",
   "legend.size",
+  "legend.strokeWidth",
   "legend.opacity",
   "legend.series"
 ]);