ggaction 0.0.4 → 0.0.5

package/src/actions/primitives/semanticValidation/scale.js

@@ -0,0 +1,74 @@
+import {
+  validateContinuousColorInterpolation,
+  validateScalePropertyForType,
+  validateSemanticScaleDomain,
+  validateSemanticScaleRange,
+  validateSemanticScaleType
+} from "../../../grammar/scales/index.js";
+import { findSemanticScale } from "../../../selectors/scales.js";
+
+function validateOwnedProperty(existing, property) {
+  if (existing?.type !== undefined) {
+    validateScalePropertyForType(existing.type, property);
+  }
+}
+
+export function validateScaleSemanticValue(program, parsed, value) {
+  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);
+    }
+    return;
+  }
+  if (property === "domain") return validateSemanticScaleDomain(value);
+  if (property === "range") return validateSemanticScaleRange(value);
+  if (["nice", "zero", "clamp", "reverse"].includes(property)) {
+    if (typeof value !== "boolean") {
+      throw new TypeError(`Scale ${property} must be a boolean.`);
+    }
+    if (property !== "reverse") validateOwnedProperty(existing, property);
+    return;
+  }
+  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.");
+    }
+    validateOwnedProperty(existing, property);
+    return;
+  }
+  if (property === "interpolate") {
+    validateContinuousColorInterpolation(value);
+    return;
+  }
+  if (property === "paddingInner") {
+    if (!Number.isFinite(value) || value < 0 || value >= 1) {
+      throw new RangeError(
+        "Scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
+      );
+    }
+    validateOwnedProperty(existing, property);
+    return;
+  }
+  if (property === "paddingOuter" || property === "padding") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new RangeError(`Scale ${property} must be a non-negative finite number.`);
+    }
+    validateOwnedProperty(existing, property);
+    return;
+  }
+  if (property === "align") {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+      throw new RangeError("Scale align must be between 0 and 1.");
+    }
+    validateOwnedProperty(existing, property);
+  }
+}

package/src/actions/primitives/semanticValidation/shared.js

@@ -0,0 +1,5 @@
+export function validateNonEmptySemanticString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+}

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,7 +9,8 @@ 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";
 
 const OPTIONS = Object.freeze([
@@ -117,14 +118,6 @@ 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 removeBand(program, id) {
   return program
     .editSemantic({ property: `layer[${id}]`, remove: true })
@@ -165,9 +158,20 @@ export const editRegression = action(
         : hadBand || bandPatch !== undefined || current.parameters.method === "loess");
     let dataId = current.dataId;
     let next = this;
+    const revision = changesStatistics
+      ? planDerivedDataRevision(this, {
+          owner: owner.id,
+          role: "RegressionData",
+          previous: current.dataId,
+          consumers: [
+            current.lineId,
+            ...(hadBand ? [current.bandId] : [])
+          ]
+        })
+      : undefined;
 
     if (changesStatistics) {
-      dataId = nextRevisionId(this, owner.id);
+      dataId = revision.id;
       next = next.createRegressionData({
         id: dataId,
         source: current.source,
@@ -176,6 +180,9 @@ export const editRegression = action(
         ...(current.groupBy === undefined ? {} : { groupBy: current.groupBy }),
         ...parameters
       });
+      for (const rebind of revision.rebinds) {
+        next = next.rebindLayerData(rebind);
+      }
     }
 
     let bandId = current.bandId;
@@ -198,21 +205,12 @@ export const editRegression = action(
       });
     } else if (hadBand && changesStatistics) {
       const bandConfig = next.markConfigs[bandId];
-      next = next
-        .editSemantic({ property: `layer[${bandId}].data`, value: dataId })
-        ._withMarkConfig(bandId, {
+      next = next._withMarkConfig(bandId, {
           ...bandConfig,
           errorBand: { ...bandConfig.errorBand, data: dataId }
         });
     }
 
-    if (changesStatistics) {
-      next = next.editSemantic({
-        property: `layer[${current.lineId}].data`,
-        value: dataId
-      });
-    }
-
     if (bandId !== undefined) {
       if (
         bandPatch !== undefined &&
@@ -232,7 +230,7 @@ export const editRegression = action(
     }
 
     if (changesStatistics) {
-      next = next.releaseDerivedData({ id: current.dataId });
+      next = next.releaseDerivedData(revision.release);
     }
     return next._withMarkConfig(owner.id, {
       ...next.markConfigs[owner.id],

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) {

package/src/actions/scales/definitions.js

@@ -13,6 +13,7 @@ import {
   validateShapeRange,
   validateSizeRange,
   validateStrokeDashRange,
+  validateStrokeWidthRange,
   validateSequentialColorRange,
   validateDiscretizedColorDomain,
   validateDiscretizedColorRange,
@@ -314,6 +315,35 @@ export function resolveOpacityScaleDefinition(program, options) {
   return withScaleUnknown(scale, { ...existing, ...options }, "opacity");
 }
 
+export function resolveStrokeWidthScaleDefinition(program, options) {
+  optionsObject(options);
+  validateKeys(options, OPACITY_OPTIONS, "scale");
+  const id = validateUserId(options.id ?? "strokeWidth", "Scale id");
+  const existing = findSemanticScale(program, id);
+  const type = options.type ?? existing?.type ?? "linear";
+  validateScaleTypeForRole(type, SCALE_ROLES.quantitativePosition);
+  for (const property of ["nice", "zero", "clamp", "reverse"]) {
+    if (options[property] !== undefined && typeof options[property] !== "boolean") {
+      throw new TypeError(`Scale ${property} must be a boolean.`);
+    }
+  }
+  const domain = validateScaleDomain(options.domain ?? existing?.domain ?? "auto");
+  if (domain !== "auto" && domain.some(value => value < 0)) {
+    throw new RangeError("StrokeWidth scale domain cannot contain negative values.");
+  }
+  const scale = {
+    id,
+    type,
+    domain,
+    range: validateStrokeWidthRange(options.range ?? existing?.range ?? "auto")
+  };
+  for (const property of ["nice", "zero", "clamp", "reverse", "base", "exponent", "constant"]) {
+    const value = options[property] ?? existing?.[property];
+    if (value !== undefined) scale[property] = value;
+  }
+  return scale;
+}
+
 export function resolveOffsetScaleDefinition(program, options, channel = "xOffset") {
   optionsObject(options);
   validateKeys(options, [...BASE_OPTIONS, "unknown"], "scale");