ggaction 0.0.9 → 0.0.11

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
       }
     });
   }

package/src/actions/errorBands/edit.js

@@ -3,17 +3,44 @@ import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import {
   validateOptionObject,
+  validateKeys,
   validateNonEmptyString,
+  validateNonNegativeFinite,
   validateUnitInterval
 } from "../../core/validation.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
-import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
+import { normalizeStrokeDashPattern } from "../../grammar/scales/index.js";
+import { findLayer } from "../../selectors/layers.js";
+import { removeOwnedMark } from "../marks/remove.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
-import { planIntervalEdit } from "../data/intervalEdit.js";
 import {
-  ERROR_BAND_BOUNDARY_OPTIONS,
-  resolveBoundaryAppearance
-} from "./options.js";
+  applyIntervalRevision,
+  ownOptions,
+  planIntervalEdit,
+  releaseIntervalRevision,
+  resolveIntervalOwner
+} from "../data/intervalEdit.js";
+
+export const ERROR_BAND_BOUNDARY_OPTIONS = Object.freeze([
+  "stroke", "strokeWidth", "strokeDash", "opacity", "curve"
+]);
+
+export function resolveBoundaryAppearance(value, { defaults, operation }) {
+  if (!isPlainObject(value)) {
+    throw new TypeError(`${operation} must be a plain object.`);
+  }
+  validateKeys(value, ERROR_BAND_BOUNDARY_OPTIONS, operation);
+  const stroke = value.stroke ?? defaults.stroke;
+  const strokeWidth = value.strokeWidth ?? defaults.strokeWidth;
+  const strokeDash = value.strokeDash ?? defaults.strokeDash;
+  const opacity = value.opacity ?? defaults.opacity;
+  const curve = validateCurveInterpolation(value.curve ?? defaults.curve);
+  validateNonEmptyString(stroke, `${operation} stroke`);
+  validateNonNegativeFinite(strokeWidth, `${operation} strokeWidth`);
+  const resolvedStrokeDash = normalizeStrokeDashPattern(strokeDash);
+  validateUnitInterval(opacity, `${operation} opacity`);
+  return { stroke, strokeWidth, strokeDash: resolvedStrokeDash, opacity, curve };
+}
 
 const EDIT_OPTIONS = Object.freeze([
   "target", "fill", "opacity", "curve", "statistics", "boundaries"
@@ -25,16 +52,27 @@ const REMATERIALIZE_OPTIONS = Object.freeze([
   "id", ...ERROR_BAND_BOUNDARY_OPTIONS
 ]);
 
+export function errorBandBoundaries(config) {
+  return [
+    [
+      config.lowerBoundaryId,
+      config.fields?.lower ?? config.lowerField,
+      "lower"
+    ],
+    [
+      config.upperBoundaryId,
+      config.fields?.upper ?? config.upperField,
+      "upper"
+    ]
+  ];
+}
+
 function resolveOwner(program, requested) {
-  const target = requested === undefined
-    ? undefined
-    : validateUserId(requested, "Error-band id");
-  return resolveEligibleLayer(program, {
-    target,
+  return resolveIntervalOwner(program, requested, {
+    idLabel: "Error-band id",
     label: "error band",
-    predicate: layer =>
-      layer.mark?.type === "area" &&
-      program.markConfigs[layer.id]?.errorBand !== undefined
+    mark: "area",
+    config: "errorBand"
   });
 }
 
@@ -90,31 +128,7 @@ function createBoundary(program, owner, id, bound, appearance) {
 }
 
 function removeBoundary(program, id) {
-  if (findLayer(program, id) === undefined) return program;
-  const selectionIds = Object.entries(
-    program.materializationConfigs.selections ?? {}
-  ).filter(([, config]) => config.target === id).map(([selection]) => selection);
-  let next = program;
-  for (const [highlight, config] of Object.entries(
-    program.materializationConfigs.highlights ?? {}
-  )) {
-    if (config.target === id || selectionIds.includes(config.selection)) {
-      next = next._withoutMaterializationConfig(["highlights", highlight]);
-    }
-  }
-  for (const selection of selectionIds) {
-    next = next._withoutMaterializationConfig(["selections", selection]);
-  }
-  return next
-    .editSemantic({ property: `layer[${id}]`, remove: true })
-    .editGraphics({ target: id, remove: true })
-    ._withoutMaterializationConfig(["marks", id])
-    ._withContext({
-      ...(program.context.currentMark === id ? { currentMark: undefined } : {}),
-      ...(selectionIds.includes(program.context.currentSelection)
-        ? { currentSelection: undefined }
-        : {})
-    });
+  return removeOwnedMark(program, id);
 }
 
 export const rematerializeErrorBandBoundary = action(
@@ -178,7 +192,8 @@ export const editErrorBand = action(
           data: errorBand.data,
           consumers: [
             owner.id,
-            ...[errorBand.lowerBoundaryId, errorBand.upperBoundaryId]
+            ...errorBandBoundaries(errorBand)
+              .map(([id]) => id)
               .filter(id => findLayer(this, id) !== undefined)
           ],
           statistics: args.statistics,
@@ -195,58 +210,43 @@ export const editErrorBand = action(
       );
     }
 
-    const applyEdit = program => {
-      let next = program;
-      if (interval.changed) {
-        next = next.createIntervalData(interval.dataArgs);
-        for (const rebind of interval.revision.rebinds) {
-          next = next.rebindLayerData(rebind);
+    let next = applyIntervalRevision(this, interval);
+    if (interval.changed) errorBand.data = interval.revision.id;
+    next = next
+      ._withMarkConfig(owner.id, { ...config, errorBand })
+      .rematerializeAreaMark({ id: owner.id });
+    if (Object.hasOwn(args, "boundaries")) {
+      if (args.boundaries === false) {
+        next = removeBoundary(next, errorBand.lowerBoundaryId);
+        next = removeBoundary(next, errorBand.upperBoundaryId);
+      } else if (Object.keys(args.boundaries).length === 0) {
+        for (const [id, bound] of errorBandBoundaries(errorBand)) {
+          next = findLayer(next, id) === undefined
+            ? createBoundary(
+                next,
+                owner.id,
+                id,
+                bound,
+                defaultBoundaryAppearance(next, owner.id)
+              )
+            : interval.changed
+              ? next.rematerializeLineMark({ id })
+              : next;
         }
-        errorBand.data = interval.revision.id;
+      } else {
+        next = next.editErrorBandBoundary({
+          target: owner.id,
+          ...args.boundaries
+        });
       }
-      next = next
-        ._withMarkConfig(owner.id, { ...config, errorBand })
-        .rematerializeAreaMark({ id: owner.id });
-      if (Object.hasOwn(args, "boundaries")) {
-        if (args.boundaries === false) {
-          next = removeBoundary(next, errorBand.lowerBoundaryId);
-          next = removeBoundary(next, errorBand.upperBoundaryId);
-        } else if (Object.keys(args.boundaries).length === 0) {
-          for (const [id, bound] of [
-            [errorBand.lowerBoundaryId, errorBand.lowerField],
-            [errorBand.upperBoundaryId, errorBand.upperField]
-          ]) {
-            next = findLayer(next, id) === undefined
-              ? createBoundary(
-                  next,
-                  owner.id,
-                  id,
-                  bound,
-                  defaultBoundaryAppearance(next, owner.id)
-                )
-              : interval.changed
-                ? next.rematerializeLineMark({ id })
-                : next;
-          }
-        } else {
-          next = next.editErrorBandBoundary({
-            target: owner.id,
-            ...args.boundaries
-          });
-        }
-      } else if (interval.changed) {
-        for (const id of [errorBand.lowerBoundaryId, errorBand.upperBoundaryId]) {
-          if (findLayer(next, id) !== undefined) {
-            next = next.rematerializeLineMark({ id });
-          }
+    } else if (interval.changed) {
+      for (const [id] of errorBandBoundaries(errorBand)) {
+        if (findLayer(next, id) !== undefined) {
+          next = next.rematerializeLineMark({ id });
         }
       }
-      return interval.changed
-        ? next.releaseDerivedData(interval.revision.release)
-        : next;
-    };
-    if (interval.changed || Object.hasOwn(args, "boundaries")) applyEdit(this);
-    return applyEdit(this);
+    }
+    return releaseIntervalRevision(next, interval);
   }
 );
 
@@ -270,13 +270,9 @@ export const editErrorBandBoundary = action(
     }
     const owner = resolveOwner(this, args.target);
     const config = this.markConfigs[owner.id].errorBand;
-    const patch = Object.fromEntries(
-      ERROR_BAND_BOUNDARY_OPTIONS
-        .filter(key => Object.hasOwn(args, key))
-        .map(key => [key, args[key]])
-    );
+    const patch = ownOptions(args, ERROR_BAND_BOUNDARY_OPTIONS);
     const ids = boundary === "both"
-      ? [config.lowerBoundaryId, config.upperBoundaryId]
+      ? errorBandBoundaries(config).map(([id]) => id)
       : [boundary === "lower" ? config.lowerBoundaryId : config.upperBoundaryId];
     const plans = ids.map(id => {
       const existing = findLayer(this, id) !== undefined;

package/src/actions/errorBands/index.js

@@ -1,5 +1,4 @@
-import { createErrorBand } from "./create.js";
-import { createErrorBandBoundary } from "./components.js";
+import { createErrorBand, createErrorBandBoundary } from "./create.js";
 import {
   editErrorBand,
   editErrorBandBoundary,