ggaction 0.0.3 → 0.0.5

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.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/components.js

@@ -7,7 +7,7 @@ import { resolveEligibleLayer } from "../../selectors/layers.js";
 import {
   REGRESSION_LOWER_FIELD,
   REGRESSION_UPPER_FIELD
-} from "../../grammar/regression.js";
+} from "../../grammar/regression/index.js";
 import { validateAreaCreateOutline } from "../marks/area/index.js";
 
 const BAND_OPTIONS = Object.freeze([

package/src/actions/regression/create.js

@@ -1,6 +1,6 @@
 import { action } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression.js";
+import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
 import {
   findRegressionPoint,
   inferRegressionGroup,

package/src/actions/regression/edit.js

@@ -7,9 +7,10 @@ import {
   validateNonNegativeFinite,
   validateUnitInterval
 } from "../../core/validation.js";
-import { normalizeRegressionParameters } from "../../grammar/regression.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

@@ -0,0 +1,109 @@
+import {
+  readNominalField,
+  readQuantitativeField,
+  readScaleField,
+  readTemporalField
+} from "../../../grammar/scales/index.js";
+import { findDataset } from "../../../selectors/datasets.js";
+import { requireSemanticScale } from "../../../selectors/scales.js";
+import { SCALED_ENCODING_CHANNELS } from "../../../core/vocabulary.js";
+
+export function findScale(program, id) {
+  return requireSemanticScale(program, id);
+}
+
+export function findScaleConsumers(program, id) {
+  const consumers = [];
+  for (const layer of program.semanticSpec.layers) {
+    for (const channel of SCALED_ENCODING_CHANNELS) {
+      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;
+}
+
+export function requireConsumerDataset(program, consumer) {
+  const dataset = findDataset(program, consumer.layer.data);
+  if (dataset === undefined) {
+    throw new Error(
+      `Mark "${consumer.layer.id}" references unknown dataset "${consumer.layer.data}".`
+    );
+  }
+  return dataset;
+}
+
+export function isDirectCategoricalConsumer(consumer) {
+  return ["color", "strokeDash", "xOffset", "yOffset", "shape"].includes(
+    consumer.channel
+  ) && consumer.encoding.fieldType === "nominal";
+}
+
+export function readConsumerFieldValues(
+  program,
+  consumer,
+  dataset,
+  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(
+          dataset.values,
+          consumer.encoding.field,
+          consumer.encoding.fieldType,
+          { allowUnknown: true }
+        )
+      : readNominalField(dataset.values, consumer.encoding.field);
+  }
+  if (consumer.encoding.fieldType === "temporal") {
+    return allowUnknown
+      ? readScaleField(dataset.values, consumer.encoding.field, "temporal", {
+          allowUnknown: true
+        })
+      : readTemporalField(dataset.values, consumer.encoding.field);
+  }
+  if (["nominal", "ordinal"].includes(consumer.encoding.fieldType)) {
+    if (!["ordinal", "band", "point"].includes(scale.type)) {
+      throw new Error(
+        `Scale materialization requires a quantitative encoding on mark "${consumer.layer.id}".`
+      );
+    }
+    return allowUnknown
+      ? readScaleField(
+          dataset.values,
+          consumer.encoding.field,
+          consumer.encoding.fieldType,
+          { allowUnknown: true }
+        )
+      : readNominalField(dataset.values, consumer.encoding.field);
+  }
+  if (consumer.encoding.fieldType !== "quantitative") {
+    throw new Error(
+      `Scale materialization requires a quantitative encoding on mark "${consumer.layer.id}".`
+    );
+  }
+  return allowUnknown
+    ? readScaleField(dataset.values, consumer.encoding.field, "quantitative", {
+        allowUnknown: true
+      })
+    : readQuantitativeField(dataset.values, consumer.encoding.field);
+}

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

@@ -0,0 +1,58 @@
+import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
+import {
+  BAR_GRAINS,
+  resolveBarGrain
+} from "../../../grammar/bars/policy.js";
+import {
+  deriveLineSeries,
+  deriveLineSeriesFieldValues
+} from "../../../grammar/lineSeries.js";
+import { isAggregate } from "../../../grammar/aggregate.js";
+import {
+  resolveRectConsumerValues
+} from "../../../materialization/rect.js";
+
+export function resolveMarkFamilyConsumerValues(consumer, dataset) {
+  if (consumer.layer.mark?.type === "rect") {
+    return {
+      matched: true,
+      values: resolveRectConsumerValues(
+        consumer.layer,
+        dataset,
+        consumer.channel
+      )
+    };
+  }
+  if (
+    consumer.layer.mark?.type === "line" &&
+    (isAggregate(consumer.layer.encoding?.y?.aggregate) ||
+      consumer.channel === "strokeWidth")
+  ) {
+    const derived = deriveLineSeries(dataset.values, consumer.layer);
+    return {
+      matched: true,
+      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) {
+    const derived = deriveBarAggregates(dataset.values, consumer.layer);
+    if (consumer.channel === "color") {
+      return {
+        matched: true,
+        values: derived.values.map(value => value.color)
+      };
+    }
+    return {
+      matched: true,
+      values: consumer.channel === "x" ? derived.xValues : derived.yValues
+    };
+  }
+  return { matched: false };
+}

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

@@ -0,0 +1,41 @@
+import { normalizeRuleDatum } from "../../../grammar/rules.js";
+import {
+  findScale,
+  isDirectCategoricalConsumer,
+  readConsumerFieldValues,
+  requireConsumerDataset
+} from "./common.js";
+import { resolveMarkFamilyConsumerValues } from "./families.js";
+
+export { findScale, findScaleConsumers } from "./common.js";
+export {
+  resolveHistogramCountValues,
+  resolveSeriesLayoutScaleValues
+} from "./seriesLayout.js";
+
+export function resolveConsumerValues(program, consumer) {
+  const dataset = requireConsumerDataset(program, consumer);
+  if (Object.hasOwn(consumer.encoding, "datum")) {
+    return [normalizeRuleDatum(
+      consumer.encoding.datum,
+      consumer.encoding.fieldType,
+      consumer.channel
+    )];
+  }
+  if (
+    consumer.channel === "strokeDash" &&
+    !["line", "rule"].includes(consumer.layer.mark?.type)
+  ) {
+    throw new Error(
+      "strokeDash scale materialization requires a line mark or rule mark."
+    );
+  }
+  const scale = findScale(program, consumer.encoding.scale);
+  if (isDirectCategoricalConsumer(consumer)) {
+    return readConsumerFieldValues(program, consumer, dataset, scale);
+  }
+  const family = resolveMarkFamilyConsumerValues(consumer, dataset);
+  return family.matched
+    ? family.values
+    : readConsumerFieldValues(program, consumer, dataset, scale);
+}