ggaction 0.0.12 → 0.0.15

package/src/materialization/marks/grouping.js

@@ -0,0 +1,52 @@
+import { findUpstreamTransform } from "../dataProvenance.js";
+import { readPathSeriesFields, validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
+
+export function validatePathGroupAppearance(program, layer, dataset) {
+  if (layer.mark.type === "area" && findUpstreamTransform(program, dataset, "density")) {
+    // Density placement owns a category/split grain beyond the visible group field.
+    readPathSeriesFields(dataset.values, layer);
+    return;
+  }
+  validatePathSeriesAppearance(dataset.values, layer);
+}
+
+export function assertPathGroupCompatible(program, layer, dataset, group) {
+  if (layer.encoding?.parallel !== undefined) {
+    throw new Error("Parallel paths have row identity and do not support encodeGroup.");
+  }
+  const field = group?.field;
+  for (const [type, editor] of [
+    ["density", "editDensity"],
+    ["horizon", "editHorizon"],
+    ["regression", "editRegression"],
+    ["interval", "editErrorBand"]
+  ]) {
+    const transform = findUpstreamTransform(program, dataset, type);
+    if (transform === undefined) continue;
+    const fields = type === "horizon" ? [transform.as.group]
+      : type === "interval"
+        ? transform.groupBy.filter(value =>
+            value !== layer.encoding?.x?.field && value !== layer.encoding?.y?.field
+          )
+        : [transform.groupBy];
+    if (group?.fields !== undefined || group === undefined ||
+        field === undefined || !fields.includes(field)) {
+      throw new Error(
+        `${type === "density" ? "Density area" : type + " path"} mark "${layer.id}" must group by ${fields.length === 1 && fields[0] !== undefined ? JSON.stringify(fields[0]) : "its owned field"}; use ${editor}.`
+      );
+    }
+  }
+  if (layer.layout?.mode !== undefined) {
+    if (group === undefined && !["overlay"].includes(layer.layout.mode)) throw new Error("Remove active series layout before removing its group.");
+    return;
+  }
+  if (layer.mark?.type === "area" && (
+    layer.encoding?.y?.stack === "center" ||
+    ![undefined, "overlay"].includes(layer.encoding?.color?.layout)
+  )) {
+    if (group?.fields !== undefined ||
+        (layer.encoding?.color !== undefined && field !== layer.encoding.color.field)) {
+      throw new Error("Area layout requires one group field matching its color field.");
+    }
+  }
+}

package/src/materialization/marks/index.js

@@ -1,8 +1,11 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
+import { findLayer } from "../../selectors/layers.js";
 import {
   POSITION_CHANNELS,
   POSITION_ENCODING_CHANNELS
 } from "../../core/vocabulary.js";
 import { getMarkMaterializationPolicy } from "./policies.js";
+import { buildMaterializationPlan } from "../planner.js";
 
 export {
   canMaterializeArc,
@@ -13,10 +16,32 @@ export {
   canMaterializeRect,
   canMaterializeRule,
   canMaterializeText,
-  canMaterializeTick
+  canMaterializeTick,
+  isTextSource
 } from "./capabilities.js";
 
-export function getMarkRematerializationStep(layer) {
+export function getLayerScaleIds(layer) {
+  if (isSourceOwnedText(layer)) return [];
+  return [
+    ...Object.values(layer.encoding ?? {}).map(encoding => encoding?.scale),
+    ...(layer.encoding?.parallel?.dimensions ?? []).map(dimension => dimension.scale)
+  ].filter(scale => scale !== undefined);
+}
+
+export function getScaleConsumerMarkSteps(program, scaleIds) {
+  return program.semanticSpec.layers
+    .filter(layer => getLayerScaleIds(layer).some(id => scaleIds.includes(id)))
+    .map(layer => getMarkMaterializationStep(program, layer))
+    .filter(step => step !== undefined);
+}
+
+export function getMarkRematerializationStep(program, layer) {
+  if (program.markConfigs?.[layer.id]?.statisticalReference !== undefined) {
+    return { op: "rematerializeStatisticalReference", args: { id: layer.id } };
+  }
+  if (program.markConfigs?.[layer.id]?.markFilter?.empty === true) {
+    return { op: "materializeEmptyMark", args: { id: layer.id } };
+  }
   const policy = getMarkMaterializationPolicy(layer);
   return policy === undefined
     ? undefined
@@ -28,57 +53,61 @@ export function getMarkMaterializationStep(program, layer) {
   if (policy === undefined || !policy.canMaterialize(program, layer)) {
     return undefined;
   }
-  return getMarkRematerializationStep(layer);
+  return getMarkRematerializationStep(program, layer);
 }
 
 export function getSourceDependentMarkSteps(program, sourceId) {
-  return program.semanticSpec.layers.flatMap(layer =>
-    layer.source === sourceId &&
-    getMarkMaterializationPolicy(layer)?.sourceDependent === true
-      ? [getMarkMaterializationStep(program, layer)].filter(
+  return (program.semanticSpec.layers ?? []).flatMap(layer => {
+    const sourceOwned = layer.source === sourceId &&
+      getMarkMaterializationPolicy(layer)?.sourceDependent === true;
+    const statistical = program.markConfigs?.[layer.id]
+      ?.statisticalReference?.source === sourceId;
+    return sourceOwned || statistical
+      ? [getMarkMaterializationStep(program, layer) ??
+          getExistingMarkRematerializationStep(program, layer)].filter(
           step => step !== undefined
         )
-      : []
-  );
+      : [];
+  });
 }
 
 export function getPositionEncodingMaterializationSteps(program, layer, scaleId) {
   const policy = getMarkMaterializationPolicy(layer);
   if (policy === undefined) return [];
   const complete = policy.canMaterialize(program, layer);
-  const mark = getMarkRematerializationStep(layer);
+  const mark = getMarkRematerializationStep(program, layer);
   const sharedConsumerMarks = (program.semanticSpec.layers ?? [])
     .filter(candidate =>
       candidate.id !== layer.id &&
+      !isSourceOwnedText(candidate) &&
       POSITION_CHANNELS.some(channel =>
         candidate.encoding?.[channel]?.scale === scaleId
       )
     )
     .map(candidate => getMarkMaterializationStep(program, candidate))
     .filter(step => step !== undefined);
+  const dependentMarks = [mark, ...sharedConsumerMarks]
+    .flatMap(step => getSourceDependentMarkSteps(program, step.args.id));
   const scale = {
     op: "rematerializeScale",
     args: sharedConsumerMarks.length === 0
       ? { id: scaleId }
       : { id: scaleId, marks: false }
   };
-  if (!complete) {
-    if (policy.positionEncoding.incomplete === "scale") {
-      return [scale, ...sharedConsumerMarks];
-    }
-    return policy.positionEncoding.scaleFirst
+  const direct = !complete && policy.positionEncoding.incomplete === "scale"
+    ? [scale, ...sharedConsumerMarks]
+    : policy.positionEncoding.scaleFirst
       ? [scale, mark, ...sharedConsumerMarks]
       : [mark, ...sharedConsumerMarks];
-  }
-  return policy.positionEncoding.scaleFirst
-    ? [scale, mark, ...sharedConsumerMarks]
-    : [mark, ...sharedConsumerMarks];
+  return buildMaterializationPlan({ marks: [...direct, ...dependentMarks] });
 }
 
 export function getScaleConsumerMaterializationMode(layer, channel) {
   const policy = getMarkMaterializationPolicy(layer);
   if (policy === undefined) return "direct";
   if (POSITION_ENCODING_CHANNELS.includes(channel)) {
+    // Attached labels require their source's completed geometry, after scales.
+    if (layer.source !== undefined && policy.sourceDependent === true) return "defer";
     return policy.scaleApplication.position ?? policy.scaleApplication.default;
   }
   if (policy.scaleApplication.deferredChannels?.includes(channel)) {
@@ -99,7 +128,7 @@ export function getExistingMarkRematerializationStep(program, layer) {
   ) {
     return undefined;
   }
-  return getMarkRematerializationStep(layer);
+  return getMarkRematerializationStep(program, layer);
 }
 
 export function getEncodingMaterializationStages(program, layer, channel, scale) {
@@ -111,22 +140,34 @@ export function getEncodingMaterializationStages(program, layer, channel, scale)
         args: { id: scale, guides: false, marks: false }
       }]
     : [];
-  const shared = policy.encoding?.sharedChannels?.includes(channel) === true &&
-    scale !== undefined;
+  const shared = scale !== undefined && (
+    scales.length > 0 || policy.encoding?.sharedChannels?.includes(channel) === true
+  );
   const candidates = shared
     ? program.semanticSpec.layers.filter(candidate =>
-        candidate.mark?.type === layer.mark?.type &&
-        candidate.encoding?.[channel]?.scale === scale
+        candidate.id === layer.id || candidate.encoding?.[channel]?.scale === scale
       )
     : [layer];
   const marks = candidates.flatMap(candidate => {
-    if (policy.encoding?.skipRematerialization?.(program, candidate) === true) {
+    const candidatePolicy = getMarkMaterializationPolicy(candidate);
+    if (candidatePolicy?.encoding?.skipRematerialization?.(program, candidate) === true) {
       return [];
     }
-    const step = policy.encoding?.completeOnly === true
+    const step = candidate.id !== layer.id || candidatePolicy?.encoding?.completeOnly === true
       ? getMarkMaterializationStep(program, candidate)
-      : getMarkRematerializationStep(candidate);
+      : getMarkRematerializationStep(program, candidate);
     return step === undefined ? [] : [step];
   });
   return { scales, marks };
 }
+
+// Reuse a plan's scale stage only when it covers every scale consumed by the mark.
+export function reusePlannedMarkScales(program, steps, scaleIds) {
+  const resolved = new Set(scaleIds);
+  return steps.map(step => {
+    const layer = findLayer(program, step.args?.id);
+    if (layer === undefined || getMarkMaterializationPolicy(layer)?.acceptsResolvedScales !== true ||
+        !getLayerScaleIds(layer).every(id => resolved.has(id))) return step;
+    return { ...step, args: { ...step.args, scales: false } };
+  });
+}

package/src/materialization/marks/policies.js

@@ -40,7 +40,9 @@ const MARK_MATERIALIZATION_POLICIES = Object.freeze({
   line: Object.freeze({
     canMaterialize: canMaterializeLine,
     op: "rematerializeLineMark",
+    acceptsResolvedScales: true,
     positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    encoding: Object.freeze({ scaleFirst: true, completeOnly: true }),
     scaleApplication: Object.freeze({ default: "defer" })
   }),
   area: Object.freeze({
@@ -48,7 +50,7 @@ const MARK_MATERIALIZATION_POLICIES = Object.freeze({
     op: "rematerializeAreaMark",
     positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: true }),
     encoding: Object.freeze({
-      sharedChannels: Object.freeze(["color"]),
+      sharedChannels: Object.freeze(["color", "stroke"]),
       skipRematerialization: isIntentionallyEmptyArea
     }),
     scaleApplication: Object.freeze({ default: "defer" })
@@ -56,6 +58,7 @@ const MARK_MATERIALIZATION_POLICIES = Object.freeze({
   arc: Object.freeze({
     canMaterialize: canMaterializeArc,
     op: "rematerializeArcMark",
+    acceptsResolvedScales: true,
     positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
     encoding: Object.freeze({ completeOnly: true }),
     scaleApplication: Object.freeze({ default: "defer" })

package/src/materialization/rect.js

@@ -2,28 +2,42 @@ import {
   mapOrdinalPositionValues,
   readScaleField
 } from "../grammar/scales/index.js";
-import { RECT_MODES, resolveRectMode } from "../grammar/rects.js";
+import { normalizePositionDatum } from "../grammar/positionDatum.js";
+import { resolveCoordinateBounds } from "./coordinateBounds.js";
+import { RECT_MODES, resolveRectMode, rectUsesFields } from "../grammar/rects.js";
 import { DEFAULT_RECT_MARK } from "./rectConfig.js";
 import { mapScaleConsumerValues } from "./scales/map.js";
+import { materializeRectItem } from "../grammar/roundedRect.js";
+import { requestedStrokeDetails } from "../grammar/strokeStyle.js";
 
-function optionalValues(rows, encoding) {
+function optionalValues(rows, encoding, length, channel) {
+  if (Object.hasOwn(encoding, "datum")) {
+    const value = normalizePositionDatum(encoding.datum, encoding.fieldType, channel, encoding.temporalUnit, "Rect");
+    return Array.from({ length }, () => value);
+  }
   return readScaleField(rows, encoding.field, encoding.fieldType, {
-    allowUnknown: true
+    allowUnknown: true, temporalUnit: encoding.temporalUnit
   });
 }
 
 function requiredChannels(layer, mode) {
-  return mode === RECT_MODES.ranged
-    ? ["x", "x2", "y", "y2", ...(layer.encoding?.color ? ["color"] : [])]
-    : ["x", "y", ...(layer.encoding?.color ? ["color"] : [])];
+  const position = mode === RECT_MODES.xSpan ? ["x", "x2"]
+    : mode === RECT_MODES.ySpan ? ["y", "y2"]
+    : mode === RECT_MODES.ranged ? ["x", "x2", "y", "y2"] : ["x", "y"];
+  return [
+    ...position,
+    ...(layer.encoding?.color ? ["color"] : []),
+    ...(layer.encoding?.stroke ? ["stroke"] : [])
+  ];
 }
 
 export function resolveRectConsumerValues(layer, dataset, channel) {
-  const requested = optionalValues(dataset.values, layer.encoding[channel]);
+  const length = rectUsesFields(layer) ? dataset.values.length : 1;
+  const requested = optionalValues(dataset.values, layer.encoding[channel], length, channel);
   const mode = resolveRectMode(layer);
   if (mode === undefined) return requested;
   const complete = requiredChannels(layer, mode).map(candidate =>
-    optionalValues(dataset.values, layer.encoding[candidate])
+    optionalValues(dataset.values, layer.encoding[candidate], length, candidate)
   );
   return requested.map((value, index) =>
     complete.every(values => values[index] !== undefined) ? value : undefined
@@ -56,37 +70,42 @@ function mappedEncoding(program, layer, dataset, channel) {
   };
 }
 
-function appearance(config, fill) {
+function appearance(config, fill, stroke) {
   return {
     fill,
     opacity: config.opacity,
-    stroke: config.stroke === false ? "transparent" : config.stroke,
-    strokeWidth: config.stroke === false ? 0 : config.strokeWidth
+    stroke: stroke ?? (config.stroke === false ? "transparent" : config.stroke),
+    strokeWidth: stroke === undefined && config.stroke === false
+      ? 0
+      : config.strokeWidth ?? 1,
+    ...requestedStrokeDetails(config, "Rect mark")
   };
 }
 
 export function resolveRectRows(program, layer, dataset) {
   const mode = resolveRectMode(layer);
   if (mode === undefined) return [];
-  const x = mappedEncoding(program, layer, dataset, "x");
-  const y = mappedEncoding(program, layer, dataset, "y");
-  const x2 = mode === RECT_MODES.ranged
-    ? mappedEncoding(program, layer, dataset, "x2")
-    : undefined;
-  const y2 = mode === RECT_MODES.ranged
-    ? mappedEncoding(program, layer, dataset, "y2")
-    : undefined;
+  const bounds = resolveCoordinateBounds(program, layer.coordinate);
+  const x = layer.encoding.x === undefined ? undefined : mappedEncoding(program, layer, dataset, "x");
+  const y = layer.encoding.y === undefined ? undefined : mappedEncoding(program, layer, dataset, "y");
+  const x2 = layer.encoding.x2 === undefined ? undefined : mappedEncoding(program, layer, dataset, "x2");
+  const y2 = layer.encoding.y2 === undefined ? undefined : mappedEncoding(program, layer, dataset, "y2");
   const color = layer.encoding?.color === undefined
     ? undefined
     : mappedEncoding(program, layer, dataset, "color").values;
+  const stroke = layer.encoding?.stroke === undefined
+    ? undefined
+    : mappedEncoding(program, layer, dataset, "stroke").values;
   const config = program.markConfigs[layer.id] ?? DEFAULT_RECT_MARK;
 
-  return dataset.values.flatMap((row, index) => {
+  const rows = rectUsesFields(layer) ? dataset.values : [{}];
+  return rows.flatMap((row, index) => {
     const fill = color === undefined ? config.fill : color[index];
     if (
-      !Number.isFinite(x.values[index]) ||
-      !Number.isFinite(y.values[index]) ||
-      typeof fill !== "string"
+      (x !== undefined && !Number.isFinite(x.values[index])) ||
+      (y !== undefined && !Number.isFinite(y.values[index])) ||
+      typeof fill !== "string" ||
+      (stroke !== undefined && typeof stroke[index] !== "string")
     ) return [];
 
     let geometry;
@@ -103,36 +122,30 @@ export function resolveRectRows(program, layer, dataset) {
         height
       };
     } else {
-      const endX = x2.values[index];
-      const endY = y2.values[index];
+      const startX = x?.values[index] ?? bounds.x;
+      const startY = y?.values[index] ?? bounds.y;
+      const endX = x2?.values[index] ?? bounds.x + bounds.width;
+      const endY = y2?.values[index] ?? bounds.y + bounds.height;
       if (!Number.isFinite(endX) || !Number.isFinite(endY)) return [];
       geometry = {
-        x: Math.min(x.values[index], endX),
-        y: Math.min(y.values[index], endY),
-        width: Math.abs(endX - x.values[index]),
-        height: Math.abs(endY - y.values[index])
+        x: Math.min(startX, endX),
+        y: Math.min(startY, endY),
+        width: Math.abs(endX - startX),
+        height: Math.abs(endY - startY)
       };
       if (geometry.width <= 0 || geometry.height <= 0) return [];
     }
     return [{
       row,
       sourceIndex: index,
-      channels: Object.fromEntries(
-        ["x", "y", "x2", "y2", "color"].flatMap(channel => {
-          const encoding = layer.encoding?.[channel];
-          return encoding?.field === undefined
-            ? []
-            : [[channel, row[encoding.field]]];
-        })
-      ),
-      properties: { ...geometry, ...appearance(config, fill) }
+      properties: { ...geometry, ...appearance(config, fill, stroke?.[index]) }
     }];
   });
 }
 
 export function resolveRectGraphicItems(program, layer, dataset) {
-  return resolveRectRows(program, layer, dataset).map(item => ({
-    type: "rect",
-    properties: item.properties
-  }));
+  const radius = program.markConfigs[layer.id]?.cornerRadius ?? 0;
+  return resolveRectRows(program, layer, dataset).map(item =>
+    materializeRectItem(item.properties, radius)
+  );
 }

package/src/materialization/rectConfig.js

@@ -4,6 +4,7 @@ import {
   validateUnitInterval
 } from "../core/validation.js";
 import { DEFAULT_COLORS } from "../theme/defaults.js";
+import { requestedRectStyleDetails } from "../grammar/roundedRect.js";
 
 export const DEFAULT_RECT_MARK = Object.freeze({
   fill: DEFAULT_COLORS.mark,
@@ -13,7 +14,10 @@ export const DEFAULT_RECT_MARK = Object.freeze({
 });
 
 export function normalizeRectMarkConfig(patch, previous = DEFAULT_RECT_MARK) {
-  const result = { ...previous };
+  const result = {
+    ...previous,
+    ...requestedRectStyleDetails(patch, "Rect")
+  };
   if (Object.hasOwn(patch, "fill")) {
     result.fill = validateNonEmptyString(patch.fill, "Rect fill");
   }

package/src/materialization/rowEncoding.js

@@ -5,15 +5,13 @@ import {
 import {
   mapOrdinalOffsetValues,
   mapOrdinalPositionValues,
-  readNominalField,
-  readQuantitativeField,
-  readScaleField,
-  readTemporalField
+  readScaleField
 } from "../grammar/scales/index.js";
 import {
   finiteMidpoint,
   requireFiniteResult
 } from "../grammar/numeric.js";
+import { normalizePositionDatum } from "../grammar/positionDatum.js";
 import { mapScaleConsumerValues } from "./scales/map.js";
 
 export function resolveRowEncodingValues(program, layer, dataset, channel) {
@@ -26,15 +24,17 @@ export function resolveRowEncodingValues(program, layer, dataset, channel) {
     );
   }
   const categorical = ["nominal", "ordinal"].includes(encoding.fieldType);
-  const values = Object.hasOwn(scale, "unknown")
-    ? readScaleField(dataset.values, encoding.field, encoding.fieldType, {
-        allowUnknown: true
-      })
-    : categorical
-      ? readNominalField(dataset.values, encoding.field)
-      : encoding.fieldType === "temporal"
-        ? readTemporalField(dataset.values, encoding.field)
-        : readQuantitativeField(dataset.values, encoding.field);
+  const values = Object.hasOwn(encoding, "datum")
+    ? Array(dataset.values.length).fill(normalizePositionDatum(
+        encoding.datum,
+        encoding.fieldType,
+        channel,
+        encoding.temporalUnit,
+        layer.mark.type[0].toUpperCase() + layer.mark.type.slice(1)
+      ))
+    : readScaleField(dataset.values, encoding.field, encoding.fieldType, {
+        allowUnknown: Object.hasOwn(scale, "unknown"), temporalUnit: encoding.temporalUnit
+      });
   if (categorical && OFFSET_POSITION_CHANNELS.includes(channel)) {
     return mapOrdinalOffsetValues(values, scale);
   }

package/src/materialization/scaleGuideDependencies.js

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../grammar/text.js";
 import { POSITION_ENCODING_CHANNELS } from "../core/vocabulary.js";
 import { materializedLegendUsesScale } from "./legends.js";
 import { buildMaterializationPlan } from "./planner.js";
@@ -19,10 +20,12 @@ const GRIDS = Object.freeze([
 
 function usesPositionalScale(program, id) {
   return program.semanticSpec.layers.some(layer =>
-    POSITION_ENCODING_CHANNELS.some(
-      channel => layer.encoding?.[channel]?.scale === id
-    ) || (layer.encoding?.parallel?.dimensions ?? []).some(
-      dimension => dimension.scale === id
+    !isSourceOwnedText(layer) && (
+      POSITION_ENCODING_CHANNELS.some(
+        channel => layer.encoding?.[channel]?.scale === id
+      ) || (layer.encoding?.parallel?.dimensions ?? []).some(
+        dimension => dimension.scale === id
+      )
     )
   );
 }
@@ -50,7 +53,7 @@ export function needsCanvasScaleRematerialization(program, scale) {
     (scale.range === "auto" ||
       usesRadialScale(program, scale.id) ||
       semanticGuideUsesScale(program, scale.id)) &&
-    program.resolvedScales[scale.id] !== undefined &&
+    (program.resolvedScales[scale.id] !== undefined || scale.radialMapping !== undefined) &&
     usesPositionalScale(program, scale.id)
   );
 }

package/src/materialization/scales/map.js

@@ -4,21 +4,24 @@ import {
   isOrdinalScaleType,
   mapContinuousScaleValues,
   mapDiscretizedColors,
+  mapSizeValues,
   mapOrdinalValues,
   mapSequentialColors
 } from "../../grammar/scales/index.js";
 
 export function mapScaleConsumerValues(values, resolvedScale, channel) {
-  if (channel === "color" && isDiscretizedColorScaleType(resolvedScale.type)) {
+  if (channel === "size") return mapSizeValues(values, resolvedScale);
+  if (["color", "stroke"].includes(channel) && isDiscretizedColorScaleType(resolvedScale.type)) {
     return mapDiscretizedColors(values, resolvedScale);
   }
-  if (channel === "color" && isContinuousColorScaleType(resolvedScale.type)) {
+  if (["color", "stroke"].includes(channel) && isContinuousColorScaleType(resolvedScale.type)) {
     return mapSequentialColors(
       values,
       resolvedScale.domain,
       resolvedScale.range,
       {
         interpolation: resolvedScale.interpolate,
+        midpoint: resolvedScale.midpoint,
         clamp: resolvedScale.clamp ?? false,
         ...(Object.hasOwn(resolvedScale, "unknown")
           ? { unknown: resolvedScale.unknown }
@@ -27,7 +30,7 @@ export function mapScaleConsumerValues(values, resolvedScale, channel) {
     );
   }
   if (
-    ["color", "strokeDash", "shape"].includes(channel) &&
+    ["color", "stroke", "strokeDash", "shape"].includes(channel) &&
     isOrdinalScaleType(resolvedScale.type)
   ) {
     return mapOrdinalValues(values, resolvedScale.domain, resolvedScale.range, {

package/src/materialization/scales/policies/arc.js

@@ -1,3 +1,4 @@
+import { validateMeasuredRadiusScale } from "../../../grammar/scales/radial.js";
 export function resolveArcAutoPositionRange({
   consumers,
   scale,
@@ -35,3 +36,44 @@ export function resolveArcAutoPositionRange({
   }
   return range;
 }
+
+
+export function resolveMeasuredRadiusDomain({ scale, channel, allValues }) {
+  if (scale.radialMapping === undefined) return undefined;
+  if (channel !== "radius") throw new Error("Measured radius scales support only radius consumers.");
+  const maximum = allValues.reduce((maximum, value) => Math.max(maximum, value), -Infinity);
+  if (!Number.isFinite(maximum) || maximum <= 0 || allValues.some(value => value < 0)) {
+    throw new Error("Measured radius requires finite non-negative aggregates and a positive maximum.");
+  }
+  const domain = scale.domain === "auto" ? [0, maximum] : scale.domain;
+  if (Array.isArray(domain) && domain[1] < maximum) {
+    throw new RangeError("Measured radius domain maximum must cover every category aggregate.");
+  }
+  return domain;
+}
+
+export function validateMeasuredRadiusConsumers({ scale, domain, range, consumers, markConfigs, thetaScales }) {
+  if (scale.radialMapping === undefined) return;
+  validateMeasuredRadiusScale({ ...scale, domain, range }, { allowAuto: true });
+  for (const consumer of consumers) {
+    const { layer, encoding } = consumer;
+    const theta = layer.encoding?.theta;
+    const thetaScale = thetaScales[layer.id];
+    if (!isPendingMeasuredRadiusConsumer(consumer) && (layer.mark?.type !== "arc" || !["count", "sum"].includes(encoding.aggregate) ||
+      !["nominal", "ordinal"].includes(theta?.fieldType) || theta.aggregate !== undefined ||
+      thetaScale?.type !== "band" || (thetaScale.paddingInner ?? 0) !== 0 || (thetaScale.paddingOuter ?? 0) !== 0)) {
+      throw new Error("Measured radius requires only equal-angle categorical Arc consumers.");
+    }
+    const config = markConfigs[layer.id] ?? {};
+    if ((config.padAngle ?? 0) !== 0) throw new Error("Measured Arc requires padAngle 0.");
+    if (scale.range !== "auto" && config.innerRadiusExplicit === true &&
+      Math.abs(config.innerRadius - range[0] / range[1]) > Number.EPSILON * 8) {
+      throw new Error("Measured Arc innerRadius must agree with its explicit radius range.");
+    }
+  }
+}
+
+export function isPendingMeasuredRadiusConsumer({ layer, channel, encoding }) {
+  return layer.mark?.type === "arc" && channel === "radius" &&
+    ["count", "sum"].includes(encoding.aggregate) && layer.encoding?.theta === undefined;
+}

package/src/materialization/scales/policies/binnedPosition.js

@@ -1,11 +1,11 @@
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import { resolveHistogramBins } from "../../../grammar/histogram.js";
 
 export function resolveBinnedPositionDomain({
   valuesByConsumer,
   channel,
   scale,
-  id,
-  allValues
+  id
 }) {
   const binnedPositions = valuesByConsumer.filter(
     ({ consumer }) =>
@@ -13,7 +13,10 @@ export function resolveBinnedPositionDomain({
       consumer.encoding.bin !== undefined
   );
   if (binnedPositions.length === 0) return undefined;
-  if (channel !== "x" || binnedPositions.length !== valuesByConsumer.length) {
+  const independentConsumers = valuesByConsumer.filter(({ consumer, scalePolicy }) =>
+    scalePolicy !== false && !isSourceOwnedText(consumer.layer)
+  );
+  if (channel !== "x" || binnedPositions.length !== independentConsumers.length) {
     throw new Error(
       `Binned scale "${id}" cannot be shared with an unbinned consumer.`
     );
@@ -25,7 +28,7 @@ export function resolveBinnedPositionDomain({
     throw new Error(`Binned scale "${id}" requires one shared bin definition.`);
   }
   return resolveHistogramBins({
-    values: allValues,
+    values: binnedPositions.flatMap(item => item.values).filter(value => value !== undefined),
     bin: binnedPositions[0].consumer.encoding.bin,
     domain: scale.domain,
     nice: scale.nice ?? true,