ggaction 0.0.5 → 0.0.6

package/src/actions/errorBands/edit.js

@@ -1,4 +1,5 @@
 import { action } from "../../core/action.js";
+import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import {
   validateOptionObject,
@@ -8,12 +9,15 @@ import {
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
+import { planIntervalEdit } from "../data/intervalEdit.js";
 import {
   ERROR_BAND_BOUNDARY_OPTIONS,
   resolveBoundaryAppearance
 } from "./options.js";
 
-const EDIT_OPTIONS = Object.freeze(["target", "fill", "opacity", "curve"]);
+const EDIT_OPTIONS = Object.freeze([
+  "target", "fill", "opacity", "curve", "statistics", "boundaries"
+]);
 const BOUNDARY_EDIT_OPTIONS = Object.freeze([
   "target", "boundary", ...ERROR_BAND_BOUNDARY_OPTIONS
 ]);
@@ -49,13 +53,16 @@ function currentBoundaryAppearance(program, id) {
 }
 
 function defaultBoundaryAppearance(program, owner) {
-  return {
-    stroke: DEFAULT_COLORS.mark,
-    strokeWidth: 1,
-    strokeDash: "solid",
-    opacity: 1,
-    curve: program.markConfigs[owner]?.curve ?? "linear"
-  };
+  return resolveBoundaryAppearance({}, {
+    defaults: {
+      stroke: DEFAULT_COLORS.mark,
+      strokeWidth: 1,
+      strokeDash: "solid",
+      opacity: 1,
+      curve: program.markConfigs[owner]?.curve ?? "linear"
+    },
+    operation: "editErrorBand boundaries"
+  });
 }
 
 function createBoundary(program, owner, id, bound, appearance) {
@@ -82,6 +89,34 @@ 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 }
+        : {})
+    });
+}
+
 export const rematerializeErrorBandBoundary = action(
   {
     op: "rematerializeErrorBandBoundary",
@@ -121,8 +156,9 @@ export const editErrorBand = action(
   },
   function (args = {}) {
     validateOptionObject(args, EDIT_OPTIONS, "editErrorBand");
-    if (!["fill", "opacity", "curve"].some(key => Object.hasOwn(args, key))) {
-      throw new Error("editErrorBand requires fill, opacity, or curve.");
+    if (!["fill", "opacity", "curve", "statistics", "boundaries"]
+      .some(key => Object.hasOwn(args, key))) {
+      throw new Error("editErrorBand requires at least one change.");
     }
     const owner = resolveOwner(this, args.target);
     const config = { ...this.markConfigs[owner.id] };
@@ -136,9 +172,81 @@ export const editErrorBand = action(
     if (Object.hasOwn(args, "curve")) {
       config.curve = validateCurveInterpolation(args.curve);
     }
-    return this
-      ._withMarkConfig(owner.id, { ...config, errorBand })
-      .rematerializeAreaMark({ id: owner.id });
+    const interval = Object.hasOwn(args, "statistics")
+      ? planIntervalEdit(this, {
+          owner: owner.id,
+          data: errorBand.data,
+          consumers: [
+            owner.id,
+            ...[errorBand.lowerBoundaryId, errorBand.upperBoundaryId]
+              .filter(id => findLayer(this, id) !== undefined)
+          ],
+          statistics: args.statistics,
+          operation: "editErrorBand"
+        })
+      : { changed: false };
+    if (
+      Object.hasOwn(args, "boundaries") &&
+      args.boundaries !== false &&
+      !isPlainObject(args.boundaries)
+    ) {
+      throw new TypeError(
+        "editErrorBand boundaries must be false or a plain object."
+      );
+    }
+
+    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);
+        }
+        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 [
+            [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 });
+          }
+        }
+      }
+      return interval.changed
+        ? next.releaseDerivedData(interval.revision.release)
+        : next;
+    };
+    if (interval.changed || Object.hasOwn(args, "boundaries")) applyEdit(this);
+    return applyEdit(this);
   }
 );
 

package/src/actions/errorBars/edit.js

@@ -2,7 +2,9 @@ import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
 import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
+import { planIntervalEdit } from "../data/intervalEdit.js";
 import {
+  ERROR_BAR_APPEARANCE_OPTIONS,
   ERROR_BAR_EDIT_OPTIONS,
   resolveErrorBarAppearance
 } from "./options.js";
@@ -112,19 +114,54 @@ export const editErrorBar = action(
     validateKeys(args, ERROR_BAR_EDIT_OPTIONS, "editErrorBar");
     const editable = ERROR_BAR_EDIT_OPTIONS.filter(option => option !== "target");
     if (!editable.some(option => Object.hasOwn(args, option))) {
-      throw new Error("editErrorBar requires at least one appearance change.");
+      throw new Error("editErrorBar requires at least one change.");
     }
     const owner = resolveOwner(this, args.target);
     const current = this.markConfigs[owner.id].errorBar;
-    const appearance = resolveErrorBarAppearance(args, {
+    const appearanceArgs = Object.fromEntries(
+      ERROR_BAR_APPEARANCE_OPTIONS
+        .filter(key => Object.hasOwn(args, key))
+        .map(key => [key, args[key]])
+    );
+    const appearance = resolveErrorBarAppearance(appearanceArgs, {
       defaults: current,
       operation: "editErrorBar"
     });
-    return this
-      ._withMarkConfig(owner.id, {
-        ...this.markConfigs[owner.id],
-        errorBar: { ...current, ...appearance }
-      })
-      .rematerializeErrorBar({ id: owner.id });
+    const interval = Object.hasOwn(args, "statistics")
+      ? planIntervalEdit(this, {
+          owner: owner.id,
+          data: current.data,
+          consumers: [
+            owner.id,
+            ...[current.lowerCapId, current.upperCapId]
+              .filter(id => findLayer(this, id) !== undefined)
+          ],
+          statistics: args.statistics,
+          operation: "editErrorBar"
+        })
+      : { changed: false };
+
+    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);
+        }
+      }
+      next = next._withMarkConfig(owner.id, {
+        ...next.markConfigs[owner.id],
+        errorBar: {
+          ...current,
+          ...appearance,
+          ...(interval.changed ? { data: interval.revision.id } : {})
+        }
+      }).rematerializeErrorBar({ id: owner.id });
+      return interval.changed
+        ? next.releaseDerivedData(interval.revision.release)
+        : next;
+    };
+    if (interval.changed) applyEdit(this);
+    return applyEdit(this);
   }
 );

package/src/actions/errorBars/options.js

@@ -13,9 +13,15 @@ import {
 
 export const ERROR_BAR_EDIT_OPTIONS = Object.freeze([
   "target", "caps", "capSize", "stroke", "strokeWidth",
-  "strokeDash", "opacity"
+  "strokeDash", "opacity", "statistics"
 ]);
 
+export const ERROR_BAR_APPEARANCE_OPTIONS = Object.freeze(
+  ERROR_BAR_EDIT_OPTIONS.filter(option =>
+    option !== "target" && option !== "statistics"
+  )
+);
+
 export function resolveErrorBarAppearance(args, {
   defaults,
   operation

package/src/actions/facets/actions.js

@@ -1,5 +1,5 @@
 import { action } from "../../core/action.js";
-import { isPlainObject } from "../../core/immutable.js";
+import { freezeOwned, isPlainObject } from "../../core/immutable.js";
 import {
   validateNonEmptyString,
   validateNonNegativeFinite,
@@ -9,6 +9,7 @@ import {
 import { resolveFacetDefinition } from "../../grammar/facets/index.js";
 import { normalizeFacetScalePolicies } from
   "../../grammar/facets/scales.js";
+import { FACET_SCALE_CHANNELS } from "../../grammar/facets/scales.js";
 import { resolveFacetLayout } from "../../layout/facets.js";
 import { compositionChildDescriptor } from
   "../../materialization/composition.js";
@@ -73,6 +74,76 @@ function requireFacetProgram(program, operation) {
   }
 }
 
+function currentFacetDefinition(program) {
+  const current = program.compositionSpec;
+  return resolveFacetDefinition(program.semanticSpec, {
+    id: current.id,
+    data: current.facet.data,
+    field: current.facet.field,
+    values: current.facet.values
+  });
+}
+
+function facetUnitTemplate(program) {
+  const seed = program.children[program.compositionSpec.children[0]];
+  if (seed === undefined) {
+    throw new Error(`Facet "${program.compositionSpec.id}" requires a retained child.`);
+  }
+  const { facets: _facets, ...unitConfigs } = program.materializationConfigs;
+  return new program.constructor({
+    semanticSpec: program.semanticSpec,
+    graphicSpec: seed.graphicSpec,
+    resolvedScales: program.resolvedScales,
+    materializationConfigs: freezeOwned({
+      ...unitConfigs,
+      canvas: seed.materializationConfigs.canvas
+    }),
+    children: {},
+    context: program.context,
+    trace: program.trace,
+    actionStack: program.actionStack,
+    actionSequence: program._actionSequence
+  });
+}
+
+function applicableScaleRequest(program, channels) {
+  return Object.fromEntries(FACET_SCALE_CHANNELS.flatMap(channel =>
+    program.semanticSpec.layers.some(
+      layer => layer.encoding?.[channel]?.scale !== undefined
+    )
+      ? [[channel, channels[channel]]]
+      : []
+  ));
+}
+
+function rederiveFacet(program, { scales, guides }) {
+  const current = program.compositionSpec;
+  const definition = currentFacetDefinition(program);
+  const request = applicableScaleRequest(program, scales);
+  const normalized = normalizeFacetScalePolicies(program.semanticSpec, request);
+  const derived = deriveFacetChildren(facetUnitTemplate(program), definition, {
+    closeInheritedAction: true,
+    stripTitle: true,
+    scales: request
+  });
+  const compositionSpec = {
+    ...current,
+    facet: {
+      ...current.facet,
+      scales: normalized.channels,
+      guides
+    }
+  };
+  let next = program._withCompositionState({
+    children: derived.children,
+    compositionSpec
+  });
+  for (const id of compositionSpec.children) {
+    next = next.useProgram({ id });
+  }
+  return next.materializeComposition();
+}
+
 export const facet = action(
   {
     op: "facet",
@@ -153,9 +224,73 @@ export const editFacetHeaders = action(
   }
 );
 
+export const editFacetScales = action(
+  {
+    op: "editFacetScales",
+    description: "Edit facet scale-resolution policies and rederive every cell.",
+    scope: "composition"
+  },
+  function (args = {}) {
+    requireFacetProgram(this, "editFacetScales");
+    validateOptionObject(args, FACET_SCALE_CHANNELS, "editFacetScales", {
+      allowEmpty: false,
+      emptyMessage: "editFacetScales requires at least one channel policy change."
+    });
+    for (const channel of Object.keys(args)) {
+      if (!this.semanticSpec.layers.some(
+        layer => layer.encoding?.[channel]?.scale !== undefined
+      )) {
+        throw new Error(
+          `Facet scale channel "${channel}" is not used by an affected layer.`
+        );
+      }
+    }
+    const current = this.compositionSpec.facet;
+    const scales = { ...current.scales, ...args };
+    if (FACET_SCALE_CHANNELS.every(
+      channel => scales[channel] === current.scales[channel]
+    )) {
+      throw new Error("editFacetScales requires at least one channel policy change.");
+    }
+    const request = applicableScaleRequest(this, scales);
+    const normalized = normalizeFacetScalePolicies(this.semanticSpec, request);
+    const applyEdit = program => rederiveFacet(program, {
+      scales: normalized.channels,
+      guides: current.guides
+    });
+    applyEdit(this);
+    return applyEdit(this);
+  }
+);
+
+export const editFacetGuides = action(
+  {
+    op: "editFacetGuides",
+    description: "Edit facet guide ownership and rederive every cell.",
+    scope: "composition"
+  },
+  function (args = {}) {
+    requireFacetProgram(this, "editFacetGuides");
+    validateOptionObject(args, GUIDE_OPTIONS, "editFacetGuides", {
+      allowEmpty: false,
+      emptyMessage: "editFacetGuides requires at least one guide policy."
+    });
+    const current = this.compositionSpec.facet;
+    const guides = normalizeGuides({ ...current.guides, ...args });
+    const applyEdit = program => rederiveFacet(program, {
+      scales: current.scales,
+      guides
+    });
+    applyEdit(this);
+    return applyEdit(this);
+  }
+);
+
 export function registerFacetActions(ProgramClass) {
   ProgramClass.prototype.replayDerivedData = replayDerivedData;
   ProgramClass.prototype.composeFacetGuides = composeFacetGuides;
   ProgramClass.prototype.facet = facet;
   ProgramClass.prototype.editFacetHeaders = editFacetHeaders;
+  ProgramClass.prototype.editFacetScales = editFacetScales;
+  ProgramClass.prototype.editFacetGuides = editFacetGuides;
 }