ggaction 0.0.12 → 0.0.15

package/src/actions/encodings/offset.js

@@ -1,3 +1,5 @@
+import { inferSeriesGroup } from "./shared.js";
+import { findSemanticScale } from "../../selectors/scales.js";
 import { action } from "../../core/action.js";
 import {
   readNominalField,
@@ -13,11 +15,9 @@ import {
   validateOptions
 } from "./shared.js";
 import {
-  resolveBarColorLayout,
   resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
-import { normalizeOffsetPadding } from "../../grammar/bars/geometry.js";
 
 const ENCODING_OPTIONS = Object.freeze([
   "field", "target", "fieldType", "scale", "paddingInner", "paddingOuter"
@@ -50,15 +50,7 @@ function createOffsetEncoding(channel) {
             `${operation} requires a complete bar with a ${parentChannel} category encoding.`
           );
         }
-        if (
-          layer.encoding?.color !== undefined &&
-          (resolveBarColorLayout(layer) !== "group" ||
-            layer.encoding.color.field !== args.field)
-        ) {
-          throw new Error(
-            `${operation} field must match a grouped bar color field.`
-          );
-        }
+
       } else {
         const parent = layer.encoding?.[parentChannel];
         if (
@@ -76,35 +68,44 @@ function createOffsetEncoding(channel) {
         layer.encoding?.[channel],
         args.scale ?? {}
       );
-      const scale = resolveOffsetScaleDefinition(this, requestedScale, channel);
+      const scaleOptions = {
+        ...requestedScale,
+        ...Object.fromEntries(
+          ["paddingInner", "paddingOuter"]
+            .filter(property => Object.hasOwn(args, property))
+            .map(property => [property, args[property]])
+        )
+      };
+      const scale = resolveOffsetScaleDefinition(this, scaleOptions, channel);
       if (Object.hasOwn(scale, "unknown")) {
         throw new Error(
           `${channel} scale unknown is not supported for offset positions.`
         );
       }
-      const padding = normalizeOffsetPadding(
-        args,
-        this.markConfigs[target]?.[channel],
-        channel
-      );
 
-      let next = setEncodingProperties(this, target, channel, {
+      const grouped = layer.mark.type === "bar" ? inferSeriesGroup(this, layer, args.field, "offset") : this;
+      let next = setEncodingProperties(grouped, target, channel, {
         field: args.field,
         fieldType,
         scale: scale.id
-      })._withMarkConfig(target, {
-          ...this.markConfigs[target],
-          [channel]: padding
-        });
-      next = applyEncodingScale(next, scale, requestedScale, {
-        reassignment: layer.encoding?.[channel]?.scale === scale.id
       });
-      if (layer.mark.type === "bar" && layer.encoding?.color === undefined) {
-        return next
-          .rematerializeScale({ id: scale.id })
-          .editGraphics({ target, property: "length", value: 0 });
+      next = applyEncodingScale(next, scale, {
+        ...Object.fromEntries(Object.entries(scaleOptions).filter(
+          ([property]) => property !== "range"
+        )),
+        paddingInner: scale.paddingInner,
+        paddingOuter: scale.paddingOuter,
+        align: scale.align
+      }, {
+        reassignment: findSemanticScale(this, scale.id) !== undefined
+      });
+      next = next._withoutMaterializationConfig(["marks", target, channel]);
+      if (layer.mark.type === "bar") {
+        if (findSemanticScale(this, scale.id) === undefined && args.scale?.id === undefined) next = next._withMarkConfig(target, { ...next.markConfigs[target], seriesOffsetScale: scale.id });
+        if (layer.layout?.mode !== "group" || layer.encoding?.group?.field !== args.field) return next.layoutSeries({ target, mode: "group" });
+        return rematerializeEncoding(next, target, channel, scale.id, layer);
       }
-      return rematerializeEncoding(next, target, channel, scale.id);
+      return rematerializeEncoding(next, target, channel, scale.id, layer);
     }
   );
 }

package/src/actions/encodings/parallel.js

@@ -13,6 +13,7 @@ import {
   setEncodingProperties
 } from "./shared.js";
 import { resolveParallelCoordinate } from "../coordinates/parallel.js";
+import { applyLayerDataRematerialization } from "../../materialization/dependencies.js";
 
 const OPTIONS = Object.freeze([
   "target", "coordinate", "dimensions", "key", "missing"
@@ -98,14 +99,7 @@ export const encodeParallelCoordinates = action(
     for (let index = 0; index < definitions.length; index += 1) {
       next = applyEncodingScale(next, definitions[index], dimensions[index].scaleOptions);
     }
-    for (const definition of definitions) {
-      next = next.rematerializeScale({
-        id: definition.id,
-        guides: false,
-        marks: false
-      });
-    }
-    return next.rematerializeLineMark({ id: target, scales: false });
+    return applyLayerDataRematerialization(next, target);
   }
 );
 

package/src/actions/encodings/position/apply.js

@@ -1,3 +1,5 @@
+import { applyTemporalUnit } from "../temporal.js";
+
 function replaceAlternateBinding(program, target, channel, previous, usesField) {
   if (previous === undefined) return program;
   const alternate = usesField ? "datum" : "field";
@@ -64,18 +66,35 @@ function applyBin(program, target, channel, previous, bin) {
   });
 }
 
-function applyArcThetaWeight(program, target, channel, previous, aggregate, weight) {
-  if (channel !== "theta") return program;
-  if (aggregate !== "sum") {
+function applyPositionWeight(
+  program,
+  target,
+  channel,
+  previous,
+  bin,
+  aggregate,
+  weight
+) {
+  const histogram = channel === "x" && bin !== undefined;
+  const arcSum = channel === "theta" && aggregate === "sum";
+  if (!histogram && !arcSum) {
+    return previous?.weight === undefined
+      ? program
+      : program.editSemantic({
+          property: `layer[${target}].encoding.${channel}.weight`,
+          remove: true
+        });
+  }
+  if (weight === undefined) {
     return previous?.weight === undefined
       ? program
       : program.editSemantic({
-          property: `layer[${target}].encoding.theta.weight`,
+          property: `layer[${target}].encoding.${channel}.weight`,
           remove: true
         });
   }
   return program.editSemantic({
-    property: `layer[${target}].encoding.theta.weight`,
+    property: `layer[${target}].encoding.${channel}.weight`,
     value: weight
   });
 }
@@ -102,6 +121,26 @@ function removeStaleArcThetaAggregate(
   });
 }
 
+function removeMeasuredRadiusAggregate(
+  program,
+  target,
+  channel,
+  previous,
+  clearRadialMapping
+) {
+  if (
+    channel !== "radius" ||
+    !clearRadialMapping ||
+    previous?.aggregate === undefined
+  ) {
+    return program;
+  }
+  return program.editSemantic({
+    property: `layer[${target}].encoding.radius.aggregate`,
+    remove: true
+  });
+}
+
 export function applyPositionSemantics(program, {
   target,
   channel,
@@ -111,10 +150,12 @@ export function applyPositionSemantics(program, {
   datum,
   hasField,
   fieldType,
+  temporalUnit,
   bin,
   aggregate,
   stack,
-  weight
+  weight,
+  clearRadialMapping
 }) {
   let next = reconcileInheritedRulePosition(program, {
     target,
@@ -128,16 +169,19 @@ export function applyPositionSemantics(program, {
     channel,
     previous,
     hasField
-  )
-    .editSemantic({
+  );
+  if (hasField || datum !== undefined) {
+    next = next.editSemantic({
       property: `layer[${target}].encoding.${channel}.${hasField ? "field" : "datum"}`,
       value: hasField ? field : datum
-    })
-    .editSemantic({
+    });
+  }
+  next = next.editSemantic({
       property: `layer[${target}].encoding.${channel}.fieldType`,
       value: fieldType
     });
 
+  next = applyTemporalUnit(next, target, channel, temporalUnit, previous);
   next = applyBin(next, target, channel, previous, bin);
   for (const [property, value] of Object.entries({ aggregate, stack })) {
     if (value === undefined) continue;
@@ -154,11 +198,19 @@ export function applyPositionSemantics(program, {
     fieldType,
     aggregate
   );
-  return applyArcThetaWeight(
+  next = removeMeasuredRadiusAggregate(
+    next,
+    target,
+    channel,
+    previous,
+    clearRadialMapping
+  );
+  return applyPositionWeight(
     next,
     target,
     channel,
     previous,
+    bin,
     aggregate,
     weight
   );

package/src/actions/encodings/position/index.js

@@ -1,12 +1,16 @@
+import { stackLayoutMode } from "../seriesLayout.js";
+import { resolveBarGrain } from "../../../grammar/bars/policy.js";
 import { action } from "../../../core/action.js";
 import {
   getPositionEncodingMaterializationSteps
 } from "../../../materialization/marks/index.js";
 import { resolvePositionEncoding } from "./resolve.js";
 import { findLayer } from "../../../selectors/layers.js";
+import { findSemanticScale } from "../../../selectors/scales.js";
 import { applyPositionSemantics } from "./apply.js";
 import {
   applyEncodingScale,
+  applyDetachedScaleRematerialization,
   rebindPositionGuides
 } from "../shared.js";
 
@@ -20,12 +24,15 @@ function encodePosition(program, channel, args, operation) {
     datum,
     hasField,
     fieldType,
+    temporalUnit,
     scale,
     coordinate,
     bin,
     aggregate,
     stack,
-    weight
+    weight,
+    companion,
+    clearRadialMapping
   } = resolvePositionEncoding(program, channel, args, operation);
 
   let next = program
@@ -43,19 +50,31 @@ function encodePosition(program, channel, args, operation) {
     datum,
     hasField,
     fieldType,
+    temporalUnit,
     bin,
     aggregate,
     stack,
-    weight
+    weight,
+    clearRadialMapping
   });
 
   next = next.editSemantic({
       property: `layer[${target}].encoding.${channel}.scale`,
       value: scale.id
     });
+  if (
+    clearRadialMapping &&
+    findSemanticScale(next, scale.id)?.radialMapping !== undefined
+  ) {
+    next = next.editScale({ id: scale.id, radialMapping: undefined });
+  }
   next = applyEncodingScale(next, scale, requestedScale, {
-    reassignment: previous?.scale === scale.id
+    reassignment: previous?.scale === scale.id,
+    allowTypeChange: layer.mark.type === "area"
   });
+  if (["bar", "area"].includes(layer.mark.type) && Object.hasOwn(args, "stack") && args.stack !== undefined) {
+    next = next.editSemantic({ property: `layer[${target}].layout.mode`, value: stackLayoutMode(args.stack) });
+  }
   next = rebindPositionGuides(
     next,
     channel,
@@ -64,13 +83,30 @@ function encodePosition(program, channel, args, operation) {
     target
   );
 
+  if (companion !== undefined) {
+    const encoding = companion.encoding;
+    const storedScale = findSemanticScale(next, encoding.scale);
+    next = next[companion.channel === "x" ? "encodeX" : "encodeY"]({
+      target,
+      field: encoding.field,
+      fieldType: encoding.fieldType,
+      aggregate: encoding.aggregate,
+      ...(layer.layout?.mode === undefined ? {} : { stack: encoding.stack }),
+      scale: {
+        id: encoding.scale,
+        ...(storedScale?.zero === undefined ? { zero: encoding.stack !== null } : {})
+      }
+    });
+  }
+
   if (layer.mark.type === "bar") {
     const updated = findLayer(next, target);
     const pendingBox = next.markConfigs[target]?.boxPlot;
     if (pendingBox !== undefined && !pendingBox.materialized) {
-      return updated.encoding?.x !== undefined && updated.encoding?.y !== undefined
+      const materialized = updated.encoding?.x !== undefined && updated.encoding?.y !== undefined
         ? next.materializeBoxPlot({ id: target })
         : next;
+      return applyDetachedScaleRematerialization(materialized, [layer]);
     }
   }
 
@@ -78,13 +114,23 @@ function encodePosition(program, channel, args, operation) {
     const updated = findLayer(next, target);
     const pendingGradient = next.markConfigs[target]?.gradientPlot;
     if (pendingGradient !== undefined && !pendingGradient.materialized) {
-      return updated.encoding?.x !== undefined && updated.encoding?.y !== undefined
+      const materialized = updated.encoding?.x !== undefined && updated.encoding?.y !== undefined
         ? next.materializeGradientPlot({ id: target })
         : next;
+      return applyDetachedScaleRematerialization(materialized, [layer]);
     }
   }
 
   const updated = findLayer(next, target);
+  if (["bar", "area"].includes(layer.mark.type) && next.markConfigs[target]?.boxPlot === undefined &&
+      updated.encoding?.x?.scale !== undefined && updated.encoding?.y?.scale !== undefined) {
+    const requested = Object.hasOwn(args, "stack") ? args.stack : undefined;
+    const mode = requested !== undefined ? stackLayoutMode(requested) : updated.layout?.mode ??
+      (layer.mark.type === "bar" && resolveBarGrain(updated) === "histogram" ? stackLayoutMode(updated.encoding.y.stack) : undefined);
+    if (mode !== undefined && (layer.mark.type === "area" || resolveBarGrain(updated) !== undefined)) {
+      return applyDetachedScaleRematerialization(next.layoutSeries({ target, mode }), [layer]);
+    }
+  }
   for (const step of getPositionEncodingMaterializationSteps(
     next,
     updated,
@@ -92,7 +138,7 @@ function encodePosition(program, channel, args, operation) {
   )) {
     next = next[step.op](step.args);
   }
-  return next;
+  return applyDetachedScaleRematerialization(next, [layer]);
 }
 
 const encodeX = action(

package/src/actions/encodings/position/policies/arc.js

@@ -1,3 +1,4 @@
+import { validateRadialMapping } from "../../../../grammar/scales/radial.js";
 import { validateAggregate } from "../../../../grammar/aggregate.js";
 import { validateNonEmptyString } from "../../../../core/validation.js";
 import { emptyPositionPolicy } from "./common.js";
@@ -15,6 +16,19 @@ export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
         "Arc radius encoding cannot be combined with quantitative theta."
       );
     }
+    if (args.mapping !== undefined) {
+      validateRadialMapping(args.mapping);
+      if (fieldType !== "quantitative" || !["count", "sum"].includes(args.aggregate)) {
+        throw new Error("Measured radius requires quantitative count or sum aggregation.");
+      }
+      if (args.aggregate === "count" && Object.hasOwn(args, "field")) {
+        throw new Error("Measured radius count does not accept a field.");
+      }
+      if (layer.encoding?.theta?.aggregate !== undefined) {
+        throw new Error("Measured radius requires equal-angle theta without aggregation.");
+      }
+      return { ...emptyPositionPolicy(), aggregate: args.aggregate };
+    }
     if (args.aggregate !== undefined) {
       throw new Error("Arc radius encoding does not support aggregate.");
     }

package/src/actions/encodings/position/policies/area.js

@@ -1,6 +1,4 @@
 import { validateStack, emptyPositionPolicy } from "./common.js";
-import { deriveCenteredAreaSeries } from "../../../../grammar/areaSeries.js";
-import { readQuantitativeField } from "../../../../grammar/scales/index.js";
 
 export function isCategoricalDensityPosition({
   layer,
@@ -50,44 +48,8 @@ export function resolveAreaPositionPolicy({
     throw new Error("Area position encoding does not support aggregate or bin.");
   }
   if (args.stack === undefined) return emptyPositionPolicy();
-  const stack = validateStack(args.stack, "Area y encoding");
-  if (stack === "center") {
-    if (channel !== "y") {
-      throw new Error("Area center stack requires a y encoding.");
-    }
-    if (layer.encoding?.group?.fieldType !== "nominal") {
-      throw new Error("Area center stack requires a nominal group encoding.");
-    }
-    if (
-      layer.encoding?.color?.layout !== undefined &&
-      layer.encoding.color.layout !== "center"
-    ) {
-      throw new Error("Area center stack requires a matching center color layout.");
-    }
-    const values = readQuantitativeField(dataset.values, field);
-    if (values.some(value => value < 0)) {
-      throw new RangeError("Area center stack requires non-negative values.");
-    }
-    if (layer.encoding?.x !== undefined) {
-      deriveCenteredAreaSeries(dataset.values, {
-        ...layer,
-        encoding: {
-          ...layer.encoding,
-          y: { field, fieldType, stack: "center" }
-        }
-      });
-    }
-    return { bin: undefined, aggregate: undefined, stack };
-  }
-  if (
-    channel !== "y" ||
-    density === undefined
-  ) {
-    throw new Error("Area stack currently requires a density y encoding.");
-  }
-  return {
-    bin: undefined,
-    aggregate: undefined,
-    stack
-  };
+  const stack = validateStack(args.stack, "Area position encoding");
+  if (fieldType !== "quantitative") throw new Error("Area stack requires a quantitative measure.");
+  if (stack === "center" && channel !== "y") throw new Error("Area center stack requires a y encoding.");
+  return { bin: undefined, aggregate: undefined, stack };
 }

package/src/actions/encodings/position/policies/bar.js

@@ -4,12 +4,16 @@ import {
 } from "../../../../grammar/aggregate.js";
 import {
   BAR_ORIENTATIONS,
+  BAR_GRAINS,
+  resolveBarGrain,
   resolveBarOffsetChannel,
   resolveBarOrientation
 } from "../../../../grammar/bars/policy.js";
 import { resolveBin, validateStack } from "./common.js";
+import { normalizeStatisticalWeight } from
+  "../../../../grammar/weightedStatistics.js";
 
-export function resolveBarPositionPolicy({
+function resolveBarChannelPolicy({
   program,
   layer,
   channel,
@@ -35,6 +39,10 @@ export function resolveBarPositionPolicy({
       throw new Error("Binned bar x encoding does not support aggregate or stack.");
     }
     bin = resolveBin(args.bin);
+    const weight = args.weight === undefined
+      ? undefined
+      : normalizeStatisticalWeight(args.weight, "Histogram weight");
+    return { bin, aggregate, stack, weight };
   } else if (
     fieldType === "quantitative" &&
     channel === "y" &&
@@ -72,17 +80,12 @@ export function resolveBarPositionPolicy({
     if (pendingBoxRange && args.aggregate === undefined) {
       return { bin, aggregate, stack };
     }
-    if (aggregate === undefined) {
-      throw new Error(
-        channel === "x"
-          ? "Quantitative bar x encoding requires bin or aggregate."
-          : "Bar y encoding requires a binned quantitative or ordinal x category, temporal x category, or aggregate."
-      );
+    stack = Object.hasOwn(args, "stack") ? args.stack : opposite === undefined ? undefined : null;
+    if (aggregate !== undefined) {
+      aggregate = validateAggregate(aggregate);
+      validateAggregateFieldType(aggregate, fieldType);
     }
-    stack = Object.hasOwn(args, "stack") ? args.stack : null;
-    aggregate = validateAggregate(aggregate);
-    validateAggregateFieldType(aggregate, fieldType);
-    stack = validateStack(stack, `Bar ${channel} encoding`);
+    if (stack !== undefined) stack = validateStack(stack, `Bar ${channel} encoding`);
     if (stack === "center") {
       throw new Error("Centered bars are not supported.");
     }
@@ -92,13 +95,48 @@ export function resolveBarPositionPolicy({
     );
   }
 
+  if (args.weight !== undefined) {
+    throw new Error("Bar weight is supported only for a binned x encoding.");
+  }
+  return { bin, aggregate, stack };
+}
+
+export function resolveBarPositionPolicy(context) {
+  const { program, layer, channel, field, fieldType } = context;
+  const policy = resolveBarChannelPolicy(context);
+  const oppositeChannel = channel === "x" ? "y" : "x";
+  const opposite = layer.encoding?.[oppositeChannel];
+  const pendingBoxRange = program.markConfigs[layer.id]?.boxPlot !== undefined;
   const candidate = {
     ...layer,
     encoding: {
       ...layer.encoding,
-      [channel]: { field, fieldType, bin, aggregate, stack }
+      [channel]: { field, fieldType, ...policy }
     }
   };
+  // The same channel policy owns a measure whether it is authored first or last.
+  // Absence of an aggregate/stack is sufficient to represent an unresolved role.
+  let companion;
+  if (
+    !pendingBoxRange && resolveBarGrain(layer) === undefined &&
+    opposite?.fieldType === "quantitative" && opposite.bin === undefined
+  ) {
+    const resolved = resolveBarChannelPolicy({
+      ...context,
+      layer: candidate,
+      channel: oppositeChannel,
+      field: opposite.field,
+      fieldType: opposite.fieldType,
+      args: opposite
+    });
+    candidate.encoding[oppositeChannel] = { ...opposite, ...resolved };
+    if (
+      (opposite.aggregate === undefined && resolved.aggregate !== undefined) ||
+      opposite.stack !== resolved.stack
+    ) {
+      companion = { channel: oppositeChannel, encoding: candidate.encoding[oppositeChannel] };
+    }
+  }
   const orientation = resolveBarOrientation(candidate);
   if (opposite !== undefined && orientation === undefined && !pendingBoxRange) {
     throw new Error(
@@ -116,5 +154,11 @@ export function resolveBarPositionPolicy({
       `${orientation} bars require ${expectedOffset}; remove the incompatible ${incompatibleOffset} encoding.`
     );
   }
-  return { bin, aggregate, stack };
+  if (
+    program.markConfigs[layer.id]?.barWidth !== undefined &&
+    resolveBarGrain(candidate) === BAR_GRAINS.histogram
+  ) {
+    throw new Error("A saved Bar width requires an aggregate or ranged category slot and cannot be applied to histogram bins.");
+  }
+  return companion === undefined ? policy : { ...policy, companion };
 }