ggaction 0.0.10 → 0.0.12

package/src/actions/encodings/ranged.js

@@ -11,11 +11,13 @@ import {
 import { normalizeRuleDatum } from "../../grammar/rules.js";
 import {
   canMaterializeArea,
-  canMaterializeLine
+  canMaterializeLine,
+  getPositionEncodingMaterializationSteps
 } from "../../materialization/marks/index.js";
 import { findLayer } from "../../selectors/layers.js";
 import {
   resolveTarget,
+  setEncodingProperties,
   validateLineSeriesCompatibility,
   validateOptions
 } from "./shared.js";
@@ -138,28 +140,21 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
       });
     }
   }
-  next = next
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.${hasField ? "field" : "datum"}`,
-      value: hasField ? args.field : args.datum
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.fieldType`,
-      value: fieldType
-    })
-    .editSemantic({
-      property: `layer[${target}].encoding.${channel}.scale`,
-      value: primary.scale
-    })
-    .rematerializeScale({ id: primary.scale });
-  if (rule) return next.rematerializeRuleMark({ id: target });
-  return layer.mark.type === "bar"
-    ? next.rematerializeBarMark({ id: target })
-    : layer.mark.type === "rect"
-      ? next.rematerializeRectMark({ id: target })
-      : canMaterializeArea(next, findLayer(next, target))
-        ? next.rematerializeAreaMark({ id: target })
-        : next;
+  next = setEncodingProperties(next, target, channel, {
+    [hasField ? "field" : "datum"]: hasField ? args.field : args.datum,
+    fieldType,
+    scale: primary.scale
+  });
+
+  const updated = findLayer(next, target);
+  for (const step of getPositionEncodingMaterializationSteps(
+    next,
+    updated,
+    primary.scale
+  )) {
+    next = next[step.op](step.args);
+  }
+  return next;
 }
 
 const encodeX2 = action(

package/src/actions/encodings/remove.js

@@ -16,6 +16,7 @@ import {
 } from "../../materialization/marks/index.js";
 import { findLayer } from "../../selectors/layers.js";
 import { removeLegendKinds } from "../guides/legends/remove.js";
+import { clearMarkGraphic } from "./shared.js";
 
 const OPTIONS = Object.freeze(["target", "channel"]);
 const REMOVABLE_CHANNELS = Object.freeze([
@@ -35,6 +36,10 @@ const SPECIALIZED_LEGEND_KIND = Object.freeze({
   opacity: Object.freeze(["opacity"]),
   strokeWidth: Object.freeze(["strokeWidth"])
 });
+const LEGEND_OPTION_KEYS = Object.freeze([
+  "position", "align", "direction", "columns", "offset", "titlePosition",
+  "title", "symbol", "labels", "titleStyle", "itemGap", "border"
+]);
 
 function resolveTarget(program, requested, channel) {
   const candidates = program.semanticSpec.layers.filter(
@@ -178,22 +183,15 @@ function reconcileCategoricalLegend(program, target, channels) {
     return removeLegendKinds(program, [kind]);
   }
   const next = removeLegendKinds(program, [kind]);
-  return next.createLegend({
-    target,
-    channels: remaining,
-    position: config.position,
-    align: config.align,
-    direction: config.direction,
-    ...(config.columns === undefined ? {} : { columns: config.columns }),
-    offset: config.offset,
-    titlePosition: config.titlePosition,
-    ...(config.inferredTitle ? {} : { title: config.title }),
-    symbol: config.symbol,
-    labels: config.labels,
-    titleStyle: config.titleStyle,
-    itemGap: config.itemGap,
-    border: config.border
-  });
+  const options = { target, channels: remaining };
+  for (const property of LEGEND_OPTION_KEYS) {
+    if (
+      (property === "columns" && config[property] === undefined) ||
+      (property === "title" && config.inferredTitle)
+    ) continue;
+    options[property] = config[property];
+  }
+  return next.createLegend(options);
 }
 
 function cleanupLegends(program, target, channels) {
@@ -204,18 +202,10 @@ function cleanupLegends(program, target, channels) {
   return kinds.length === 0 ? next : removeLegendKinds(next, kinds);
 }
 
-function clearGraphic(program, target) {
-  const graphic = program.graphicSpec.objects[target];
-  if (graphic === undefined) return program;
-  return graphic.type === "collection"
-    ? program.editGraphics({ target, property: "items", value: [] })
-    : program.editGraphics({ target, property: "length", value: 0 });
-}
-
 function rematerializeTarget(program, target) {
   const layer = findLayer(program, target);
   const step = getMarkMaterializationStep(program, layer);
-  const baseline = clearGraphic(program, target);
+  const baseline = clearMarkGraphic(program, target);
   let next = step === undefined
     ? baseline
     : baseline[step.op](step.args);

package/src/actions/encodings/ruleAppearance.js

@@ -7,12 +7,12 @@ import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { resolveStrokeWidthScaleDefinition } from "../scales/definitions.js";
 import {
   applyEncodingScale,
+  rematerializeEncoding,
   resolveReassignmentScaleOptions,
   resolveTarget,
+  setEncodingProperties,
   validateOptions
 } from "./shared.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
-import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import { findLayer } from "../../selectors/layers.js";
 
 const STROKE_OPTIONS = Object.freeze(["target", "value"]);
@@ -91,31 +91,16 @@ const encodeStrokeWidth = action(
     const scale = resolveStrokeWidthScaleDefinition(this, requestedScale);
     const { strokeWidth, ...config } = this.markConfigs[id] ?? {};
     void strokeWidth;
-    let next = this
-      ._withMarkConfig(id, config)
-      .editSemantic({
-        property: `layer[${id}].encoding.strokeWidth.field`,
-        value: args.field
-      })
-      .editSemantic({
-        property: `layer[${id}].encoding.strokeWidth.fieldType`,
-        value: fieldType
-      })
-      .editSemantic({
-        property: `layer[${id}].encoding.strokeWidth.scale`,
-        value: scale.id
-      });
+    let next = setEncodingProperties(
+      this._withMarkConfig(id, config),
+      id,
+      "strokeWidth",
+      { field: args.field, fieldType, scale: scale.id }
+    );
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
-    return applyMaterializationPlan(
-      next,
-      planEncodingRematerialization(next, {
-        target: id,
-        channel: "strokeWidth",
-        scale: scale.id
-      })
-    );
+    return rematerializeEncoding(next, id, "strokeWidth", scale.id);
   }
 );
 

package/src/actions/encodings/shared.js

@@ -2,6 +2,8 @@ import { validateUserId } from "../../core/identifiers.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { resolveEligibleLayer } from "../../selectors/layers.js";
 import { hasMaterializedLegend } from "../../materialization/legends.js";
+import { applyMaterializationPlan } from "../../materialization/dependencies.js";
+import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { validateOptionObject } from "../../core/validation.js";
 import {
@@ -13,6 +15,41 @@ export function validateOptions(args, supported, operation) {
   validateOptionObject(args, supported, operation);
 }
 
+export function setEncodingProperties(
+  program,
+  target,
+  channel,
+  properties
+) {
+  let next = program;
+  for (const [property, value] of Object.entries(properties)) {
+    next = next.editSemantic({
+      property: `layer[${target}].encoding.${channel}.${property}`,
+      value
+    });
+  }
+  return next;
+}
+
+export function rematerializeEncoding(program, target, channel, scale) {
+  return applyMaterializationPlan(
+    program,
+    planEncodingRematerialization(program, { target, channel, scale })
+  );
+}
+
+export function clearMarkGraphic(program, target) {
+  const graphic = program.graphicSpec.objects[target];
+  if (graphic === undefined) return program;
+  const collection = graphic.type === "collection";
+  return program.editGraphics({
+    target,
+    property: collection ? "items" : "length",
+    value: collection ? [] : 0
+  });
+}
+
+
 export function validateLineSeriesCompatibility(layer, channel, field) {
   if (layer.mark?.type !== "line") return;
   for (const companion of ["group", "color", "strokeDash"]) {

package/src/actions/encodings/strokeDash.js

@@ -5,12 +5,12 @@ import {
   validateNominalFieldType
 } from "../../grammar/scales/index.js";
 import { resolveStrokeDashScaleDefinition } from "../scales/definitions.js";
-import { applyMaterializationPlan } from "../../materialization/dependencies.js";
-import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import {
   applyEncodingScale,
+  rematerializeEncoding,
   resolveReassignmentScaleOptions,
   resolveTarget,
+  setEncodingProperties,
   validateLineSeriesCompatibility,
   validateOptions
 } from "./shared.js";
@@ -111,31 +111,16 @@ const encodeStrokeDash = action(
     let next = previous === undefined
       ? this
       : this.clearStrokeDashEncoding({ target });
-    next = next
-      .editSemantic({
-        property: `layer[${target}].encoding.strokeDash.field`,
-        value: args.field
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.strokeDash.fieldType`,
-        value: fieldType
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.strokeDash.scale`,
-        value: scale.id
-      });
+    next = setEncodingProperties(next, target, "strokeDash", {
+      field: args.field,
+      fieldType,
+      scale: scale.id
+    });
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
 
-    return applyMaterializationPlan(
-      next,
-      planEncodingRematerialization(next, {
-        target,
-        channel: "strokeDash",
-        scale: scale.id
-      })
-    );
+    return rematerializeEncoding(next, target, "strokeDash", scale.id);
   }
 );
 

package/src/actions/encodings/text.js

@@ -2,7 +2,11 @@ import { action } from "../../core/action.js";
 import { formatTextValue, validateTextFormat } from "../../grammar/text.js";
 import { canMaterializeText } from "../../materialization/marks/index.js";
 import { findLayer } from "../../selectors/layers.js";
-import { resolveTarget, validateOptions } from "./shared.js";
+import {
+  resolveTarget,
+  setEncodingProperties,
+  validateOptions
+} from "./shared.js";
 
 const OPTIONS = Object.freeze(["target", "field", "value", "format"]);
 
@@ -52,15 +56,10 @@ export const encodeText = action(
         remove: true
       });
     }
-    next = next
-      .editSemantic({
-        property: `layer[${target}].encoding.text.${hasField ? "field" : "datum"}`,
-        value: hasField ? args.field : args.value
-      })
-      .editSemantic({
-        property: `layer[${target}].encoding.text.format`,
-        value: format
-      });
+    next = setEncodingProperties(next, target, "text", {
+      [hasField ? "field" : "datum"]: hasField ? args.field : args.value,
+      format
+    });
     const updated = findLayer(next, target);
     return canMaterializeText(next, updated)
       ? next.rematerializeTextMark({ id: target })

package/src/actions/errorBands/create.js

@@ -5,8 +5,9 @@ import {
 } from "../../core/validation.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
-import { resolveBoundaryAppearance } from "./options.js";
-import { resolveErrorBand } from "./resolve.js";
+import { createResolvedIntervalData } from "../data/intervalEdit.js";
+import { resolveIntervalComposite } from "../intervals/resolve.js";
+import { errorBandBoundaries, resolveBoundaryAppearance } from "./edit.js";
 
 const OPTIONS = Object.freeze([
   "id",
@@ -21,6 +22,38 @@ const OPTIONS = Object.freeze([
   "curve",
   "boundaries"
 ]);
+
+const ERROR_BAND_POLICY = Object.freeze({
+  operation: "createErrorBand",
+  resourceLabel: "error-band",
+  defaultId: "errorBand",
+  ownerLabel: "Error-band id",
+  positionTypes: Object.freeze(["quantitative", "temporal"]),
+  defaultPositionType: "quantitative",
+  defaultIntervalChannel: "y",
+  scaleDefaults: fieldType => fieldType === "temporal"
+    ? { nice: true }
+    : { nice: true, zero: false },
+  intervalScaleDefaults: Object.freeze({ nice: true, zero: false }),
+  allowExplicitGrouping: true,
+  ambiguousMessage:
+    "createErrorBand cannot infer the interval axis when both positions are quantitative; provide an interval option."
+});
+
+function resolveErrorBand(program, args) {
+  const resolved = resolveIntervalComposite(program, args, ERROR_BAND_POLICY);
+  if (resolved.groupField === resolved.position.field) {
+    throw new Error(
+      "createErrorBand groupBy must differ from the independent position field."
+    );
+  }
+  return {
+    ...resolved,
+    lowerBoundaryId: `${resolved.id}LowerBoundary`,
+    upperBoundaryId: `${resolved.id}UpperBoundary`
+  };
+}
+
 function resolveBoundaries(value, areaCurve) {
   if (value === undefined || value === false) return undefined;
   if (!isPlainObject(value)) {
@@ -38,6 +71,62 @@ function resolveBoundaries(value, areaCurve) {
   });
 }
 
+function positionOptions({ target, field, fieldType, coordinate, scale }) {
+  return { target, field, fieldType, coordinate, scale: { id: scale } };
+}
+
+export const createErrorBandBoundary = action(
+  {
+    op: "createErrorBandBoundary",
+    description: "Create one lower or upper error-band boundary line."
+  },
+  function ({
+    id,
+    data,
+    orientation,
+    bound,
+    position,
+    coordinate,
+    intervalScale,
+    positionScale,
+    groupBy,
+    stroke,
+    strokeWidth,
+    strokeDash,
+    opacity,
+    curve
+  } = {}) {
+    const vertical = orientation === "vertical";
+    let next = this
+      .createLineMark({ id, data, strokeWidth, curve })
+      .encodeY(positionOptions({
+        target: id,
+        field: vertical ? bound : position.field,
+        fieldType: vertical ? "quantitative" : position.fieldType,
+        coordinate,
+        scale: vertical ? intervalScale : positionScale
+      }))
+      .encodeX(positionOptions({
+        target: id,
+        field: vertical ? position.field : bound,
+        fieldType: vertical ? position.fieldType : "quantitative",
+        coordinate,
+        scale: vertical ? positionScale : intervalScale
+      }));
+    if (groupBy !== undefined) {
+      next = next.encodeGroup({ target: id, field: groupBy });
+    }
+    return next
+      .editGraphics({ target: id, property: "stroke", value: stroke })
+      .editGraphics({
+        target: id,
+        property: "strokeDash",
+        value: next.graphicSpec.objects[id].items.map(() => strokeDash)
+      })
+      .editGraphics({ target: id, property: "opacity", value: opacity });
+  }
+);
+
 function positionArgs(resolved) {
   return {
     target: resolved.id,
@@ -69,21 +158,7 @@ export const createErrorBand = action(
     const resolved = resolveErrorBand(this, args);
     const curve = validateCurveInterpolation(args.curve ?? "linear");
     const boundaries = resolveBoundaries(args.boundaries, curve);
-    let next = this;
-
-    if (resolved.interval.mode === "statistical") {
-      next = next.createIntervalData({
-        id: resolved.dataId,
-        source: resolved.source,
-        field: resolved.interval.field,
-        groupBy: resolved.groupBy,
-        center: resolved.interval.center,
-        extent: resolved.interval.extent,
-        level: resolved.interval.level,
-        as: resolved.fields
-      });
-    }
-
+    let next = createResolvedIntervalData(this, resolved);
     next = next.createAreaMark({
       id: resolved.id,
       data: resolved.dataId,
@@ -91,13 +166,11 @@ export const createErrorBand = action(
       ...(args.opacity === undefined ? {} : { opacity: args.opacity }),
       ...(Object.hasOwn(args, "curve") ? { curve } : {})
     });
-    next = resolved.orientation === "vertical"
-      ? next
-          .encodeX(positionArgs(resolved))
-          .encodeYRange(rangeArgs(resolved))
-      : next
-          .encodeY(positionArgs(resolved))
-          .encodeXRange(rangeArgs(resolved));
+    const vertical = resolved.orientation === "vertical";
+    next = next[vertical ? "encodeX" : "encodeY"](positionArgs(resolved));
+    next = next[vertical ? "encodeYRange" : "encodeXRange"](
+      rangeArgs(resolved)
+    );
 
     if (resolved.interval.mode === "explicit") {
       next = next.editSemantic({
@@ -125,21 +198,14 @@ export const createErrorBand = action(
         groupBy: resolved.groupField,
         ...boundaries
       };
-      next = next
-        .createErrorBandBoundary({
+      for (const [id, field] of errorBandBoundaries(resolved)) {
+        next = next.createErrorBandBoundary({
           ...shared,
-          id: `${resolved.id}LowerBoundary`,
-          bound: resolved.fields.lower
-        })
-        .createErrorBandBoundary({
-          ...shared,
-          id: `${resolved.id}UpperBoundary`,
-          bound: resolved.fields.upper
+          id,
+          bound: field
         });
-      for (const [id, bound] of [
-        [`${resolved.id}LowerBoundary`, "lower"],
-        [`${resolved.id}UpperBoundary`, "upper"]
-      ]) {
+      }
+      for (const [id, , bound] of errorBandBoundaries(resolved)) {
         next = next._withMarkConfig(id, {
           ...next.markConfigs[id],
           ...boundaries,
@@ -159,8 +225,8 @@ export const createErrorBand = action(
         groupBy: resolved.groupField,
         lowerField: resolved.fields.lower,
         upperField: resolved.fields.upper,
-        lowerBoundaryId: `${resolved.id}LowerBoundary`,
-        upperBoundaryId: `${resolved.id}UpperBoundary`
+        lowerBoundaryId: resolved.lowerBoundaryId,
+        upperBoundaryId: resolved.upperBoundaryId
       }
     });
   }