ggaction 0.0.4 → 0.0.6

package/src/actions/primitives/semanticValue.js

@@ -1,204 +1 @@
-import { validateUserId } from "../../core/identifiers.js";
-import { isPlainObject } from "../../core/immutable.js";
-import {
-  COLOR_LAYOUTS,
-  STACK_MODES,
-  CATEGORICAL_LEGEND_CHANNELS,
-  MARK_TYPES
-} from "../../core/vocabulary.js";
-import { validateAggregate } from "../../grammar/aggregate.js";
-import { findLayer, findSemanticScale, hasDataset } from "../../selectors/index.js";
-import { validateCoordinateType } from "../../grammar/coordinates.js";
-import {
-  normalizeHistogramBin,
-  validateHistogramBinBoundaries,
-  validateHistogramBinStep
-} from "../../grammar/histogram.js";
-import { validateDatasetTransforms } from "../../grammar/transforms.js";
-import {
-  validateSemanticFieldType,
-  validateContinuousColorInterpolation,
-  validateScalePropertyForType,
-  validateSemanticScaleDomain,
-  validateSemanticScaleRange,
-  validateSemanticScaleType
-} from "../../grammar/scales/index.js";
-
-function nonEmptyString(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-}
-
-function validateLegend(property, value) {
-  if (property === "title") {
-    nonEmptyString(value, "Legend title");
-    return;
-  }
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new TypeError(`Legend ${property} must be a non-empty array.`);
-  }
-  if (new Set(value).size !== value.length) {
-    throw new Error(`Legend ${property} must not contain duplicates.`);
-  }
-  if (property === "channels") {
-    if (!value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
-      throw new Error("Legend channels support only color, strokeDash, and shape.");
-    }
-    return;
-  }
-  for (const id of value) validateUserId(id, "Legend scale id");
-}
-
-export function validateSemanticValue(program, parsed, value) {
-  if (parsed.kind === "dataset" && parsed.path[0] === "values") {
-    if (!Array.isArray(value) || !value.every(isPlainObject)) {
-      throw new TypeError("Dataset values must be an array of plain row objects.");
-    }
-  }
-  if (parsed.kind === "dataset" && parsed.path[0] === "source") {
-    validateUserId(value, "Dataset source id");
-    if (!hasDataset(program, value)) {
-      throw new Error(`Unknown source dataset "${value}".`);
-    }
-  }
-  if (parsed.kind === "dataset" && parsed.path[0] === "transform") {
-    validateDatasetTransforms(value);
-  }
-  if (
-    parsed.kind === "layer" &&
-    parsed.path.join(".") === "mark.type" &&
-    !MARK_TYPES.includes(value)
-  ) {
-    throw new Error(`Unknown mark type "${value}".`);
-  }
-  if (parsed.kind === "layer") {
-    const property = parsed.path.join(".");
-    if (property === "source") {
-      validateUserId(value, "Layer source id");
-      if (value === parsed.id) {
-        throw new Error("A layer cannot use itself as its source.");
-      }
-      const source = findLayer(program, value);
-      if (source === undefined) {
-        throw new Error(`Unknown source layer "${value}".`);
-      }
-      if (!["point", "bar", "rule", "rect"].includes(source.mark?.type)) {
-        throw new Error(
-          `Layer source "${value}" must be a point, bar, rule, or rect mark.`
-        );
-      }
-    }
-    if (property.endsWith(".title")) {
-      nonEmptyString(value, "Encoding title");
-    }
-    if (property.endsWith(".fieldType")) validateSemanticFieldType(value);
-    if (property.endsWith(".aggregate")) validateAggregate(value);
-    if (property.endsWith(".bin.maxBins")) normalizeHistogramBin({ maxBins: value });
-    if (property.endsWith(".bin.step")) validateHistogramBinStep(value);
-    if (property.endsWith(".bin.boundaries")) {
-      validateHistogramBinBoundaries(value);
-    }
-    if (
-      property.endsWith(".stack") &&
-      value !== null &&
-      !STACK_MODES.includes(value)
-    ) {
-      throw new Error(`Unsupported stack "${value}".`);
-    }
-    if (
-      property === "encoding.color.layout" &&
-      !COLOR_LAYOUTS.includes(value)
-    ) {
-      throw new Error(`Unsupported color layout "${value}".`);
-    }
-  }
-  if (parsed.kind === "scale") {
-    const property = parsed.path.join(".");
-    const existing = findSemanticScale(program, parsed.id);
-    if (property === "type") {
-      validateSemanticScaleType(value);
-      for (const owned of [
-        "nice", "zero", "clamp", "base", "exponent", "constant",
-        "paddingInner", "paddingOuter", "padding", "align"
-      ]) {
-        if (existing?.[owned] !== undefined) {
-          validateScalePropertyForType(value, owned);
-        }
-      }
-    } else if (property === "domain") validateSemanticScaleDomain(value);
-    else if (property === "range") validateSemanticScaleRange(value);
-    else if (property === "nice") {
-      if (typeof value !== "boolean") throw new TypeError("Scale nice must be a boolean.");
-      if (existing?.type !== undefined) {
-        validateScalePropertyForType(existing.type, "nice");
-      }
-    } else if (property === "zero") {
-      if (typeof value !== "boolean") throw new TypeError("Scale zero must be a boolean.");
-      if (existing?.type !== undefined) {
-        validateScalePropertyForType(existing.type, "zero");
-      }
-    } else if (property === "clamp") {
-      if (typeof value !== "boolean") throw new TypeError("Scale clamp must be a boolean.");
-      if (existing?.type !== undefined) {
-        validateScalePropertyForType(existing.type, "clamp");
-      }
-    } else if (property === "reverse") {
-      if (typeof value !== "boolean") throw new TypeError("Scale reverse must be a boolean.");
-    } else if (["base", "exponent", "constant"].includes(property)) {
-      if (!Number.isFinite(value) || value <= 0) {
-        throw new RangeError(`Scale ${property} must be a positive finite number.`);
-      }
-      if (property === "base" && value === 1) {
-        throw new RangeError("Scale base must not equal 1.");
-      }
-      if (existing?.type !== undefined) {
-        validateScalePropertyForType(existing.type, property);
-      }
-    } else if (property === "interpolate") {
-      validateContinuousColorInterpolation(value);
-    } else if (property === "paddingInner") {
-      if (!Number.isFinite(value) || value < 0 || value >= 1) {
-        throw new RangeError(
-          "Scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
-        );
-      }
-      if (existing?.type !== undefined) {
-        validateScalePropertyForType(existing.type, property);
-      }
-    } else if (property === "paddingOuter" || property === "padding") {
-      if (!Number.isFinite(value) || value < 0) {
-        throw new RangeError(`Scale ${property} must be a non-negative finite number.`);
-      }
-      if (existing?.type !== undefined) {
-        validateScalePropertyForType(existing.type, property);
-      }
-    } else if (property === "align") {
-      if (!Number.isFinite(value) || value < 0 || value > 1) {
-        throw new RangeError("Scale align must be between 0 and 1.");
-      }
-      if (existing?.type !== undefined) {
-        validateScalePropertyForType(existing.type, property);
-      }
-    }
-  }
-  if (parsed.kind === "coordinate" && parsed.path[0] === "type") {
-    validateCoordinateType(value);
-  }
-  if (parsed.kind === "guide" && parsed.id === "legend.series") {
-    validateLegend(parsed.path.at(-1), value);
-  }
-  if (parsed.kind === "guide" && (
-    parsed.id.startsWith("grid.") || parsed.id.startsWith("axis.")
-  )) {
-    const property = parsed.path.at(-1);
-    if (property === "title") nonEmptyString(value, "Axis title");
-    else {
-      const guideKind = parsed.id.startsWith("grid.") ? "Grid" : "Axis";
-      validateUserId(value, `${guideKind} ${property} id`);
-    }
-  }
-  if (parsed.kind === "title") {
-    nonEmptyString(value, `Chart title ${parsed.path[0]}`);
-  }
-}
+export { validateSemanticValue } from "./semanticValidation/index.js";

package/src/actions/regression/edit.js

@@ -9,14 +9,15 @@ import {
 } from "../../core/validation.js";
 import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
-import { hasDataset } from "../../selectors/index.js";
+import { planDerivedDataRevision } from
+  "../../materialization/dataProvenance.js";
 import { findLayer } from "../../selectors/layers.js";
+import { removeLegendKinds } from "../guides/legends/remove.js";
+import { requireRegressionField } from "./resolve.js";
 
 const OPTIONS = Object.freeze([
-  "target", "method", "degree", "span", "confidence", "interval", "band", "line"
-]);
-const STATISTICAL_OPTIONS = Object.freeze([
-  "method", "degree", "span", "confidence", "interval"
+  "target", "data", "x", "y", "groupBy", "method", "degree", "span",
+  "confidence", "interval", "band", "line"
 ]);
 const BAND_OPTIONS = Object.freeze([
   "color", "opacity", "stroke", "strokeWidth", "curve"
@@ -117,19 +118,137 @@ function resolveParameters(previous, args) {
   return normalizeRegressionParameters(raw);
 }
 
-function nextRevisionId(program, ownerId) {
-  let revision = 1;
-  while (hasDataset(program, `${ownerId}RegressionDataRevision${revision}`)) {
-    revision += 1;
-  }
-  return `${ownerId}RegressionDataRevision${revision}`;
+function removeOwnedColorLegends(program, target) {
+  const kinds = Object.entries(program.guideConfigs.legend ?? {})
+    .filter(([kind, config]) =>
+      config?.target === target &&
+      (
+        config.channels?.includes("color") ||
+        ["gradient", "interval"].includes(kind)
+      )
+    )
+    .map(([kind]) => kind);
+  return kinds.length === 0 ? program : removeLegendKinds(program, kinds);
 }
 
 function removeBand(program, id) {
-  return program
+  const selectionIds = Object.entries(
+    program.materializationConfigs.selections ?? {}
+  ).filter(([, config]) => config.target === id).map(([selection]) => selection);
+  let next = program;
+  for (const [highlight, config] of Object.entries(
+    program.materializationConfigs.highlights ?? {}
+  )) {
+    if (config.target === id || selectionIds.includes(config.selection)) {
+      next = next._withoutMaterializationConfig(["highlights", highlight]);
+    }
+  }
+  for (const selection of selectionIds) {
+    next = next._withoutMaterializationConfig(["selections", selection]);
+  }
+  return next
     .editSemantic({ property: `layer[${id}]`, remove: true })
     .editGraphics({ target: id, remove: true })
-    ._withoutMaterializationConfig(["marks", id]);
+    ._withoutMaterializationConfig(["marks", id])
+    ._withContext({
+      ...(program.context.currentMark === id ? { currentMark: undefined } : {}),
+      ...(selectionIds.includes(program.context.currentSelection)
+        ? { currentSelection: undefined }
+        : {})
+    });
+}
+
+function regressionColorScale(owner, current, groupBy) {
+  if (groupBy === undefined || groupBy === current.groupBy) {
+    return current.colorScale;
+  }
+  return owner.encoding?.color?.field === groupBy
+    ? owner.encoding.color.scale
+    : `${owner.id}RegressionColor`;
+}
+
+function updateRegressionLineSemantics(program, current, {
+  x,
+  y,
+  groupBy,
+  colorScale
+}) {
+  let next = program
+    .editSemantic({
+      property: `layer[${current.lineId}].encoding.x.field`,
+      value: x
+    })
+    .editSemantic({
+      property: `layer[${current.lineId}].encoding.y.field`,
+      value: y
+    });
+  if (groupBy === undefined) {
+    if (findLayer(next, current.lineId).encoding?.group !== undefined) {
+      next = next.editSemantic({
+        property: `layer[${current.lineId}].encoding.group`,
+        remove: true
+      });
+    }
+    if (findLayer(next, current.lineId).encoding?.color !== undefined) {
+      next = next.editSemantic({
+        property: `layer[${current.lineId}].encoding.color`,
+        remove: true
+      });
+      next = removeOwnedColorLegends(next, current.lineId);
+    }
+    return next;
+  }
+  next = findLayer(next, current.lineId).encoding?.group === undefined
+    ? next.encodeGroup({ target: current.lineId, field: groupBy })
+    : next.editSemantic({
+        property: `layer[${current.lineId}].encoding.group.field`,
+        value: groupBy
+      });
+  const color = findLayer(next, current.lineId).encoding?.color;
+  if (color === undefined || color.scale !== colorScale) {
+    next = next.encodeColor({
+      target: current.lineId,
+      field: groupBy,
+      scale: { id: colorScale }
+    });
+  } else {
+    next = next.editSemantic({
+      property: `layer[${current.lineId}].encoding.color.field`,
+      value: groupBy
+    });
+  }
+  return next;
+}
+
+function updateRegressionBandSemantics(program, bandId, { x, groupBy }) {
+  if (bandId === undefined) return program;
+  let next = program.editSemantic({
+    property: `layer[${bandId}].encoding.x.field`,
+    value: x
+  });
+  const layer = findLayer(next, bandId);
+  if (groupBy === undefined && layer.encoding?.group !== undefined) {
+    next = next.editSemantic({
+      property: `layer[${bandId}].encoding.group`,
+      remove: true
+    });
+  } else if (groupBy !== undefined) {
+    next = layer.encoding?.group === undefined
+      ? next.encodeGroup({ target: bandId, field: groupBy })
+      : next.editSemantic({
+          property: `layer[${bandId}].encoding.group.field`,
+          value: groupBy
+        });
+  }
+  const config = next.markConfigs[bandId];
+  return next._withMarkConfig(bandId, {
+    ...config,
+    errorBand: {
+      ...config.errorBand,
+      position: { ...config.errorBand.position, field: x },
+      groupBy
+    }
+  });
 }
 
 export const editRegression = action(
@@ -144,10 +263,27 @@ export const editRegression = action(
     }
     const owner = resolveRegressionOwner(this, args.target);
     const current = this.markConfigs[owner.id].regression;
+    const source = Object.hasOwn(args, "data")
+      ? validateUserId(args.data, "Regression data id")
+      : current.source;
+    const x = Object.hasOwn(args, "x")
+      ? requireRegressionField(args.x, "Regression x")
+      : current.x;
+    const y = Object.hasOwn(args, "y")
+      ? requireRegressionField(args.y, "Regression y")
+      : current.y;
+    const groupBy = Object.hasOwn(args, "groupBy")
+      ? args.groupBy === false
+        ? undefined
+        : requireRegressionField(args.groupBy, "Regression groupBy")
+      : current.groupBy;
+    const colorScale = regressionColorScale(owner, current, groupBy);
     const parameters = resolveParameters(current.parameters, args);
-    const changesStatistics = STATISTICAL_OPTIONS.some(
-      key => Object.hasOwn(args, key)
-    ) && JSON.stringify(parameters) !== JSON.stringify(current.parameters);
+    const changesProvenance = source !== current.source ||
+      x !== current.x || y !== current.y || groupBy !== current.groupBy;
+    const changesParameters = JSON.stringify(parameters) !==
+      JSON.stringify(current.parameters);
+    const changesStatistics = changesProvenance || changesParameters;
     const bandPatch = Object.hasOwn(args, "band")
       ? validateBandPatch(args.band)
       : undefined;
@@ -163,85 +299,108 @@ export const editRegression = action(
       (bandPatch === false
         ? false
         : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
-    let dataId = current.dataId;
-    let next = this;
-
-    if (changesStatistics) {
-      dataId = nextRevisionId(this, owner.id);
-      next = next.createRegressionData({
-        id: dataId,
-        source: current.source,
-        x: current.x,
-        y: current.y,
-        ...(current.groupBy === undefined ? {} : { groupBy: current.groupBy }),
-        ...parameters
-      });
-    }
+    const revision = changesStatistics
+      ? planDerivedDataRevision(this, {
+          owner: owner.id,
+          role: "RegressionData",
+          previous: current.dataId,
+          consumers: [
+            current.lineId,
+            ...(hadBand ? [current.bandId] : [])
+          ]
+        })
+      : undefined;
 
-    let bandId = current.bandId;
-    if (hadBand && !wantsBand) {
-      next = removeBand(next, current.bandId);
-      bandId = undefined;
-    } else if (!hadBand && wantsBand) {
-      bandId = `${owner.id}RegressionBands`;
-      next = next.createRegressionBand({
-        id: bandId,
-        data: dataId,
-        x: current.x,
-        lower: "__regression_ci_lower",
-        upper: "__regression_ci_upper",
-        ...(current.groupBy === undefined ? {} : { groupBy: current.groupBy }),
-        coordinate: current.coordinate,
-        xScale: current.xScale,
-        yScale: current.yScale,
-        ...(bandPatch === undefined || bandPatch === false ? {} : bandPatch)
-      });
-    } else if (hadBand && changesStatistics) {
-      const bandConfig = next.markConfigs[bandId];
-      next = next
-        .editSemantic({ property: `layer[${bandId}].data`, value: dataId })
-        ._withMarkConfig(bandId, {
-          ...bandConfig,
-          errorBand: { ...bandConfig.errorBand, data: dataId }
+    const applyEdit = program => {
+      let dataId = current.dataId;
+      let next = program;
+      if (changesStatistics) {
+        dataId = revision.id;
+        next = next.createRegressionData({
+          id: dataId,
+          source,
+          x,
+          y,
+          ...(groupBy === undefined ? {} : { groupBy }),
+          ...parameters
         });
-    }
+        for (const rebind of revision.rebinds) {
+          next = next.rebindLayerData(rebind);
+        }
+      }
 
-    if (changesStatistics) {
-      next = next.editSemantic({
-        property: `layer[${current.lineId}].data`,
-        value: dataId
-      });
-    }
+      let bandId = current.bandId;
+      if (hadBand && !wantsBand) {
+        next = removeBand(next, current.bandId);
+        bandId = undefined;
+      } else if (!hadBand && wantsBand) {
+        bandId = `${owner.id}RegressionBands`;
+        next = next.createRegressionBand({
+          id: bandId,
+          data: dataId,
+          x,
+          lower: "__regression_ci_lower",
+          upper: "__regression_ci_upper",
+          ...(groupBy === undefined ? {} : { groupBy }),
+          coordinate: current.coordinate,
+          xScale: current.xScale,
+          yScale: current.yScale,
+          ...(bandPatch === undefined || bandPatch === false ? {} : bandPatch)
+        });
+      } else if (hadBand && changesStatistics) {
+        const bandConfig = next.markConfigs[bandId];
+        next = next._withMarkConfig(bandId, {
+            ...bandConfig,
+            errorBand: { ...bandConfig.errorBand, data: dataId }
+          });
+      }
 
-    if (bandId !== undefined) {
-      if (
-        bandPatch !== undefined &&
-        bandPatch !== false &&
-        Object.keys(bandPatch).length > 0 &&
-        hadBand
-      ) {
-        next = next.editRegressionBand({ target: bandId, ...bandPatch });
+      if (changesProvenance) {
+        next = updateRegressionLineSemantics(next, current, {
+          x,
+          y,
+          groupBy,
+          colorScale
+        });
+        next = updateRegressionBandSemantics(next, bandId, { x, groupBy });
+      }
+      if (bandId !== undefined) {
+        if (
+          bandPatch !== undefined &&
+          bandPatch !== false &&
+          Object.keys(bandPatch).length > 0 &&
+          hadBand
+        ) {
+          next = next.editRegressionBand({ target: bandId, ...bandPatch });
+        } else if (changesStatistics) {
+          next = next.rematerializeAreaMark({ id: bandId });
+        }
+      }
+      if (linePatch !== undefined && Object.keys(linePatch).length > 0) {
+        next = next.editRegressionLine({ target: current.lineId, ...linePatch });
       } else if (changesStatistics) {
-        next = next.rematerializeAreaMark({ id: bandId });
+        next = next.rematerializeLineMark({ id: current.lineId });
       }
-    }
-    if (linePatch !== undefined && Object.keys(linePatch).length > 0) {
-      next = next.editRegressionLine({ target: current.lineId, ...linePatch });
-    } else if (changesStatistics) {
-      next = next.rematerializeLineMark({ id: current.lineId });
-    }
 
-    if (changesStatistics) {
-      next = next.releaseDerivedData({ id: current.dataId });
-    }
-    return next._withMarkConfig(owner.id, {
-      ...next.markConfigs[owner.id],
-      regression: {
-        ...current,
-        dataId,
-        bandId,
-        parameters
+      if (changesStatistics) {
+        next = next.releaseDerivedData(revision.release);
       }
-    });
+      return next._withMarkConfig(owner.id, {
+        ...next.markConfigs[owner.id],
+        regression: {
+          ...current,
+          source,
+          x,
+          y,
+          groupBy,
+          colorScale,
+          dataId,
+          bandId,
+          parameters
+        }
+      });
+    };
+    if (changesStatistics || hadBand !== wantsBand) applyEdit(this);
+    return applyEdit(this);
   }
 );

package/src/actions/scales/consumers/common.js

@@ -19,6 +19,16 @@ export function findScaleConsumers(program, id) {
       const encoding = layer.encoding?.[channel];
       if (encoding?.scale === id) consumers.push({ layer, channel, encoding });
     }
+    for (const dimension of layer.encoding?.parallel?.dimensions ?? []) {
+      if (dimension.scale === id) {
+        consumers.push({
+          layer,
+          channel: "y",
+          encoding: dimension,
+          role: "parallelDimension"
+        });
+      }
+    }
   }
   return consumers;
 }
@@ -46,6 +56,14 @@ export function readConsumerFieldValues(
   scale = findScale(program, consumer.encoding.scale)
 ) {
   const allowUnknown = Object.hasOwn(scale, "unknown");
+  if (consumer.role === "parallelDimension") {
+    return readScaleField(
+      dataset.values,
+      consumer.encoding.field,
+      consumer.encoding.fieldType,
+      { allowUnknown: true }
+    );
+  }
   if (isDirectCategoricalConsumer(consumer)) {
     return allowUnknown
       ? readScaleField(

package/src/actions/scales/consumers/families.js

@@ -3,7 +3,10 @@ import {
   BAR_GRAINS,
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
-import { deriveLineSeries } from "../../../grammar/lineSeries.js";
+import {
+  deriveLineSeries,
+  deriveLineSeriesFieldValues
+} from "../../../grammar/lineSeries.js";
 import { isAggregate } from "../../../grammar/aggregate.js";
 import {
   resolveRectConsumerValues
@@ -22,12 +25,20 @@ export function resolveMarkFamilyConsumerValues(consumer, dataset) {
   }
   if (
     consumer.layer.mark?.type === "line" &&
-    isAggregate(consumer.layer.encoding?.y?.aggregate)
+    (isAggregate(consumer.layer.encoding?.y?.aggregate) ||
+      consumer.channel === "strokeWidth")
   ) {
     const derived = deriveLineSeries(dataset.values, consumer.layer);
     return {
       matched: true,
-      values: consumer.channel === "x" ? derived.xValues : derived.yValues
+      values: consumer.channel === "strokeWidth"
+        ? deriveLineSeriesFieldValues(
+            dataset.values,
+            consumer.layer,
+            derived,
+            consumer.encoding.field
+          )
+        : consumer.channel === "x" ? derived.xValues : derived.yValues
     };
   }
   if (resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate) {