ggaction 0.0.3 → 0.0.5

package/src/actions/scales/{consumers.js → consumers/seriesLayout.js}

@@ -1,144 +1,26 @@
-import { deriveBarAggregates } from "../../grammar/bars/aggregate.js";
+import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
 import {
   BAR_GRAINS,
   resolveBarChannels,
   resolveBarColorLayout,
   resolveBarGrain
-} from "../../grammar/bars/policy.js";
+} from "../../../grammar/bars/policy.js";
 import {
   countHistogramBins,
   findHistogramBinIndex,
   resolveHistogramBins
-} from "../../grammar/histogram.js";
-import { deriveDensityAreaSeries } from "../../grammar/areaSeries.js";
-import { deriveLineSeries } from "../../grammar/lineSeries.js";
-import { resolveSeriesLayoutDomainValues } from "../../grammar/seriesLayout.js";
+} from "../../../grammar/histogram.js";
+import { deriveDensityAreaSeries } from "../../../grammar/areaSeries.js";
+import {
+  resolveSeriesLayoutDomainValues
+} from "../../../grammar/seriesLayout.js";
 import {
   readNominalField,
   readQuantitativeField,
-  readScaleField,
-  readTemporalField,
   resolveOrdinalDomain
-} from "../../grammar/scales.js";
-import { findDataset } from "../../selectors/datasets.js";
-import { requireSemanticScale } from "../../selectors/scales.js";
-import { isAggregate } from "../../grammar/aggregate.js";
-import { normalizeRuleDatum } from "../../grammar/rules.js";
-import { SCALED_ENCODING_CHANNELS } from "../../core/vocabulary.js";
-import { resolveRectConsumerValues } from "../../materialization/rect.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 });
-    }
-  }
-  return consumers;
-}
-
-export function resolveConsumerValues(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}".`
-    );
-  }
-
-  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);
-  const allowUnknown = Object.hasOwn(scale, "unknown");
-  if (consumer.layer.mark?.type === "rect") {
-    return resolveRectConsumerValues(
-      consumer.layer,
-      dataset,
-      consumer.channel
-    );
-  }
-
-  if (
-    ["color", "strokeDash", "xOffset", "yOffset", "shape"].includes(consumer.channel) &&
-    consumer.encoding.fieldType === "nominal"
-  ) {
-    return allowUnknown
-      ? readScaleField(
-          dataset.values,
-          consumer.encoding.field,
-          consumer.encoding.fieldType,
-          { allowUnknown: true }
-        )
-      : readNominalField(dataset.values, consumer.encoding.field);
-  }
-
-  if (
-    consumer.layer.mark?.type === "line" &&
-    isAggregate(consumer.layer.encoding?.y?.aggregate)
-  ) {
-    const derived = deriveLineSeries(dataset.values, consumer.layer);
-    return 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 derived.values.map(value => value.color);
-    }
-    return consumer.channel === "x" ? derived.xValues : derived.yValues;
-  }
-
-  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);
-}
+} from "../../../grammar/scales/index.js";
+import { findDataset } from "../../../selectors/datasets.js";
+import { findScale } from "./common.js";
 
 export function resolveHistogramCountValues(program, consumer) {
   const xEncoding = consumer.layer.encoding?.x;
@@ -146,7 +28,6 @@ export function resolveHistogramCountValues(program, consumer) {
     ? undefined
     : findScale(program, xEncoding.scale);
   const dataset = findDataset(program, consumer.layer.data);
-
   if (xEncoding?.bin === undefined || xScale === undefined) {
     throw new Error(
       `Histogram mark "${consumer.layer.id}" requires a binned x scale.`
@@ -157,7 +38,6 @@ export function resolveHistogramCountValues(program, consumer) {
       `Histogram mark "${consumer.layer.id}" requires an existing dataset.`
     );
   }
-
   const xValues = readQuantitativeField(dataset.values, xEncoding.field);
   const bins = resolveHistogramBins({
     values: xValues,
@@ -186,7 +66,6 @@ function resolveHistogramPartitions(program, consumer) {
   if (colorEncoding?.scale === undefined) {
     return countHistogramBins(xValues, bins.boundaries).map(value => [value]);
   }
-
   const colorScale = findScale(program, colorEncoding.scale);
   const colorValues = readNominalField(dataset.values, colorEncoding.field);
   const colorDomain = resolveOrdinalDomain(colorScale.domain, colorValues);
@@ -224,7 +103,6 @@ function resolveAggregatePartitions(program, consumer) {
     ]));
     return categoryDomain.map(value => [byCategory.get(value) ?? 0]);
   }
-
   const colorScale = findScale(program, colorEncoding.scale);
   const colorValues = readNominalField(dataset.values, colorEncoding.field);
   const colorDomain = resolveOrdinalDomain(colorScale.domain, colorValues);

package/src/actions/scales/create.js

@@ -15,7 +15,7 @@ import {
   isContinuousColorScaleType,
   isDiscretizedColorScaleType,
   normalizeScaleDefinition
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 
 const CREATE_SCALE_OPTIONS = Object.freeze([

package/src/actions/scales/definitions.js

@@ -13,6 +13,7 @@ import {
   validateShapeRange,
   validateSizeRange,
   validateStrokeDashRange,
+  validateStrokeWidthRange,
   validateSequentialColorRange,
   validateDiscretizedColorDomain,
   validateDiscretizedColorRange,
@@ -22,12 +23,12 @@ import {
   validateScalePropertyForType,
   validateScaleTypeForRole,
   isDiscretePositionScaleType
-} from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
 import {
   validateRadialRange,
   validateThetaRange
 } from "../../grammar/polar.js";
-import { withScaleUnknown } from "../../grammar/scales.js";
+import { withScaleUnknown } from "../../grammar/scales/index.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 
 const BASE_OPTIONS = Object.freeze(["id", "type", "domain", "range"]);
@@ -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");

package/src/actions/scales/edit.js

@@ -1,32 +1,7 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateOptionObject } from "../../core/validation.js";
-import {
-  isTransformedScaleType,
-  SCALE_ROLES,
-  validateColorRange,
-  validateDiscretizedColorDomain,
-  validateDiscretizedColorRange,
-  validateOrdinalDomain,
-  validateScaleDomain,
-  validateScaleRange,
-  validateScaleType,
-  validateScaleTypeForRole,
-  validateShapeRange,
-  validateSizeRange,
-  validateStrokeDashRange,
-  validateSequentialColorRange,
-  validateScaleUnknown,
-  isDiscretizedColorScaleType,
-  isDiscretePositionScaleType,
-  hasOrdinalDomain,
-  normalizeScaleDefinition
-} from "../../grammar/scales.js";
-import {
-  validateRadialRange,
-  validateThetaRange
-} from "../../grammar/polar.js";
-import { getMarkMaterializationStep } from "../../materialization/marks.js";
+import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
 import {
   applyMaterializationPlan
 } from "../../materialization/dependencies.js";
@@ -34,8 +9,11 @@ import {
   findSemanticScale,
   requireSemanticScale
 } from "../../selectors/scales.js";
-import { findScaleConsumers } from "./consumers.js";
-import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
+import { findScaleConsumers } from "./consumers/index.js";
+import {
+  prepareScaleEdit,
+  resolveScaleConsumerChannel
+} from "./editPolicy.js";
 
 const OPTIONS = Object.freeze([
   "id", "type", "domain", "range", "nice", "zero", "clamp", "reverse",
@@ -67,162 +45,6 @@ function resolveScaleId(program, requested) {
   );
 }
 
-function resolveChannel(consumers, id) {
-  const channels = new Set(
-    consumers.map(consumer => normalizePositionScaleChannel(consumer.channel))
-  );
-  if (channels.size > 1) {
-    throw new Error(`Scale "${id}" cannot be shared across channels.`);
-  }
-  return channels.values().next().value;
-}
-
-function validateRangeForChannel(scale, channel, value) {
-  if (value === "auto") return value;
-  if (channel === "theta") return validateThetaRange(value);
-  if (channel === "radius") return validateRadialRange(value);
-  if (scale.type === "sequential") {
-    return validateSequentialColorRange(value);
-  }
-  if (isDiscretizedColorScaleType(scale.type)) {
-    return validateDiscretizedColorRange(value);
-  }
-  if (scale.type !== "ordinal") return validateScaleRange(value);
-  if (channel === "color") return validateColorRange(value);
-  if (channel === "shape") return validateShapeRange(value);
-  if (channel === "strokeDash") return validateStrokeDashRange(value);
-  if (channel === "size") return validateSizeRange(value);
-  return validateScaleRange(value);
-}
-
-function validateTypeTransition(scale, nextType, channel, consumers) {
-  if (nextType === scale.type) return;
-  validateScaleType(nextType);
-  if (consumers.length === 0) return;
-  if (nextType === "sequential" || isDiscretizedColorScaleType(nextType)) {
-    const discretized = isDiscretizedColorScaleType(nextType);
-    if (channel !== "color" || consumers.some(consumer =>
-      ["nominal", "ordinal"].includes(consumer.encoding.fieldType) ||
-      (discretized && (
-        consumer.encoding.fieldType !== "quantitative" ||
-        consumer.layer.mark?.type !== "point"
-      )) ||
-      (!discretized && !["point", "bar"].includes(consumer.layer.mark?.type))
-    )) {
-      throw new Error(
-        `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
-      );
-    }
-    return;
-  }
-  if (nextType === "time") {
-    if (
-      consumers.length > 0 &&
-      (!["x", "y", "theta"].includes(channel) ||
-        consumers.some(consumer => consumer.encoding.fieldType !== "temporal"))
-    ) {
-      throw new Error(
-        `Scale "${scale.id}" has a consumer incompatible with type "time".`
-      );
-    }
-    return;
-  }
-  const discrete = isDiscretePositionScaleType(nextType);
-  if (discrete) {
-    if (
-      consumers.length > 0 &&
-      (!["x", "y", "theta"].includes(channel) || consumers.some(consumer =>
-        !["nominal", "ordinal"].includes(consumer.encoding.fieldType)
-      ))
-    ) {
-      throw new Error(
-        `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
-      );
-    }
-    if (
-      nextType === "point" &&
-      consumers.some(consumer => consumer.layer.mark?.type === "bar")
-    ) {
-      throw new Error("Point scales cannot provide bar bandwidth.");
-    }
-    return;
-  }
-  const quantitative = nextType === "linear" || isTransformedScaleType(nextType);
-  if (
-    !quantitative ||
-    (consumers.length > 0 && !["x", "y", "theta", "radius"].includes(channel))
-  ) {
-    throw new Error(
-      "editScale type transition currently requires a quantitative position scale."
-    );
-  }
-  validateScaleTypeForRole(nextType, SCALE_ROLES.quantitativePosition);
-  if (channel === "theta" && nextType !== "linear") {
-    throw new Error("Theta quantitative position currently requires a linear scale.");
-  }
-  if (consumers.some(consumer => consumer.encoding.fieldType !== "quantitative")) {
-    throw new Error(
-      `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
-    );
-  }
-}
-
-function validateLegendTypeTransition(program, scale, nextType) {
-  if (nextType === scale.type) return;
-  const legends = program.guideConfigs.legend ?? {};
-  if (
-    legends.gradient?.scale === scale.id &&
-    nextType !== "sequential"
-  ) {
-    throw new Error(
-      `Scale "${scale.id}" cannot change type while its gradient legend is active.`
-    );
-  }
-  if (
-    legends.interval?.scale === scale.id &&
-    !isDiscretizedColorScaleType(nextType)
-  ) {
-    throw new Error(
-      `Scale "${scale.id}" cannot change type while its interval legend is active.`
-    );
-  }
-}
-
-function normalizeDefinition(scale, channel, consumers, args) {
-  const type = args.type ?? scale.type;
-  validateTypeTransition(scale, type, channel, consumers);
-  const definition = normalizeScaleDefinition({
-    type,
-    previous: scale,
-    patch: args,
-    retainCoreOnTypeChange: true,
-    retainCompatibleOnTypeChange: true,
-    validateDomain: (scaleType, value) =>
-      isDiscretizedColorScaleType(scaleType)
-        ? validateDiscretizedColorDomain(scaleType, value)
-        : hasOrdinalDomain(scaleType)
-          ? validateOrdinalDomain(value)
-          : validateScaleDomain(value),
-    validateRange: (scaleType, value) =>
-      validateRangeForChannel({ type: scaleType }, channel, value)
-  });
-  const typeChanged = type !== scale.type;
-  const unknown = Object.hasOwn(args, "unknown")
-    ? args.unknown
-    : typeChanged ? undefined : scale.unknown;
-  if (unknown !== undefined) {
-    if (consumers.some(consumer => consumer.layer.mark?.type !== "point")) {
-      throw new Error(
-        "Scale unknown currently requires row-owned point consumers."
-      );
-    }
-    definition.unknown = consumers.length === 0
-      ? unknown
-      : validateScaleUnknown(channel, unknown);
-  }
-  return definition;
-}
-
 function sameValue(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
@@ -254,31 +76,11 @@ export const editScale = action(
     if (!REQUESTED_CHANGES.some(property => Object.hasOwn(args, property))) {
       throw new Error("editScale requires at least one editable property.");
     }
-    const hasPalette = Object.hasOwn(args, "palette");
-    if (hasPalette && Object.hasOwn(args, "range")) {
-      throw new Error("editScale cannot specify both palette and range.");
-    }
-
     const id = resolveScaleId(this, args.id);
     const scale = requireSemanticScale(this, id);
     const consumers = findScaleConsumers(this, id);
-    const channel = resolveChannel(consumers, id);
-    if (
-      hasPalette &&
-      channel !== "color" &&
-      scale.type !== "sequential" &&
-      !isDiscretizedColorScaleType(scale.type)
-    ) {
-      throw new Error("editScale palette requires a color scale.");
-    }
-    const patch = !hasPalette
-      ? args
-      : Object.fromEntries([
-          ...Object.entries(args).filter(([key]) => key !== "palette"),
-          ["range", { palette: args.palette }]
-        ]);
-    validateLegendTypeTransition(this, scale, args.type ?? scale.type);
-    const definition = normalizeDefinition(scale, channel, consumers, patch);
+    const channel = resolveScaleConsumerChannel(consumers, id);
+    const definition = prepareScaleEdit(this, scale, channel, consumers, args);
 
     let next = this;
     for (const property of EDITABLE) {