ggaction 0.0.5 → 0.0.7

package/src/actions/encodings/appearance.js

@@ -9,7 +9,10 @@ import {
   resolveAppearanceScaleDefinition,
   resolveOpacityScaleDefinition
 } from "../scales/definitions.js";
-import { findLayer } from "../../selectors/layers.js";
+import {
+  findLayer,
+  resolveEligibleLayer
+} from "../../selectors/layers.js";
 import { applyMaterializationPlan } from "../../materialization/dependencies.js";
 import { planEncodingRematerialization } from "../../materialization/encodings.js";
 import {
@@ -20,6 +23,7 @@ import {
 } from "./shared.js";
 
 const RADIUS_OPTIONS = Object.freeze(["value", "target"]);
+const REMOVE_RADIUS_OPTIONS = Object.freeze(["target"]);
 const OPACITY_OPTIONS = Object.freeze([
   "value", "field", "target", "fieldType", "scale"
 ]);
@@ -129,6 +133,35 @@ const encodePointRadius = action(
   }
 );
 
+const removePointRadius = action(
+  {
+    op: "removePointRadius",
+    description: "Remove a constant point radius and restore the theme default."
+  },
+  function (args = {}) {
+    validateOptions(args, REMOVE_RADIUS_OPTIONS, "removePointRadius");
+    const requested = args.target === undefined
+      ? undefined
+      : args.target;
+    const layer = resolveEligibleLayer(this, {
+      target: requested,
+      predicate: candidate =>
+        candidate.mark?.type === "point" &&
+        this.markConfigs[candidate.id]?.radius !== undefined,
+      label: "point mark with an explicit radius"
+    });
+    const next = this
+      ._withoutMaterializationConfig(["marks", layer.id, "radius"]);
+    const graphic = next.graphicSpec.objects[layer.id];
+    const baseline = graphic === undefined
+      ? next
+      : graphic.type === "collection"
+        ? next.editGraphics({ target: layer.id, property: "items", value: [] })
+        : next.editGraphics({ target: layer.id, property: "length", value: 0 });
+    return baseline.rematerializePointMark({ id: layer.id });
+  }
+);
+
 const encodeSize = action(
   {
     op: "encodeSize",
@@ -244,11 +277,16 @@ const encodeOpacity = action(
   }
 );
 
+export function registerBasicAppearanceEncodingActions(ProgramClass) {
+  ProgramClass.prototype.encodeSize = encodeSize;
+  ProgramClass.prototype.encodeShape = encodeShape;
+}
+
 export function registerAppearanceEncodingAction(ProgramClass) {
+  registerBasicAppearanceEncodingActions(ProgramClass);
   ProgramClass.prototype.encodeRadius = encodeRadius;
   ProgramClass.prototype.encodePointRadius = encodePointRadius;
-  ProgramClass.prototype.encodeSize = encodeSize;
-  ProgramClass.prototype.encodeShape = encodeShape;
+  ProgramClass.prototype.removePointRadius = removePointRadius;
   ProgramClass.prototype.encodeOpacity = encodeOpacity;
   ProgramClass.prototype.clearOpacityEncoding = clearOpacityEncoding;
 }

package/src/actions/encodings/basic.js

@@ -0,0 +1,21 @@
+import { registerBasicAppearanceEncodingActions } from "./appearance.js";
+import { registerBarWidthEncodingAction } from "./barWidth.js";
+import { registerColorEncodingAction } from "./color/index.js";
+import { registerHistogramEncodingAction } from "./histogram.js";
+import { registerOffsetEncodingAction } from "./offset.js";
+import {
+  registerCartesianPositionEncodingActions
+} from "./position/index.js";
+import { registerBasicRangedEncodingActions } from "./ranged.js";
+import { registerStrokeDashEncodingActions } from "./strokeDash.js";
+
+export function registerBasicEncodingActions(ProgramClass) {
+  registerCartesianPositionEncodingActions(ProgramClass);
+  registerBasicRangedEncodingActions(ProgramClass);
+  registerColorEncodingAction(ProgramClass);
+  registerBasicAppearanceEncodingActions(ProgramClass);
+  registerStrokeDashEncodingActions(ProgramClass);
+  registerOffsetEncodingAction(ProgramClass);
+  registerHistogramEncodingAction(ProgramClass);
+  registerBarWidthEncodingAction(ProgramClass);
+}

package/src/actions/encodings/density.js

@@ -15,6 +15,7 @@ import { planDerivedDataRevision } from
 import { validateOptions } from "./shared.js";
 import { normalizeDensityPlacement } from "../../grammar/density.js";
 import { scaleEditPatch } from "../scales/patch.js";
+import { removeLegendKinds } from "../guides/legends/remove.js";
 import {
   requireDensityField,
   resolveDensityCategoryScaleOptions,
@@ -29,8 +30,8 @@ const OPTIONS = Object.freeze([
   "valueScale", "densityScale", "placement"
 ]);
 const EDIT_OPTIONS = Object.freeze([
-  "target", "bandwidth", "extent", "steps", "kernel", "normalization",
-  "placement"
+  "target", "source", "field", "groupBy", "bandwidth", "extent", "steps",
+  "kernel", "normalization", "placement"
 ]);
 const EDITABLE = Object.freeze(EDIT_OPTIONS.filter(option => option !== "target"));
 
@@ -190,6 +191,43 @@ function findDensityArea(program, requested) {
   });
 }
 
+function densityCategoryField(layer, transform, groupBy) {
+  if (transform.placement === undefined) return undefined;
+  if (transform.placement.categoryField !== transform.groupBy) {
+    return transform.placement.categoryField;
+  }
+  return groupBy ?? `${layer.id}DensityCategory`;
+}
+
+function assertGroupingSelectionCompatibility(program, layer, changesGroup) {
+  if (!changesGroup) return;
+  const referenced = Object.entries(
+    program.materializationConfigs.selections ?? {}
+  ).find(([, selection]) =>
+    selection.target === layer.id &&
+    ["group", "color"].includes(selection.selector?.channel)
+  );
+  if (referenced !== undefined) {
+    throw new Error(
+      `editDensity cannot change groupBy while selection "${referenced[0]}" ` +
+      `references ${referenced[1].selector.channel}.`
+    );
+  }
+}
+
+function removeOwnedColorLegends(program, target) {
+  const kinds = Object.entries(program.guideConfigs.legend ?? {})
+    .filter(([kind, config]) =>
+      config?.target === target &&
+      (
+        config.channels?.includes("color") ||
+        ["gradient", "interval"].includes(kind)
+      )
+    )
+    .map(([kind]) => kind);
+  return kinds.length === 0 ? program : removeLegendKinds(program, kinds);
+}
+
 const editDensity = action(
   {
     op: "editDensity",
@@ -203,21 +241,55 @@ const editDensity = action(
     const layer = findDensityArea(this, args.target);
     const previous = findDataset(this, layer.data);
     const transform = previous.transform[0];
+    const source = Object.hasOwn(args, "source")
+      ? validateUserId(args.source, "Density source dataset id")
+      : previous.source;
+    const field = Object.hasOwn(args, "field")
+      ? requireDensityField(args.field, "Density field")
+      : transform.field;
+    const groupBy = Object.hasOwn(args, "groupBy")
+      ? args.groupBy === false
+        ? undefined
+        : requireDensityField(args.groupBy, "Density groupBy")
+      : transform.groupBy;
+    const changesGroup = groupBy !== transform.groupBy;
+    assertGroupingSelectionCompatibility(this, layer, changesGroup);
+    const categoryField = densityCategoryField(layer, transform, groupBy);
     const requestedPlacement = Object.hasOwn(args, "placement")
       ? normalizeDensityPlacement(args.placement, {
           densityChannel: transform.placement?.channel ?? "x",
-          groupBy: transform.groupBy,
-          categoryField: transform.groupBy ??
-            transform.placement?.categoryField ??
+          groupBy,
+          categoryField: categoryField ?? groupBy ??
             `${layer.id}DensityCategory`
         })
-      : transform.placement;
+      : transform.placement === undefined || !changesGroup
+        ? transform.placement
+        : normalizeDensityPlacement({
+            type: "category",
+            ...(transform.placement.side === undefined
+              ? {}
+              : { side: transform.placement.side }),
+            width: transform.placement.width,
+            ...(transform.placement.split === undefined
+              ? {}
+              : { split: transform.placement.split })
+          }, {
+            densityChannel: transform.placement.channel,
+            groupBy,
+            categoryField
+          });
     const colorField = layer.encoding?.color?.field;
+    const colorFollowsGroup = transform.groupBy !== undefined &&
+      colorField === transform.groupBy;
     const availableColorFields = [
-      transform.groupBy,
+      groupBy,
       requestedPlacement?.split?.field
     ].filter(Boolean);
-    if (colorField !== undefined && !availableColorFields.includes(colorField)) {
+    if (
+      colorField !== undefined &&
+      !colorFollowsGroup &&
+      !availableColorFields.includes(colorField)
+    ) {
       throw new Error(
         `editDensity placement would remove color field "${colorField}" from the density series.`
       );
@@ -234,11 +306,11 @@ const editDensity = action(
 
     const dataArgs = {
       id: revision.id,
-      source: previous.source,
-      field: transform.field,
-      ...(transform.groupBy === undefined
+      source,
+      field,
+      ...(groupBy === undefined
         ? {}
-        : { groupBy: transform.groupBy }),
+        : { groupBy }),
       bandwidth: option("bandwidth"),
       extent: option("extent"),
       steps: option("steps"),
@@ -249,78 +321,141 @@ const editDensity = action(
         ? {}
         : { placement: requestedPlacement })
     };
-    let next = requestedPlacement === undefined
-      ? this.createDensityData(dataArgs)
-      : this.createCategoricalDensityData(dataArgs);
-    next = next.rebindLayerData(revision.rebinds[0])
-      .releaseDerivedData(revision.release);
-
     const changesPlacementMode = Object.hasOwn(args, "placement") &&
       (transform.placement === undefined) !== (requestedPlacement === undefined);
-    if (changesPlacementMode) {
-      const xScaleId = layer.encoding?.x?.scale;
-      const yScaleId = layer.encoding?.y?.scale;
-      const scaleDefinitions = resolveDensityTransitionScaleDefinitions(
-        this,
-        layer,
-        transform,
-        requestedPlacement,
-        args.placement
-      );
-      next = next
-        .editSemantic({ property: `layer[${layer.id}].encoding.x`, remove: true })
-        .editSemantic({ property: `layer[${layer.id}].encoding.y`, remove: true });
-      next = next
-        .editScale(scaleEditPatch(xScaleId, scaleDefinitions.x))
-        .editScale(scaleEditPatch(yScaleId, scaleDefinitions.y));
-      const densityChannel = requestedPlacement?.channel ?? (
-        layer.encoding.x.field === transform.as[1] ? "x" : "y"
-      );
-      const definition = resolveDensityPositionDefinition({
-        layer: { densityChannel },
-        output: transform.as,
-        groupBy: transform.groupBy,
-        placement: requestedPlacement,
-        coordinate: layer.coordinate,
-        valueScale: {
-          id: requestedPlacement?.channel === "x" ? yScaleId : xScaleId,
-          ...scaleDefinitions[requestedPlacement?.channel === "x" ? "y" : "x"]
-        },
-        densityScale: requestedPlacement === undefined
-          ? {
-              id: densityChannel === "x" ? xScaleId : yScaleId,
-              ...scaleDefinitions[densityChannel]
-            }
-          : undefined,
-        placementScale: requestedPlacement === undefined
-          ? undefined
-          : {
-              id: requestedPlacement.channel === "x" ? xScaleId : yScaleId,
-              ...scaleDefinitions[requestedPlacement.channel]
-            }
-      });
-      next = applyDensityPosition(next, layer.id, definition);
-    } else if (
-      requestedPlacement !== undefined &&
-      Object.hasOwn(args.placement ?? {}, "scale")
-    ) {
-      const channel = requestedPlacement.channel;
-      const scaleId = layer.encoding[channel].scale;
-      const requestedScale = resolveDensityCategoryScaleOptions(
-        args.placement.scale,
-        scaleId
-      );
-      if (requestedScale.id !== scaleId) {
-        throw new Error("editDensity placement scale cannot change its id.");
+    const applyEdit = program => {
+      let next = requestedPlacement === undefined
+        ? program.createDensityData(dataArgs)
+        : program.createCategoricalDensityData(dataArgs);
+      next = next.rebindLayerData(revision.rebinds[0])
+        .releaseDerivedData(revision.release);
+
+      if (changesGroup) {
+        if (groupBy === undefined) {
+          if (findLayer(next, layer.id).encoding?.group !== undefined) {
+            next = next.editSemantic({
+              property: `layer[${layer.id}].encoding.group`,
+              remove: true
+            });
+          }
+          if (colorFollowsGroup) {
+            next = next.editSemantic({
+              property: `layer[${layer.id}].encoding.color`,
+              remove: true
+            });
+            next = removeOwnedColorLegends(next, layer.id);
+          }
+        } else {
+          next = next
+            .editSemantic({
+              property: `layer[${layer.id}].encoding.group.field`,
+              value: groupBy
+            })
+            .editSemantic({
+              property: `layer[${layer.id}].encoding.group.fieldType`,
+              value: "nominal"
+            });
+          if (colorFollowsGroup) {
+            next = next.editSemantic({
+              property: `layer[${layer.id}].encoding.color.field`,
+              value: groupBy
+            });
+          }
+        }
+        if (
+          requestedPlacement !== undefined &&
+          transform.placement?.categoryField !== requestedPlacement.categoryField
+        ) {
+          next = next.editSemantic({
+            property: `layer[${layer.id}].encoding.${requestedPlacement.channel}.field`,
+            value: requestedPlacement.categoryField
+          });
+        }
       }
-      next = next.editScale(scaleEditPatch(scaleId, requestedScale));
-    }
 
-    next = applyMaterializationPlan(
-      next,
-      planDensityRematerialization(next, layer.id)
-    );
-    return next;
+      if (changesPlacementMode) {
+        const xScaleId = layer.encoding?.x?.scale;
+        const yScaleId = layer.encoding?.y?.scale;
+        const scaleDefinitions = resolveDensityTransitionScaleDefinitions(
+          program,
+          layer,
+          transform,
+          requestedPlacement,
+          args.placement
+        );
+        next = next
+          .editSemantic({
+            property: `layer[${layer.id}].encoding.x`,
+            remove: true
+          })
+          .editSemantic({
+            property: `layer[${layer.id}].encoding.y`,
+            remove: true
+          });
+        next = next
+          .editScale(scaleEditPatch(xScaleId, scaleDefinitions.x))
+          .editScale(scaleEditPatch(yScaleId, scaleDefinitions.y));
+        const densityChannel = requestedPlacement?.channel ?? (
+          layer.encoding.x.field === transform.as[1] ? "x" : "y"
+        );
+        const valueChannel = requestedPlacement?.channel === "x" ? "y" : "x";
+        const definition = resolveDensityPositionDefinition({
+          layer: { densityChannel },
+          output: transform.as,
+          groupBy,
+          placement: requestedPlacement,
+          coordinate: layer.coordinate,
+          valueScale: {
+            id: valueChannel === "y" ? yScaleId : xScaleId,
+            ...scaleDefinitions[valueChannel]
+          },
+          densityScale: requestedPlacement === undefined
+            ? {
+                id: densityChannel === "x" ? xScaleId : yScaleId,
+                ...scaleDefinitions[densityChannel]
+              }
+            : undefined,
+          placementScale: requestedPlacement === undefined
+            ? undefined
+            : {
+                id: requestedPlacement.channel === "x" ? xScaleId : yScaleId,
+                ...scaleDefinitions[requestedPlacement.channel]
+              }
+        });
+        next = applyDensityPosition(next, layer.id, definition, groupBy);
+      } else if (
+        requestedPlacement !== undefined &&
+        Object.hasOwn(args.placement ?? {}, "scale")
+      ) {
+        const channel = requestedPlacement.channel;
+        const scaleId = layer.encoding[channel].scale;
+        const requestedScale = resolveDensityCategoryScaleOptions(
+          args.placement.scale,
+          scaleId
+        );
+        if (requestedScale.id !== scaleId) {
+          throw new Error("editDensity placement scale cannot change its id.");
+        }
+        next = next.editScale(scaleEditPatch(scaleId, requestedScale));
+      }
+
+      next = applyMaterializationPlan(
+        next,
+        planDensityRematerialization(next, layer.id)
+      );
+      if (
+        changesGroup &&
+        colorFollowsGroup &&
+        groupBy !== undefined &&
+        Object.values(next.guideConfigs.legend ?? {})
+          .some(config => config?.target === layer.id)
+      ) {
+        next = next.rematerializeLegend();
+      }
+      return next;
+    };
+    applyEdit(this);
+    return applyEdit(this);
   }
 );
 

package/src/actions/encodings/index.js

@@ -12,6 +12,7 @@ import { registerStrokeDashEncodingActions } from "./strokeDash.js";
 import { registerRuleAppearanceEncodingActions } from "./ruleAppearance.js";
 import { registerTextEncodingAction } from "./text.js";
 import { registerParallelEncodingAction } from "./parallel.js";
+import { registerEncodingRemovalAction } from "./remove.js";
 
 export function registerEncodingActions(ProgramClass) {
   registerPositionEncodingActions(ProgramClass);
@@ -28,4 +29,5 @@ export function registerEncodingActions(ProgramClass) {
   registerRuleAppearanceEncodingActions(ProgramClass);
   registerTextEncodingAction(ProgramClass);
   registerParallelEncodingAction(ProgramClass);
+  registerEncodingRemovalAction(ProgramClass);
 }

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

@@ -135,9 +135,13 @@ const encodeR = action(
   }
 );
 
-export function registerPositionEncodingActions(ProgramClass) {
+export function registerCartesianPositionEncodingActions(ProgramClass) {
   ProgramClass.prototype.encodeX = encodeX;
   ProgramClass.prototype.encodeY = encodeY;
+}
+
+export function registerPositionEncodingActions(ProgramClass) {
+  registerCartesianPositionEncodingActions(ProgramClass);
   ProgramClass.prototype.encodeTheta = encodeTheta;
   ProgramClass.prototype.encodeR = encodeR;
 }

package/src/actions/encodings/ranged.js

@@ -291,10 +291,14 @@ const encodeGroup = action(
   }
 );
 
-export function registerRangedEncodingActions(ProgramClass) {
+export function registerBasicRangedEncodingActions(ProgramClass) {
   ProgramClass.prototype.encodeX2 = encodeX2;
   ProgramClass.prototype.encodeY2 = encodeY2;
+  ProgramClass.prototype.encodeGroup = encodeGroup;
+}
+
+export function registerRangedEncodingActions(ProgramClass) {
+  registerBasicRangedEncodingActions(ProgramClass);
   ProgramClass.prototype.encodeXRange = encodeXRange;
   ProgramClass.prototype.encodeYRange = encodeYRange;
-  ProgramClass.prototype.encodeGroup = encodeGroup;
 }